from __future__ import generators # This file was automatically generated by SWIG (http://www.swig.org). # Version 3.0.12 # # Do not make changes to this file unless you know what you are doing--modify # the SWIG interface file instead. from sys import version_info as _swig_python_version_info if _swig_python_version_info >= (2, 7, 0): def swig_import_helper(): import importlib pkg = __name__.rpartition('.')[0] mname = '.'.join((pkg, '_libsbml')).lstrip('.') try: return importlib.import_module(mname) except ImportError: return importlib.import_module('_libsbml') _libsbml = swig_import_helper() del swig_import_helper elif _swig_python_version_info >= (2, 6, 0): def swig_import_helper(): from os.path import dirname import imp fp = None try: fp, pathname, description = imp.find_module('_libsbml', [dirname(__file__)]) except ImportError: import _libsbml return _libsbml try: _mod = imp.load_module('_libsbml', fp, pathname, description) finally: if fp is not None: fp.close() return _mod _libsbml = swig_import_helper() del swig_import_helper else: import _libsbml del _swig_python_version_info try: _swig_property = property except NameError: pass # Python < 2.2 doesn't have 'property'. try: import builtins as __builtin__ except ImportError: import __builtin__ def _swig_setattr_nondynamic(self, class_type, name, value, static=1): if (name == "thisown"): return self.this.own(value) if (name == "this"): if type(value).__name__ == 'SwigPyObject': self.__dict__[name] = value return method = class_type.__swig_setmethods__.get(name, None) if method: return method(self, value) if (not static): if _newclass: object.__setattr__(self, name, value) else: self.__dict__[name] = value else: raise AttributeError("You cannot add attributes to %s" % self) def _swig_setattr(self, class_type, name, value): return _swig_setattr_nondynamic(self, class_type, name, value, 0) def _swig_getattr(self, class_type, name): if (name == "thisown"): return self.this.own() method = class_type.__swig_getmethods__.get(name, None) if method: return method(self) raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name)) def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() except __builtin__.Exception: strthis = "" return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) try: _object = object _newclass = 1 except __builtin__.Exception: class _object: pass _newclass = 0 try: import weakref weakref_proxy = weakref.proxy except __builtin__.Exception: weakref_proxy = lambda x: x class ModelCreatorList(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, ModelCreatorList, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, ModelCreatorList, name) __repr__ = _swig_repr def __init__(self): this = _libsbml.new_ModelCreatorList() try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_ModelCreatorList __del__ = lambda self: None def add(self, item): return _libsbml.ModelCreatorList_add(self, item) def get(self, n): return _libsbml.ModelCreatorList_get(self, n) def prepend(self, item): return _libsbml.ModelCreatorList_prepend(self, item) def remove(self, n): return _libsbml.ModelCreatorList_remove(self, n) def getSize(self): return _libsbml.ModelCreatorList_getSize(self) ModelCreatorList_swigregister = _libsbml.ModelCreatorList_swigregister ModelCreatorList_swigregister(ModelCreatorList) class DateList(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, DateList, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, DateList, name) __repr__ = _swig_repr def __init__(self): this = _libsbml.new_DateList() try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_DateList __del__ = lambda self: None def add(self, item): return _libsbml.DateList_add(self, item) def get(self, n): return _libsbml.DateList_get(self, n) def prepend(self, item): return _libsbml.DateList_prepend(self, item) def remove(self, n): return _libsbml.DateList_remove(self, n) def getSize(self): return _libsbml.DateList_getSize(self) DateList_swigregister = _libsbml.DateList_swigregister DateList_swigregister(DateList) class CVTermList(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, CVTermList, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, CVTermList, name) __repr__ = _swig_repr def __init__(self): this = _libsbml.new_CVTermList() try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_CVTermList __del__ = lambda self: None def add(self, item): return _libsbml.CVTermList_add(self, item) def get(self, n): return _libsbml.CVTermList_get(self, n) def prepend(self, item): return _libsbml.CVTermList_prepend(self, item) def remove(self, n): return _libsbml.CVTermList_remove(self, n) def getSize(self): return _libsbml.CVTermList_getSize(self) CVTermList_swigregister = _libsbml.CVTermList_swigregister CVTermList_swigregister(CVTermList) class ASTNodeList(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, ASTNodeList, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, ASTNodeList, name) __repr__ = _swig_repr def __init__(self): this = _libsbml.new_ASTNodeList() try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_ASTNodeList __del__ = lambda self: None def add(self, item): return _libsbml.ASTNodeList_add(self, item) def get(self, n): return _libsbml.ASTNodeList_get(self, n) def prepend(self, item): return _libsbml.ASTNodeList_prepend(self, item) def remove(self, n): return _libsbml.ASTNodeList_remove(self, n) def getSize(self): return _libsbml.ASTNodeList_getSize(self) ASTNodeList_swigregister = _libsbml.ASTNodeList_swigregister ASTNodeList_swigregister(ASTNodeList) class SBMLNamespacesList(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLNamespacesList, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, SBMLNamespacesList, name) __repr__ = _swig_repr def __init__(self): this = _libsbml.new_SBMLNamespacesList() try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_SBMLNamespacesList __del__ = lambda self: None def add(self, item): return _libsbml.SBMLNamespacesList_add(self, item) def get(self, n): return _libsbml.SBMLNamespacesList_get(self, n) def prepend(self, item): return _libsbml.SBMLNamespacesList_prepend(self, item) def remove(self, n): return _libsbml.SBMLNamespacesList_remove(self, n) def getSize(self): return _libsbml.SBMLNamespacesList_getSize(self) SBMLNamespacesList_swigregister = _libsbml.SBMLNamespacesList_swigregister SBMLNamespacesList_swigregister(SBMLNamespacesList) class SBaseList(_object): __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, SBaseList, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, SBaseList, name) __repr__ = _swig_repr def __init__(self): this = _libsbml.new_SBaseList() try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_SBaseList __del__ = lambda self: None def add(self, item): return _libsbml.SBaseList_add(self, item) def get(self, n): return _libsbml.SBaseList_get(self, n) def prepend(self, item): return _libsbml.SBaseList_prepend(self, item) def remove(self, n): return _libsbml.SBaseList_remove(self, n) def getSize(self): return _libsbml.SBaseList_getSize(self) SBaseList_swigregister = _libsbml.SBaseList_swigregister SBaseList_swigregister(SBaseList) ## enable optional new API2 functionality by configure or environment if 'USE_LIBSBML_PYTHON_API2_WARNINGS' in os.environ: try: _etest = int(os.environ['USE_LIBSBML_PYTHON_API2_WARNINGS']) except ValueError: _etest = 0 print('\nThe environment variable "USE_LIBSBML_PYTHON_API2_WARNINGS" should have the value 1 or 0\n') if _etest: USE_LIBSBML_PYTHON_API2_WARNINGS = True else: USE_LIBSBML_PYTHON_API2_WARNINGS = False # class decorator, from six, that will be used to solve Python2/3 metaclass issues # usage is NewClass(with_metaclass(MetaClass, BaseClasses)): #def with_metaclass(meta, *bases): # """Create a base class with a metaclass. #Usage is: NewClass(with_metaclass(MetaClass, BaseClass*)""" # This requires a bit of explanation: the basic idea is to make a dummy # metaclass for one level of class instantiation that replaces itself with # the actual metaclass. # class metaclass(type): # # def __new__(cls, name, this_bases, d): # return meta(name, bases, d) # # @classmethod # def __prepare__(cls, name, this_bases): # return meta.__prepare__(name, bases) # return type.__new__(metaclass, 'temporary_class', (), {}) if USE_LIBSBML_PYTHON_API2_WARNINGS: import warnings class PythonAPI2Warning(UserWarning): """ Custom warning class for warnings generated by libSBML Python API2. """ def __init__(self, msg): """ x.__init__(...) initializes x; see help(type(x)) for signature """ print(msg) def p_func_warning_decorator(F): try: incoming_name = F.__name__ except: return F from functools import wraps @wraps(F) def warning_wrap(*args, **kwargs): res = msg = None res = F(*args, **kwargs) if type(res) == int and res < 0: msg = '\"{}\" returns an error ({}): {}'.format(incoming_name, res,\ OperationReturnValue_toString(res)) warnings.warn(msg, category=PythonAPI2Warning) return res return warning_wrap class AutoProperty(type): """ Auto-detect Python class getX/setX methods. This class is attached to SBase and automatically applies for all classes which inherit from it. Its purpose is to make libSBML more convenient to use from Python. It works by analyzing classes at class creation time (not at instantiation) and adding corresponding properties (directly calling C methods where possible) to the class dictionary. @note The code should work for python 2.6 upwards, however for python 3 it needs to be attached via constructors. """ def __new__(cls, classname, bases, classdict): """ Iterate over the items in the classdict looking for get/set pairs and declaring them as properties. """ import re import keyword import sys if sys.version_info < (3, 0): from inspect import getargspec as mygetargspec else: from inspect import getfullargspec as mygetargspec re_mangle = re.compile(r'[A-Za-z][a-z]+|[A-Z]+(?=$|[A-Z0-9])|\d+') re_id = re.compile(r'^[A-Za-z_][A-Za-z0-9_]*$') re_getdoc = re.compile(r'^\s*[A-Za-z_][A-Za-z0-9_]*\(self\)') re_setdoc = re.compile(r'^\s*[A-Za-z_][A-Za-z0-9_]*\(self,[^,)]+\)') #convert ACapitalCasedStringXYZ123 -> a_capital_cased_string_xyz_123 mangle_name = lambda x: ('_'.join(re_mangle.findall(x))).lower() get_methods = set() set_methods = set() swig_setter = classdict.get('__swig_setmethods__', {}) if USE_LIBSBML_PYTHON_API2_WARNINGS: # explicitly collect unsetX methods separately for method decorator unset_methods = set() # collect addX and methods for method decorator re_addfunc = re.compile(r'add[A-Z][A-Za-z0-9_]*') add_methods = set() allowed_methods = [ 'Annotation', 'AnnotationString', 'Notes', 'NotesString', ] #only search for get/set methods #we assume that any unset method also has either get or set #a small number of set without get cases exist so we can't only #search for get methods for k, v in classdict.items(): name = k[3:] prefix = k[:3] mangled = mangle_name(name) if name: if callable(v): if re_id.match(mangled) and mangled not in keyword.kwlist: if prefix == 'get': get_methods.add(name) elif prefix == 'set': set_methods.add(name) if USE_LIBSBML_PYTHON_API2_WARNINGS: # find addX methods for decoration if re_addfunc.match(k) is not None: add_methods.add(k) for name in get_methods | set_methods: mangled = mangle_name(name) #ListOfFoobars -> foobars if mangled.startswith('list_of_'): mangled = mangled[8:] getter = setter = deleter = None if name in get_methods: getter = classdict['get'+name] #this is a very dirty way of checking if the get method #requires extra arguments (and hence cannot be a property) #it should be possible to do this properly in SWIG? try: argspec = mygetargspec(getter) numargs = len(argspec.args) if numargs > 1 or (numargs == 1 and argspec.args[0] != 'self') \ or (argspec.varargs!=None and name not in allowed_methods and not name.startswith('ListOf') ): continue except Exception: continue #use the c-level get function if the python function #only consists of a call to it cname = classname + '_get' + name #test if function is "return _libsbml.CLASS_getNAME(__args__)" try: if getter.func_code.co_names == ('_libsbml', cname): getter = getattr(_libsbml, cname) except: if getter.__code__.co_names == ('_libsbml', cname): getter = getattr(_libsbml, cname) if name in set_methods: setter = classdict['set'+name] try: argspec = mygetargspec(getter) numargs = len(argspec.args) if numargs > 1 and argspec.args[0] == 'self': cname = classname + '_set' + name try: if setter.func_code.co_names == ('_libsbml', cname): setter = getattr(_libsbml, cname) except: if setter.__code__.co_names == ('_libsbml', cname): setter = getattr(_libsbml, cname) #property fget does not get intercepted by __getattr__ #but fset does, so we implement property setting via #the __swig_setmethods__ dict if USE_LIBSBML_PYTHON_API2_WARNINGS: swig_setter[mangled] = p_func_warning_decorator(setter) else: swig_setter[mangled] = setter continue except: pass if 'unset' + name in classdict: deleter = classdict['unset'+name] try: argspec = mygetargspec(getter) numargs = len(argspec.args) if numargs == 1 and argspec.args[0] == 'self' and \ (argspec.varargs==None or name in allowed_methods): cname = classname + '_unset' + name try: if deleter.func_code.co_names == ('_libsbml', cname): deleter = getattr(_libsbml, cname) except: if deleter.__code__.co_names == ('_libsbml', cname): deleter = getattr(_libsbml, cname) except: pass # wrap mangled deleters if USE_LIBSBML_PYTHON_API2_WARNINGS: unset_methods.add(name) if getter or setter or deleter: #fset is technically redundant since the method is dispatched #via _swig_setattr rather than through the property due to that #function not delegating to object.__setattr__ which properly #handles properties classdict[mangled] = property(fget=getter, fset=setter, fdel=deleter) def __repr__(self): desc = self.__class__.__name__ if hasattr(self, '__len__'): desc += '[%s]' % self.__len__() if hasattr(self, 'id') and self.id: desc += ' %s' % self.id if hasattr(self, 'name') and self.name: desc += ' "%s"' % self.name return '<' + desc + '>' if classdict.get('__repr__', None) in (_swig_repr, None): classdict['__repr__'] = __repr__ if USE_LIBSBML_PYTHON_API2_WARNINGS: # decorate get methods for gm in get_methods: if 'get'+gm in classdict: classdict['get'+gm] = p_func_warning_decorator(classdict['get'+gm]) # decorate set methods for sm in set_methods: if 'set'+sm in classdict: classdict['set'+sm] = p_func_warning_decorator(classdict['set'+sm]) # decorate unset methods for dm in unset_methods: if 'unset'+dm in classdict: classdict['unset'+dm] = p_func_warning_decorator(classdict['unset'+dm]) # decorate unset methods if len(add_methods) > 0: for am in add_methods: if am in classdict: classdict[am] = p_func_warning_decorator(classdict[am]) return type.__new__(cls, classname, bases, classdict) class SwigPyIterator(_object): """Proxy of C++ swig::SwigPyIterator class.""" __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name) def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_SwigPyIterator __del__ = lambda self: None def value(self): """value(SwigPyIterator self) -> PyObject *""" return _libsbml.SwigPyIterator_value(self) def incr(self, n=1): """ incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator incr(SwigPyIterator self) -> SwigPyIterator """ return _libsbml.SwigPyIterator_incr(self, n) def decr(self, n=1): """ decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator decr(SwigPyIterator self) -> SwigPyIterator """ return _libsbml.SwigPyIterator_decr(self, n) def distance(self, x): """distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t""" return _libsbml.SwigPyIterator_distance(self, x) def equal(self, x): """equal(SwigPyIterator self, SwigPyIterator x) -> bool""" return _libsbml.SwigPyIterator_equal(self, x) def copy(self): """copy(SwigPyIterator self) -> SwigPyIterator""" return _libsbml.SwigPyIterator_copy(self) def next(self): """next(SwigPyIterator self) -> PyObject *""" return _libsbml.SwigPyIterator_next(self) def __next__(self): """__next__(SwigPyIterator self) -> PyObject *""" return _libsbml.SwigPyIterator___next__(self) def previous(self): """previous(SwigPyIterator self) -> PyObject *""" return _libsbml.SwigPyIterator_previous(self) def advance(self, n): """advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator""" return _libsbml.SwigPyIterator_advance(self, n) def __eq__(self, x): """__eq__(SwigPyIterator self, SwigPyIterator x) -> bool""" return _libsbml.SwigPyIterator___eq__(self, x) def __ne__(self, x): """__ne__(SwigPyIterator self, SwigPyIterator x) -> bool""" return _libsbml.SwigPyIterator___ne__(self, x) def __iadd__(self, n): """__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator""" return _libsbml.SwigPyIterator___iadd__(self, n) def __isub__(self, n): """__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator""" return _libsbml.SwigPyIterator___isub__(self, n) def __add__(self, n): """__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator""" return _libsbml.SwigPyIterator___add__(self, n) def __sub__(self, *args): """ __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t """ return _libsbml.SwigPyIterator___sub__(self, *args) def __iter__(self): return self SwigPyIterator_swigregister = _libsbml.SwigPyIterator_swigregister SwigPyIterator_swigregister(SwigPyIterator) class string(_object): """Proxy of C++ std::basic_string<(char)> class.""" __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, string, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, string, name) __repr__ = _swig_repr def length(self): """length(string self) -> std::basic_string< char >::size_type""" return _libsbml.string_length(self) def max_size(self): """max_size(string self) -> std::basic_string< char >::size_type""" return _libsbml.string_max_size(self) def copy(self, __s, __n, __pos=0): """ copy(string self, char * __s, std::basic_string< char >::size_type __n, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type copy(string self, char * __s, std::basic_string< char >::size_type __n) -> std::basic_string< char >::size_type """ return _libsbml.string_copy(self, __s, __n, __pos) def c_str(self): """c_str(string self) -> char const *""" return _libsbml.string_c_str(self) def find(self, *args): """ find(string self, char const * __s, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n) -> std::basic_string< char >::size_type find(string self, string __str, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type find(string self, string __str) -> std::basic_string< char >::size_type find(string self, char __c, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type find(string self, char __c) -> std::basic_string< char >::size_type """ return _libsbml.string_find(self, *args) def rfind(self, *args): """ rfind(string self, string __str, std::basic_string< char >::size_type __pos) -> std::basic_string< char >::size_type rfind(string self, string __str) -> std::basic_string< char >::size_type rfind(string self, char const * __s, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n) -> std::basic_string< char >::size_type rfind(string self, char __c, std::basic_string< char >::size_type __pos) -> std::basic_string< char >::size_type rfind(string self, char __c) -> std::basic_string< char >::size_type """ return _libsbml.string_rfind(self, *args) def find_first_of(self, *args): """ find_first_of(string self, string __str, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type find_first_of(string self, string __str) -> std::basic_string< char >::size_type find_first_of(string self, char const * __s, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n) -> std::basic_string< char >::size_type find_first_of(string self, char __c, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type find_first_of(string self, char __c) -> std::basic_string< char >::size_type """ return _libsbml.string_find_first_of(self, *args) def find_last_of(self, *args): """ find_last_of(string self, string __str, std::basic_string< char >::size_type __pos) -> std::basic_string< char >::size_type find_last_of(string self, string __str) -> std::basic_string< char >::size_type find_last_of(string self, char const * __s, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n) -> std::basic_string< char >::size_type find_last_of(string self, char __c, std::basic_string< char >::size_type __pos) -> std::basic_string< char >::size_type find_last_of(string self, char __c) -> std::basic_string< char >::size_type """ return _libsbml.string_find_last_of(self, *args) def find_first_not_of(self, *args): """ find_first_not_of(string self, string __str, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type find_first_not_of(string self, string __str) -> std::basic_string< char >::size_type find_first_not_of(string self, char const * __s, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n) -> std::basic_string< char >::size_type find_first_not_of(string self, char __c, std::basic_string< char >::size_type __pos=0) -> std::basic_string< char >::size_type find_first_not_of(string self, char __c) -> std::basic_string< char >::size_type """ return _libsbml.string_find_first_not_of(self, *args) def find_last_not_of(self, *args): """ find_last_not_of(string self, string __str, std::basic_string< char >::size_type __pos) -> std::basic_string< char >::size_type find_last_not_of(string self, string __str) -> std::basic_string< char >::size_type find_last_not_of(string self, char const * __s, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n) -> std::basic_string< char >::size_type find_last_not_of(string self, char __c, std::basic_string< char >::size_type __pos) -> std::basic_string< char >::size_type find_last_not_of(string self, char __c) -> std::basic_string< char >::size_type """ return _libsbml.string_find_last_not_of(self, *args) def substr(self, *args): """ substr(string self, std::basic_string< char >::size_type __pos=0, std::basic_string< char >::size_type __n) -> string substr(string self, std::basic_string< char >::size_type __pos=0) -> string substr(string self) -> string """ return _libsbml.string_substr(self, *args) def empty(self): """empty(string self) -> bool""" return _libsbml.string_empty(self) def size(self): """size(string self) -> std::basic_string< char >::size_type""" return _libsbml.string_size(self) def swap(self, v): """swap(string self, string v)""" return _libsbml.string_swap(self, v) def erase(self, *args): """ erase(string self, std::basic_string< char >::size_type __pos=0, std::basic_string< char >::size_type __n) -> string erase(string self, std::basic_string< char >::size_type __pos=0) -> string erase(string self) -> string erase(string self, std::basic_string< char >::iterator pos) -> std::basic_string< char >::iterator erase(string self, std::basic_string< char >::iterator first, std::basic_string< char >::iterator last) -> std::basic_string< char >::iterator """ return _libsbml.string_erase(self, *args) def __init__(self, *args): """ __init__(std::basic_string<(char)> self, char const * __s, std::basic_string< char >::size_type __n) -> string __init__(std::basic_string<(char)> self) -> string __init__(std::basic_string<(char)> self, string arg2) -> string __init__(std::basic_string<(char)> self, std::basic_string< char >::size_type size, std::basic_string< char >::value_type value) -> string """ this = _libsbml.new_string(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def assign(self, *args): """ assign(string self, string __str) -> string assign(string self, string __str, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n) -> string assign(string self, char const * __s, std::basic_string< char >::size_type __n) -> string assign(string self, std::basic_string< char >::size_type n, std::basic_string< char >::value_type x) """ return _libsbml.string_assign(self, *args) def resize(self, *args): """ resize(string self, std::basic_string< char >::size_type new_size) resize(string self, std::basic_string< char >::size_type new_size, std::basic_string< char >::value_type x) """ return _libsbml.string_resize(self, *args) def iterator(self): """iterator(string self) -> SwigPyIterator""" return _libsbml.string_iterator(self) def __iter__(self): return self.iterator() def __nonzero__(self): """__nonzero__(string self) -> bool""" return _libsbml.string___nonzero__(self) def __bool__(self): """__bool__(string self) -> bool""" return _libsbml.string___bool__(self) def __len__(self): """__len__(string self) -> std::basic_string< char >::size_type""" return _libsbml.string___len__(self) def __getslice__(self, i, j): """__getslice__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::difference_type j) -> string""" return _libsbml.string___getslice__(self, i, j) def __setslice__(self, *args): """ __setslice__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::difference_type j) __setslice__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::difference_type j, string v) """ return _libsbml.string___setslice__(self, *args) def __delslice__(self, i, j): """__delslice__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::difference_type j)""" return _libsbml.string___delslice__(self, i, j) def __delitem__(self, *args): """ __delitem__(string self, std::basic_string< char >::difference_type i) __delitem__(string self, PySliceObject * slice) """ return _libsbml.string___delitem__(self, *args) def __getitem__(self, *args): """ __getitem__(string self, PySliceObject * slice) -> string __getitem__(string self, std::basic_string< char >::difference_type i) -> std::basic_string< char >::value_type """ return _libsbml.string___getitem__(self, *args) def __setitem__(self, *args): """ __setitem__(string self, PySliceObject * slice, string v) __setitem__(string self, PySliceObject * slice) __setitem__(string self, std::basic_string< char >::difference_type i, std::basic_string< char >::value_type x) """ return _libsbml.string___setitem__(self, *args) def insert(self, *args): """ insert(string self, std::basic_string< char >::size_type __pos1, string __str) -> string insert(string self, std::basic_string< char >::size_type __pos1, string __str, std::basic_string< char >::size_type __pos2, std::basic_string< char >::size_type __n) -> string insert(string self, std::basic_string< char >::size_type __pos, char const * __s, std::basic_string< char >::size_type __n) -> string insert(string self, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n, char __c) -> string insert(string self, std::basic_string< char >::iterator pos, std::basic_string< char >::value_type x) -> std::basic_string< char >::iterator insert(string self, std::basic_string< char >::iterator pos, std::basic_string< char >::size_type n, std::basic_string< char >::value_type x) insert(string self, std::basic_string< char >::iterator __p, std::basic_string< char >::size_type __n, char __c) """ return _libsbml.string_insert(self, *args) def replace(self, *args): """ replace(string self, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n, string __str) -> string replace(string self, std::basic_string< char >::size_type __pos1, std::basic_string< char >::size_type __n1, string __str, std::basic_string< char >::size_type __pos2, std::basic_string< char >::size_type __n2) -> string replace(string self, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n1, char const * __s, std::basic_string< char >::size_type __n2) -> string replace(string self, std::basic_string< char >::size_type __pos, std::basic_string< char >::size_type __n1, std::basic_string< char >::size_type __n2, char __c) -> string replace(string self, std::basic_string< char >::iterator __i1, std::basic_string< char >::iterator __i2, string __str) -> string replace(string self, std::basic_string< char >::iterator __i1, std::basic_string< char >::iterator __i2, char const * __s, std::basic_string< char >::size_type __n) -> string replace(string self, std::basic_string< char >::iterator __i1, std::basic_string< char >::iterator __i2, std::basic_string< char >::size_type __n, char __c) -> string replace(string self, std::basic_string< char >::iterator __i1, std::basic_string< char >::iterator __i2, char const * __k1, char const * __k2) -> string replace(string self, std::basic_string< char >::iterator __i1, std::basic_string< char >::iterator __i2, std::basic_string< char >::const_iterator __k1, std::basic_string< char >::const_iterator __k2) -> string """ return _libsbml.string_replace(self, *args) def __iadd__(self, v): """__iadd__(string self, string v) -> string""" return _libsbml.string___iadd__(self, v) def __add__(self, v): """__add__(string self, string v) -> string""" return _libsbml.string___add__(self, v) def __radd__(self, v): """__radd__(string self, string v) -> string""" return _libsbml.string___radd__(self, v) def __str__(self): """__str__(string self) -> string""" return _libsbml.string___str__(self) def __rlshift__(self, out): """__rlshift__(string self, ostream out) -> ostream""" return _libsbml.string___rlshift__(self, out) def __eq__(self, v): """__eq__(string self, string v) -> bool""" return _libsbml.string___eq__(self, v) def __ne__(self, v): """__ne__(string self, string v) -> bool""" return _libsbml.string___ne__(self, v) def __gt__(self, v): """__gt__(string self, string v) -> bool""" return _libsbml.string___gt__(self, v) def __lt__(self, v): """__lt__(string self, string v) -> bool""" return _libsbml.string___lt__(self, v) def __ge__(self, v): """__ge__(string self, string v) -> bool""" return _libsbml.string___ge__(self, v) def __le__(self, v): """__le__(string self, string v) -> bool""" return _libsbml.string___le__(self, v) __swig_destroy__ = _libsbml.delete_string __del__ = lambda self: None string_swigregister = _libsbml.string_swigregister string_swigregister(string) cvar = _libsbml.cvar string.npos = _libsbml.cvar.string_npos class ostream(_object): """Proxy of C++ std::basic_ostream<(char)> class.""" __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, ostream, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, ostream, name) __repr__ = _swig_repr def __init__(self, __sb): """__init__(std::basic_ostream<(char)> self, std::basic_streambuf< char,std::char_traits< char > > * __sb) -> ostream""" this = _libsbml.new_ostream(__sb) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_ostream __del__ = lambda self: None ostream_swigregister = _libsbml.ostream_swigregister ostream_swigregister(ostream) class ostringstream(ostream): """Proxy of C++ std::basic_ostringstream<(char)> class.""" __swig_setmethods__ = {} for _s in [ostream]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, ostringstream, name, value) __swig_getmethods__ = {} for _s in [ostream]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, ostringstream, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(std::basic_ostringstream<(char)> self, std::ios_base::openmode __mode) -> ostringstream __init__(std::basic_ostringstream<(char)> self) -> ostringstream """ this = _libsbml.new_ostringstream(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_ostringstream __del__ = lambda self: None def str(self, *args): """ str(ostringstream self) -> string str(ostringstream self, string __s) """ return _libsbml.ostringstream_str(self, *args) ostringstream_swigregister = _libsbml.ostringstream_swigregister ostringstream_swigregister(ostringstream) def endl(arg1): """endl(ostream arg1) -> ostream""" return _libsbml.endl(arg1) def flush(arg1): """flush(ostream arg1) -> ostream""" return _libsbml.flush(arg1) import sys import os.path # @cond doxygenLibsbmlInternal def conditional_abspath (filename): """conditional_abspath (filename) -> filename Returns filename with an absolute path prepended, if necessary. Some combinations of platforms and underlying XML parsers *require* an absolute path to a filename while others do not. This function encapsulates the appropriate logic. It is used by readSBML() and SBMLReader.readSBML(). """ if sys.platform.find('cygwin') != -1: return filename else: return os.path.abspath(filename) # @endcond def readSBML(*args): """ readSBML(self, string filename) -> SBMLDocument Reads an SBML document from a file. This method is identical to readSBMLFromFile(). If the file named 'filename' does not exist or its content is not valid SBML, one or more errors will be logged with the SBMLDocument object returned by this method. Callers can use the methods on SBMLDocument such as SBMLDocument.getNumErrors() and SBMLDocument.getError() to get the errors. The object returned by SBMLDocument.getError() is an SBMLError object, and it has methods to get the error code, category, and severity level of the problem, as well as a textual description of the problem. The possible severity levels range from informational messages to fatal errors; see the documentation for SBMLError for more information. If the file 'filename' could not be read, the file-reading error will appear first. The error code can provide a clue about what happened. For example, a file might be unreadable (either because it does not actually exist or because the user does not have the necessary access priviledges to read it) or some sort of file operation error may have been reported by the underlying operating system. Callers can check for these situations using a program fragment such as the following: reader = SBMLReader() doc = reader.readSBML(filename) if doc.getNumErrors() > 0: if doc.getError(0).getErrorId() == libsbml.XMLFileUnreadable: # Handle case of unreadable file here. elif doc.getError(0).getErrorId() == libsbml.XMLFileOperationError: # Handle case of other file error here. else: # Handle other error cases here. If the given filename ends with the suffix \".gz\" (for example, \"myfile.xml.gz\"), the file is assumed to be compressed in gzip format and will be automatically decompressed upon reading. Similarly, if the given filename ends with \".zip\" or \".bz2\", the file is assumed to be compressed in zip or bzip2 format (respectively). Files whose names lack these suffixes will be read uncompressed. Note that if the file is in zip format but the archive contains more than one file, only the first file in the archive will be read and the rest ignored. To read a gzip/zip file, libSBML needs to be configured and linked with the zlib library at compile time. It also needs to be linked with the bzip2 library to read files in bzip2 format. (Both of these are the default configurations for libSBML.) Errors about unreadable files will be logged if a compressed filename is given and libSBML was not linked with the corresponding required library. Parameter 'filename is the name or full pathname of the file to be read. Returns a pointer to the SBMLDocument created from the SBML content. See also SBMLError. Note: LibSBML versions 2.x and later versions behave differently in error handling in several respects. One difference is how early some errors are caught and whether libSBML continues processing a file in the face of some early errors. In general, libSBML versions after 2.x stop parsing SBML inputs sooner than libSBML version 2.x in the face of XML errors, because the errors may invalidate any further SBML content. For example, a missing XML declaration at the beginning of the file was ignored by libSBML 2.x but in version 3.x and later, it will cause libSBML to stop parsing the rest of the input altogether. While this behavior may seem more severe and intolerant, it was necessary in order to provide uniform behavior regardless of which underlying XML parser (Expat, Xerces, libxml2) is being used by libSBML. The XML parsers themselves behave differently in their error reporting, and sometimes libSBML has to resort to the lowest common denominator. """ reader = SBMLReader() return reader.readSBML(args[0]) class ListWrapperSBMLNamespaces(_object): """Proxy of C++ ListWrapper<(SBMLNamespaces)> class.""" __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, ListWrapperSBMLNamespaces, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, ListWrapperSBMLNamespaces, name) __repr__ = _swig_repr def __init__(self): """__init__(ListWrapper<(SBMLNamespaces)> self) -> ListWrapperSBMLNamespaces""" this = _libsbml.new_ListWrapperSBMLNamespaces() try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_ListWrapperSBMLNamespaces __del__ = lambda self: None def add(self, item): """add(ListWrapperSBMLNamespaces self, SBMLNamespaces item)""" return _libsbml.ListWrapperSBMLNamespaces_add(self, item) def get(self, n): """get(ListWrapperSBMLNamespaces self, unsigned int n) -> SBMLNamespaces""" return _libsbml.ListWrapperSBMLNamespaces_get(self, n) def prepend(self, item): """prepend(ListWrapperSBMLNamespaces self, SBMLNamespaces item)""" return _libsbml.ListWrapperSBMLNamespaces_prepend(self, item) def remove(self, n): """remove(ListWrapperSBMLNamespaces self, unsigned int n) -> SBMLNamespaces""" return _libsbml.ListWrapperSBMLNamespaces_remove(self, n) def getSize(self): """getSize(ListWrapperSBMLNamespaces self) -> unsigned int""" return _libsbml.ListWrapperSBMLNamespaces_getSize(self) def __len__(self): """__len__(ListWrapperSBMLNamespaces self) -> int""" return _libsbml.ListWrapperSBMLNamespaces___len__(self) def __getitem__(self, key): try: keyIsSlice = isinstance(key, slice) except: keyIsSlice = 0 if keyIsSlice: start = key.start if start is None: start = 0 stop = key.stop if stop is None: stop = self.getSize() return [self[i] for i in range( self._fixNegativeIndex(start), self._fixNegativeIndex(stop) )] key = self._fixNegativeIndex(key) if key < 0 or key >= self.getSize(): raise IndexError(key) return self.get(key) def _fixNegativeIndex(self, index): if index < 0: return index + self.getSize() else: return index def __iter__(self): for i in range(self.getSize()): yield self[i] def __repr__(self): return "[" + ", ".join([repr(self[i]) for i in range(len(self))]) + "]" def __str__(self): return repr(self) ListWrapperSBMLNamespaces_swigregister = _libsbml.ListWrapperSBMLNamespaces_swigregister ListWrapperSBMLNamespaces_swigregister(ListWrapperSBMLNamespaces) cout = cvar.cout cerr = cvar.cerr clog = cvar.clog class ListWrapperCVTerm(_object): """Proxy of C++ ListWrapper<(CVTerm)> class.""" __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, ListWrapperCVTerm, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, ListWrapperCVTerm, name) __repr__ = _swig_repr def __init__(self): """__init__(ListWrapper<(CVTerm)> self) -> ListWrapperCVTerm""" this = _libsbml.new_ListWrapperCVTerm() try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_ListWrapperCVTerm __del__ = lambda self: None def add(self, item): """add(ListWrapperCVTerm self, CVTerm item)""" return _libsbml.ListWrapperCVTerm_add(self, item) def get(self, n): """get(ListWrapperCVTerm self, unsigned int n) -> CVTerm""" return _libsbml.ListWrapperCVTerm_get(self, n) def prepend(self, item): """prepend(ListWrapperCVTerm self, CVTerm item)""" return _libsbml.ListWrapperCVTerm_prepend(self, item) def remove(self, n): """remove(ListWrapperCVTerm self, unsigned int n) -> CVTerm""" return _libsbml.ListWrapperCVTerm_remove(self, n) def getSize(self): """getSize(ListWrapperCVTerm self) -> unsigned int""" return _libsbml.ListWrapperCVTerm_getSize(self) def __len__(self): """__len__(ListWrapperCVTerm self) -> int""" return _libsbml.ListWrapperCVTerm___len__(self) def __getitem__(self, key): try: keyIsSlice = isinstance(key, slice) except: keyIsSlice = 0 if keyIsSlice: start = key.start if start is None: start = 0 stop = key.stop if stop is None: stop = self.getSize() return [self[i] for i in range( self._fixNegativeIndex(start), self._fixNegativeIndex(stop) )] key = self._fixNegativeIndex(key) if key < 0 or key >= self.getSize(): raise IndexError(key) return self.get(key) def _fixNegativeIndex(self, index): if index < 0: return index + self.getSize() else: return index def __iter__(self): for i in range(self.getSize()): yield self[i] def __repr__(self): return "[" + ", ".join([repr(self[i]) for i in range(len(self))]) + "]" def __str__(self): return repr(self) ListWrapperCVTerm_swigregister = _libsbml.ListWrapperCVTerm_swigregister ListWrapperCVTerm_swigregister(ListWrapperCVTerm) class ListWrapperDate(_object): """Proxy of C++ ListWrapper<(Date)> class.""" __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, ListWrapperDate, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, ListWrapperDate, name) __repr__ = _swig_repr def __init__(self): """__init__(ListWrapper<(Date)> self) -> ListWrapperDate""" this = _libsbml.new_ListWrapperDate() try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_ListWrapperDate __del__ = lambda self: None def add(self, item): """add(ListWrapperDate self, Date item)""" return _libsbml.ListWrapperDate_add(self, item) def get(self, n): """get(ListWrapperDate self, unsigned int n) -> Date""" return _libsbml.ListWrapperDate_get(self, n) def prepend(self, item): """prepend(ListWrapperDate self, Date item)""" return _libsbml.ListWrapperDate_prepend(self, item) def remove(self, n): """remove(ListWrapperDate self, unsigned int n) -> Date""" return _libsbml.ListWrapperDate_remove(self, n) def getSize(self): """getSize(ListWrapperDate self) -> unsigned int""" return _libsbml.ListWrapperDate_getSize(self) def __len__(self): """__len__(ListWrapperDate self) -> int""" return _libsbml.ListWrapperDate___len__(self) def __getitem__(self, key): try: keyIsSlice = isinstance(key, slice) except: keyIsSlice = 0 if keyIsSlice: start = key.start if start is None: start = 0 stop = key.stop if stop is None: stop = self.getSize() return [self[i] for i in range( self._fixNegativeIndex(start), self._fixNegativeIndex(stop) )] key = self._fixNegativeIndex(key) if key < 0 or key >= self.getSize(): raise IndexError(key) return self.get(key) def _fixNegativeIndex(self, index): if index < 0: return index + self.getSize() else: return index def __iter__(self): for i in range(self.getSize()): yield self[i] def __repr__(self): return "[" + ", ".join([repr(self[i]) for i in range(len(self))]) + "]" def __str__(self): return repr(self) ListWrapperDate_swigregister = _libsbml.ListWrapperDate_swigregister ListWrapperDate_swigregister(ListWrapperDate) class ListWrapperModelCreator(_object): """Proxy of C++ ListWrapper<(ModelCreator)> class.""" __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, ListWrapperModelCreator, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, ListWrapperModelCreator, name) __repr__ = _swig_repr def __init__(self): """__init__(ListWrapper<(ModelCreator)> self) -> ListWrapperModelCreator""" this = _libsbml.new_ListWrapperModelCreator() try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_ListWrapperModelCreator __del__ = lambda self: None def add(self, item): """add(ListWrapperModelCreator self, ModelCreator item)""" return _libsbml.ListWrapperModelCreator_add(self, item) def get(self, n): """get(ListWrapperModelCreator self, unsigned int n) -> ModelCreator""" return _libsbml.ListWrapperModelCreator_get(self, n) def prepend(self, item): """prepend(ListWrapperModelCreator self, ModelCreator item)""" return _libsbml.ListWrapperModelCreator_prepend(self, item) def remove(self, n): """remove(ListWrapperModelCreator self, unsigned int n) -> ModelCreator""" return _libsbml.ListWrapperModelCreator_remove(self, n) def getSize(self): """getSize(ListWrapperModelCreator self) -> unsigned int""" return _libsbml.ListWrapperModelCreator_getSize(self) def __len__(self): """__len__(ListWrapperModelCreator self) -> int""" return _libsbml.ListWrapperModelCreator___len__(self) def __getitem__(self, key): try: keyIsSlice = isinstance(key, slice) except: keyIsSlice = 0 if keyIsSlice: start = key.start if start is None: start = 0 stop = key.stop if stop is None: stop = self.getSize() return [self[i] for i in range( self._fixNegativeIndex(start), self._fixNegativeIndex(stop) )] key = self._fixNegativeIndex(key) if key < 0 or key >= self.getSize(): raise IndexError(key) return self.get(key) def _fixNegativeIndex(self, index): if index < 0: return index + self.getSize() else: return index def __iter__(self): for i in range(self.getSize()): yield self[i] def __repr__(self): return "[" + ", ".join([repr(self[i]) for i in range(len(self))]) + "]" def __str__(self): return repr(self) ListWrapperModelCreator_swigregister = _libsbml.ListWrapperModelCreator_swigregister ListWrapperModelCreator_swigregister(ListWrapperModelCreator) class ListWrapperSBase(_object): """Proxy of C++ ListWrapper<(SBase)> class.""" __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, ListWrapperSBase, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, ListWrapperSBase, name) __repr__ = _swig_repr def __init__(self): """__init__(ListWrapper<(SBase)> self) -> ListWrapperSBase""" this = _libsbml.new_ListWrapperSBase() try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_ListWrapperSBase __del__ = lambda self: None def add(self, item): """add(ListWrapperSBase self, SBase item)""" return _libsbml.ListWrapperSBase_add(self, item) def get(self, n): """get(ListWrapperSBase self, unsigned int n) -> SBase""" return _libsbml.ListWrapperSBase_get(self, n) def prepend(self, item): """prepend(ListWrapperSBase self, SBase item)""" return _libsbml.ListWrapperSBase_prepend(self, item) def remove(self, n): """remove(ListWrapperSBase self, unsigned int n) -> SBase""" return _libsbml.ListWrapperSBase_remove(self, n) def getSize(self): """getSize(ListWrapperSBase self) -> unsigned int""" return _libsbml.ListWrapperSBase_getSize(self) def __len__(self): """__len__(ListWrapperSBase self) -> int""" return _libsbml.ListWrapperSBase___len__(self) def __getitem__(self, key): try: keyIsSlice = isinstance(key, slice) except: keyIsSlice = 0 if keyIsSlice: start = key.start if start is None: start = 0 stop = key.stop if stop is None: stop = self.getSize() return [self[i] for i in range( self._fixNegativeIndex(start), self._fixNegativeIndex(stop) )] key = self._fixNegativeIndex(key) if key < 0 or key >= self.getSize(): raise IndexError(key) return self.get(key) def _fixNegativeIndex(self, index): if index < 0: return index + self.getSize() else: return index def __iter__(self): for i in range(self.getSize()): yield self[i] def __repr__(self): return "[" + ", ".join([repr(self[i]) for i in range(len(self))]) + "]" def __str__(self): return repr(self) ListWrapperSBase_swigregister = _libsbml.ListWrapperSBase_swigregister ListWrapperSBase_swigregister(ListWrapperSBase) LIBSBML_DOTTED_VERSION = _libsbml.LIBSBML_DOTTED_VERSION LIBSBML_VERSION = _libsbml.LIBSBML_VERSION LIBSBML_VERSION_STRING = _libsbml.LIBSBML_VERSION_STRING def getLibSBMLVersion(): """ getLibSBMLVersion() -> int Returns the version number of this copy of libSBML as an integer. Returns the libSBML version as an integer; version 1.2.3 becomes 10203. """ return _libsbml.getLibSBMLVersion() def getLibSBMLDottedVersion(): """ getLibSBMLDottedVersion() -> char const * Returns the version number of this copy of libSBML as a string. Returns the libSBML version as a string; version 1.2.3 becomes '1.2.3'. See also getLibSBMLVersionString(). """ return _libsbml.getLibSBMLDottedVersion() def getLibSBMLVersionString(): """ getLibSBMLVersionString() -> char const * Returns the version number of this copy of libSBML as a string without periods. Returns the libSBML version as a string: version 1.2.3 becomes '10203'. See also getLibSBMLDottedVersion(). """ return _libsbml.getLibSBMLVersionString() def isLibSBMLCompiledWith(option): """ isLibSBMLCompiledWith(char const * option) -> int Returns an indication whether libSBML has been compiled with against a specific library. Parameter 'option' is the library to test against, this can be one of 'expat', 'libxml', 'xerces-c', 'bzip2', 'zip' Returns 0 in case the libSBML has not been compiled against that library and non-zero otherwise (for libraries that define an integer version number that number will be returned). See also getLibSBMLDependencyVersionOf(). """ return _libsbml.isLibSBMLCompiledWith(option) def getLibSBMLDependencyVersionOf(option): """ getLibSBMLDependencyVersionOf(char const * option) -> char const * Returns the version string for the dependency library used. Parameter 'option' is the library for which the version should be retrieved, this can be one of 'expat', 'libxml', 'xerces-c', 'bzip2', 'zip' Returns None in case libSBML has not been compiled against that library and a version string otherwise. See also isLibSBMLCompiledWith(). """ return _libsbml.getLibSBMLDependencyVersionOf(option) LIBSBML_OPERATION_SUCCESS = _libsbml.LIBSBML_OPERATION_SUCCESS LIBSBML_INDEX_EXCEEDS_SIZE = _libsbml.LIBSBML_INDEX_EXCEEDS_SIZE LIBSBML_UNEXPECTED_ATTRIBUTE = _libsbml.LIBSBML_UNEXPECTED_ATTRIBUTE LIBSBML_OPERATION_FAILED = _libsbml.LIBSBML_OPERATION_FAILED LIBSBML_INVALID_ATTRIBUTE_VALUE = _libsbml.LIBSBML_INVALID_ATTRIBUTE_VALUE LIBSBML_INVALID_OBJECT = _libsbml.LIBSBML_INVALID_OBJECT LIBSBML_DUPLICATE_OBJECT_ID = _libsbml.LIBSBML_DUPLICATE_OBJECT_ID LIBSBML_LEVEL_MISMATCH = _libsbml.LIBSBML_LEVEL_MISMATCH LIBSBML_VERSION_MISMATCH = _libsbml.LIBSBML_VERSION_MISMATCH LIBSBML_INVALID_XML_OPERATION = _libsbml.LIBSBML_INVALID_XML_OPERATION LIBSBML_NAMESPACES_MISMATCH = _libsbml.LIBSBML_NAMESPACES_MISMATCH LIBSBML_DUPLICATE_ANNOTATION_NS = _libsbml.LIBSBML_DUPLICATE_ANNOTATION_NS LIBSBML_ANNOTATION_NAME_NOT_FOUND = _libsbml.LIBSBML_ANNOTATION_NAME_NOT_FOUND LIBSBML_ANNOTATION_NS_NOT_FOUND = _libsbml.LIBSBML_ANNOTATION_NS_NOT_FOUND LIBSBML_MISSING_METAID = _libsbml.LIBSBML_MISSING_METAID LIBSBML_DEPRECATED_ATTRIBUTE = _libsbml.LIBSBML_DEPRECATED_ATTRIBUTE LIBSBML_USE_ID_ATTRIBUTE_FUNCTION = _libsbml.LIBSBML_USE_ID_ATTRIBUTE_FUNCTION LIBSBML_PKG_VERSION_MISMATCH = _libsbml.LIBSBML_PKG_VERSION_MISMATCH LIBSBML_PKG_UNKNOWN = _libsbml.LIBSBML_PKG_UNKNOWN LIBSBML_PKG_UNKNOWN_VERSION = _libsbml.LIBSBML_PKG_UNKNOWN_VERSION LIBSBML_PKG_DISABLED = _libsbml.LIBSBML_PKG_DISABLED LIBSBML_PKG_CONFLICTED_VERSION = _libsbml.LIBSBML_PKG_CONFLICTED_VERSION LIBSBML_PKG_CONFLICT = _libsbml.LIBSBML_PKG_CONFLICT LIBSBML_CONV_INVALID_TARGET_NAMESPACE = _libsbml.LIBSBML_CONV_INVALID_TARGET_NAMESPACE LIBSBML_CONV_PKG_CONVERSION_NOT_AVAILABLE = _libsbml.LIBSBML_CONV_PKG_CONVERSION_NOT_AVAILABLE LIBSBML_CONV_INVALID_SRC_DOCUMENT = _libsbml.LIBSBML_CONV_INVALID_SRC_DOCUMENT LIBSBML_CONV_CONVERSION_NOT_AVAILABLE = _libsbml.LIBSBML_CONV_CONVERSION_NOT_AVAILABLE LIBSBML_CONV_PKG_CONSIDERED_UNKNOWN = _libsbml.LIBSBML_CONV_PKG_CONSIDERED_UNKNOWN def OperationReturnValue_toString(returnValue): """ OperationReturnValue_toString(int returnValue) -> char const * This method takes an SBML operation return value and returns a string representing the code. Parameter 'returnValue' is the operation return value to convert to a string. Returns a human readable name for the given operation return value . Note: The caller does not own the returned string and is therefore not allowed to modify it. """ return _libsbml.OperationReturnValue_toString(returnValue) class IdList(_object): """ Internal implementation method. """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, IdList, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, IdList, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(IdList self) -> IdList __init__(IdList self, string commaSeparated) -> IdList Internal implementation method. """ this = _libsbml.new_IdList(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def append(self, id): """ append(IdList self, string id) Internal implementation method. """ return _libsbml.IdList_append(self, id) def contains(self, id): """ contains(IdList self, string id) -> bool Internal implementation method. """ return _libsbml.IdList_contains(self, id) def empty(self): """ empty(IdList self) -> bool Internal implementation method. """ return _libsbml.IdList_empty(self) def removeIdsBefore(self, id): """ removeIdsBefore(IdList self, string id) Internal implementation method. """ return _libsbml.IdList_removeIdsBefore(self, id) def size(self): """ size(IdList self) -> unsigned int Internal implementation method. """ return _libsbml.IdList_size(self) def clear(self): """clear(IdList self)""" return _libsbml.IdList_clear(self) def at(self, n): """at(IdList self, int n) -> string""" return _libsbml.IdList_at(self, n) __swig_destroy__ = _libsbml.delete_IdList __del__ = lambda self: None IdList_swigregister = _libsbml.IdList_swigregister IdList_swigregister(IdList) class IdentifierTransformer(_object): """ Internal implementation method. """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, IdentifierTransformer, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, IdentifierTransformer, name) __repr__ = _swig_repr def __init__(self): """ __init__(IdentifierTransformer self) -> IdentifierTransformer Internal implementation method. """ if self.__class__ == IdentifierTransformer: _self = None else: _self = self this = _libsbml.new_IdentifierTransformer(_self, ) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_IdentifierTransformer __del__ = lambda self: None def transform(self, element): """transform(IdentifierTransformer self, SBase element) -> int""" return _libsbml.IdentifierTransformer_transform(self, element) def __disown__(self): self.this.disown() _libsbml.disown_IdentifierTransformer(self) return weakref_proxy(self) IdentifierTransformer_swigregister = _libsbml.IdentifierTransformer_swigregister IdentifierTransformer_swigregister(IdentifierTransformer) class ElementFilter(_object): """ Base class for filter functions. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. It is a class used in the implementation of extra functionality provided by libSBML. Some libSBML objects provide the ability to return lists of components. To provide callers with greater control over exactly what is returned, these methods take optional arguments in the form of filters. The ElementFilter class is the parent class for these filters. """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, ElementFilter, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, ElementFilter, name) __repr__ = _swig_repr def __init__(self): """ __init__(ElementFilter self) -> ElementFilter Creates a new ElementFilter object. """ if self.__class__ == ElementFilter: _self = None else: _self = self this = _libsbml.new_ElementFilter(_self, ) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_ElementFilter __del__ = lambda self: None def filter(self, element): """ filter(ElementFilter self, SBase element) -> bool Predicate to test elements. This is the central predicate of the ElementFilter class. In subclasses of ElementFilter, callers should implement this method such that it returns 'True' for 'element' arguments that are 'desirable' and 'False' for those that are 'undesirable' in whatever filtering context the ElementFilter subclass is designed to be used. Parameter 'element' is the element to be tested. Returns 'True' if the 'element' is desirable or should be kept, 'False' otherwise. """ return _libsbml.ElementFilter_filter(self, element) def __disown__(self): self.this.disown() _libsbml.disown_ElementFilter(self) return weakref_proxy(self) ElementFilter_swigregister = _libsbml.ElementFilter_swigregister ElementFilter_swigregister(ElementFilter) class SBMLReader(_object): """ File and text-string SBML reader. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. The SBMLReader class provides the main interface for reading SBML content from files and strings. The methods for reading SBML all return an SBMLDocument object representing the results. In the case of failures (such as if the SBML contains errors or a file cannot be read), the errors will be recorded with the SBMLErrorLog object kept in the SBMLDocument returned by SBMLReader. Consequently, immediately after calling a method on SBMLReader, callers should always check for errors and warnings using the methods for this purpose provided by SBMLDocument. For convenience as well as easy access from other languages besides C++, this file also defines two global functions, @sbmlglobalfunction{readSBML, String} and @sbmlglobalfunction{readSBMLFromString, String}. They are equivalent to creating an SBMLReader object and then calling the SBMLReader.readSBML() and SBMLReader.readSBMLFromString() methods, respectively. Support for reading compressed files ====================================================================== LibSBML provides support for reading (as well as writing) compressed SBML files. The process is transparent to the calling application--- the application does not need to do anything deliberate to invoke the functionality. If a given SBML filename ends with an extension for the gzip, zip or bzip2 compression formats (respectively, '.gz,' '.zip,' or '.bz2),' then the methods SBMLReader.readSBML() and SBMLWriter.writeSBML() will automatically decompress and compress the file while reading and writing it. If the filename has no such extension, it will be read and written uncompressed as normal. The compression feature requires that the zlib (for gzip and zip formats) and/or bzip2 (for bzip2 format) be available on the system running libSBML, and that libSBML was configured with their support compiled-in. Please see the libSBML installation instructions for more information about this. The methods hasZlib() and hasBzip2() can be used by an application to query at run-time whether support for the compression libraries is available in the present copy of libSBML. Support for compression is not mandated by the SBML standard, but applications may find it helpful, particularly when large SBML models are being communicated across data links of limited bandwidth. """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLReader, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, SBMLReader, name) __repr__ = _swig_repr def __init__(self): """ __init__(SBMLReader self) -> SBMLReader Creates a new SBMLReader object and returns it. The libSBML SBMLReader object offers methods for reading SBML in XML form from files and text strings. """ this = _libsbml.new_SBMLReader() try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_SBMLReader __del__ = lambda self: None def readSBML(*args): """ readSBML(self, string filename) -> SBMLDocument Reads an SBML document from a file. This method is identical to readSBMLFromFile(). If the file named 'filename' does not exist or its content is not valid SBML, one or more errors will be logged with the SBMLDocument object returned by this method. Callers can use the methods on SBMLDocument such as SBMLDocument.getNumErrors() and SBMLDocument.getError() to get the errors. The object returned by SBMLDocument.getError() is an SBMLError object, and it has methods to get the error code, category, and severity level of the problem, as well as a textual description of the problem. The possible severity levels range from informational messages to fatal errors; see the documentation for SBMLError for more information. If the file 'filename' could not be read, the file-reading error will appear first. The error code can provide a clue about what happened. For example, a file might be unreadable (either because it does not actually exist or because the user does not have the necessary access priviledges to read it) or some sort of file operation error may have been reported by the underlying operating system. Callers can check for these situations using a program fragment such as the following: reader = SBMLReader() doc = reader.readSBML(filename) if doc.getNumErrors() > 0: if doc.getError(0).getErrorId() == libsbml.XMLFileUnreadable: # Handle case of unreadable file here. elif doc.getError(0).getErrorId() == libsbml.XMLFileOperationError: # Handle case of other file error here. else: # Handle other error cases here. If the given filename ends with the suffix \".gz\" (for example, \"myfile.xml.gz\"), the file is assumed to be compressed in gzip format and will be automatically decompressed upon reading. Similarly, if the given filename ends with \".zip\" or \".bz2\", the file is assumed to be compressed in zip or bzip2 format (respectively). Files whose names lack these suffixes will be read uncompressed. Note that if the file is in zip format but the archive contains more than one file, only the first file in the archive will be read and the rest ignored. To read a gzip/zip file, libSBML needs to be configured and linked with the zlib library at compile time. It also needs to be linked with the bzip2 library to read files in bzip2 format. (Both of these are the default configurations for libSBML.) Errors about unreadable files will be logged if a compressed filename is given and libSBML was not linked with the corresponding required library. Parameter 'filename is the name or full pathname of the file to be read. Returns a pointer to the SBMLDocument created from the SBML content. See also SBMLError. Note: LibSBML versions 2.x and later versions behave differently in error handling in several respects. One difference is how early some errors are caught and whether libSBML continues processing a file in the face of some early errors. In general, libSBML versions after 2.x stop parsing SBML inputs sooner than libSBML version 2.x in the face of XML errors, because the errors may invalidate any further SBML content. For example, a missing XML declaration at the beginning of the file was ignored by libSBML 2.x but in version 3.x and later, it will cause libSBML to stop parsing the rest of the input altogether. While this behavior may seem more severe and intolerant, it was necessary in order to provide uniform behavior regardless of which underlying XML parser (Expat, Xerces, libxml2) is being used by libSBML. The XML parsers themselves behave differently in their error reporting, and sometimes libSBML has to resort to the lowest common denominator. """ args_copy = list(args) args_copy[1] = conditional_abspath(args[1]) return _libsbml.SBMLReader_readSBML(*args_copy) def readSBMLFromFile(*args): """ Reads an SBML document from the given file. If the file named 'filename' does not exist or its content is not valid SBML, one or more errors will be logged with the SBMLDocument object returned by this method. Callers can use the methods on SBMLDocument such as SBMLDocument.getNumErrors() and SBMLDocument.getError() to get the errors. The object returned by SBMLDocument.getError() is an SBMLError object, and it has methods to get the error code, category, and severity level of the problem, as well as a textual description of the problem. The possible severity levels range from informational messages to fatal errors; see the documentation for SBMLError for more information. If the file 'filename' could not be read, the file-reading error will appear first. The error code can provide a clue about what happened. For example, a file might be unreadable (either because it does not actually exist or because the user does not have the necessary access priviledges to read it) or some sort of file operation error may have been reported by the underlying operating system. Callers can check for these situations using a program fragment such as the following: reader = SBMLReader() if reader == None: # Handle the truly exceptional case of no object created here. doc = reader.readSBMLFromFile(filename) if doc.getNumErrors() > 0: if doc.getError(0).getErrorId() == XMLFileUnreadable: # Handle case of unreadable file here. elif doc.getError(0).getErrorId() == XMLFileOperationError: # Handle case of other file error here. else: # Handle other error cases here. If the given filename ends with the suffix '.gz' (for example, 'myfile.xml.gz'), the file is assumed to be compressed in gzip format and will be automatically decompressed upon reading. Similarly, if the given filename ends with '.zip' or '.bz2', the file is assumed to be compressed in zip or bzip2 format (respectively). Files whose names lack these suffixes will be read uncompressed. Note that if the file is in zip format but the archive contains more than one file, only the first file in the archive will be read and the rest ignored. To read a gzip/zip file, libSBML needs to be configured and linked with the zlib library at compile time. It also needs to be linked with the bzip2 library to read files in bzip2 format. (Both of these are the default configurations for libSBML.) Errors about unreadable files will be logged if a compressed filename is given and libSBML was not linked with the corresponding required library. Parameter 'filename' is the name or full pathname of the file to be read. Returns a pointer to the SBMLDocument structure created from the SBML content in 'filename'. """ args_copy = list(args) args_copy[1] = conditional_abspath(args[1]) return _libsbml.SBMLReader_readSBML(*args_copy) def readSBMLFromString(self, xml): """ readSBMLFromString(SBMLReader self, string xml) -> SBMLDocument Reads an SBML document from a text string. This method is flexible with respect to the presence of an XML declaration at the beginning of the string. In particular, if the string in 'xml' does not begin with the XML declaration then this method will automatically prepend the declaration to 'xml'. This method will log a fatal error if the content given in the parameter 'xml' is not in SBML format. See the method documentation for SBMLReader.readSBML() for an example of code for testing the returned error code. Parameter 'xml' is a string containing a full SBML model. Returns a pointer to the SBMLDocument created from the SBML content, or a null pointer if 'xml' is 'None.' Note: When using this method to read an SBMLDocument that uses the SBML Level 3 Hierarchical Model Composition package (comp) the document location cannot be set automatically. Thus, if the model contains references to ExternalModelDefinition objects, it will be necessary to manually set the document URI location (SBMLDocument.setLocationURI() ) in order to facilitate resolving these models. See also SBMLReader.readSBML(). """ return _libsbml.SBMLReader_readSBMLFromString(self, xml) def hasZlib(): """ hasZlib() -> bool Static method; returns 'True' if this copy of libSBML supports gzip and zip format compression. Returns 'True' if libSBML has been linked with the zlib library, 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also SBMLReader.hasBzip2(). """ return _libsbml.SBMLReader_hasZlib() hasZlib = staticmethod(hasZlib) def hasBzip2(): """ hasBzip2() -> bool Static method; returns 'True' if this copy of libSBML supports bzip2 format compression. Returns 'True' if libSBML is linked with the bzip2 libraries, 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also SBMLReader.hasZlib(). """ return _libsbml.SBMLReader_hasBzip2() hasBzip2 = staticmethod(hasBzip2) def __eq__(self, rhs): if ((self is None) and (rhs is None)): return True if ((self is None) or (rhs is None)): return False if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return True return False def __ne__(self, rhs): if ((self is None) and (rhs is None)): return False if ((self is None) or (rhs is None)): return True if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return False return True SBMLReader_swigregister = _libsbml.SBMLReader_swigregister SBMLReader_swigregister(SBMLReader) def SBMLReader_hasZlib(): """ SBMLReader_hasZlib() -> bool Static method; returns 'True' if this copy of libSBML supports gzip and zip format compression. Returns 'True' if libSBML has been linked with the zlib library, 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also SBMLReader.hasBzip2(). """ return _libsbml.SBMLReader_hasZlib() def SBMLReader_hasBzip2(): """ SBMLReader_hasBzip2() -> bool Static method; returns 'True' if this copy of libSBML supports bzip2 format compression. Returns 'True' if libSBML is linked with the bzip2 libraries, 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also SBMLReader.hasZlib(). """ return _libsbml.SBMLReader_hasBzip2() def readSBMLFromFile(filename): """ readSBMLFromFile(char const * filename) -> SBMLDocument Reads an SBML document from the given file. If the file named 'filename' does not exist or its content is not valid SBML, one or more errors will be logged with the SBMLDocument object returned by this method. Callers can use the methods on SBMLDocument such as SBMLDocument.getNumErrors(), SBMLDocument.getNumErrors() and SBMLDocument.getError() to get the errors. The object returned by SBMLDocument.getError() is an SBMLError object, and it has methods to get the error code, category, and severity level of the problem, as well as a textual description of the problem. The possible severity levels range from informational messages to fatal errors; see the documentation for SBMLError for more information. If the file 'filename' could not be read, the file-reading error will appear first. The error code can provide a clue about what happened. For example, a file might be unreadable (either because it does not actually exist or because the user does not have the necessary access privileges to read it) or some sort of file operation error may have been reported by the underlying operating system. Callers can check for these situations using a program fragment such as the following: reader = SBMLReader() if reader == None: # Handle the truly exceptional case of no object created here. doc = reader.readSBMLFromFile(filename) if doc.getNumErrors() > 0: if doc.getError(0).getErrorId() == XMLFileUnreadable: # Handle case of unreadable file here. elif doc.getError(0).getErrorId() == XMLFileOperationError: # Handle case of other file error here. else: # Handle other error cases here. If the given filename ends with the suffix ''.gz'' (for example, ''myfile.xml.gz'),' the file is assumed to be compressed in gzip format and will be automatically decompressed upon reading. Similarly, if the given filename ends with ''.zip'' or ''.bz2',' the file is assumed to be compressed in zip or bzip2 format (respectively). Files whose names lack these suffixes will be read uncompressed. Note that if the file is in zip format but the archive contains more than one file, only the first file in the archive will be read and the rest ignored. To read a gzip/zip file, libSBML needs to be configured and linked with the zlib library at compile time. It also needs to be linked with the bzip2 library to read files in bzip2 format. (Both of these are the default configurations for libSBML.) Errors about unreadable files will be logged if a compressed filename is given and libSBML was not linked with the corresponding required library. Parameter 'filename' is the name or full pathname of the file to be read. Returns a pointer to the SBMLDocument structure created from the SBML content in 'filename'. """ return _libsbml.readSBMLFromFile(filename) def readSBMLFromString(xml): """ readSBMLFromString(char const * xml) -> SBMLDocument Reads an SBML document from a text string. This method is flexible with respect to the presence of an XML declaration at the beginning of the string. In particular, if the string in 'xml' does not begin with the XML declaration then this method will automatically prepend the declaration to 'xml'. This method will log a fatal error if the content given in the parameter 'xml' is not in SBML format. See the method documentation for SBMLReader.readSBML() for an example of code for testing the returned error code. Parameter 'xml' is a string containing a full SBML model. Returns a pointer to the SBMLDocument structure created from the SBML content in 'xml'. Note: When using this method to read an SBMLDocument that uses the SBML Level 3 Hierarchical Model Composition package (comp) the document location cannot be set automatically. Thus, if the model contains references to ExternalModelDefinition objects, it will be necessary to manually set the document URI location (SBMLDocument.setLocationURI() ) in order to facilitate resolving these models. """ return _libsbml.readSBMLFromString(xml) class SBMLWriter(_object): """ File and text-string SBML writer. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. The SBMLWriter class is the converse of SBMLReader, and provides the main interface for serializing SBML models into XML and writing the result to an output stream or to files and text strings. The methods for writing SBML all take an SBMLDocument object and a destination. They return a boolean or integer value to indicate success or failure. Support for writing compressed files ====================================================================== LibSBML provides support for writing (as well as reading) compressed SBML files. The process is transparent to the calling application--- the application does not need to do anything deliberate to invoke the functionality. If a given SBML filename ends with an extension for the gzip, zip or bzip2 compression formats (respectively, ".gz", ".zip", or ".bz2"), then the methods SBMLWriter.writeSBML() and SBMLReader.readSBML() will automatically compress and decompress the file while writing and reading it. If the filename has no such extension, it will be written and read uncompressed as normal. The compression feature requires that the zlib (for gzip and zip formats) and/or bzip2 (for bzip2 format) be available on the system running libSBML, and that libSBML was configured with their support compiled-in. Please see the libSBML installation instructions for more information about this. The methods SBMLWriter.hasZlib() and SBMLWriter.hasBzip2() can be used by an application to query at run- time whether support for the compression libraries is available in the present copy of libSBML. Support for compression is not mandated by the SBML standard, but applications may find it helpful, particularly when large SBML models are being communicated across data links of limited bandwidth. """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLWriter, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, SBMLWriter, name) __repr__ = _swig_repr def __init__(self): """ __init__(SBMLWriter self) -> SBMLWriter Creates a new SBMLWriter. The libSBML SBMLWriter objects offer methods for writing SBML in XML form to files and text strings. """ this = _libsbml.new_SBMLWriter() try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_SBMLWriter __del__ = lambda self: None def setProgramName(self, name): """ setProgramName(SBMLWriter self, string name) -> int Sets the name of this program, i.e., the program that is about to write out the SBMLDocument. If the program name and version are set (see SBMLWriter.setProgramVersion()), the following XML comment, intended for human consumption, will be written at the beginning of the XML document: If the program name and version are not set at some point before calling the writeSBML() methods, no such comment is written out. Parameter 'name' is the name of this program (where 'this program' refers to program in which libSBML is embedded, not libSBML itself!) Returns integer value indicating success/failure of the function. This particular function only does one thing irrespective of user input or object state, and thus will only return a single value: * LIBSBML_OPERATION_SUCCESS See also setProgramVersion(). """ return _libsbml.SBMLWriter_setProgramName(self, name) def setProgramVersion(self, version): """ setProgramVersion(SBMLWriter self, string version) -> int Sets the version of this program, i.e., the program that is about to write out the SBMLDocument. If the program version and name are set (see SBMLWriter.setProgramName()), the following XML comment, intended for human consumption, will be written at the beginning of the document: If the program version and name are not set at some point before calling the writeSBML() methods, no such comment is written out. Parameter 'version' is the version of this program (where 'this program' refers to program in which libSBML is embedded, not libSBML itself!) Returns integer value indicating success/failure of the function. This particular function only does one thing irrespective of user input or object state, and thus will only return a single value: * LIBSBML_OPERATION_SUCCESS See also setProgramName(). """ return _libsbml.SBMLWriter_setProgramVersion(self, version) def writeSBML(self, *args): """ writeSBML(SBMLWriter self, SBMLDocument d, string filename) -> bool writeSBML(SBMLWriter self, SBMLDocument d, ostream stream) -> bool This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: writeSBML(SBMLDocument d, string filename) Writes the given SBML document to filename. If the given filename ends with the suffix ".gz" (for example, "myfile.xml.gz"), libSBML assumes the caller wants the file to be written compressed in gzip format. Similarly, if the given filename ends with ".zip" or ".bz2", libSBML assumes the caller wants the file to be compressed in zip or bzip2 format (respectively). Files whose names lack these suffixes will be written uncompressed. Special considerations for the zip format: If the given filename ends with ".zip", the file placed in the zip archive will have the suffix ".xml" or ".sbml". For example, the file in the zip archive will be named "test.xml" if the given filename is "test.xml.zip" or "test.zip". Similarly, the filename in the archive will be "test.sbml" if the given filename is "test.sbml.zip". Parameter 'd' is the SBML document to be written. Parameter 'filename' is the name or full pathname of the file where the SBML is to be written. Returns 'True' on success and 'False' if the filename could not be opened for writing. Note: To write a gzip/zip file, libSBML needs to be configured and linked with the zlib library at compile time. It also needs to be linked with the bzip2 library to write files in bzip2 format. (Both of these are the default configurations for libSBML.) Errors about unreadable files will be logged and this method will return false if a compressed filename is given and libSBML was not linked with the corresponding required library. See also setProgramVersion(), setProgramName(). ______________________________________________________________________ Method variant with the following signature: writeSBML(SBMLDocument d, std::ostream stream) Writes the given SBML document to the output stream. Parameter 'd' is the SBML document to be written. Parameter 'stream' is the stream object where the SBML is to be written. Returns 'True' on success and 'False' if one of the underlying parser components fail (rare). See also setProgramVersion(), setProgramName(). """ return _libsbml.SBMLWriter_writeSBML(self, *args) def writeToString(self, d): """ writeToString(SBMLWriter self, SBMLDocument d) -> char * Internal implementation method. """ return _libsbml.SBMLWriter_writeToString(self, d) def writeSBMLToFile(self, d, filename): """ writeSBMLToFile(SBMLWriter self, SBMLDocument d, string filename) -> bool Writes the given SBML document to filename. If the given filename ends with the suffix ".gz" (for example, "myfile.xml.gz"), libSBML assumes the caller wants the file to be written compressed in gzip format. Similarly, if the given filename ends with ".zip" or ".bz2", libSBML assumes the caller wants the file to be compressed in zip or bzip2 format (respectively). Files whose names lack these suffixes will be written uncompressed. Special considerations for the zip format: If the given filename ends with ".zip", the file placed in the zip archive will have the suffix ".xml" or ".sbml". For example, the file in the zip archive will be named "test.xml" if the given filename is "test.xml.zip" or "test.zip". Similarly, the filename in the archive will be "test.sbml" if the given filename is "test.sbml.zip". Parameter 'd' is the SBML document to be written. Parameter 'filename' is the name or full pathname of the file where the SBML is to be written. Returns 'True' on success and 'False' if the filename could not be opened for writing. Note: To write a gzip/zip file, libSBML needs to be configured and linked with the zlib library at compile time. It also needs to be linked with the bzip2 library to write files in bzip2 format. (Both of these are the default configurations for libSBML.) Errors about unreadable files will be logged and this method will return false if a compressed filename is given and libSBML was not linked with the corresponding required library. See also setProgramVersion(), setProgramName(). """ return _libsbml.SBMLWriter_writeSBMLToFile(self, d, filename) def writeSBMLToString(self, d): """ writeSBMLToString(SBMLWriter self, SBMLDocument d) -> char * Writes the given SBML document to an in-memory string and returns a pointer to it. The string is owned by the caller and should be freed (with 'free())' when no longer needed. Parameter 'd' is the SBML document to be written. Returns the string on success and '0' if one of the underlying parser components fail. See also setProgramVersion(), setProgramName(). """ return _libsbml.SBMLWriter_writeSBMLToString(self, d) def hasZlib(): """ hasZlib() -> bool Predicate returning 'True' if this copy of libSBML has been linked with the zlib library. LibSBML supports reading and writing files compressed with either bzip2 or zip/gzip compression. The facility depends on libSBML having been compiled with the necessary support libraries. This method allows a calling program to inquire whether that is the case for the copy of libSBML it is using. Returns 'True' if libSBML is linked with zlib, 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also SBMLWriter.hasBzip2() . """ return _libsbml.SBMLWriter_hasZlib() hasZlib = staticmethod(hasZlib) def hasBzip2(): """ hasBzip2() -> bool Predicate returning 'True' if this copy of libSBML has been linked with the bzip2 library. LibSBML supports reading and writing files compressed with either bzip2 or zip/gzip compression. The facility depends on libSBML having been compiled with the necessary support libraries. This method allows a calling program to inquire whether that is the case for the copy of libSBML it is using. Returns 'True' if libSBML is linked with bzip2, 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also SBMLWriter.hasZlib() . """ return _libsbml.SBMLWriter_hasBzip2() hasBzip2 = staticmethod(hasBzip2) def __eq__(self, rhs): if ((self is None) and (rhs is None)): return True if ((self is None) or (rhs is None)): return False if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return True return False def __ne__(self, rhs): if ((self is None) and (rhs is None)): return False if ((self is None) or (rhs is None)): return True if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return False return True SBMLWriter_swigregister = _libsbml.SBMLWriter_swigregister SBMLWriter_swigregister(SBMLWriter) def SBMLWriter_hasZlib(): """ SBMLWriter_hasZlib() -> bool Predicate returning 'True' if this copy of libSBML has been linked with the zlib library. LibSBML supports reading and writing files compressed with either bzip2 or zip/gzip compression. The facility depends on libSBML having been compiled with the necessary support libraries. This method allows a calling program to inquire whether that is the case for the copy of libSBML it is using. Returns 'True' if libSBML is linked with zlib, 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also SBMLWriter.hasBzip2() . """ return _libsbml.SBMLWriter_hasZlib() def SBMLWriter_hasBzip2(): """ SBMLWriter_hasBzip2() -> bool Predicate returning 'True' if this copy of libSBML has been linked with the bzip2 library. LibSBML supports reading and writing files compressed with either bzip2 or zip/gzip compression. The facility depends on libSBML having been compiled with the necessary support libraries. This method allows a calling program to inquire whether that is the case for the copy of libSBML it is using. Returns 'True' if libSBML is linked with bzip2, 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also SBMLWriter.hasZlib() . """ return _libsbml.SBMLWriter_hasBzip2() def writeSBML(d, filename): """ writeSBML(SBMLDocument d, char const * filename) -> int Writes the given SBML document 'd' to the file named by 'filename'. This convenience function is functionally equivalent to: SBMLWriter_writeSBML(SBMLWriter_create(), d, filename); If the given filename ends with the suffix ".gz" (for example, "myfile.xml.gz"), libSBML assumes the caller wants the file to be written compressed in gzip format. Similarly, if the given filename ends with ".zip" or ".bz2", libSBML assumes the caller wants the file to be compressed in zip or bzip2 format (respectively). Files whose names lack these suffixes will be written uncompressed. Special considerations for the zip format: If the given filename ends with ".zip", the file placed in the zip archive will have the suffix ".xml" or ".sbml". For example, the file in the zip archive will be named "test.xml" if the given filename is "test.xml.zip" or "test.zip". Similarly, the filename in the archive will be "test.sbml" if the given filename is "test.sbml.zip". Parameter 'd' is the SBMLDocument object to be written out in XML format. Parameter 'filename' is a string giving the path to a file where the XML content is to be written. Returns '1' (true) on success and '0' (false) if 'filename' could not be written. Some possible reasons for failure include (a) being unable to open the file, and (b) using a filename that indicates a compressed SBML file (i.e., a filename ending in ".zip" or similar) when the compression functionality has not been enabled in the underlying copy of libSBML. See also SBMLWriter.hasZlib(), SBMLWriter.hasBzip2(). """ return _libsbml.writeSBML(d, filename) def writeSBMLToString(d): """ writeSBMLToString(SBMLDocument d) -> char * Writes the given SBML document 'd' to an in-memory string and returns a pointer to it. The string is owned by the caller and should be freed (with free()) when no longer needed. This convenience function is functionally equivalent to: SBMLWriter_writeSBMLToString(SBMLWriter_create(), d); but does not require the caller to create an SBMLWriter object first. Parameter 'd' is an SBMLDocument object to be written out in XML format. Returns the string on success and 'None' if one of the underlying parser components fail. """ return _libsbml.writeSBMLToString(d) def writeSBMLToFile(d, filename): """ writeSBMLToFile(SBMLDocument d, char const * filename) -> int Writes the given SBML document 'd' to the file 'filename'. This convenience function is functionally equivalent to: SBMLWriter_writeSBMLToFile(SBMLWriter_create(), d, filename); but that does not require the caller to create an SBMLWriter object first. If the given filename ends with the suffix ".gz" (for example, "myfile.xml.gz"), libSBML assumes the caller wants the file to be written compressed in gzip format. Similarly, if the given filename ends with ".zip" or ".bz2", libSBML assumes the caller wants the file to be compressed in zip or bzip2 format (respectively). Files whose names lack these suffixes will be written uncompressed. Special considerations for the zip format: If the given filename ends with ".zip", the file placed in the zip archive will have the suffix ".xml" or ".sbml". For example, the file in the zip archive will be named "test.xml" if the given filename is "test.xml.zip" or "test.zip". Similarly, the filename in the archive will be "test.sbml" if the given filename is "test.sbml.zip". Parameter 'd' is an SBMLDocument object to be written out in XML format. Parameter 'filename' is a string giving the path to a file where the XML content is to be written. Returns '1' (true) on success and '0' (false) if 'filename' could not be written. Some possible reasons for failure include (a) being unable to open the file, and (b) using a filename that indicates a compressed SBML file (i.e., a filename ending in ".zip" or similar) when the compression functionality has not been enabled in the underlying copy of libSBML. See also SBMLWriter.hasZlib(), SBMLWriter.hasBzip2(). """ return _libsbml.writeSBMLToFile(d, filename) SBML_UNKNOWN = _libsbml.SBML_UNKNOWN SBML_COMPARTMENT = _libsbml.SBML_COMPARTMENT SBML_COMPARTMENT_TYPE = _libsbml.SBML_COMPARTMENT_TYPE SBML_CONSTRAINT = _libsbml.SBML_CONSTRAINT SBML_DOCUMENT = _libsbml.SBML_DOCUMENT SBML_EVENT = _libsbml.SBML_EVENT SBML_EVENT_ASSIGNMENT = _libsbml.SBML_EVENT_ASSIGNMENT SBML_FUNCTION_DEFINITION = _libsbml.SBML_FUNCTION_DEFINITION SBML_INITIAL_ASSIGNMENT = _libsbml.SBML_INITIAL_ASSIGNMENT SBML_KINETIC_LAW = _libsbml.SBML_KINETIC_LAW SBML_LIST_OF = _libsbml.SBML_LIST_OF SBML_MODEL = _libsbml.SBML_MODEL SBML_PARAMETER = _libsbml.SBML_PARAMETER SBML_REACTION = _libsbml.SBML_REACTION SBML_RULE = _libsbml.SBML_RULE SBML_SPECIES = _libsbml.SBML_SPECIES SBML_SPECIES_REFERENCE = _libsbml.SBML_SPECIES_REFERENCE SBML_SPECIES_TYPE = _libsbml.SBML_SPECIES_TYPE SBML_MODIFIER_SPECIES_REFERENCE = _libsbml.SBML_MODIFIER_SPECIES_REFERENCE SBML_UNIT_DEFINITION = _libsbml.SBML_UNIT_DEFINITION SBML_UNIT = _libsbml.SBML_UNIT SBML_ALGEBRAIC_RULE = _libsbml.SBML_ALGEBRAIC_RULE SBML_ASSIGNMENT_RULE = _libsbml.SBML_ASSIGNMENT_RULE SBML_RATE_RULE = _libsbml.SBML_RATE_RULE SBML_SPECIES_CONCENTRATION_RULE = _libsbml.SBML_SPECIES_CONCENTRATION_RULE SBML_COMPARTMENT_VOLUME_RULE = _libsbml.SBML_COMPARTMENT_VOLUME_RULE SBML_PARAMETER_RULE = _libsbml.SBML_PARAMETER_RULE SBML_TRIGGER = _libsbml.SBML_TRIGGER SBML_DELAY = _libsbml.SBML_DELAY SBML_STOICHIOMETRY_MATH = _libsbml.SBML_STOICHIOMETRY_MATH SBML_LOCAL_PARAMETER = _libsbml.SBML_LOCAL_PARAMETER SBML_PRIORITY = _libsbml.SBML_PRIORITY SBML_GENERIC_SBASE = _libsbml.SBML_GENERIC_SBASE def SBMLTypeCode_toString(tc, pkgName): """ SBMLTypeCode_toString(int tc, char const * pkgName) -> char const * This method takes an SBML type code and returns a string representing the code. LibSBML attaches an identifying code to every kind of SBML object. These are known as SBML type codes. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. The names of the type codes all begin with the characters 'SBML_.' Returns a human readable name for the given SBML type code. Note: The caller does not own the returned string and is therefore not allowed to modify it. """ return _libsbml.SBMLTypeCode_toString(tc, pkgName) class SBase(_object): """ SBML's SBase class, base class of most SBML objects. Most components in SBML are derived from a single abstract base type, SBase. In addition to serving as the parent class for most other classes of objects in SBML, this base type is designed to allow a modeler or a software package to attach arbitrary information to each major element or list in an SBML model. SBase has an optional subelement called 'notes'. It is intended to serve as a place for storing optional information intended to be seen by humans. An example use of the 'notes' element would be to contain formatted user comments about the model element in which the 'notes' element is enclosed. There are certain conditions on the XHTML content permitted inside the 'notes' element; please consult the SBML specification document corresponding to the SBML Level and Version of your model for more information about the requirements for 'notes' content. SBase has another optional subelement called 'annotation'. Whereas the 'notes' element described above is a container for content to be shown directly to humans, the 'annotation' element is a container for optional software-generated content not meant to be shown to humans. The element's content type is XML type 'any', allowing essentially arbitrary data content. SBML places only a few restrictions on the organization of the content; these are intended to help software tools read and write the data as well as help reduce conflicts between annotations added by different tools. As is the case with 'notes', it is important to refer to the SBML specification document corresponding to the SBML Level and Version of your model for more information about the requirements for 'annotation' content. It is worth pointing out that the 'annotation' element in the definition of SBase exists in order that software developers may attach optional application-specific data to the elements in an SBML model. However, it is important that this facility not be misused. In particular, it is critical that data essential to a model definition or that can be encoded in existing SBML elements is not stored in 'annotation'. Parameter values, functional dependencies between model elements, etc., should not be recorded as annotations. It is crucial to keep in mind the fact that data placed in annotations can be freely ignored by software applications. If such data affects the interpretation of a model, then software interoperability is greatly impeded. SBML Level 2 introduced an optional SBase attribute named 'metaid' for supporting metadata annotations using RDF (Resource Description Format). The attribute value has the data type XML ID, the XML identifier type, which means each 'metaid' value must be globally unique within an SBML file. (Importantly, this uniqueness criterion applies across any attribute with type XML ID, not just the 'metaid' attribute used by SBML---something to be aware of if your application- specific XML content inside the 'annotation' subelement happens to use XML ID.) The 'metaid' value serves to identify a model component for purposes such as referencing that component from metadata placed within 'annotation' subelements. Beginning with SBML Level 2 Version 2, SBase has an optional attribute named 'sboTerm' for supporting the use of the Systems Biology Ontology. In SBML proper, the data type of the attribute is a string of the form 'SBO:NNNNNNN', where 'NNNNNNN' is a seven digit integer number; libSBML simplifies the representation by only storing the 'NNNNNNN' integer portion. Thus, in libSBML, the 'sboTerm' attribute on SBase has data type 'int,' and SBO identifiers are stored simply as integers. (For convenience, SBase offers methods for returning both the integer form and a text-string form of the SBO identifier.) SBO terms are a type of optional annotation, and each different class of SBML object derived from SBase imposes its own requirements about the values permitted for 'sboTerm'. More details can be found in SBML specifications for Level 2 Version 2 and above. Finally, note that, in the list of methods on SBase, there is no public constructor because SBase is an abstract class. The constructors reside in the subclasses derived from SBase. Standard format for annotations linking data resources ====================================================================== SBML Level 2 Versions 2, 3 and 4, and Level 3, define a proposed regular format for encoding two particular categories of annotations: (a) references to controlled vocabulary terms and database identifiers which define and describe biological and biochemical entities in a model; and (b) descriptions of the provenance of a model, including its author(s) and modification history. """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, SBase, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, SBase, name) def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_SBase __del__ = lambda self: None def clone(self): """ clone(SBase self) -> SBase Creates and returns a deep copy of this SBase object. Returns the (deep) copy of this SBase object. """ return _libsbml.SBase_clone(self) def getElementBySId(self, *args): """ getElementBySId(SBase self, string id) -> SBase getElementBySId(SBase self, string id) -> SBase Returns the first child element found that has the given 'id' in the model-wide 'SId' namespace, or 'None' if no such object is found. Parameter 'id' is string representing the 'id' attribute value of the object to find. Returns pointer to the first element found with the given identifier. """ return _libsbml.SBase_getElementBySId(self, *args) def getElementByMetaId(self, *args): """ getElementByMetaId(SBase self, string metaid) -> SBase getElementByMetaId(SBase self, string metaid) -> SBase Returns the first child element it can find with a specific 'metaid' attribute value, or 'None' if no such object is found. The optional attribute named 'metaid', present on every major SBML component type, is for supporting metadata annotations using RDF (Resource Description Format). The attribute value has the data type XML ID, the XML identifier type, which means each 'metaid' value must be globally unique within an SBML file. The latter point is important, because the uniqueness criterion applies across any attribute with type ID anywhere in the file, not just the 'metaid' attribute used by SBML---something to be aware of if your application- specific XML content inside the 'annotation' subelement happens to use the XML ID type. Although SBML itself specifies the use of XML ID only for the 'metaid' attribute, SBML-compatible applications should be careful if they use XML ID's in XML portions of a model that are not defined by SBML, such as in the application-specific content of the 'annotation' subelement. Finally, note that LibSBML does not provide an explicit XML ID data type; it uses ordinary character strings, which is easier for applications to support. Parameter 'metaid' is string representing the 'metaid' attribute value of the object to find. Returns pointer to the first element found with the given meta- identifier. """ return _libsbml.SBase_getElementByMetaId(self, *args) def renameSIdRefs(self, oldid, newid): """ renameSIdRefs(SBase self, string oldid, string newid) Replaces all uses of a given 'SIdRef' type attribute value with another value. In SBML, object identifiers are of a data type called SId. In SBML Level 3, an explicit data type called SIdRef was introduced for attribute values that refer to SId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to an identifier', but the effective data type was the same as SIdRef in Level 3. These and other methods of libSBML refer to the type SIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all attributes and (if appropriate) mathematical formulas in MathML content, comparing the referenced identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.SBase_renameSIdRefs(self, oldid, newid) def renameMetaIdRefs(self, oldid, newid): """ renameMetaIdRefs(SBase self, string oldid, string newid) Replaces all uses of a given meta identifier attribute value with another value. In SBML, object 'meta' identifiers are of the XML data type ID; the SBML object attribute itself is typically named metaid. All attributes that hold values referring to values of type ID are of the XML data type IDREF. They are also sometimes informally referred to as 'metaid refs', in analogy to the SBML-defined type SIdRef. This method works by looking at all meta-identifier attribute values, comparing the identifiers to the value of 'oldid'. If any matches are found, the matching identifiers are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.SBase_renameMetaIdRefs(self, oldid, newid) def renameUnitSIdRefs(self, oldid, newid): """ renameUnitSIdRefs(SBase self, string oldid, string newid) Replaces all uses of a given 'UnitSIdRef' type attribute value with another value. In SBML, unit definitions have identifiers of type UnitSId. In SBML Level 3, an explicit data type called UnitSIdRef was introduced for attribute values that refer to UnitSId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to a unit identifier', but the effective data type was the same as UnitSIdRef in Level 3. These and other methods of libSBML refer to the type UnitSIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all unit identifier attribute values (including, if appropriate, inside mathematical formulas), comparing the referenced unit identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.SBase_renameUnitSIdRefs(self, oldid, newid) def replaceSIDWithFunction(self, id, function): """ replaceSIDWithFunction(SBase self, string id, ASTNode function) Internal implementation method. """ return _libsbml.SBase_replaceSIDWithFunction(self, id, function) def divideAssignmentsToSIdByFunction(self, id, function): """ divideAssignmentsToSIdByFunction(SBase self, string id, ASTNode function) Internal implementation method. """ return _libsbml.SBase_divideAssignmentsToSIdByFunction(self, id, function) def multiplyAssignmentsToSIdByFunction(self, id, function): """ multiplyAssignmentsToSIdByFunction(SBase self, string id, ASTNode function) Internal implementation method. """ return _libsbml.SBase_multiplyAssignmentsToSIdByFunction(self, id, function) def getElementFromPluginsBySId(self, id): """ getElementFromPluginsBySId(SBase self, string id) -> SBase Internal implementation method. """ return _libsbml.SBase_getElementFromPluginsBySId(self, id) def getElementFromPluginsByMetaId(self, metaid): """ getElementFromPluginsByMetaId(SBase self, string metaid) -> SBase Internal implementation method. """ return _libsbml.SBase_getElementFromPluginsByMetaId(self, metaid) def hasNonstandardIdentifierBeginningWith(self, prefix): """ hasNonstandardIdentifierBeginningWith(SBase self, string prefix) -> bool Internal implementation method. """ return _libsbml.SBase_hasNonstandardIdentifierBeginningWith(self, prefix) def prependStringToAllIdentifiers(self, prefix): """ prependStringToAllIdentifiers(SBase self, string prefix) -> int Internal implementation method. """ return _libsbml.SBase_prependStringToAllIdentifiers(self, prefix) def transformIdentifiers(self, idTransformer): """ transformIdentifiers(SBase self, IdentifierTransformer idTransformer) -> int Internal implementation method. """ return _libsbml.SBase_transformIdentifiers(self, idTransformer) def getMetaId(self): """ getMetaId(SBase self) -> string Returns the value of the 'metaid' attribute of this SBML object. The optional attribute named 'metaid', present on every major SBML component type, is for supporting metadata annotations using RDF (Resource Description Format). The attribute value has the data type XML ID, the XML identifier type, which means each 'metaid' value must be globally unique within an SBML file. The latter point is important, because the uniqueness criterion applies across any attribute with type ID anywhere in the file, not just the 'metaid' attribute used by SBML---something to be aware of if your application- specific XML content inside the 'annotation' subelement happens to use the XML ID type. Although SBML itself specifies the use of XML ID only for the 'metaid' attribute, SBML-compatible applications should be careful if they use XML ID's in XML portions of a model that are not defined by SBML, such as in the application-specific content of the 'annotation' subelement. Finally, note that LibSBML does not provide an explicit XML ID data type; it uses ordinary character strings, which is easier for applications to support. Returns the meta-identifier of this SBML object. See also isSetMetaId(), setMetaId(). """ return _libsbml.SBase_getMetaId(self) def getId(self): """ getId(SBase self) -> string Returns the value of the 'id' attribute of this SBML object, if it has one, or the 'variable' attribute of a Rule, or the 'symbol' attribute of an InitialAssignment. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Returns the id of this SBML object, or the 'variable' if the object is a Rule, or the 'symbol' if the object is an InitialAssignment. Note: Because of the inconsistent behavior of this function with respect to assignments and rules, callers should use getIdAttribute() instead. See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(). """ return _libsbml.SBase_getId(self) def getIdAttribute(self): """ getIdAttribute(SBase self) -> string Returns the value of the 'id' attribute of this SBML object. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Returns the id of this SBML object, if set and valid for this level and version of SBML; an empty string otherwise. Note: Because of the inconsistent behavior of this function with respect to assignments and rules, callers should use getIdAttribute() instead. See also setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(). """ return _libsbml.SBase_getIdAttribute(self) def getName(self): """ getName(SBase self) -> string Returns the value of the 'name' attribute of this SBML object. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns the name of this SBML object, or the empty string if not set or unsettable. See also getIdAttribute(), isSetName(), setName(), unsetName(). """ return _libsbml.SBase_getName(self) def getNotes(self, *args): """ getNotes(SBase self) -> XMLNode getNotes(SBase self) -> XMLNode Returns the content of the 'notes' subelement of this object as a tree of XMLNode objects. The optional SBML element named 'notes', present on every major SBML component type (and in SBML Level 3, the 'message' subelement of Constraint), is intended as a place for storing optional information intended to be seen by humans. An example use of the 'notes' element would be to contain formatted user comments about the model element in which the 'notes' element is enclosed. Every object derived directly or indirectly from type SBase can have a separate value for 'notes', allowing users considerable freedom when adding comments to their models. The format of 'notes' elements conform to the definition of XHTML 1.0. However, the content cannot be entirely free-form; it must satisfy certain requirements defined in the SBML specifications for specific SBML Levels. To help verify the formatting of 'notes' content, libSBML provides the static utility method SyntaxChecker.hasExpectedXHTMLSyntax(); this method implements a verification process that lets callers check whether the content of a given XMLNode object conforms to the SBML requirements for 'notes' and 'message' structure. Developers are urged to consult the appropriate SBML specification document for the Level and Version of their model for more in-depth explanations of using 'notes' in SBML. The SBML Level 2 and 3 specifications have considerable detail about how 'notes' element content must be structured. The 'notes' element content returned by this method will be in XML form, but libSBML does not provide an object model specifically for the content of notes. Callers will need to traverse the XML tree structure using the facilities available on XMLNode and related objects. For an alternative method of accessing the notes, see getNotesString(). Returns the content of the 'notes' subelement of this SBML object as a tree structure composed of XMLNode objects. See also getNotesString(), isSetNotes(), setNotes(), setNotes(), appendNotes(), appendNotes(), unsetNotes(), SyntaxChecker.hasExpectedXHTMLSyntax(). """ return _libsbml.SBase_getNotes(self, *args) def getNotesString(self, *args): """ getNotesString(SBase self) -> string getNotesString(SBase self) -> string Returns the content of the 'notes' subelement of this object as a string. The optional SBML element named 'notes', present on every major SBML component type (and in SBML Level 3, the 'message' subelement of Constraint), is intended as a place for storing optional information intended to be seen by humans. An example use of the 'notes' element would be to contain formatted user comments about the model element in which the 'notes' element is enclosed. Every object derived directly or indirectly from type SBase can have a separate value for 'notes', allowing users considerable freedom when adding comments to their models. The format of 'notes' elements conform to the definition of XHTML 1.0. However, the content cannot be entirely free-form; it must satisfy certain requirements defined in the SBML specifications for specific SBML Levels. To help verify the formatting of 'notes' content, libSBML provides the static utility method SyntaxChecker.hasExpectedXHTMLSyntax(); this method implements a verification process that lets callers check whether the content of a given XMLNode object conforms to the SBML requirements for 'notes' and 'message' structure. Developers are urged to consult the appropriate SBML specification document for the Level and Version of their model for more in-depth explanations of using 'notes' in SBML. The SBML Level 2 and 3 specifications have considerable detail about how 'notes' element content must be structured. For an alternative method of accessing the notes, see getNotes(), which returns the content as an XMLNode tree structure. Depending on an application's needs, one or the other method may be more convenient. Returns the content of the 'notes' subelement of this SBML object as a string. See also getNotes(), isSetNotes(), setNotes(), setNotes(), appendNotes(), appendNotes(), unsetNotes(), SyntaxChecker.hasExpectedXHTMLSyntax(). """ return _libsbml.SBase_getNotesString(self, *args) def getAnnotation(self, *args): """ getAnnotation(SBase self) -> XMLNode getAnnotation(SBase self) -> XMLNode Returns the content of the 'annotation' subelement of this object as a tree of XMLNode objects. Whereas the SBML 'notes' subelement is a container for content to be shown directly to humans, the 'annotation' element is a container for optional software-generated content not meant to be shown to humans. Every object derived from SBase can have its own value for 'annotation'. The element's content type is XML type 'any', allowing essentially arbitrary well-formed XML data content. SBML places a few restrictions on the organization of the content of annotations; these are intended to help software tools read and write the data as well as help reduce conflicts between annotations added by different tools. Please see the SBML specifications for more details. The annotations returned by this method will be in XML form. LibSBML provides an object model and related interfaces for certain specific kinds of annotations, namely model history information and RDF content. See the ModelHistory, CVTerm and RDFAnnotationParser classes for more information about the facilities available. Returns the annotation of this SBML object as a tree of XMLNode objects. See also getAnnotationString(), isSetAnnotation(), setAnnotation(), setAnnotation(), appendAnnotation(), appendAnnotation(), unsetAnnotation(). """ return _libsbml.SBase_getAnnotation(self, *args) def getAnnotationString(self, *args): """ getAnnotationString(SBase self) -> string getAnnotationString(SBase self) -> string Returns the content of the 'annotation' subelement of this object as a character string. Whereas the SBML 'notes' subelement is a container for content to be shown directly to humans, the 'annotation' element is a container for optional software-generated content not meant to be shown to humans. Every object derived from SBase can have its own value for 'annotation'. The element's content type is XML type 'any', allowing essentially arbitrary well-formed XML data content. SBML places a few restrictions on the organization of the content of annotations; these are intended to help software tools read and write the data as well as help reduce conflicts between annotations added by different tools. Please see the SBML specifications for more details. The annotations returned by this method will be in string form. See the method getAnnotation() for a version that returns annotations in XML form. Returns the annotation of this SBML object as a character string. See also getAnnotation(), isSetAnnotation(), setAnnotation(), setAnnotation(), appendAnnotation(), appendAnnotation(), unsetAnnotation(). """ return _libsbml.SBase_getAnnotationString(self, *args) def getNamespaces(self): """ getNamespaces(SBase self) -> XMLNamespaces Returns a list of the XML Namespaces declared on the SBML document owning this object. The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. Returns the XML Namespaces associated with this SBML object, or 'None' in certain very usual circumstances where a namespace is not set. See also getLevel(), getVersion(). """ return _libsbml.SBase_getNamespaces(self) def getSBMLDocument(self, *args): """ getSBMLDocument(SBase self) -> SBMLDocument getSBMLDocument(SBase self) -> SBMLDocument Returns the SBMLDocument object containing this object instance. LibSBML uses the class SBMLDocument as a top-level container for storing SBML content and data associated with it (such as warnings and error messages). An SBML model in libSBML is contained inside an SBMLDocument object. SBMLDocument corresponds roughly to the class SBML defined in the SBML Level 3 and Level 2 specifications, but it does not have a direct correspondence in SBML Level 1. (But, it is created by libSBML no matter whether the model is Level 1, Level 2 or Level 3.) This method allows the caller to obtain the SBMLDocument for the current object. Returns the parent SBMLDocument object of this SBML object. See also getParentSBMLObject(), getModel(). """ return _libsbml.SBase_getSBMLDocument(self, *args) def getParentSBMLObject(self, *args): """ getParentSBMLObject(SBase self) -> SBase getParentSBMLObject(SBase self) -> SBase Returns the parent SBML object containing this object. This returns the immediately-containing object. This method is convenient when holding an object nested inside other objects in an SBML model. Returns the parent SBML object of this SBML object. See also getSBMLDocument(), getModel(). """ return _libsbml.SBase_getParentSBMLObject(self, *args) def getAncestorOfType(self, *args): """ getAncestorOfType(SBase self, int type, string pkgName) -> SBase getAncestorOfType(SBase self, int type) -> SBase getAncestorOfType(SBase self, int type, string pkgName) -> SBase getAncestorOfType(SBase self, int type) -> SBase Returns the first ancestor object that has the given SBML type code from the given package. LibSBML attaches an identifying code to every kind of SBML object. These are known as SBML type codes. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. The names of the type codes all begin with the characters 'SBML_.' This method searches the tree of objects that are parents of this object, and returns the first one that has the given SBML type code from the given 'pkgName'. Parameter 'type' is the SBML type code of the object sought. Parameter 'pkgName' is (optional) the short name of an SBML Level 3 package to which the sought-after object must belong. Returns the ancestor SBML object of this SBML object that corresponds to the given SBML object type code, or 'None' if no ancestor exists. WARNING: The optional argument 'pkgName' must be used for all type codes from SBML Level 3 packages. Otherwise, the function will search the 'core' namespace alone, not find any corresponding elements, and return None.
Documentation note:
The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation.
Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.SBase_getAncestorOfType(self, *args) def getSBOTerm(self): """ getSBOTerm(SBase self) -> int Returns the integer portion of the value of the 'sboTerm' attribute of this object. Beginning with SBML Level 2 Version 2, objects derived from SBase have an optional attribute named 'sboTerm' for supporting the use of the Systems Biology Ontology. In SBML proper, the data type of the attribute is a string of the form 'SBO:NNNNNNN', where 'NNNNNNN' is a seven digit integer number; libSBML simplifies the representation by only storing the 'NNNNNNN' integer portion. Thus, in libSBML, the 'sboTerm' attribute on SBase has data type 'int,' and SBO identifiers are stored simply as integers. SBO terms are a type of optional annotation, and each different class of SBML object derived from SBase imposes its own requirements about the values permitted for 'sboTerm'. More details can be found in SBML specifications for Level 2 Version 2 and above. Returns the value of the 'sboTerm' attribute as an integer, or '-1' if the value is not set. """ return _libsbml.SBase_getSBOTerm(self) def getSBOTermID(self): """ getSBOTermID(SBase self) -> string Returns the string representation of the 'sboTerm' attribute of this object. Beginning with SBML Level 2 Version 2, objects derived from SBase have an optional attribute named 'sboTerm' for supporting the use of the Systems Biology Ontology. In SBML proper, the data type of the attribute is a string of the form 'SBO:NNNNNNN', where 'NNNNNNN' is a seven digit integer number; libSBML simplifies the representation by only storing the 'NNNNNNN' integer portion. Thus, in libSBML, the 'sboTerm' attribute on SBase has data type 'int,' and SBO identifiers are stored simply as integers. SBO terms are a type of optional annotation, and each different class of SBML object derived from SBase imposes its own requirements about the values permitted for 'sboTerm'. More details can be found in SBML specifications for Level 2 Version 2 and above. Returns the value of the 'sboTerm' attribute as a string (its value will be of the form 'SBO:NNNNNNN'), or an empty string if the value is not set. """ return _libsbml.SBase_getSBOTermID(self) def getSBOTermAsURL(self): """ getSBOTermAsURL(SBase self) -> string Returns the URL representation of the 'sboTerm' attribute of this object. This method returns the entire SBO identifier as a text string in the form http://identifiers.org/biomodels.sbo/SBO:NNNNNNN'. SBO terms are a type of optional annotation, and each different class of SBML object derived from SBase imposes its own requirements about the values permitted for 'sboTerm'. More details can be found in SBML specifications for Level 2 Version 2 and above. Returns the value of the 'sboTerm' attribute as an identifiers.org URL, or an empty string if the value is not set. """ return _libsbml.SBase_getSBOTermAsURL(self) def getLine(self): """ getLine(SBase self) -> unsigned int Returns the line number where this object first appears in the XML representation of the SBML document. Returns the line number of this SBML object. If this object was created programmatically and not read from a file, this method will return the value '0.' Note: The line number for each construct in an SBML model is set upon reading the model. The accuracy of the line number depends on the correctness of the XML representation of the model, and on the particular XML parser library being used. The former limitation relates to the following problem: if the model is actually invalid XML, then the parser may not be able to interpret the data correctly and consequently may not be able to establish the real line number. The latter limitation is simply that different parsers seem to have their own accuracy limitations, and out of all the parsers supported by libSBML, none have been 100% accurate in all situations. (At this time, libSBML supports the use of libxml2, Expat and Xerces.) See also getColumn(). """ return _libsbml.SBase_getLine(self) def getColumn(self): """ getColumn(SBase self) -> unsigned int Returns the column number where this object first appears in the XML representation of the SBML document. Returns the column number of this SBML object. If this object was created programmatically and not read from a file, this method will return the value '0.' Note: The column number for each construct in an SBML model is set upon reading the model. The accuracy of the column number depends on the correctness of the XML representation of the model, and on the particular XML parser library being used. The former limitation relates to the following problem: if the model is actually invalid XML, then the parser may not be able to interpret the data correctly and consequently may not be able to establish the real column number. The latter limitation is simply that different parsers seem to have their own accuracy limitations, and out of all the parsers supported by libSBML, none have been 100% accurate in all situations. (At this time, libSBML supports the use of libxml2, Expat and Xerces.) See also getLine(). """ return _libsbml.SBase_getColumn(self) def getModelHistory(self, *args): """ getModelHistory(SBase self) -> ModelHistory getModelHistory(SBase self) -> ModelHistory Returns the ModelHistory object, if any, attached to this object. Returns the ModelHistory object attached to this object, or 'None' if none exist. Note: In SBML Level 2, model history annotations were only permitted on the Model element. In SBML Level 3, they are permitted on all SBML components derived from SBase. """ return _libsbml.SBase_getModelHistory(self, *args) def isSetMetaId(self): """ isSetMetaId(SBase self) -> bool Predicate returning 'True' if this object's 'metaid' attribute is set. The optional attribute named 'metaid', present on every major SBML component type, is for supporting metadata annotations using RDF (Resource Description Format). The attribute value has the data type XML ID, the XML identifier type, which means each 'metaid' value must be globally unique within an SBML file. The latter point is important, because the uniqueness criterion applies across any attribute with type ID anywhere in the file, not just the 'metaid' attribute used by SBML---something to be aware of if your application- specific XML content inside the 'annotation' subelement happens to use the XML ID type. Although SBML itself specifies the use of XML ID only for the 'metaid' attribute, SBML-compatible applications should be careful if they use XML ID's in XML portions of a model that are not defined by SBML, such as in the application-specific content of the 'annotation' subelement. Finally, note that LibSBML does not provide an explicit XML ID data type; it uses ordinary character strings, which is easier for applications to support. Returns 'True' if the 'metaid' attribute of this SBML object is set, 'False' otherwise. See also getMetaId(), setMetaId(). """ return _libsbml.SBase_isSetMetaId(self) def isSetId(self): """ isSetId(SBase self) -> bool Predicate returning 'True' if a call to getId() returns a non-empty string. For most objects, this function will return 'True' if its 'id' attribute is set, and 'False' if it is not, or if the object has no 'id' attribute at all. However, for an EventAssignment or a Rule, isSetId() checks whether the 'variable' attribute is set, and for an InitialAssignment, it checks whether the 'symbol' attribute is set. Because those elements will also have an 'id' attribute in SBML Level 3 Version 2 which isSetId() will not check, the function itself is deprecated, and it is recommended to use isSetIdAttribute() in all cases where one needs to know whether the 'id' attribute is set, and to use EventAssignment.isSetVariable(), Rule.isSetVariable() and InitialAssignment.isSetSymbol() when the status of the 'variable' or 'symbol' attributes need to be checked. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Returns 'True' if the 'id' attribute of this SBML object is set, 'False' otherwise. Note: Because of the inconsistent behavior of this function with respect to assignments and rules, it is recommended that callers use isSetIdAttribute() instead. See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(), isSetIdAttribute(). """ return _libsbml.SBase_isSetId(self) def isSetIdAttribute(self): """ isSetIdAttribute(SBase self) -> bool Predicate returning 'True' if this object's 'id' attribute is set. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Returns 'True' if the 'id' attribute of this SBML object is set, 'False' otherwise. See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(). """ return _libsbml.SBase_isSetIdAttribute(self) def isSetName(self): """ isSetName(SBase self) -> bool Predicate returning 'True' if this object's 'name' attribute is set. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns 'True' if the 'name' attribute of this SBML object is set, 'False' otherwise. See also getName(), setName(), unsetName(). """ return _libsbml.SBase_isSetName(self) def isSetNotes(self): """ isSetNotes(SBase self) -> bool Predicate returning 'True' if this object's 'notes' subelement exists and has content. The optional SBML element named 'notes', present on every major SBML component type, is intended as a place for storing optional information intended to be seen by humans. An example use of the 'notes' element would be to contain formatted user comments about the model element in which the 'notes' element is enclosed. Every object derived directly or indirectly from type SBase can have a separate value for 'notes', allowing users considerable freedom when adding comments to their models. The format of 'notes' elements must be XHTML 1.0. To help verify the formatting of 'notes' content, libSBML provides the static utility method SyntaxChecker.hasExpectedXHTMLSyntax(); however, readers are urged to consult the appropriate SBML specification document for the Level and Version of their model for more in-depth explanations. The SBML Level 2 and 3 specifications have considerable detail about how 'notes' element content must be structured. Returns 'True' if a 'notes' subelement exists, 'False' otherwise. See also getNotes(), getNotesString(), setNotes(), setNotes(), appendNotes(), appendNotes(), unsetNotes(), SyntaxChecker.hasExpectedXHTMLSyntax(). """ return _libsbml.SBase_isSetNotes(self) def isSetAnnotation(self): """ isSetAnnotation(SBase self) -> bool Predicate returning 'True' if this object's 'annotation' subelement exists and has content. Whereas the SBase 'notes' subelement is a container for content to be shown directly to humans, the 'annotation' element is a container for optional software-generated content not meant to be shown to humans. Every object derived from SBase can have its own value for 'annotation'. The element's content type is XML type 'any', allowing essentially arbitrary well-formed XML data content. SBML places a few restrictions on the organization of the content of annotations; these are intended to help software tools read and write the data as well as help reduce conflicts between annotations added by different tools. Please see the SBML specifications for more details. Returns 'True' if a 'annotation' subelement exists, 'False' otherwise. See also getAnnotation(), getAnnotationString(), setAnnotation(), setAnnotation(), appendAnnotation(), appendAnnotation(), unsetAnnotation(). """ return _libsbml.SBase_isSetAnnotation(self) def isSetSBOTerm(self): """ isSetSBOTerm(SBase self) -> bool Predicate returning 'True' if this object's 'sboTerm' attribute is set. Returns 'True' if the 'sboTerm' attribute of this SBML object is set, 'False' otherwise. """ return _libsbml.SBase_isSetSBOTerm(self) def setMetaId(self, metaid): """ setMetaId(SBase self, string metaid) -> int Sets the value of the meta-identifier attribute of this SBML object. The optional attribute named 'metaid', present on every major SBML component type, is for supporting metadata annotations using RDF (Resource Description Format). The attribute value has the data type XML ID, the XML identifier type, which means each 'metaid' value must be globally unique within an SBML file. The latter point is important, because the uniqueness criterion applies across any attribute with type ID anywhere in the file, not just the 'metaid' attribute used by SBML---something to be aware of if your application- specific XML content inside the 'annotation' subelement happens to use the XML ID type. Although SBML itself specifies the use of XML ID only for the 'metaid' attribute, SBML-compatible applications should be careful if they use XML ID's in XML portions of a model that are not defined by SBML, such as in the application-specific content of the 'annotation' subelement. Finally, note that LibSBML does not provide an explicit XML ID data type; it uses ordinary character strings, which is easier for applications to support. The string 'metaid' is copied. Parameter 'metaid' is the identifier string to use as the value of the 'metaid' attribute. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE * LIBSBML_UNEXPECTED_ATTRIBUTE See also getMetaId(), isSetMetaId(). """ return _libsbml.SBase_setMetaId(self, metaid) def isSetModelHistory(self): """ isSetModelHistory(SBase self) -> bool Predicate returning 'True' if this object has a ModelHistory object attached to it. Returns 'True' if the ModelHistory of this object is set, 'False' otherwise. Note: In SBML Level 2, model history annotations were only permitted on the Model element. In SBML Level 3, they are permitted on all SBML components derived from SBase. """ return _libsbml.SBase_isSetModelHistory(self) def setId(self, sid): """ setId(SBase self, string sid) -> int Sets the value of the 'id' attribute of this SBML object. The string 'sid' is copied. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Parameter 'sid' is the string to use as the identifier of this object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE * LIBSBML_UNEXPECTED_ATTRIBUTE See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(). """ return _libsbml.SBase_setId(self, sid) def setIdAttribute(self, sid): """ setIdAttribute(SBase self, string sid) -> int Sets the value of the 'id' attribute of this SBML object. The string 'sid' is copied. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Parameter 'sid' is the string to use as the identifier of this object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE * LIBSBML_UNEXPECTED_ATTRIBUTE See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(). """ return _libsbml.SBase_setIdAttribute(self, sid) def setName(self, name): """ setName(SBase self, string name) -> int Sets the value of the 'name' attribute of this SBML object. The string in 'name' is copied. Parameter 'name' is the new name for the SBML object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.SBase_setName(self, name) def setAnnotation(self, *args): """ setAnnotation(SBase self, XMLNode annotation) -> int setAnnotation(SBase self, string annotation) -> int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: setAnnotation(XMLNode annotation) Sets the value of the 'annotation' subelement of this SBML object. The content of 'annotation' is copied, and any previous content of this object's 'annotation' subelement is deleted. Whereas the SBase 'notes' subelement is a container for content to be shown directly to humans, the 'annotation' element is a container for optional software-generated content not meant to be shown to humans. Every object derived from SBase can have its own value for 'annotation'. The element's content type is XML type 'any', allowing essentially arbitrary well-formed XML data content. SBML places a few restrictions on the organization of the content of annotations; these are intended to help software tools read and write the data as well as help reduce conflicts between annotations added by different tools. Please see the SBML specifications for more details. Call this method will result in any existing content of the 'annotation' subelement to be discarded. Unless you have taken steps to first copy and reconstitute any existing annotations into the 'annotation' that is about to be assigned, it is likely that performing such wholesale replacement is unfriendly towards other software applications whose annotations are discarded. An alternative may be to use SBase.appendAnnotation() or SBase.appendAnnotation(). Parameter 'annotation' is an XML structure that is to be used as the new content of the 'annotation' subelement of this object. Returns integer value indicating success/failure of the function. This particular function only does one thing irrespective of user input or object state, and thus will only return a single value: * LIBSBML_OPERATION_SUCCESS See also getAnnotationString(), isSetAnnotation(), setAnnotation(), appendAnnotation(), appendAnnotation(), unsetAnnotation(). ______________________________________________________________________ Method variant with the following signature: setAnnotation(string annotation) Sets the value of the 'annotation' subelement of this SBML object. The content of 'annotation' is copied, and any previous content of this object's 'annotation' subelement is deleted. Whereas the SBase 'notes' subelement is a container for content to be shown directly to humans, the 'annotation' element is a container for optional software-generated content not meant to be shown to humans. Every object derived from SBase can have its own value for 'annotation'. The element's content type is XML type 'any', allowing essentially arbitrary well-formed XML data content. SBML places a few restrictions on the organization of the content of annotations; these are intended to help software tools read and write the data as well as help reduce conflicts between annotations added by different tools. Please see the SBML specifications for more details. Call this method will result in any existing content of the 'annotation' subelement to be discarded. Unless you have taken steps to first copy and reconstitute any existing annotations into the 'annotation' that is about to be assigned, it is likely that performing such wholesale replacement is unfriendly towards other software applications whose annotations are discarded. An alternative may be to use SBase.appendAnnotation() or SBase.appendAnnotation(). Parameter 'annotation' is an XML string that is to be used as the content of the 'annotation' subelement of this object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also getAnnotationString(), isSetAnnotation(), setAnnotation(), appendAnnotation(), appendAnnotation(), unsetAnnotation(). """ return _libsbml.SBase_setAnnotation(self, *args) def appendAnnotation(self, *args): """ appendAnnotation(SBase self, XMLNode annotation) -> int appendAnnotation(SBase self, string annotation) -> int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: appendAnnotation(XMLNode annotation) Appends the given 'annotation' to the 'annotation' subelement of this object. Whereas the SBase 'notes' subelement is a container for content to be shown directly to humans, the 'annotation' element is a container for optional software-generated content not meant to be shown to humans. Every object derived from SBase can have its own value for 'annotation'. The element's content type is XML type 'any', allowing essentially arbitrary well-formed XML data content. SBML places a few restrictions on the organization of the content of annotations; these are intended to help software tools read and write the data as well as help reduce conflicts between annotations added by different tools. Please see the SBML specifications for more details. Unlike SBase.setAnnotation() or SBase.setAnnotation(), this method allows other annotations to be preserved when an application adds its own data. Parameter 'annotation' is an XML structure that is to be copied and appended to the content of the 'annotation' subelement of this object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_UNEXPECTED_ATTRIBUTE (if the parent element does not have the 'metaid' attribute set) * LIBSBML_DUPLICATE_ANNOTATION_NS (if the parent was already annotated with the annotation in question) See also getAnnotationString(), isSetAnnotation(), setAnnotation(), setAnnotation(), appendAnnotation(), unsetAnnotation(). ______________________________________________________________________ Method variant with the following signature: appendAnnotation(string annotation) Appends the given 'annotation' to the 'annotation' subelement of this object. Whereas the SBase 'notes' subelement is a container for content to be shown directly to humans, the 'annotation' element is a container for optional software-generated content not meant to be shown to humans. Every object derived from SBase can have its own value for 'annotation'. The element's content type is XML type 'any', allowing essentially arbitrary well-formed XML data content. SBML places a few restrictions on the organization of the content of annotations; these are intended to help software tools read and write the data as well as help reduce conflicts between annotations added by different tools. Please see the SBML specifications for more details. Unlike SBase.setAnnotation() or SBase.setAnnotation(), this method allows other annotations to be preserved when an application adds its own data. Parameter 'annotation' is an XML string that is to be copied and appended to the content of the 'annotation' subelement of this object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_UNEXPECTED_ATTRIBUTE (if the parent element does not have the 'metaid' attribute set) * LIBSBML_DUPLICATE_ANNOTATION_NS (if the parent was already annotated with the annotation in question) See also getAnnotationString(), isSetAnnotation(), setAnnotation(), setAnnotation(), appendAnnotation(), unsetAnnotation(). """ return _libsbml.SBase_appendAnnotation(self, *args) def removeTopLevelAnnotationElement(self, *args): """ removeTopLevelAnnotationElement(SBase self, string elementName, string elementURI, bool removeEmpty=True) -> int removeTopLevelAnnotationElement(SBase self, string elementName, string elementURI) -> int removeTopLevelAnnotationElement(SBase self, string elementName) -> int Removes the top-level element within the 'annotation' subelement of this SBML object with the given name and optional URI. SBML places a few restrictions on the organization of the content of annotations; these are intended to help software tools read and write the data as well as help reduce conflicts between annotations added by different tools. Please see the SBML specifications for more details. Calling this method allows a particular annotation element to be removed whilst the remaining annotations remain intact. Parameter 'elementName' is a string representing the name of the top level annotation element that is to be removed. Parameter 'elementURI' is an optional string that is used to check both the name and URI of the top level element to be removed. Parameter 'removeEmpty' is if after removing of the element, the annotation is empty, and the removeEmpty argument is true, the annotation node will be deleted (default). Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_ANNOTATION_NAME_NOT_FOUND * LIBSBML_ANNOTATION_NS_NOT_FOUND See also replaceTopLevelAnnotationElement(), replaceTopLevelAnnotationElement(). Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.SBase_removeTopLevelAnnotationElement(self, *args) def replaceTopLevelAnnotationElement(self, *args): """ replaceTopLevelAnnotationElement(SBase self, XMLNode annotation) -> int replaceTopLevelAnnotationElement(SBase self, string annotation) -> int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: replaceTopLevelAnnotationElement(XMLNode annotation) Replaces the given top-level element within the 'annotation' subelement of this SBML object and with the annotation element supplied. SBML places a few restrictions on the organization of the content of annotations; these are intended to help software tools read and write the data as well as help reduce conflicts between annotations added by different tools. Please see the SBML specifications for more details. This method determines the name of the element to be replaced from the annotation argument. Functionally it is equivalent to calling removeTopLevelAnnotationElement(name) followed by calling appendAnnotation(annotation_with_name), with the exception that the placement of the annotation element remains the same. Parameter 'annotation' is XMLNode representing the replacement top level annotation. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_INVALID_OBJECT See also removeTopLevelAnnotationElement(), replaceTopLevelAnnotationElement(). ______________________________________________________________________ Method variant with the following signature: replaceTopLevelAnnotationElement(string annotation) Replaces the given top-level element within the 'annotation' subelement of this SBML object and with the annotation element supplied. SBML places a few restrictions on the organization of the content of annotations; these are intended to help software tools read and write the data as well as help reduce conflicts between annotations added by different tools. Please see the SBML specifications for more details. This method determines the name of the element to be replaced from the annotation argument. Functionally it is equivalent to calling removeTopLevelAnnotationElement(name) followed by calling appendAnnotation(annotation_with_name), with the exception that the placement of the annotation element remains the same. Parameter 'annotation' is string representing the replacement top level annotation. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_INVALID_OBJECT See also removeTopLevelAnnotationElement(), replaceTopLevelAnnotationElement(). """ return _libsbml.SBase_replaceTopLevelAnnotationElement(self, *args) def setNotes(self, *args): """ setNotes(SBase self, XMLNode notes) -> int setNotes(SBase self, string notes, bool addXHTMLMarkup=False) -> int setNotes(SBase self, string notes) -> int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: setNotes(string notes, bool addXHTMLMarkup = false) Sets the value of the 'notes' subelement of this SBML object to a copy of the string 'notes'. The content of 'notes' is copied, and any existing content of this object's 'notes' subelement is deleted. The optional SBML element named 'notes', present on every major SBML component type, is intended as a place for storing optional information intended to be seen by humans. An example use of the 'notes' element would be to contain formatted user comments about the model element in which the 'notes' element is enclosed. Every object derived directly or indirectly from type SBase can have a separate value for 'notes', allowing users considerable freedom when adding comments to their models. The format of 'notes' elements must be XHTML 1.0. To help verify the formatting of 'notes' content, libSBML provides the static utility method SyntaxChecker.hasExpectedXHTMLSyntax(); however, readers are urged to consult the appropriate SBML specification document for the Level and Version of their model for more in-depth explanations. The SBML Level 2 and 3 specifications have considerable detail about how 'notes' element content must be structured. The following code illustrates a very simple way of setting the notes using this method. Here, the object being annotated is the whole SBML document, but that is for illustration purposes only; you could of course use this same approach to annotate any other SBML component. try: sbmlDoc = SBMLDocument(3, 1) except ValueError: print('Could not create SBMLDocument object') sys.exit(1) note = '

here is my note

' status = sbmlDoc.setNotes(note) if status != LIBSBML_OPERATION_SUCCESS: # Do something to handle the error here. print('Unable to set notes on the SBML document object') sys.exit(1) Parameter 'notes' is an XML string that is to be used as the content of the 'notes' subelement of this object. Parameter 'addXHTMLMarkup' is a boolean indicating whether to wrap the contents of the 'notes' argument with XHTML paragraph (

) tags. This is appropriate when the string in 'notes' does not already containg the appropriate XHTML markup. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT * LIBSBML_OPERATION_FAILED See also getNotesString(), isSetNotes(), setNotes(), appendNotes(), appendNotes(), unsetNotes(), SyntaxChecker.hasExpectedXHTMLSyntax(). Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. ______________________________________________________________________ Method variant with the following signature: setNotes(XMLNode notes) Sets the value of the 'notes' subelement of this SBML object. The content of 'notes' is copied, and any existing content of this object's 'notes' subelement is deleted. The optional SBML element named 'notes', present on every major SBML component type, is intended as a place for storing optional information intended to be seen by humans. An example use of the 'notes' element would be to contain formatted user comments about the model element in which the 'notes' element is enclosed. Every object derived directly or indirectly from type SBase can have a separate value for 'notes', allowing users considerable freedom when adding comments to their models. The format of 'notes' elements must be XHTML 1.0. To help verify the formatting of 'notes' content, libSBML provides the static utility method SyntaxChecker.hasExpectedXHTMLSyntax(); however, readers are urged to consult the appropriate SBML specification document for the Level and Version of their model for more in-depth explanations. The SBML Level 2 and 3 specifications have considerable detail about how 'notes' element content must be structured. Parameter 'notes' is an XML structure that is to be used as the content of the 'notes' subelement of this object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT See also getNotesString(), isSetNotes(), setNotes(), appendNotes(), appendNotes(), unsetNotes(), SyntaxChecker.hasExpectedXHTMLSyntax(). """ return _libsbml.SBase_setNotes(self, *args) def appendNotes(self, *args): """ appendNotes(SBase self, XMLNode notes) -> int appendNotes(SBase self, string notes) -> int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: appendNotes(string notes) Appends the given 'notes' to the 'notes' subelement of this object. The content of the parameter 'notes' is copied. The optional SBML element named 'notes', present on every major SBML component type, is intended as a place for storing optional information intended to be seen by humans. An example use of the 'notes' element would be to contain formatted user comments about the model element in which the 'notes' element is enclosed. Every object derived directly or indirectly from type SBase can have a separate value for 'notes', allowing users considerable freedom when adding comments to their models. The format of 'notes' elements must be XHTML 1.0. To help verify the formatting of 'notes' content, libSBML provides the static utility method SyntaxChecker.hasExpectedXHTMLSyntax(); however, readers are urged to consult the appropriate SBML specification document for the Level and Version of their model for more in-depth explanations. The SBML Level 2 and 3 specifications have considerable detail about how 'notes' element content must be structured. Parameter 'notes' is an XML string that is to appended to the content of the 'notes' subelement of this object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT * LIBSBML_OPERATION_FAILED See also getNotesString(), isSetNotes(), setNotes(), setNotes(), appendNotes(), unsetNotes(), SyntaxChecker.hasExpectedXHTMLSyntax(). ______________________________________________________________________ Method variant with the following signature: appendNotes(XMLNode notes) Appends the given 'notes' to the 'notes' subelement of this object. The content of 'notes' is copied. The optional SBML element named 'notes', present on every major SBML component type, is intended as a place for storing optional information intended to be seen by humans. An example use of the 'notes' element would be to contain formatted user comments about the model element in which the 'notes' element is enclosed. Every object derived directly or indirectly from type SBase can have a separate value for 'notes', allowing users considerable freedom when adding comments to their models. The format of 'notes' elements must be XHTML 1.0. To help verify the formatting of 'notes' content, libSBML provides the static utility method SyntaxChecker.hasExpectedXHTMLSyntax(); however, readers are urged to consult the appropriate SBML specification document for the Level and Version of their model for more in-depth explanations. The SBML Level 2 and 3 specifications have considerable detail about how 'notes' element content must be structured. Parameter 'notes' is an XML node structure that is to appended to the content of the 'notes' subelement of this object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT * LIBSBML_OPERATION_FAILED See also getNotesString(), isSetNotes(), setNotes(), setNotes(), appendNotes(), unsetNotes(), SyntaxChecker.hasExpectedXHTMLSyntax(). """ return _libsbml.SBase_appendNotes(self, *args) def setModelHistory(self, history): """ setModelHistory(SBase self, ModelHistory history) -> int Sets the ModelHistory of this object. The content of 'history' is copied, and this object's existing model history content is deleted. Parameter 'history' is ModelHistory of this object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE * LIBSBML_INVALID_OBJECT Note: In SBML Level 2, model history annotations were only permitted on the Model element. In SBML Level 3, they are permitted on all SBML components derived from SBase. """ return _libsbml.SBase_setModelHistory(self, history) def connectToParent(self, parent): """ connectToParent(SBase self, SBase parent) Internal implementation method. """ return _libsbml.SBase_connectToParent(self, parent) def connectToChild(self): """connectToChild(SBase self)""" return _libsbml.SBase_connectToChild(self) def setSBOTerm(self, *args): """ setSBOTerm(SBase self, int value) -> int setSBOTerm(SBase self, string sboid) -> int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: setSBOTerm(int value) Sets the value of the 'sboTerm' attribute. Beginning with SBML Level 2 Version 2, objects derived from SBase have an optional attribute named 'sboTerm' for supporting the use of the Systems Biology Ontology. In SBML proper, the data type of the attribute is a string of the form 'SBO:NNNNNNN', where 'NNNNNNN' is a seven digit integer number; libSBML simplifies the representation by only storing the 'NNNNNNN' integer portion. Thus, in libSBML, the 'sboTerm' attribute on SBase has data type 'int,' and SBO identifiers are stored simply as integers. SBO terms are a type of optional annotation, and each different class of SBML object derived from SBase imposes its own requirements about the values permitted for 'sboTerm'. More details can be found in SBML specifications for Level 2 Version 2 and above. Parameter 'value' is the NNNNNNN integer portion of the SBO identifier. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE * LIBSBML_UNEXPECTED_ATTRIBUTE See also setSBOTerm(). ______________________________________________________________________ Method variant with the following signature: setSBOTerm(string &sboid) Sets the value of the 'sboTerm' attribute by string. Beginning with SBML Level 2 Version 2, objects derived from SBase have an optional attribute named 'sboTerm' for supporting the use of the Systems Biology Ontology. In SBML proper, the data type of the attribute is a string of the form 'SBO:NNNNNNN', where 'NNNNNNN' is a seven digit integer number; libSBML simplifies the representation by only storing the 'NNNNNNN' integer portion. Thus, in libSBML, the 'sboTerm' attribute on SBase has data type 'int,' and SBO identifiers are stored simply as integers. SBO terms are a type of optional annotation, and each different class of SBML object derived from SBase imposes its own requirements about the values permitted for 'sboTerm'. More details can be found in SBML specifications for Level 2 Version 2 and above. Parameter 'sboid' is the SBO identifier string of the form 'SBO:NNNNNNN'. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE * LIBSBML_UNEXPECTED_ATTRIBUTE See also setSBOTerm(). """ return _libsbml.SBase_setSBOTerm(self, *args) def setNamespaces(self, xmlns): """ setNamespaces(SBase self, XMLNamespaces xmlns) -> int Sets the namespaces relevant of this SBML object. The content of 'xmlns' is copied, and this object's existing namespace content is deleted. The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. Parameter 'xmlns' is the namespaces to set. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS """ return _libsbml.SBase_setNamespaces(self, xmlns) def unsetMetaId(self): """ unsetMetaId(SBase self) -> int Unsets the value of the 'metaid' attribute of this SBML object. The optional attribute named 'metaid', present on every major SBML component type, is for supporting metadata annotations using RDF (Resource Description Format). The attribute value has the data type XML ID, the XML identifier type, which means each 'metaid' value must be globally unique within an SBML file. The latter point is important, because the uniqueness criterion applies across any attribute with type ID anywhere in the file, not just the 'metaid' attribute used by SBML---something to be aware of if your application- specific XML content inside the 'annotation' subelement happens to use the XML ID type. Although SBML itself specifies the use of XML ID only for the 'metaid' attribute, SBML-compatible applications should be careful if they use XML ID's in XML portions of a model that are not defined by SBML, such as in the application-specific content of the 'annotation' subelement. Finally, note that LibSBML does not provide an explicit XML ID data type; it uses ordinary character strings, which is easier for applications to support. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE * LIBSBML_OPERATION_FAILED """ return _libsbml.SBase_unsetMetaId(self) def unsetId(self): """ unsetId(SBase self) -> int Unsets the value of the 'id' attribute of this SBML object. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(). """ return _libsbml.SBase_unsetId(self) def unsetIdAttribute(self): """ unsetIdAttribute(SBase self) -> int Unsets the value of the 'id' attribute of this SBML object. Most (but not all) objects in SBML include two common attributes: 'id' and 'name'. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(). """ return _libsbml.SBase_unsetIdAttribute(self) def unsetName(self): """ unsetName(SBase self) -> int Unsets the value of the 'name' attribute of this SBML object. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also getName(), setName(), isSetName(). """ return _libsbml.SBase_unsetName(self) def unsetNotes(self): """ unsetNotes(SBase self) -> int Unsets the value of the 'notes' subelement of this SBML object. The optional SBML element named 'notes', present on every major SBML component type, is intended as a place for storing optional information intended to be seen by humans. An example use of the 'notes' element would be to contain formatted user comments about the model element in which the 'notes' element is enclosed. Every object derived directly or indirectly from type SBase can have a separate value for 'notes', allowing users considerable freedom when adding comments to their models. The format of 'notes' elements must be XHTML 1.0. To help verify the formatting of 'notes' content, libSBML provides the static utility method SyntaxChecker.hasExpectedXHTMLSyntax(); however, readers are urged to consult the appropriate SBML specification document for the Level and Version of their model for more in-depth explanations. The SBML Level 2 and 3 specifications have considerable detail about how 'notes' element content must be structured. Returns integer value indicating success/failure of the function. This particular function only does one thing irrespective of user input or object state, and thus will only return a single value: * LIBSBML_OPERATION_SUCCESS See also getNotesString(), isSetNotes(), setNotes(), setNotes(), appendNotes(), appendNotes(), SyntaxChecker.hasExpectedXHTMLSyntax(). """ return _libsbml.SBase_unsetNotes(self) def unsetAnnotation(self): """ unsetAnnotation(SBase self) -> int Unsets the value of the 'annotation' subelement of this SBML object. Whereas the SBase 'notes' subelement is a container for content to be shown directly to humans, the 'annotation' element is a container for optional software-generated content not meant to be shown to humans. Every object derived from SBase can have its own value for 'annotation'. The element's content type is XML type 'any', allowing essentially arbitrary well-formed XML data content. SBML places a few restrictions on the organization of the content of annotations; these are intended to help software tools read and write the data as well as help reduce conflicts between annotations added by different tools. Please see the SBML specifications for more details. Returns integer value indicating success/failure of the function. This particular function only does one thing irrespective of user input or object state, and thus will only return a single value: * LIBSBML_OPERATION_SUCCESS See also getAnnotation(), getAnnotationString(), isSetAnnotation(), setAnnotation(), setAnnotation(), appendAnnotation(), appendAnnotation(). """ return _libsbml.SBase_unsetAnnotation(self) def unsetSBOTerm(self): """ unsetSBOTerm(SBase self) -> int Unsets the value of the 'sboTerm' attribute of this SBML object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE """ return _libsbml.SBase_unsetSBOTerm(self) def addCVTerm(self, term, newBag=False): """ addCVTerm(SBase self, CVTerm term, bool newBag=False) -> int addCVTerm(SBase self, CVTerm term) -> int Adds a copy of the given CVTerm object to this SBML object. Parameter 'term' is the CVTerm to assign. Parameter 'newBag' is if 'True,' creates a new RDF bag with the same identifier as a previous bag, and if 'False,' adds the term to an existing RDF bag with the same type of qualifier as the term being added. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_UNEXPECTED_ATTRIBUTE, if this object lacks a 'metaid' attribute * LIBSBML_INVALID_OBJECT Note: Since the CV Term uses the 'metaid' attribute of the object as a reference, if the object has no 'metaid' attribute value set, then the CVTerm will not be added. Note: This method should be used with some caution. The fact that this method copies the object passed to it means that the caller will be left holding a physically different object instance than the one contained inside this object. Changes made to the original object instance (such as resetting attribute values) will not affect the instance in this object. In addition, the caller should make sure to free the original object if it is no longer being used, or else a memory leak will result. Please see other methods on this class (particularly a corresponding method whose name begins with the word create) for alternatives that do not lead to these issues.

Documentation note:
The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation.
Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.SBase_addCVTerm(self, term, newBag) def getCVTerms(self): """ getCVTerms(self) -> CVTermList Get the List of CVTerm objects in this element. Returns the CVTermList for this element. """ cvlist = _libsbml.SBase_getCVTerms(self) if cvlist is None: return [] else: return cvlist def getNumCVTerms(self): """ getNumCVTerms(SBase self) -> unsigned int Returns the number of CVTerm objects in the annotations of this SBML object. Returns the number of CVTerms for this SBML object. """ return _libsbml.SBase_getNumCVTerms(self) def getCVTerm(self, n): """ getCVTerm(SBase self, unsigned int n) -> CVTerm Returns the nth CVTerm in the list of CVTerms of this SBML object. Parameter 'n' is long the index of the CVTerm to retrieve. Returns the nth CVTerm in the list of CVTerms for this SBML object. If the index 'n' is invalid, 'None' is returned. """ return _libsbml.SBase_getCVTerm(self, n) def unsetCVTerms(self): """ unsetCVTerms(SBase self) -> int Clears the list of CVTerm objects attached to this SBML object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.SBase_unsetCVTerms(self) def unsetModelHistory(self): """ unsetModelHistory(SBase self) -> int Unsets the ModelHistory object attached to this object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE * LIBSBML_OPERATION_FAILED Note: In SBML Level 2, model history annotations were only permitted on the Model element. In SBML Level 3, they are permitted on all SBML components derived from SBase. """ return _libsbml.SBase_unsetModelHistory(self) def getResourceBiologicalQualifier(self, resource): """ getResourceBiologicalQualifier(SBase self, string resource) -> BiolQualifierType_t Returns the MIRIAM biological qualifier associated with the given resource. In MIRIAM, qualifiers are an optional means of indicating the relationship between a model component and its annotations. There are two broad kinds of annotations: model and biological. The latter kind is used to qualify the relationship between a model component and a biological entity which it represents. Examples of relationships include 'is' and 'has part', but many others are possible. MIRIAM defines numerous relationship qualifiers to enable different software tools to qualify biological annotations in the same standardized way. In libSBML, the MIRIAM controlled-vocabulary annotations on an SBML model element are represented using lists of CVTerm objects, and the the MIRIAM biological qualifiers are represented using values whose names begin with BQB_ in the interface class libsbml. This method searches the controlled-vocabulary annotations (i.e., the list of CVTerm objects) on the present object, then out of those that have biological qualifiers, looks for an annotation to the given 'resource'. If such an annotation is found, it returns the type of biological qualifier associated with that resource as a value whose name begins with BQB_ from the interface class libsbml. Parameter 'resource' is string representing the resource; e.g., 'http://www.geneontology.org/#GO:0005892'. Returns the qualifier associated with the resource, or BQB_UNKNOWN if the resource does not exist. Note: The set of MIRIAM biological qualifiers grows over time, although relatively slowly. The values are up to date with MIRIAM at the time of a given libSBML release. The set of values in list of BQB_ constants defined in libsbml may be expanded in later libSBML releases, to match the values defined by MIRIAM at that later time. """ return _libsbml.SBase_getResourceBiologicalQualifier(self, resource) def getResourceModelQualifier(self, resource): """ getResourceModelQualifier(SBase self, string resource) -> ModelQualifierType_t Returns the MIRIAM model qualifier associated with the given resource. In MIRIAM, qualifiers are an optional means of indicating the relationship between a model component and its annotations. There are two broad kinds of annotations: model and biological. The former kind is used to qualify the relationship between a model component and another modeling object. An example qualifier is 'isDerivedFrom', to indicate that a given component of the model is derived from the modeling object represented by the referenced resource. MIRIAM defines numerous relationship qualifiers to enable different software tools to qualify model annotations in the same standardized way. In libSBML, the MIRIAM controlled-vocabulary annotations on an SBML model element are represented using lists of CVTerm objects, and the the MIRIAM model qualifiers are represented using values whose names begin with BQM_ in the interface class libsbml. This method method searches the controlled-vocabulary annotations (i.e., the list of CVTerm objects) on the present object, then out of those that have model qualifiers, looks for an annotation to the given 'resource'. If such an annotation is found, it returns the type of type of model qualifier associated with that resource as a value whose name begins with BQM_ from the interface class libsbml. Parameter 'resource' is string representing the resource; e.g., 'http://www.geneontology.org/#GO:0005892'. Returns the model qualifier type associated with the resource, or BQM_UNKNOWN if the resource does not exist. Note: The set of MIRIAM model qualifiers grows over time, although relatively slowly. The values are up to date with MIRIAM at the time of a given libSBML release. The set of values in list of BQM_ constants defined in libsbml may be expanded in later libSBML releases, to match the values defined by MIRIAM at that later time. """ return _libsbml.SBase_getResourceModelQualifier(self, resource) def getModel(self): """ getModel(SBase self) -> Model Returns the Model object for the SBML Document in which the current object is located. Returns the Model object for the SBML Document of this SBML object. See also getParentSBMLObject(), getSBMLDocument(). """ return _libsbml.SBase_getModel(self) def getLevel(self): """ getLevel(SBase self) -> unsigned int Returns the SBML Level of the SBMLDocument object containing this object. LibSBML uses the class SBMLDocument as a top-level container for storing SBML content and data associated with it (such as warnings and error messages). An SBML model in libSBML is contained inside an SBMLDocument object. SBMLDocument corresponds roughly to the class SBML defined in the SBML Level 3 and Level 2 specifications, but it does not have a direct correspondence in SBML Level 1. (But, it is created by libSBML no matter whether the model is Level 1, Level 2 or Level 3.) Returns the SBML level of this SBML object. See also getVersion(), getNamespaces(), getPackageVersion(). """ return _libsbml.SBase_getLevel(self) def getVersion(self): """ getVersion(SBase self) -> unsigned int Returns the Version within the SBML Level of the SBMLDocument object containing this object. LibSBML uses the class SBMLDocument as a top-level container for storing SBML content and data associated with it (such as warnings and error messages). An SBML model in libSBML is contained inside an SBMLDocument object. SBMLDocument corresponds roughly to the class SBML defined in the SBML Level 3 and Level 2 specifications, but it does not have a direct correspondence in SBML Level 1. (But, it is created by libSBML no matter whether the model is Level 1, Level 2 or Level 3.) Returns the SBML version of this SBML object. See also getLevel(), getNamespaces(). """ return _libsbml.SBase_getVersion(self) def getPackageCoreVersion(self): """ getPackageCoreVersion(SBase self) -> unsigned int Returns the SBML Core Version within the SBML Level of the actual object. LibSBML uses the class SBMLDocument as a top-level container for storing SBML content and data associated with it (such as warnings and error messages). An SBML model in libSBML is contained inside an SBMLDocument object. SBMLDocument corresponds roughly to the class SBML defined in the SBML Level 3 and Level 2 specifications, but it does not have a direct correspondence in SBML Level 1. (But, it is created by libSBML no matter whether the model is Level 1, Level 2 or Level 3.) Returns the SBML core version of this SBML object. """ return _libsbml.SBase_getPackageCoreVersion(self) def getPackageVersion(self): """ getPackageVersion(SBase self) -> unsigned int Returns the Version of the SBML Level 3 package to which this element belongs to. Returns the version of the SBML Level 3 package to which this element belongs. The value '0' will be returned if this element belongs to the SBML Level 3 Core package. See also getLevel(), getVersion(). """ return _libsbml.SBase_getPackageVersion(self) def getPackageName(self): """ getPackageName(SBase self) -> string Returns the name of the SBML Level 3 package in which this element is defined. Returns the name of the SBML package in which this element is defined. The string "core" will be returned if this element is defined in SBML Level 3 Core. The string "unknown" will be returned if this element is not defined in any SBML package. """ return _libsbml.SBase_getPackageName(self) def getTypeCode(self): """ getTypeCode(SBase self) -> int Returns the libSBML type code for this object. LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Here follow some additional general information about libSBML type codes: * The codes are the possible return values (integers) for the following functions: * SBase.getTypeCode() * ListOf.getItemTypeCode() (Compatibility note: in libSBML 5, the type of return values of these functions changed from an enumeration to an integer for extensibility in the face of different programming languages.) * Each package extension must define similar sets of values for each SBase subclass (e.g. SBMLLayoutTypeCode_t for the SBML Level 3 Layout extension, SBMLFbcTypeCode_t for the SBML Level 3 Flux Balance Constraints extension, etc.). * The value of each package-specific type code can be duplicated between those of different packages. (This is necessary because the development of libSBML extensions for different SBML packages may be undertaken by different developers at different times; requiring the developers to coordinate their use of type codes would be nettlesome and probably doomed to failure.) * To distinguish between the type codes of different packages, both the return value of SBase.getTypeCode() and SBase.getPackageName() must be checked. This is particularly important for functions that take an SBML type code as an argument, such as SBase.getAncestorOfType(), which by default assumes you are handing it a core type, and will return 'None' if the value you give it is actually from a package. The following example code illustrates the combined use of SBase.getPackageName() and SBase.getTypeCode(): def example(item): pkg_name = item.getPackageName() type_code = item.getTypeCode() if pkg_name == 'core': print('Got a ' + SBMLTypeCode_toString(type_code, 'core') + ' object') if type_code == SBML_MODEL: print('This is a very, very nice model') # Do whatever the application wants to do with the model. elif type_code == SBML_COMPARTMENT: print('This is a very, very nice compartment') # Do whatever the application wants to do with the compartment. elif type_code == SBML_SPECIES: print('This is a very, very nice species') # Do whatever the application wants to do with the species. elif ... ... elif pkg_name == 'layout': print('Got a ' + SBMLTypeCode_toString(type_code, 'layout') + ' object') if type_code == SBML_LAYOUT_POINT: print('This is a very, very nice layout point') # Do whatever the application wants to do with the layout point. elif type_code == SBML_LAYOUT_BOUNDINGBOX: print('This is a very, very nice layout bounding box') # Do whatever the application wants to do with the layout bounding box. elif ... ... elif pkg_name == 'unknown': print('Something went wrong -- libSBML did not recognize the object type') # Handle errors Returns the SBML object type code of this SBML object, or SBML_UNKNOWN (the default). The latter is possible because subclasses of SBase are not required to implement this method to return a type code. WARNING: The specific integer values of the possible type codes may be reused by different libSBML plug-ins for SBML Level 3. packages, To fully identify the correct code, it is necessary to invoke both getPackageName() and getTypeCode() (or ListOf.getItemTypeCode()). See also getPackageName(), getElementName(). """ return _libsbml.SBase_getTypeCode(self) def hasValidLevelVersionNamespaceCombination(self): """ hasValidLevelVersionNamespaceCombination(SBase self) -> bool Predicate returning @c true if this object's level/version and namespace values correspond to a valid SBML specification. The valid combinations of SBML Level, Version and Namespace as of this release of libSBML are the following: @return @c true if the level, version and namespace values of this SBML object correspond to a valid set of values, @c false otherwise. """ return _libsbml.SBase_hasValidLevelVersionNamespaceCombination(self) def getElementName(self): """ getElementName(SBase self) -> string Returns the XML element name of this object. This is overridden by subclasses to return a string appropriate to the SBML component. For example, Model defines it as returning ''model',' CompartmentType defines it as returning ''compartmentType',' and so on. """ return _libsbml.SBase_getElementName(self) def toSBML(self): """ toSBML(SBase self) -> char * Returns a string consisting of a partial SBML corresponding to just this object. Returns the partial SBML that describes this SBML object. WARNING: This is primarily provided for testing and debugging purposes. It may be removed in a future version of libSBML. """ return _libsbml.SBase_toSBML(self) def toXMLNode(self): """ toXMLNode(SBase self) -> XMLNode Returns this element as an XMLNode. Returns this element as an XMLNode. WARNING: This operation is computationally expensive, because the element has to be fully serialized to a string and then parsed into the XMLNode structure. Attempting to convert a large tree structure (e.g., a large Model) may consume significant computer memory and time. """ return _libsbml.SBase_toXMLNode(self) def getPlugin(self, *args): """ getPlugin(SBase self, string package) -> SBasePlugin getPlugin(SBase self, string package) -> SBasePlugin getPlugin(SBase self, unsigned int n) -> SBasePlugin getPlugin(SBase self, unsigned int n) -> SBasePlugin This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getPlugin(long n) Returns the nth plug-in object (extension interface) for an SBML Level 3 package extension. The returned plug-in will be the appropriate type of plugin requested: calling Model.getPlugin() will return an FbcModelPlugin; calling Parameter.getPlugin() will return CompSBasePlugin, etc. If no such plugin exists, None is returned. SBML Level 3 consists of a Core definition that can be extended via optional SBML Level 3 packages. A given model may indicate that it uses one or more SBML packages, and likewise, a software tool may be able to support one or more packages. LibSBML does not come preconfigured with all possible packages included and enabled, in part because not all package specifications have been finalized. To support the ability for software systems to enable support for the Level 3 packages they choose, libSBML features a plug-in mechanism. Each SBML Level 3 package is implemented in a separate code plug-in that can be enabled by the application to support working with that SBML package. A given SBML model may thus contain not only objects defined by SBML Level 3 Core, but also objects created by libSBML plug-ins supporting additional Level 3 packages. Parameter 'n' is the index of the plug-in to return. Returns the nth plug-in object (the libSBML extension interface) of a package extension. If the index 'n' is invalid, 'None' is returned. See also getNumPlugins(), getPlugin(). ______________________________________________________________________ Method variant with the following signature: getPlugin(string package) Returns a plug-in object (extension interface) for an SBML Level 3 package extension with the given package name or URI. The returned plug-in will be the appropriate type of plugin requested: calling Model.getPlugin() will return an FbcModelPlugin; calling Parameter.getPlugin() will return CompSBasePlugin, etc. If no such plugin exists, None is returned. SBML Level 3 consists of a Core definition that can be extended via optional SBML Level 3 packages. A given model may indicate that it uses one or more SBML packages, and likewise, a software tool may be able to support one or more packages. LibSBML does not come preconfigured with all possible packages included and enabled, in part because not all package specifications have been finalized. To support the ability for software systems to enable support for the Level 3 packages they choose, libSBML features a plug-in mechanism. Each SBML Level 3 package is implemented in a separate code plug-in that can be enabled by the application to support working with that SBML package. A given SBML model may thus contain not only objects defined by SBML Level 3 Core, but also objects created by libSBML plug-ins supporting additional Level 3 packages. Parameter 'package' is the name or URI of the package. Returns the plug-in object (the libSBML extension interface) of a package extension with the given package name or URI. See also getPlugin(). """ return _libsbml.SBase_getPlugin(self, *args) def getDisabledPlugin(self, *args): """ getDisabledPlugin(SBase self, unsigned int n) -> SBasePlugin getDisabledPlugin(SBase self, unsigned int n) -> SBasePlugin Returns the nth disabled plug-in object (extension interface) for an SBML Level 3 package extension. If no such plugin exists, None is returned. SBML Level 3 consists of a Core definition that can be extended via optional SBML Level 3 packages. A given model may indicate that it uses one or more SBML packages, and likewise, a software tool may be able to support one or more packages. LibSBML does not come preconfigured with all possible packages included and enabled, in part because not all package specifications have been finalized. To support the ability for software systems to enable support for the Level 3 packages they choose, libSBML features a plug-in mechanism. Each SBML Level 3 package is implemented in a separate code plug-in that can be enabled by the application to support working with that SBML package. A given SBML model may thus contain not only objects defined by SBML Level 3 Core, but also objects created by libSBML plug-ins supporting additional Level 3 packages. If a plugin is disabled, the package information it contains is no longer considered to be part of the SBML document for the purposes of searching the document or writing out the document. However, the information is still retained, so if the plugin is enabled again, the same information will once again be available, and will be written out to the final model. Parameter 'n' is the index of the disabled plug-in to return. Returns the nth disabled plug-in object (the libSBML extension interface) of a package extension. If the index 'n' is invalid, 'None' is returned. See also getNumDisabledPlugins(), getPlugin(). """ return _libsbml.SBase_getDisabledPlugin(self, *args) def getNumPlugins(self): """ getNumPlugins(SBase self) -> unsigned int Returns the number of plug-in objects (extenstion interfaces) for SBML Level 3 package extensions known. SBML Level 3 consists of a Core definition that can be extended via optional SBML Level 3 packages. A given model may indicate that it uses one or more SBML packages, and likewise, a software tool may be able to support one or more packages. LibSBML does not come preconfigured with all possible packages included and enabled, in part because not all package specifications have been finalized. To support the ability for software systems to enable support for the Level 3 packages they choose, libSBML features a plug-in mechanism. Each SBML Level 3 package is implemented in a separate code plug-in that can be enabled by the application to support working with that SBML package. A given SBML model may thus contain not only objects defined by SBML Level 3 Core, but also objects created by libSBML plug-ins supporting additional Level 3 packages. Returns the number of plug-in objects (extension interfaces) of package extensions known by this instance of libSBML. See also getPlugin(). """ return _libsbml.SBase_getNumPlugins(self) def getNumDisabledPlugins(self): """ getNumDisabledPlugins(SBase self) -> unsigned int Returns the number of disabled plug-in objects (extension interfaces) for SBML Level 3 package extensions known. SBML Level 3 consists of a Core definition that can be extended via optional SBML Level 3 packages. A given model may indicate that it uses one or more SBML packages, and likewise, a software tool may be able to support one or more packages. LibSBML does not come preconfigured with all possible packages included and enabled, in part because not all package specifications have been finalized. To support the ability for software systems to enable support for the Level 3 packages they choose, libSBML features a plug-in mechanism. Each SBML Level 3 package is implemented in a separate code plug-in that can be enabled by the application to support working with that SBML package. A given SBML model may thus contain not only objects defined by SBML Level 3 Core, but also objects created by libSBML plug-ins supporting additional Level 3 packages. If a plugin is disabled, the package information it contains is no longer considered to be part of the SBML document for the purposes of searching the document or writing out the document. However, the information is still retained, so if the plugin is enabled again, the same information will once again be available, and will be written out to the final model. Returns the number of disabled plug-in objects (extension interfaces) of package extensions known by this instance of libSBML. """ return _libsbml.SBase_getNumDisabledPlugins(self) def deleteDisabledPlugins(self, recursive=True): """ deleteDisabledPlugins(SBase self, bool recursive=True) deleteDisabledPlugins(SBase self) Deletes all information stored in disabled plugins. If the plugin is re-enabled later, it will then not have any previously-stored information. SBML Level 3 consists of a Core definition that can be extended via optional SBML Level 3 packages. A given model may indicate that it uses one or more SBML packages, and likewise, a software tool may be able to support one or more packages. LibSBML does not come preconfigured with all possible packages included and enabled, in part because not all package specifications have been finalized. To support the ability for software systems to enable support for the Level 3 packages they choose, libSBML features a plug-in mechanism. Each SBML Level 3 package is implemented in a separate code plug-in that can be enabled by the application to support working with that SBML package. A given SBML model may thus contain not only objects defined by SBML Level 3 Core, but also objects created by libSBML plug-ins supporting additional Level 3 packages. If a plugin is disabled, the package information it contains is no longer considered to be part of the SBML document for the purposes of searching the document or writing out the document. However, the information is still retained, so if the plugin is enabled again, the same information will once again be available, and will be written out to the final model. Parameter 'recursive' is if 'True,' the disabled information will be deleted also from all child elements, otherwise only from this SBase element. See also getNumDisabledPlugins(). """ return _libsbml.SBase_deleteDisabledPlugins(self, recursive) def enablePackage(self, pkgURI, pkgPrefix, flag): """ enablePackage(SBase self, string pkgURI, string pkgPrefix, bool flag) -> int Enables or disables the given SBML Level 3 package on this object. This method enables the specified package on this object and other objects connected by child-parent links in the same SBMLDocument object. This method is the converse of SBase.disablePackage(). Parameter 'pkgURI' is the URI of the package. Parameter 'pkgPrefix' is the XML prefix of the package. Parameter 'flag' is whether to enable ('True)' or disable ('False)' the package. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_PKG_UNKNOWN * LIBSBML_PKG_VERSION_MISMATCH * LIBSBML_PKG_CONFLICTED_VERSION See also disablePackage(). """ return _libsbml.SBase_enablePackage(self, pkgURI, pkgPrefix, flag) def disablePackage(self, pkgURI, pkgPrefix): """ disablePackage(SBase self, string pkgURI, string pkgPrefix) -> int Disables the given SBML Level 3 package on this object. This method disables the specified package on this object and other objects connected by child-parent links in the same SBMLDocument object. An example of when this may be useful is during construction of model components when mixing existing and new models. Suppose your application read an SBML document containing a model that used the SBML Hierarchical Model Composition ("comp") package, and extracted parts of that model in order to construct a new model in memory. The new, in-memory model will not accept a component drawn from an other SBMLDocument with different package namespace declarations. You could reconstruct the same namespaces in the in-memory model first, but as a shortcut, you could also disable the package namespace on the object being added. Here is a code example to help clarify this: import sys import os.path from libsbml import * # We read an SBML L3V1 model that uses the 'comp' package. doc = readSBML('sbml-file-with-comp-elements.xml'); if doc.getNumErrors() > 0: print('readSBML encountered errors while reading the file.') doc.printErrors() sys.exit(1) # We extract one of the species from the model. model = doc.getModel() if model == None: print('Unable to retrieve Model object') sys.exit(1) s1 = model.getSpecies(0) if s1 == None: print('Unable to retrieve Species object') sys.exit(1) # We construct a new model. # This model does not use the 'comp' package. try: newDoc = SBMLDocument(3, 1) except ValueError: print('Could not create SBMLDocument object') sys.exit(1) newModel = newDoc.createModel() if newModel == None: print('Unable to create new Model object') sys.exit(1) # The following would normally fail with an error, because # addSpecies() would first check that the parent of the given # object has namespaces declared, and will discover that s1 # does but newModel does not. # newModel.addSpecies(s1) # However, if we disable the 'comp' package on s1, then the # call to addSpecies will work. compNS = 'http://www.sbml.org/sbml/level3/version1/comp/version1' status = s1.disablePackage(compNS, 'comp') if status != LIBSBML_OPERATION_SUCCESS: print('Unable to disable package.') sys.exit(1) newSpecies = newModel.addSpecies(s1) # This will work now. if newSpecies == None: print('Could not add Species') # (This will not happen, sys.exit(1) # but always check errors.) Parameter 'pkgURI' is the URI of the package. Parameter 'pkgPrefix' is the XML prefix of the package. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_PKG_UNKNOWN * LIBSBML_PKG_VERSION_MISMATCH * LIBSBML_PKG_CONFLICTED_VERSION See also enablePackage(). """ return _libsbml.SBase_disablePackage(self, pkgURI, pkgPrefix) def enablePackageInternal(self, pkgURI, pkgPrefix, flag): """ enablePackageInternal(SBase self, string pkgURI, string pkgPrefix, bool flag) Internal implementation method. """ return _libsbml.SBase_enablePackageInternal(self, pkgURI, pkgPrefix, flag) def isPackageURIEnabled(self, pkgURI): """ isPackageURIEnabled(SBase self, string pkgURI) -> bool Predicate returning 'True' if an SBML Level 3 package with the given URI is enabled with this object. Parameter 'pkgURI' is the URI of the package. Returns 'True' if the given package is enabled within this object, 'False' otherwise. See also isPackageEnabled(). """ return _libsbml.SBase_isPackageURIEnabled(self, pkgURI) def isPackageEnabled(self, pkgName): """ isPackageEnabled(SBase self, string pkgName) -> bool Predicate returning 'True' if the given SBML Level 3 package is enabled with this object. The search ignores the package version. Parameter 'pkgName' is the name of the package. Returns 'True' if the given package is enabled within this object, 'False' otherwise. See also isPackageURIEnabled(). """ return _libsbml.SBase_isPackageEnabled(self, pkgName) def isPkgURIEnabled(self, pkgURI): """ isPkgURIEnabled(SBase self, string pkgURI) -> bool Predicate returning 'True' if an SBML Level 3 package with the given URI is enabled with this object. Parameter 'pkgURI' is the URI of the package. Returns 'True' if the given package is enabled within this object, 'False' otherwise. DEPRECATED. Replaced in libSBML 5.2.0 by SBase.isPackageURIEnabled(). See also isPkgEnabled(). """ return _libsbml.SBase_isPkgURIEnabled(self, pkgURI) def isPkgEnabled(self, pkgName): """ isPkgEnabled(SBase self, string pkgName) -> bool Predicate returning 'True' if the given SBML Level 3 package is enabled with this object. The search ignores the package version. Parameter 'pkgName' is the name of the package. Returns 'True' if the given package is enabled within this object, 'False' otherwise. DEPRECATED. Replaced in libSBML 5.2.0 by SBase.isPackageEnabled(). See also isPkgURIEnabled(). """ return _libsbml.SBase_isPkgEnabled(self, pkgName) def writeExtensionElements(self, stream): """ writeExtensionElements(SBase self, XMLOutputStream stream) Internal implementation method. """ return _libsbml.SBase_writeExtensionElements(self, stream) def hasRequiredAttributes(self): """ hasRequiredAttributes(SBase self) -> bool Internal implementation method. """ return _libsbml.SBase_hasRequiredAttributes(self) def hasRequiredElements(self): """ hasRequiredElements(SBase self) -> bool Internal implementation method. """ return _libsbml.SBase_hasRequiredElements(self) def checkCompatibility(self, object): """ checkCompatibility(SBase self, SBase object) -> int Internal implementation method. """ return _libsbml.SBase_checkCompatibility(self, object) def setSBMLNamespacesAndOwn(self, disownedNs): """ setSBMLNamespacesAndOwn(SBase self, SBMLNamespaces disownedNs) Internal implementation method. """ return _libsbml.SBase_setSBMLNamespacesAndOwn(self, disownedNs) def getSBMLNamespaces(self): """ getSBMLNamespaces(SBase self) -> SBMLNamespaces Internal implementation method. """ return _libsbml.SBase_getSBMLNamespaces(self) def checkMathMLNamespace(self, elem): """ checkMathMLNamespace(SBase self, XMLToken elem) -> string Internal implementation method. """ return _libsbml.SBase_checkMathMLNamespace(self, elem) def getDerivedUnitDefinition(self): """ getDerivedUnitDefinition(SBase self) -> UnitDefinition Internal implementation method. """ return _libsbml.SBase_getDerivedUnitDefinition(self) def containsUndeclaredUnits(self): """ containsUndeclaredUnits(SBase self) -> bool Internal implementation method. """ return _libsbml.SBase_containsUndeclaredUnits(self) def removeFromParentAndDelete(self): """ removeFromParentAndDelete(SBase self) -> int Removes this object from its parent. If the parent was storing this object as a pointer, it is deleted. If not, it is simply cleared (as in ListOf objects). This is a pure virtual method, as every SBase element has different parents, and therefore different methods of removing itself. Will fail (and not delete itself) if it has no parent object. This function is designed to be overridden, but for all objects whose parent is of the class ListOf, the default implementation will work. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.SBase_removeFromParentAndDelete(self) def matchesSBMLNamespaces(self, *args): """ matchesSBMLNamespaces(SBase self, SBase sb) -> bool matchesSBMLNamespaces(SBase self, SBase sb) -> bool Returns 'True' if this object's set of XML namespaces are the same as the given object's XML namespaces. The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments. Parameter 'sb' is an object to compare with respect to namespaces. Returns boolean, 'True' if this object's collection of namespaces is the same as 'sb's', 'False' otherwise. """ return _libsbml.SBase_matchesSBMLNamespaces(self, *args) def matchesRequiredSBMLNamespacesForAddition(self, *args): """ matchesRequiredSBMLNamespacesForAddition(SBase self, SBase sb) -> bool matchesRequiredSBMLNamespacesForAddition(SBase self, SBase sb) -> bool Returns 'True' if this object's set of XML namespaces are a subset of the given object's XML namespaces. The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments. Parameter 'sb' is an object to compare with respect to namespaces. Returns boolean, 'True' if this object's collection of namespaces is a subset of 'sb's', 'False' otherwise. """ return _libsbml.SBase_matchesRequiredSBMLNamespacesForAddition(self, *args) def isSetUserData(self): """ isSetUserData(SBase self) -> bool Predicate returning true or false depending on whether the user data of this element has been set. The user data associated with an SBML object can be used by an application developer to attach custom information to that object in the model. In case of a deep copy, this data will passed as-is. The data attribute will never be interpreted by libSBML. Returns boolean, 'True' if this object's user data has been set, 'False' otherwise. """ return _libsbml.SBase_isSetUserData(self) def unsetUserData(self): """ unsetUserData(SBase self) -> int Unsets the user data of this element. The user data associated with an SBML object can be used by an application developer to attach custom information to that object in the model. In case of a deep copy, this data will passed as-is. The data attribute will never be interpreted by libSBML. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.SBase_unsetUserData(self) def getURI(self): """ getURI(SBase self) -> string Gets the namespace URI to which this element belongs to. For example, all elements that belong to SBML Level 3 Version 1 Core must would have the URI 'http://www.sbml.org/sbml/level3/version1/core'; all elements that belong to Layout Extension Version 1 for SBML Level 3 Version 1 Core must would have the URI 'http://www.sbml.org/sbml/level3/version1/layout/version1'. This function first returns the URI for this element by looking into the SBMLNamespaces object of the document with the its package name. If not found, it will then look for the namespace associated with the element itself. Returns the URI of this element, as a text string. See also getSBMLDocument(), getPackageName(). """ return _libsbml.SBase_getURI(self) def getPrefix(self): """ getPrefix(SBase self) -> string Returns the XML namespace prefix of this element. This reports the XML namespace prefix chosen for this class of object in the current SBML document. This may be an empty string if the component has no explicit prefix (for instance, if it is a core SBML object placed in the default SBML namespace of the document). If it is not empty, then it corresponds to the XML namespace prefix used set the object, whatever that may be in a given SBML document. Returns a text string representing the XML namespace prefix. """ return _libsbml.SBase_getPrefix(self) def hasOptionalAttributes(self): """ hasOptionalAttributes(SBase self) -> bool Internal implementation method. """ return _libsbml.SBase_hasOptionalAttributes(self) def hasOptionalElements(self): """ hasOptionalElements(SBase self) -> bool Internal implementation method. """ return _libsbml.SBase_hasOptionalElements(self) def updateSBMLNamespace(self, package, level, version): """ updateSBMLNamespace(SBase self, string package, unsigned int level, unsigned int version) Internal implementation method. """ return _libsbml.SBase_updateSBMLNamespace(self, package, level, version) __metaclass__ = AutoProperty def __eq__(self, rhs): if ((self is None) and (rhs is None)): return True if ((self is None) or (rhs is None)): return False if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return True return False def __ne__(self, rhs): if ((self is None) and (rhs is None)): return False if ((self is None) or (rhs is None)): return True if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return False return True def getListOfAllElements(self, *args): """ getListOfAllElements(self) -> SBaseList Get the List of all SBase objects in this element. Returns the List of all child elements. """ return _libsbml.SBase_getListOfAllElements(self, *args) def getListOfAllElementsFromPlugins(self, *args): """ getListOfAllElementsFromPlugins(self) -> SBaseList Get the List of SBase objects in this elements plugins. Returns the SBaseList of all plugins for this element. """ return _libsbml.SBase_getListOfAllElementsFromPlugins(self, *args) SBase_swigregister = _libsbml.SBase_swigregister SBase_swigregister(SBase) class ListOf(SBase): """ Parent class for libSBML's 'ListOfXYZ' classes. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. The ListOf class in libSBML is a utility class that serves as the parent class for implementing the ListOf__ classes. It provides methods for working generically with the various SBML lists of objects in a program. LibSBML uses this separate list class rather than ordinary Python lists, so that it can provide the methods and features associated with SBase. Whether a given ListOf element may be empty or not depends on the element in question, and on what level and version of SBML it is being used for. For ListOf elements in SBML Level 3 Version 1 and prior, no core list and few package lists could be empty. As of SBML Level 3 Version 2, the rules were relaxed, and lists were allowed to be empty. In libSBML, documents created for Level 3 Version 2 will be written with empty ListOf's if that ListOf contains some other 'extra' information: an attribute such as metaid or sboTerm, a child '' or '', or information from a SBML Level 3 package. The various ListOf___ classes in SBML are merely containers used for organizing the main components of an SBML model. In libSBML's implementation, ListOf___ classes are derived from the intermediate utility class ListOf, which is not defined by the SBML specifications but serves as a useful programmatic construct. ListOf is itself is in turn derived from SBase, which provides all of the various ListOf___ classes with common features defined by the SBML specification, such as 'metaid' attributes and annotations. The relationship between the lists and the rest of an SBML model is illustrated by the following (for SBML Level 2 Version 4): ... ... ... ... ... ... ... elements of subclasses of Rule ... ... ... ... SBML Level 3 Version 1 has essentially the same structure as Level 2 Version 4, depicted above, but SBML Level 3 Version 2 allows containers to contain zero or more of the relevant object, instead of requiring at least one. As such, libsbml will write out an otherwise-empty ListOf___ element that has any optional attribute set (such as 'id' or 'metaid'), that has an optional child (such as a 'notes' or 'annotation'), or that has attributes or children set from any SBML Level 3 package, whether or not the ListOf___ has any other children. Readers may wonder about the motivations for using the ListOf___ containers in SBML. A simpler approach in XML might be to place the components all directly at the top level of the model definition. The choice made in SBML is to group them within XML elements named after ListOfClassname, in part because it helps organize the components. More importantly, the fact that the container classes are derived from SBase means that software tools can add information about the lists themselves into each list container's 'annotation'. See also ListOfFunctionDefinitions, ListOfUnitDefinitions, ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments, ListOfSpecies, ListOfParameters, ListOfInitialAssignments, ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents. """ __swig_setmethods__ = {} for _s in [SBase]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, ListOf, name, value) __swig_getmethods__ = {} for _s in [SBase]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, ListOf, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_ListOf __del__ = lambda self: None def __init__(self, *args): """ __init__(ListOf self, unsigned int level, unsigned int version) -> ListOf __init__(ListOf self, unsigned int level) -> ListOf __init__(ListOf self) -> ListOf __init__(ListOf self, SBMLNamespaces sbmlns) -> ListOf __init__(ListOf self, ListOf orig) -> ListOf This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: ListOf(SBMLNamespaces sbmlns) Creates a new ListOf with a given SBMLNamespaces object. Parameter 'sbmlns' is the set of SBML namespaces that this ListOf should contain. Note: Bare ListOf objects are impossible to add to SBML models. The ListOf class is simply the base of other classes in libSBML. Calling programs are not intended to create bare ListOf objects themselves. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: ListOf(long level = SBML_DEFAULT_LEVEL, long version = SBML_DEFAULT_VERSION) Creates a new ListOf object. Parameter 'level' is the SBML Level; if not assigned, defaults to the value of SBMLDocument.getDefaultLevel(). Parameter 'version' is the Version within the SBML Level; if not assigned, defaults to the value of SBMLDocument.getDefaultVersion(). Note: Bare ListOf objects are impossible to add to SBML models. The ListOf class is simply the base of other classes in libSBML. Calling programs are not intended to create bare ListOf objects themselves. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute.
Documentation note:
The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation.
Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. ______________________________________________________________________ Method variant with the following signature: ListOf(ListOf orig) Copy constructor; creates a copy of this ListOf. Parameter 'orig' is the ListOf instance to copy. """ this = _libsbml.new_ListOf(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(ListOf self) -> ListOf Creates and returns a deep copy of this ListOf object. Returns the (deep) copy of this ListOf object. """ return _libsbml.ListOf_clone(self) def append(self, item): """ append(ListOf self, SBase item) -> int Adds an item to the end of this ListOf's list of items. This method makes a clone of the 'item' handed to it. This means that when the ListOf object is destroyed, the original items will not be destroyed. For a method with an alternative ownership behavior, see the ListOf.appendAndOwn() method. Parameter 'item' is the item to be added to the list. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT See also appendAndOwn(), appendFrom(). """ return _libsbml.ListOf_append(self, item) def appendAndOwn(self, disownedItem): """ appendAndOwn(ListOf self, SBase disownedItem) -> int Adds an item to the end of this ListOf's list of items. This method does not clone the 'disownedItem' handed to it; instead, it assumes ownership of it. This means that when the ListOf is destroyed, the item will be destroyed along with it. For a method with an alternative ownership behavior, see the ListOf.append() method. Parameter 'disownedItem' is the item to be added to the list. Will become a child of the parent list. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT See also append(), appendFrom(). """ return _libsbml.ListOf_appendAndOwn(self, disownedItem) def appendFrom(self, list): """ appendFrom(ListOf self, ListOf list) -> int Adds a clone of a list of items to this ListOf's list. Note that because this clones the objects handed to it, the original items will not be destroyed when this ListOf object is destroyed. Parameter 'list' is a list of items to be added. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT See also append(), appendAndOwn(). """ return _libsbml.ListOf_appendFrom(self, list) def insert(self, location, item): """ insert(ListOf self, int location, SBase item) -> int Inserts an item at a given position in this ListOf's list of items. This variant of the method makes a clone of the 'item' handed to it. This means that when the ListOf is destroyed, the original 'item' will not be destroyed. Parameter 'location' is the location in the list where to insert the item. Parameter 'item' is the item to be inserted to the list. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT See also insertAndOwn(). """ return _libsbml.ListOf_insert(self, location, item) def insertAndOwn(self, location, disownedItem): """ insertAndOwn(ListOf self, int location, SBase disownedItem) -> int Inserts an item at a given position in this ListOf's list of items. This variant of the method does not make a clone of the 'disownedItem' handed to it. This means that when the ListOf is destroyed, the original 'item' will be destroyed. Parameter 'location' is the location where to insert the item. Parameter 'disownedItem' is the item to be inserted to the list. Will become a child of the parent list. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT See also insert(). """ return _libsbml.ListOf_insertAndOwn(self, location, disownedItem) def get(self, *args): """ get(ListOf self, unsigned int n) -> SBase get(ListOf self, unsigned int n) -> SBase Get an item from the list. Parameter 'n' is the index number of the item to get. Returns the nth item in this ListOf items, or a null pointer if the index number 'n' refers to a nonexistent position in this list. See also size(). """ return _libsbml.ListOf_get(self, *args) def getElementBySId(self, id): """ getElementBySId(ListOf self, string id) -> SBase Returns the first child element found that has the given identifier. This method searches this ListOf's list of items for SBML objects based on their 'id' attribute value in the model-wide SId identifier namespace. Parameter 'id' is string representing the id of the object to find. Returns the first element found with the given 'id', or 'None' if no such object is found. """ return _libsbml.ListOf_getElementBySId(self, id) def getElementByMetaId(self, metaid): """ getElementByMetaId(ListOf self, string metaid) -> SBase Returns the first child element found with the given meta-identifier. Parameter 'metaid' is string representing the 'metaid' attribute of the object to find. Returns the first element found with the given 'metaid', or 'None' if no such object is found. """ return _libsbml.ListOf_getElementByMetaId(self, metaid) def clear(self, doDelete=True): """ clear(ListOf self, bool doDelete=True) clear(ListOf self) Removes all items in this ListOf object. If parameter 'doDelete' is 'True' (default), all items in this ListOf object are deleted and cleared, and thus the caller doesn't have to delete those items. Otherwise, all items are cleared only from this ListOf object; the caller is still responsible for deleting the actual items. (In the latter case, callers are advised to store pointers to all items elsewhere before calling this function.) Parameter 'doDelete' is if 'True' (default), all items are deleted and cleared. Otherwise, all items are just cleared and not deleted.
Documentation note:
The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation.
Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.ListOf_clear(self, doDelete) def removeFromParentAndDelete(self): """ removeFromParentAndDelete(ListOf self) -> int Removes all items in this ListOf object and deletes its properties too. This performs a call to clear() with an argument of 'True' (thus removing all the child objects in the list), followed by calls to various libSBML unsetFoo methods to delete everything else: CVTerm objects, model history objects, etc. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS """ return _libsbml.ListOf_removeFromParentAndDelete(self) def remove(self, n): """ remove(ListOf self, unsigned int n) -> SBase Removes the nth item from this ListOf list of items and returns it. The caller owns the returned item and is responsible for deleting it. Parameter 'n' is the index of the item to remove. See also size(). """ return _libsbml.ListOf_remove(self, n) def size(self): """ size(ListOf self) -> unsigned int Returns number of items in this ListOf list. Returns the number of items in this ListOf items. """ return _libsbml.ListOf_size(self) def connectToChild(self): """connectToChild(ListOf self)""" return _libsbml.ListOf_connectToChild(self) def getTypeCode(self): """ getTypeCode(ListOf self) -> int Returns the libSBML type code for this object, namely, SBML_LIST_OF. LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for this object: SBML_LIST_OF (default). Note: The various ListOf classes mostly differ from each other in what they contain. Hence, one must call getItemTypeCode() to fully determine the class of this SBML object. WARNING: The specific integer values of the possible type codes may be reused by different libSBML plug-ins for SBML Level 3. packages, To fully identify the correct code, it is necessary to invoke both getPackageName() and getTypeCode() (or ListOf.getItemTypeCode()). See also getItemTypeCode(), getElementName(), getPackageName(). """ return _libsbml.ListOf_getTypeCode(self) def getItemTypeCode(self): """ getItemTypeCode(ListOf self) -> int Get the type code of the objects contained in this ListOf. LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Classes that inherit from the ListOf class should override this method to return the SBML type code for the objects contained in this ListOf. If they do not, this method will return SBML_UNKNOWN Returns The ListOf base class contains no SBML objects, and therefore this method returns SBML_UNKNOWN. See also getElementName(), getPackageName(). """ return _libsbml.ListOf_getItemTypeCode(self) def getElementName(self): """ getElementName(ListOf self) -> string Returns the XML element name of this object, which for ListOf, is always ''listOf'.' Returns the XML name of this element. """ return _libsbml.ListOf_getElementName(self) def enablePackageInternal(self, pkgURI, pkgPrefix, flag): """ enablePackageInternal(ListOf self, string pkgURI, string pkgPrefix, bool flag) Internal implementation method. """ return _libsbml.ListOf_enablePackageInternal(self, pkgURI, pkgPrefix, flag) def updateSBMLNamespace(self, package, level, version): """ updateSBMLNamespace(ListOf self, string package, unsigned int level, unsigned int version) Internal implementation method. """ return _libsbml.ListOf_updateSBMLNamespace(self, package, level, version) def hasOptionalElements(self): """ hasOptionalElements(ListOf self) -> bool Internal implementation method. """ return _libsbml.ListOf_hasOptionalElements(self) def isExplicitlyListed(self): """ isExplicitlyListed(ListOf self) -> bool Internal implementation method. """ return _libsbml.ListOf_isExplicitlyListed(self) def setExplicitlyListed(self, value=True): """ setExplicitlyListed(ListOf self, bool value=True) setExplicitlyListed(ListOf self) Internal implementation method. """ return _libsbml.ListOf_setExplicitlyListed(self, value) def __len__(self): """__len__(ListOf self) -> int""" return _libsbml.ListOf___len__(self) def __getitem__(self, key): try: keyIsSlice = isinstance(key, slice) except: keyIsSlice = 0 if keyIsSlice: start = key.start if start is None: start = 0 stop = key.stop if stop is None: stop = self.size() return [self[i] for i in range( self._fixNegativeIndex(start), self._fixNegativeIndex(stop) )] key = self._fixNegativeIndex(key) if key < 0 or key >= self.size(): raise IndexError(key) return self.get(key) def _fixNegativeIndex(self, index): if index < 0: return index + self.size() else: return index def __iter__(self): for i in range(self.size()): yield self[i] def __repr__(self): return "[" + ", ".join([repr(self[i]) for i in range(len(self))]) + "]" def __str__(self): return repr(self) ListOf_swigregister = _libsbml.ListOf_swigregister ListOf_swigregister(ListOf) class Model(SBase): """ An SBML model. In an SBML model definition, a single object of class Model serves as the overall container for the lists of the various model components. All of the lists are optional, but if a given list container is present within the model, the list must not be empty; that is, it must have length one or more. The following are the components and lists permitted in different Levels and Versions of SBML in version 5.17.2 of libSBML: * In SBML Level 1, the components are: UnitDefinition, Compartment, Species, Parameter, Rule, and Reaction. Instances of the classes are placed inside instances of classes ListOfUnitDefinitions, ListOfCompartments, ListOfSpecies, ListOfParameters, ListOfRules, and ListOfReactions. * In SBML Level 2 Version 1, the components are: FunctionDefinition, UnitDefinition, Compartment, Species, Parameter, Rule, Reaction and Event. Instances of the classes are placed inside instances of classes ListOfFunctionDefinitions, ListOfUnitDefinitions, ListOfCompartments, ListOfSpecies, ListOfParameters, ListOfRules, ListOfReactions, and ListOfEvents. * In SBML Level 2 Versions 2, 3 and 4, the components are: FunctionDefinition, UnitDefinition, CompartmentType, SpeciesType, Compartment, Species, Parameter, InitialAssignment, Rule, Constraint, Reaction and Event. Instances of the classes are placed inside instances of classes ListOfFunctionDefinitions, ListOfUnitDefinitions, ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments, ListOfSpecies, ListOfParameters, ListOfInitialAssignments, ListOfRules, ListOfConstraints, ListOfReactions, and ListOfEvents. * In SBML Level 3 Version 1, the components are: FunctionDefinition, UnitDefinition, Compartment, Species, Parameter, InitialAssignment, Rule, Constraint, Reaction and Event. Instances of the classes are placed inside instances of classes ListOfFunctionDefinitions, ListOfUnitDefinitions, ListOfCompartments, ListOfSpecies, ListOfParameters, ListOfInitialAssignments, ListOfRules, ListOfConstraints, ListOfReactions, and ListOfEvents. Although all the lists are optional, there are dependencies between SBML components such that defining some components requires defining others. An example is that defining a species requires defining a compartment, and defining a reaction requires defining a species. The dependencies are explained in more detail in the SBML specifications. In addition to the above lists and attributes, the Model class in both SBML Level 2 and Level 3 has the usual two attributes of 'id' and 'name', and both are optional. As is the case for other SBML components with 'id' and 'name' attributes, they must be used according to the guidelines described in the SBML specifications. (Within the frameworks of SBML Level 2 and Level 3, a Model object identifier has no assigned meaning, but extension packages planned for SBML Level 3 are likely to make use of this identifier.) Finally, SBML Level 3 has introduced a number of additional Model attributes. They are discussed in a separate section below. Approaches to creating objects using the libSBML API ====================================================================== LibSBML provides two main mechanisms for creating objects: class constructors (e.g., Species.Species() ), and createObject() methods (such as Model.createSpecies()) provided by certain Object classes such as Model. These multiple mechanisms are provided by libSBML for flexibility and to support different use-cases, but they also have different implications for the overall model structure. In general, the recommended approach is to use the createObject() methods. These methods both create an object and link it to the parent in one step. Here is an example: # Create an SBMLDocument object in Level 3 Version 1 format. # Make sure to check for possible failures. try: sbmlDoc = SBMLDocument(3, 1) except ValueError: print('Could not create SBMLDocument object') sys.exit(1) # Create a Model object inside the SBMLDocument object and set its # identifier, checking the returned values. The call to setId() returns a # status code to indicate whether the assignment was successful. model = sbmlDoc.createModel() if model == None: # Do something to handle the error here. print('Unable to create Model object.') sys.exit(1) status = model.setId('BestModelEver') if status != LIBSBML_OPERATION_SUCCESS: # Do something to handle the error here. print('Unable to set identifier on the Model object') sys.exit(1) # Create a Species object inside the Model and set its identifier. # Again, the setId() returns a status code to indicate whether the # assignment was successful. sp = model.createSpecies() if sp == None: # Do something to handle the error here. print('Unable to create Species object.') sys.exit(1) status = sp.setId('BestSpeciesEver') if status != LIBSBML_OPERATION_SUCCESS: # Do something to handle the error here. print('Unable to set identifier on the Species object') sys.exit(1) The createObject() methods return a pointer to the object created, but they also add the object to the relevant list of object instances contained in the parent. (These lists become the elements in the finished XML rendition of SBML.) In the example above, Model.createSpecies() adds the created species directly to the Model __init__(Model self, SBMLNamespaces sbmlns) -> Model __init__(Model self, Model orig) -> Model This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: Model(SBMLNamespaces sbmlns) Creates a new Model using the given SBMLNamespaces object 'sbmlns'. The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments. Parameter 'sbmlns' is an SBMLNamespaces object. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: Model(long level, long version) Creates a new Model using the given SBML 'level' and 'version' values. Parameter 'level' is a long integer, the SBML Level to assign to this Model. Parameter 'version' is a long integer, the SBML Version to assign to this Model. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: Model(Model orig) Copy constructor; creates a (deep) copy of the given Model object. Parameter 'orig' is the object to copy. """ this = _libsbml.new_Model(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(Model self) -> Model Creates and returns a deep copy of this Model object. Returns the (deep) copy of this Model object. """ return _libsbml.Model_clone(self) def getElementBySId(self, id): """ getElementBySId(Model self, string id) -> SBase Returns the first child element found that has the given 'id'. This operation searches the model-wide SId identifier type namespace Parameter 'id' is string representing the id of the object to find. Returns pointer to the first element found with the given 'id', or 'None' if no such object is found. """ return _libsbml.Model_getElementBySId(self, id) def getElementByMetaId(self, metaid): """ getElementByMetaId(Model self, string metaid) -> SBase Returns the first child element it can find with the given 'metaid'. Parameter 'metaid' is string representing the meta-identifier of the object to find. Returns pointer to the first element found with the given 'metaid', or None if no such object is found. """ return _libsbml.Model_getElementByMetaId(self, metaid) def getId(self): """ getId(Model self) -> string Returns the value of the 'id' attribute of this Model. Note: Because of the inconsistent behavior of this function with respect to assignments and rules, it is now recommended to use the getIdAttribute() function instead. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Returns the id of this Model. See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(). """ return _libsbml.Model_getId(self) def getName(self): """ getName(Model self) -> string Returns the value of the 'name' attribute of this Model object. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns the name of this SBML object, or the empty string if not set or unsettable. See also getIdAttribute(), isSetName(), setName(), unsetName(). """ return _libsbml.Model_getName(self) def getSubstanceUnits(self): """ getSubstanceUnits(Model self) -> string Returns the value of the 'substanceUnits' attribute of this Model. Returns the substanceUnits of this Model. Note: The 'substanceUnits' attribute is available in SBML Level 3 but is not present on Model in lower Levels of SBML. """ return _libsbml.Model_getSubstanceUnits(self) def getTimeUnits(self): """ getTimeUnits(Model self) -> string Returns the value of the 'timeUnits' attribute of this Model. Returns the timeUnits of this Model. Note: The 'timeUnits' attribute is available in SBML Level 3 but is not present on Model in lower Levels of SBML. """ return _libsbml.Model_getTimeUnits(self) def getVolumeUnits(self): """ getVolumeUnits(Model self) -> string Returns the value of the 'volumeUnits' attribute of this Model. Returns the volumeUnits of this Model. Note: The 'volumeUnits' attribute is available in SBML Level 3 but is not present on Model in lower Levels of SBML. """ return _libsbml.Model_getVolumeUnits(self) def getAreaUnits(self): """ getAreaUnits(Model self) -> string Returns the value of the 'areaUnits' attribute of this Model. Returns the areaUnits of this Model. Note: The 'areaUnits' attribute is available in SBML Level 3 but is not present on Model in lower Levels of SBML. """ return _libsbml.Model_getAreaUnits(self) def getLengthUnits(self): """ getLengthUnits(Model self) -> string Returns the value of the 'lengthUnits' attribute of this Model. Returns the lengthUnits of this Model. Note: The 'lengthUnits' attribute is available in SBML Level 3 but is not present on Model in lower Levels of SBML. """ return _libsbml.Model_getLengthUnits(self) def getExtentUnits(self): """ getExtentUnits(Model self) -> string Returns the value of the 'extentUnits' attribute of this Model. Returns the extentUnits of this Model. Note: The 'extentUnits' attribute is available in SBML Level 3 but is not present on Model in lower Levels of SBML. """ return _libsbml.Model_getExtentUnits(self) def getConversionFactor(self): """ getConversionFactor(Model self) -> string Returns the value of the 'conversionFactor' attribute of this Model. Returns the conversionFactor of this Model. Note: The 'conversionFactor' attribute is available in SBML Level 3 but is not present on Model in lower Levels of SBML. """ return _libsbml.Model_getConversionFactor(self) def isSetId(self): """ isSetId(Model self) -> bool Predicate returning 'True' if this Model's 'id' attribute is set. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Returns 'True' if the 'id' attribute of this SBML object is set, 'False' otherwise. Note: Because of the inconsistent behavior of this function with respect to assignments and rules, it is recommended that callers use isSetIdAttribute() instead. See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(), isSetIdAttribute(). """ return _libsbml.Model_isSetId(self) def isSetName(self): """ isSetName(Model self) -> bool Predicate returning 'True' if this Model's 'name' attribute is set. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns 'True' if the 'name' attribute of this SBML object is set, 'False' otherwise. See also getName(), setName(), unsetName(). """ return _libsbml.Model_isSetName(self) def isSetSubstanceUnits(self): """ isSetSubstanceUnits(Model self) -> bool Predicate returning 'True' if this Model's 'substanceUnits' attribute is set. Returns 'True' if the 'substanceUnits' attribute of this Model is set, 'False' otherwise. Note: The 'substanceUnits' attribute is available in SBML Level 3 but is not present on Model in lower Levels of SBML. """ return _libsbml.Model_isSetSubstanceUnits(self) def isSetTimeUnits(self): """ isSetTimeUnits(Model self) -> bool Predicate returning 'True' if this Model's 'timeUnits' attribute is set. Returns 'True' if the 'timeUnits' attribute of this Model is set, 'False' otherwise. Note: The 'substanceUnits' attribute is available in SBML Level 3 but is not present on Model in lower Levels of SBML. """ return _libsbml.Model_isSetTimeUnits(self) def isSetVolumeUnits(self): """ isSetVolumeUnits(Model self) -> bool Predicate returning 'True' if this Model's 'volumeUnits' attribute is set. Returns 'True' if the 'volumeUnits' attribute of this Model is set, 'False' otherwise. Note: The 'volumeUnits' attribute is available in SBML Level 3 but is not present on Model in lower Levels of SBML. """ return _libsbml.Model_isSetVolumeUnits(self) def isSetAreaUnits(self): """ isSetAreaUnits(Model self) -> bool Predicate returning 'True' if this Model's 'areaUnits' attribute is set. Returns 'True' if the 'areaUnits' attribute of this Model is set, 'False' otherwise. Note: The 'areaUnits' attribute is available in SBML Level 3 but is not present on Model in lower Levels of SBML. """ return _libsbml.Model_isSetAreaUnits(self) def isSetLengthUnits(self): """ isSetLengthUnits(Model self) -> bool Predicate returning 'True' if this Model's 'lengthUnits' attribute is set. Returns 'True' if the 'lengthUnits' attribute of this Model is set, 'False' otherwise. Note: The 'lengthUnits' attribute is available in SBML Level 3 but is not present on Model in lower Levels of SBML. """ return _libsbml.Model_isSetLengthUnits(self) def isSetExtentUnits(self): """ isSetExtentUnits(Model self) -> bool Predicate returning 'True' if this Model's 'extentUnits' attribute is set. Returns 'True' if the 'extentUnits' attribute of this Model is set, 'False' otherwise. Note: The 'extentUnits' attribute is available in SBML Level 3 but is not present on Model in lower Levels of SBML. """ return _libsbml.Model_isSetExtentUnits(self) def isSetConversionFactor(self): """ isSetConversionFactor(Model self) -> bool Predicate returning 'True' if this Model's 'conversionFactor' attribute is set. Returns 'True' if the 'conversionFactor' attribute of this Model is set, 'False' otherwise. Note: The 'conversionFactor' attribute is available in SBML Level 3 but is not present on Model in lower Levels of SBML. """ return _libsbml.Model_isSetConversionFactor(self) def setId(self, sid): """ setId(Model self, string sid) -> int Sets the value of the 'id' attribute of this Model. The string 'sid' is copied. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Parameter 'sid' is the string to use as the identifier of this object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE * LIBSBML_UNEXPECTED_ATTRIBUTE See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(). """ return _libsbml.Model_setId(self, sid) def setName(self, name): """ setName(Model self, string name) -> int Sets the value of the 'name' attribute of this Model. The string in 'name' is copied. Parameter 'name' is the new name for the SBML object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.Model_setName(self, name) def setSubstanceUnits(self, units): """ setSubstanceUnits(Model self, string units) -> int Sets the value of the 'substanceUnits' attribute of this Model. The string in 'units' is copied. Parameter 'units' is the new substanceUnits for the Model. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE * LIBSBML_INVALID_ATTRIBUTE_VALUE Note: The 'substanceUnits' attribute is available in SBML Level 3 but is not present on Model in lower Levels of SBML. """ return _libsbml.Model_setSubstanceUnits(self, units) def setTimeUnits(self, units): """ setTimeUnits(Model self, string units) -> int Sets the value of the 'timeUnits' attribute of this Model. The string in 'units' is copied. Parameter 'units' is the new timeUnits for the Model. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE * LIBSBML_INVALID_ATTRIBUTE_VALUE Note: The 'timeUnits' attribute is available in SBML Level 3 but is not present on Model in lower Levels of SBML. """ return _libsbml.Model_setTimeUnits(self, units) def setVolumeUnits(self, units): """ setVolumeUnits(Model self, string units) -> int Sets the value of the 'volumeUnits' attribute of this Model. The string in 'units' is copied. Parameter 'units' is the new volumeUnits for the Model. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE * LIBSBML_INVALID_ATTRIBUTE_VALUE Note: The 'volumeUnits' attribute is available in SBML Level 3 but is not present on Model in lower Levels of SBML. """ return _libsbml.Model_setVolumeUnits(self, units) def setAreaUnits(self, units): """ setAreaUnits(Model self, string units) -> int Sets the value of the 'areaUnits' attribute of this Model. The string in 'units' is copied. Parameter 'units' is the new areaUnits for the Model. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE * LIBSBML_INVALID_ATTRIBUTE_VALUE Note: The 'areaUnits' attribute is available in SBML Level 3 but is not present on Model in lower Levels of SBML. """ return _libsbml.Model_setAreaUnits(self, units) def setLengthUnits(self, units): """ setLengthUnits(Model self, string units) -> int Sets the value of the 'lengthUnits' attribute of this Model. The string in 'units' is copied. Parameter 'units' is the new lengthUnits for the Model. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE * LIBSBML_INVALID_ATTRIBUTE_VALUE Note: The 'lengthUnits' attribute is available in SBML Level 3 but is not present on Model in lower Levels of SBML. """ return _libsbml.Model_setLengthUnits(self, units) def setExtentUnits(self, units): """ setExtentUnits(Model self, string units) -> int Sets the value of the 'extentUnits' attribute of this Model. The string in 'units' is copied. Parameter 'units' is the new extentUnits for the Model. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE * LIBSBML_INVALID_ATTRIBUTE_VALUE Note: The 'extentUnits' attribute is available in SBML Level 3 but is not present on Model in lower Levels of SBML. """ return _libsbml.Model_setExtentUnits(self, units) def setConversionFactor(self, units): """ setConversionFactor(Model self, string units) -> int Sets the value of the 'conversionFactor' attribute of this Model. The string in 'units' is copied. Parameter 'units' is the new conversionFactor for the Model. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE * LIBSBML_INVALID_ATTRIBUTE_VALUE Note: The 'conversionFactor' attribute is available in SBML Level 3 but is not present on Model in lower Levels of SBML. """ return _libsbml.Model_setConversionFactor(self, units) def unsetId(self): """ unsetId(Model self) -> int Unsets the value of the 'id' attribute of this Model. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(). """ return _libsbml.Model_unsetId(self) def unsetName(self): """ unsetName(Model self) -> int Unsets the value of the 'name' attribute of this Model. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also getName(), setName(), isSetName(). """ return _libsbml.Model_unsetName(self) def unsetSubstanceUnits(self): """ unsetSubstanceUnits(Model self) -> int Unsets the value of the 'substanceUnits' attribute of this Model. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED Note: The 'substanceUnits' attribute is available in SBML Level 3 but is not present on Model in lower Levels of SBML. """ return _libsbml.Model_unsetSubstanceUnits(self) def unsetTimeUnits(self): """ unsetTimeUnits(Model self) -> int Unsets the value of the 'timeUnits' attribute of this Model. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED Note: The 'timeUnits' attribute is available in SBML Level 3 but is not present on Model in lower Levels of SBML. """ return _libsbml.Model_unsetTimeUnits(self) def unsetVolumeUnits(self): """ unsetVolumeUnits(Model self) -> int Unsets the value of the 'volumeUnits' attribute of this Model. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED Note: The 'volumeUnits' attribute is available in SBML Level 3 but is not present on Model in lower Levels of SBML. """ return _libsbml.Model_unsetVolumeUnits(self) def unsetAreaUnits(self): """ unsetAreaUnits(Model self) -> int Unsets the value of the 'areaUnits' attribute of this Model. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE * LIBSBML_OPERATION_FAILED Note: The 'areaUnits' attribute is available in SBML Level 3 but is not present on Model in lower Levels of SBML. """ return _libsbml.Model_unsetAreaUnits(self) def unsetLengthUnits(self): """ unsetLengthUnits(Model self) -> int Unsets the value of the 'lengthUnits' attribute of this Model. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE * LIBSBML_OPERATION_FAILED Note: The 'lengthUnits' attribute is available in SBML Level 3 but is not present on Model in lower Levels of SBML. """ return _libsbml.Model_unsetLengthUnits(self) def unsetExtentUnits(self): """ unsetExtentUnits(Model self) -> int Unsets the value of the 'extentUnits' attribute of this Model. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE * LIBSBML_OPERATION_FAILED Note: The 'extentUnits' attribute is available in SBML Level 3 but is not present on Model in lower Levels of SBML. """ return _libsbml.Model_unsetExtentUnits(self) def unsetConversionFactor(self): """ unsetConversionFactor(Model self) -> int Unsets the value of the 'conversionFactor' attribute of this Model. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE * LIBSBML_OPERATION_FAILED Note: The 'conversionFactor' attribute is available in SBML Level 3 but is not present on Model in lower Levels of SBML. """ return _libsbml.Model_unsetConversionFactor(self) def addFunctionDefinition(self, fd): """ addFunctionDefinition(Model self, FunctionDefinition fd) -> int Adds a copy of the given FunctionDefinition object to this Model. Parameter 'fd' is the FunctionDefinition to add. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_LEVEL_MISMATCH * LIBSBML_VERSION_MISMATCH * LIBSBML_DUPLICATE_OBJECT_ID * LIBSBML_INVALID_OBJECT * LIBSBML_OPERATION_FAILED Note: This method should be used with some caution. The fact that this method copies the object passed to it means that the caller will be left holding a physically different object instance than the one contained inside this object. Changes made to the original object instance (such as resetting attribute values) will not affect the instance in this object. In addition, the caller should make sure to free the original object if it is no longer being used, or else a memory leak will result. Please see other methods on this class (particularly a corresponding method whose name begins with the word create) for alternatives that do not lead to these issues. See also createFunctionDefinition(). """ return _libsbml.Model_addFunctionDefinition(self, fd) def addUnitDefinition(self, ud): """ addUnitDefinition(Model self, UnitDefinition ud) -> int Adds a copy of the given UnitDefinition object to this Model. Parameter 'ud' is the UnitDefinition object to add. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_LEVEL_MISMATCH * LIBSBML_VERSION_MISMATCH * LIBSBML_DUPLICATE_OBJECT_ID * LIBSBML_INVALID_OBJECT * LIBSBML_OPERATION_FAILED Note: This method should be used with some caution. The fact that this method copies the object passed to it means that the caller will be left holding a physically different object instance than the one contained inside this object. Changes made to the original object instance (such as resetting attribute values) will not affect the instance in this object. In addition, the caller should make sure to free the original object if it is no longer being used, or else a memory leak will result. Please see other methods on this class (particularly a corresponding method whose name begins with the word create) for alternatives that do not lead to these issues. See also createUnitDefinition(). """ return _libsbml.Model_addUnitDefinition(self, ud) def addCompartmentType(self, ct): """ addCompartmentType(Model self, CompartmentType ct) -> int Adds a copy of the given CompartmentType object to this Model. Parameter 'ct' is the CompartmentType object to add. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_LEVEL_MISMATCH * LIBSBML_VERSION_MISMATCH * LIBSBML_DUPLICATE_OBJECT_ID * LIBSBML_INVALID_OBJECT * LIBSBML_OPERATION_FAILED Note: This method should be used with some caution. The fact that this method copies the object passed to it means that the caller will be left holding a physically different object instance than the one contained inside this object. Changes made to the original object instance (such as resetting attribute values) will not affect the instance in this object. In addition, the caller should make sure to free the original object if it is no longer being used, or else a memory leak will result. Please see other methods on this class (particularly a corresponding method whose name begins with the word create) for alternatives that do not lead to these issues. Note: The CompartmentType object class is only available in SBML Level 2 Versions 2-4. It is not available in Level 1 nor Level 3. See also createCompartmentType(). """ return _libsbml.Model_addCompartmentType(self, ct) def addSpeciesType(self, st): """ addSpeciesType(Model self, SpeciesType st) -> int Adds a copy of the given SpeciesType object to this Model. Parameter 'st' is the SpeciesType object to add. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_LEVEL_MISMATCH * LIBSBML_VERSION_MISMATCH * LIBSBML_DUPLICATE_OBJECT_ID * LIBSBML_INVALID_OBJECT * LIBSBML_OPERATION_FAILED Note: This method should be used with some caution. The fact that this method copies the object passed to it means that the caller will be left holding a physically different object instance than the one contained inside this object. Changes made to the original object instance (such as resetting attribute values) will not affect the instance in this object. In addition, the caller should make sure to free the original object if it is no longer being used, or else a memory leak will result. Please see other methods on this class (particularly a corresponding method whose name begins with the word create) for alternatives that do not lead to these issues. Note: The SpeciesType object class is only available in SBML Level 2 Versions 2-4. It is not available in Level 1 nor Level 3. See also createSpeciesType(). """ return _libsbml.Model_addSpeciesType(self, st) def addCompartment(self, c): """ addCompartment(Model self, Compartment c) -> int Adds a copy of the given Compartment object to this Model. Parameter 'c' is the Compartment object to add. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_LEVEL_MISMATCH * LIBSBML_VERSION_MISMATCH * LIBSBML_DUPLICATE_OBJECT_ID * LIBSBML_INVALID_OBJECT * LIBSBML_OPERATION_FAILED Note: This method should be used with some caution. The fact that this method copies the object passed to it means that the caller will be left holding a physically different object instance than the one contained inside this object. Changes made to the original object instance (such as resetting attribute values) will not affect the instance in this object. In addition, the caller should make sure to free the original object if it is no longer being used, or else a memory leak will result. Please see other methods on this class (particularly a corresponding method whose name begins with the word create) for alternatives that do not lead to these issues. See also createCompartment(). """ return _libsbml.Model_addCompartment(self, c) def addSpecies(self, s): """ addSpecies(Model self, Species s) -> int Adds a copy of the given Species object to this Model. Parameter 's' is the Species object to add. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_LEVEL_MISMATCH * LIBSBML_VERSION_MISMATCH * LIBSBML_DUPLICATE_OBJECT_ID * LIBSBML_INVALID_OBJECT * LIBSBML_OPERATION_FAILED Note: This method should be used with some caution. The fact that this method copies the object passed to it means that the caller will be left holding a physically different object instance than the one contained inside this object. Changes made to the original object instance (such as resetting attribute values) will not affect the instance in this object. In addition, the caller should make sure to free the original object if it is no longer being used, or else a memory leak will result. Please see other methods on this class (particularly a corresponding method whose name begins with the word create) for alternatives that do not lead to these issues. See also createSpecies(). """ return _libsbml.Model_addSpecies(self, s) def addParameter(self, p): """ addParameter(Model self, Parameter p) -> int Adds a copy of the given Parameter object to this Model. Parameter 'p' is the Parameter object to add. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_LEVEL_MISMATCH * LIBSBML_VERSION_MISMATCH * LIBSBML_DUPLICATE_OBJECT_ID * LIBSBML_INVALID_OBJECT * LIBSBML_OPERATION_FAILED Note: This method should be used with some caution. The fact that this method copies the object passed to it means that the caller will be left holding a physically different object instance than the one contained inside this object. Changes made to the original object instance (such as resetting attribute values) will not affect the instance in this object. In addition, the caller should make sure to free the original object if it is no longer being used, or else a memory leak will result. Please see other methods on this class (particularly a corresponding method whose name begins with the word create) for alternatives that do not lead to these issues. See also createParameter(). """ return _libsbml.Model_addParameter(self, p) def addInitialAssignment(self, ia): """ addInitialAssignment(Model self, InitialAssignment ia) -> int Adds a copy of the given InitialAssignment object to this Model. Parameter 'ia' is the InitialAssignment object to add. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_LEVEL_MISMATCH * LIBSBML_VERSION_MISMATCH * LIBSBML_DUPLICATE_OBJECT_ID * LIBSBML_INVALID_OBJECT * LIBSBML_OPERATION_FAILED Note: This method should be used with some caution. The fact that this method copies the object passed to it means that the caller will be left holding a physically different object instance than the one contained inside this object. Changes made to the original object instance (such as resetting attribute values) will not affect the instance in this object. In addition, the caller should make sure to free the original object if it is no longer being used, or else a memory leak will result. Please see other methods on this class (particularly a corresponding method whose name begins with the word create) for alternatives that do not lead to these issues. See also createInitialAssignment(). """ return _libsbml.Model_addInitialAssignment(self, ia) def addRule(self, r): """ addRule(Model self, Rule r) -> int Adds a copy of the given Rule object to this Model. Parameter 'r' is the Rule object to add. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_LEVEL_MISMATCH * LIBSBML_VERSION_MISMATCH * LIBSBML_DUPLICATE_OBJECT_ID * LIBSBML_INVALID_OBJECT * LIBSBML_OPERATION_FAILED Note: This method should be used with some caution. The fact that this method copies the object passed to it means that the caller will be left holding a physically different object instance than the one contained inside this object. Changes made to the original object instance (such as resetting attribute values) will not affect the instance in this object. In addition, the caller should make sure to free the original object if it is no longer being used, or else a memory leak will result. Please see other methods on this class (particularly a corresponding method whose name begins with the word create) for alternatives that do not lead to these issues. See also createAlgebraicRule(), createAssignmentRule(), createRateRule(). """ return _libsbml.Model_addRule(self, r) def addConstraint(self, c): """ addConstraint(Model self, Constraint c) -> int Adds a copy of the given Constraint object to this Model. Parameter 'c' is the Constraint object to add. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_LEVEL_MISMATCH * LIBSBML_VERSION_MISMATCH * LIBSBML_INVALID_OBJECT * LIBSBML_OPERATION_FAILED Note: This method should be used with some caution. The fact that this method copies the object passed to it means that the caller will be left holding a physically different object instance than the one contained inside this object. Changes made to the original object instance (such as resetting attribute values) will not affect the instance in this object. In addition, the caller should make sure to free the original object if it is no longer being used, or else a memory leak will result. Please see other methods on this class (particularly a corresponding method whose name begins with the word create) for alternatives that do not lead to these issues. See also createConstraint(). """ return _libsbml.Model_addConstraint(self, c) def addReaction(self, r): """ addReaction(Model self, Reaction r) -> int Adds a copy of the given Reaction object to this Model. Parameter 'r' is the Reaction object to add. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_LEVEL_MISMATCH * LIBSBML_VERSION_MISMATCH * LIBSBML_DUPLICATE_OBJECT_ID * LIBSBML_INVALID_OBJECT * LIBSBML_OPERATION_FAILED Note: This method should be used with some caution. The fact that this method copies the object passed to it means that the caller will be left holding a physically different object instance than the one contained inside this object. Changes made to the original object instance (such as resetting attribute values) will not affect the instance in this object. In addition, the caller should make sure to free the original object if it is no longer being used, or else a memory leak will result. Please see other methods on this class (particularly a corresponding method whose name begins with the word create) for alternatives that do not lead to these issues. See also createReaction(). """ return _libsbml.Model_addReaction(self, r) def addEvent(self, e): """ addEvent(Model self, Event e) -> int Adds a copy of the given Event object to this Model. Parameter 'e' is the Event object to add. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_LEVEL_MISMATCH * LIBSBML_VERSION_MISMATCH * LIBSBML_DUPLICATE_OBJECT_ID * LIBSBML_INVALID_OBJECT * LIBSBML_OPERATION_FAILED Note: This method should be used with some caution. The fact that this method copies the object passed to it means that the caller will be left holding a physically different object instance than the one contained inside this object. Changes made to the original object instance (such as resetting attribute values) will not affect the instance in this object. In addition, the caller should make sure to free the original object if it is no longer being used, or else a memory leak will result. Please see other methods on this class (particularly a corresponding method whose name begins with the word create) for alternatives that do not lead to these issues. See also createEvent(). """ return _libsbml.Model_addEvent(self, e) def createFunctionDefinition(self): """ createFunctionDefinition(Model self) -> FunctionDefinition Creates a new FunctionDefinition inside this Model and returns it. The SBML Level and Version of the enclosing Model object, as well as any SBML package namespaces, are used to initialize this object's corresponding attributes. Returns the FunctionDefinition object created. See also addFunctionDefinition(). """ return _libsbml.Model_createFunctionDefinition(self) def createUnitDefinition(self): """ createUnitDefinition(Model self) -> UnitDefinition Creates a new UnitDefinition inside this Model and returns it. The SBML Level and Version of the enclosing Model object, as well as any SBML package namespaces, are used to initialize this object's corresponding attributes. Returns the UnitDefinition object created. See also addUnitDefinition(). """ return _libsbml.Model_createUnitDefinition(self) def createUnit(self): """ createUnit(Model self) -> Unit Creates a new Unit object within the last UnitDefinition object created in this model and returns a pointer to it. The SBML Level and Version of the enclosing Model object, as well as any SBML package namespaces, are used to initialize this object's corresponding attributes. The mechanism by which the UnitDefinition was created is not significant. If a UnitDefinition object does not exist in this model, a new Unit is not created and 'None' is returned instead. Returns the Unit object created. See also addUnitDefinition(). """ return _libsbml.Model_createUnit(self) def createCompartmentType(self): """ createCompartmentType(Model self) -> CompartmentType Creates a new CompartmentType inside this Model and returns it. The SBML Level and Version of the enclosing Model object, as well as any SBML package namespaces, are used to initialize this object's corresponding attributes. Returns the CompartmentType object created. Note: The CompartmentType object class is only available in SBML Level 2 Versions 2-4. It is not available in Level 1 nor Level 3. See also addCompartmentType(). """ return _libsbml.Model_createCompartmentType(self) def createSpeciesType(self): """ createSpeciesType(Model self) -> SpeciesType Creates a new SpeciesType inside this Model and returns it. The SBML Level and Version of the enclosing Model object, as well as any SBML package namespaces, are used to initialize this object's corresponding attributes. Returns the SpeciesType object created. Note: The SpeciesType object class is only available in SBML Level 2 Versions 2-4. It is not available in Level 1 nor Level 3. See also addSpeciesType(). """ return _libsbml.Model_createSpeciesType(self) def createCompartment(self): """ createCompartment(Model self) -> Compartment Creates a new Compartment inside this Model and returns it. The SBML Level and Version of the enclosing Model object, as well as any SBML package namespaces, are used to initialize this object's corresponding attributes. Returns the Compartment object created. See also addCompartment(). """ return _libsbml.Model_createCompartment(self) def createSpecies(self): """ createSpecies(Model self) -> Species Creates a new Species inside this Model and returns it. The SBML Level and Version of the enclosing Model object, as well as any SBML package namespaces, are used to initialize this object's corresponding attributes. Returns the Species object created. See also addSpecies(). """ return _libsbml.Model_createSpecies(self) def createParameter(self): """ createParameter(Model self) -> Parameter Creates a new Parameter inside this Model and returns it. The SBML Level and Version of the enclosing Model object, as well as any SBML package namespaces, are used to initialize this object's corresponding attributes. Returns the Parameter object created. See also addParameter(). """ return _libsbml.Model_createParameter(self) def createInitialAssignment(self): """ createInitialAssignment(Model self) -> InitialAssignment Creates a new InitialAssignment inside this Model and returns it. The SBML Level and Version of the enclosing Model object, as well as any SBML package namespaces, are used to initialize this object's corresponding attributes. Returns the InitialAssignment object created. See also addInitialAssignment(). """ return _libsbml.Model_createInitialAssignment(self) def createAlgebraicRule(self): """ createAlgebraicRule(Model self) -> AlgebraicRule Creates a new AlgebraicRule inside this Model and returns it. The SBML Level and Version of the enclosing Model object, as well as any SBML package namespaces, are used to initialize this object's corresponding attributes. Returns the AlgebraicRule object created. See also addRule(). """ return _libsbml.Model_createAlgebraicRule(self) def createAssignmentRule(self): """ createAssignmentRule(Model self) -> AssignmentRule Creates a new AssignmentRule inside this Model and returns it. The SBML Level and Version of the enclosing Model object, as well as any SBML package namespaces, are used to initialize this object's corresponding attributes. Returns the AssignmentRule object created. See also addRule(). """ return _libsbml.Model_createAssignmentRule(self) def createRateRule(self): """ createRateRule(Model self) -> RateRule Creates a new RateRule inside this Model and returns it. The SBML Level and Version of the enclosing Model object, as well as any SBML package namespaces, are used to initialize this object's corresponding attributes. Returns the RateRule object created. See also addRule(). """ return _libsbml.Model_createRateRule(self) def createConstraint(self): """ createConstraint(Model self) -> Constraint Creates a new Constraint inside this Model and returns it. The SBML Level and Version of the enclosing Model object, as well as any SBML package namespaces, are used to initialize this object's corresponding attributes. Returns the Constraint object created. See also addConstraint(). """ return _libsbml.Model_createConstraint(self) def createReaction(self): """ createReaction(Model self) -> Reaction Creates a new Reaction inside this Model and returns it. The SBML Level and Version of the enclosing Model object, as well as any SBML package namespaces, are used to initialize this object's corresponding attributes. Returns the Reaction object created. See also addReaction(). """ return _libsbml.Model_createReaction(self) def createReactant(self): """ createReactant(Model self) -> SpeciesReference Creates a new SpeciesReference object for a reactant inside the last Reaction object in this Model, and returns a pointer to it. The SBML Level and Version of the enclosing Model object, as well as any SBML package namespaces, are used to initialize this object's corresponding attributes. The mechanism by which the last Reaction object was created and added to this Model is not significant. It could have been created in a variety of ways, for example using createReaction(). If a Reaction does not exist for this model, a new SpeciesReference is not created and 'None' is returned instead. Returns the SpeciesReference object created. If a Reaction does not exist for this model, a new SpeciesReference is not created and 'None' is returned. """ return _libsbml.Model_createReactant(self) def createProduct(self): """ createProduct(Model self) -> SpeciesReference Creates a new SpeciesReference object for a product inside the last Reaction object in this Model, and returns a pointer to it. The SBML Level and Version of the enclosing Model object, as well as any SBML package namespaces, are used to initialize this object's corresponding attributes. The mechanism by which the last Reaction object was created and added to this Model is not significant. It could have been created in a variety of ways, for example using createReaction(). If a Reaction does not exist for this model, a new SpeciesReference is not created and 'None' is returned instead. Returns the SpeciesReference object created. If a Reaction does not exist for this model, a new SpeciesReference is not created and 'None' is returned. """ return _libsbml.Model_createProduct(self) def createModifier(self): """ createModifier(Model self) -> ModifierSpeciesReference Creates a new ModifierSpeciesReference object for a modifier species inside the last Reaction object in this Model, and returns a pointer to it. The SBML Level and Version of the enclosing Model object, as well as any SBML package namespaces, are used to initialize this object's corresponding attributes. The mechanism by which the last Reaction object was created and added to this Model is not significant. It could have been created in a variety of ways, for example using createReaction(). If a Reaction does not exist for this model, a new SpeciesReference is not created and 'None' is returned instead. Returns the SpeciesReference object created. If a Reaction does not exist for this model, a new SpeciesReference is not created and 'None' is returned. """ return _libsbml.Model_createModifier(self) def createKineticLaw(self): """ createKineticLaw(Model self) -> KineticLaw Creates a new KineticLaw inside the last Reaction object created in this Model, and returns a pointer to it. The SBML Level and Version of the enclosing Model object, as well as any SBML package namespaces, are used to initialize this object's corresponding attributes. The mechanism by which the last Reaction object was created and added to this Model is not significant. It could have been created in a variety of ways, for example using createReaction(). If a Reaction does not exist for this model, a new SpeciesReference is not created and 'None' is returned instead. Returns the KineticLaw object created. If a Reaction does not exist for this model, or a Reaction does exist but already has a KineticLaw, a new KineticLaw is not created and 'None' is returned. """ return _libsbml.Model_createKineticLaw(self) def createKineticLawParameter(self): """ createKineticLawParameter(Model self) -> Parameter Creates a new local Parameter inside the KineticLaw object of the last Reaction created inside this Model, and returns a pointer to it. The SBML Level and Version of the enclosing Model object, as well as any SBML package namespaces, are used to initialize this object's corresponding attributes. The last KineticLaw object in this Model could have been created in a variety of ways. For example, it could have been added using createKineticLaw(), or it could be the result of using Reaction.createKineticLaw() on the Reaction object created by a createReaction(). If a Reaction does not exist for this model, or the last Reaction does not contain a KineticLaw object, a new Parameter is not created and 'None' is returned instead. Returns the Parameter object created. If a Reaction does not exist for this model, or a KineticLaw for the Reaction does not exist, a new Parameter is not created and 'None' is returned. """ return _libsbml.Model_createKineticLawParameter(self) def createKineticLawLocalParameter(self): """ createKineticLawLocalParameter(Model self) -> LocalParameter Creates a new LocalParameter inside the KineticLaw object of the last Reaction created inside this Model, and returns a pointer to it. The SBML Level and Version of the enclosing Model object, as well as any SBML package namespaces, are used to initialize this object's corresponding attributes. The last KineticLaw object in this Model could have been created in a variety of ways. For example, it could have been added using createKineticLaw(), or it could be the result of using Reaction.createKineticLaw() on the Reaction object created by a createReaction(). If a Reaction does not exist for this model, or the last Reaction does not contain a KineticLaw object, a new Parameter is not created and 'None' is returned instead. Returns the Parameter object created. If a Reaction does not exist for this model, or a KineticLaw for the Reaction does not exist, a new Parameter is not created and 'None' is returned. """ return _libsbml.Model_createKineticLawLocalParameter(self) def createEvent(self): """ createEvent(Model self) -> Event Creates a new Event inside this Model and returns it. The SBML Level and Version of the enclosing Model object, as well as any SBML package namespaces, are used to initialize this object's corresponding attributes. Returns the Event object created. """ return _libsbml.Model_createEvent(self) def createEventAssignment(self): """ createEventAssignment(Model self) -> EventAssignment Creates a new EventAssignment inside the last Event object created in this Model, and returns a pointer to it. The SBML Level and Version of the enclosing Model object, as well as any SBML package namespaces, are used to initialize this object's corresponding attributes. The mechanism by which the last Event object in this model was created is not significant. It could have been created in a variety of ways, for example by using createEvent(). If no Event object exists in this Model object, a new EventAssignment is not created and 'None' is returned instead. Returns the EventAssignment object created. """ return _libsbml.Model_createEventAssignment(self) def createTrigger(self): """ createTrigger(Model self) -> Trigger Creates a new Trigger inside the last Event object created in this Model, and returns a pointer to it. The SBML Level and Version of the enclosing Model object, as well as any SBML package namespaces, are used to initialize this object's corresponding attributes. The mechanism by which the last Event object in this model was created is not significant. It could have been created in a variety of ways, for example by using createEvent(). If no Event object exists in this Model object, a new EventAssignment is not created and 'None' is returned instead. Returns the Trigger object created. """ return _libsbml.Model_createTrigger(self) def createDelay(self): """ createDelay(Model self) -> Delay Creates a new Delay inside the last Event object created in this Model, and returns a pointer to it. The SBML Level and Version of the enclosing Model object, as well as any SBML package namespaces, are used to initialize this object's corresponding attributes. The mechanism by which the last Event object in this model was created is not significant. It could have been created in a variety of ways, for example by using createEvent(). If no Event object exists in this Model object, a new EventAssignment is not created and 'None' is returned instead. Returns the Delay object created. """ return _libsbml.Model_createDelay(self) def setAnnotation(self, *args): """ setAnnotation(Model self, XMLNode annotation) -> int setAnnotation(Model self, string annotation) -> int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: setAnnotation(XMLNode annotation) Sets the value of the 'annotation' subelement of this SBML object to a copy of 'annotation'. Any existing content of the 'annotation' subelement is discarded. Unless you have taken steps to first copy and reconstitute any existing annotations into the 'annotation' that is about to be assigned, it is likely that performing such wholesale replacement is unfriendly towards other software applications whose annotations are discarded. An alternative may be to use appendAnnotation(). Parameter 'annotation' is an XML structure that is to be used as the content of the 'annotation' subelement of this object. Returns integer value indicating success/failure of the function. This particular function only does one thing irrespective of user input or object state, and thus will only return a single value: * LIBSBML_OPERATION_SUCCESS See also appendAnnotation(). ______________________________________________________________________ Method variant with the following signature: setAnnotation(string annotation) Sets the value of the 'annotation' subelement of this SBML object to a copy of 'annotation'. Any existing content of the 'annotation' subelement is discarded. Unless you have taken steps to first copy and reconstitute any existing annotations into the 'annotation' that is about to be assigned, it is likely that performing such wholesale replacement is unfriendly towards other software applications whose annotations are discarded. An alternative may be to use appendAnnotation(). Parameter 'annotation' is an XML string that is to be used as the content of the 'annotation' subelement of this object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also appendAnnotation(). """ return _libsbml.Model_setAnnotation(self, *args) def appendAnnotation(self, *args): """ appendAnnotation(Model self, XMLNode annotation) -> int appendAnnotation(Model self, string annotation) -> int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: appendAnnotation(XMLNode annotation) Appends annotation content to any existing content in the 'annotation' subelement of this object. The content in 'annotation' is copied. Unlike setAnnotation(), this method allows other annotations to be preserved when an application adds its own data. Parameter 'annotation' is an XML structure that is to be copied and appended to the content of the 'annotation' subelement of this object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also setAnnotation(). ______________________________________________________________________ Method variant with the following signature: appendAnnotation(string annotation) Appends annotation content to any existing content in the 'annotation' subelement of this object. The content in 'annotation' is copied. Unlike setAnnotation(), this method allows other annotations to be preserved when an application adds its own data. Parameter 'annotation' is an XML string that is to be copied and appended to the content of the 'annotation' subelement of this object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also setAnnotation(). """ return _libsbml.Model_appendAnnotation(self, *args) def getListOfFunctionDefinitions(self, *args): """ getListOfFunctionDefinitions(Model self) -> ListOfFunctionDefinitions getListOfFunctionDefinitions(Model self) -> ListOfFunctionDefinitions Get the ListOfFunctionDefinitions object in this Model. Returns the list of FunctionDefinitions for this Model. """ return _libsbml.Model_getListOfFunctionDefinitions(self, *args) def getListOfUnitDefinitions(self, *args): """ getListOfUnitDefinitions(Model self) -> ListOfUnitDefinitions getListOfUnitDefinitions(Model self) -> ListOfUnitDefinitions Get the ListOfUnitDefinitions object in this Model. Returns the list of UnitDefinitions for this Model. """ return _libsbml.Model_getListOfUnitDefinitions(self, *args) def getListOfCompartmentTypes(self, *args): """ getListOfCompartmentTypes(Model self) -> ListOfCompartmentTypes getListOfCompartmentTypes(Model self) -> ListOfCompartmentTypes Get the ListOfCompartmentTypes object in this Model. Returns the list of CompartmentTypes for this Model. Note: The CompartmentType object class is only available in SBML Level 2 Versions 2-4. It is not available in Level 1 nor Level 3. """ return _libsbml.Model_getListOfCompartmentTypes(self, *args) def getListOfSpeciesTypes(self, *args): """ getListOfSpeciesTypes(Model self) -> ListOfSpeciesTypes getListOfSpeciesTypes(Model self) -> ListOfSpeciesTypes Get the ListOfSpeciesTypes object in this Model. Returns the list of SpeciesTypes for this Model. Note: The SpeciesType object class is only available in SBML Level 2 Versions 2-4. It is not available in Level 1 nor Level 3. """ return _libsbml.Model_getListOfSpeciesTypes(self, *args) def getListOfCompartments(self, *args): """ getListOfCompartments(Model self) -> ListOfCompartments getListOfCompartments(Model self) -> ListOfCompartments Get the ListOfCompartments object in this Model. Returns the list of Compartments for this Model. """ return _libsbml.Model_getListOfCompartments(self, *args) def getListOfSpecies(self, *args): """ getListOfSpecies(Model self) -> ListOfSpecies getListOfSpecies(Model self) -> ListOfSpecies Get the ListOfSpecies object in this Model. Returns the list of Species for this Model. """ return _libsbml.Model_getListOfSpecies(self, *args) def getListOfParameters(self, *args): """ getListOfParameters(Model self) -> ListOfParameters getListOfParameters(Model self) -> ListOfParameters Get the ListOfParameters object in this Model. Returns the list of Parameters for this Model. """ return _libsbml.Model_getListOfParameters(self, *args) def getListOfInitialAssignments(self, *args): """ getListOfInitialAssignments(Model self) -> ListOfInitialAssignments getListOfInitialAssignments(Model self) -> ListOfInitialAssignments Get the ListOfInitialAssignments object in this Model. Returns the list of InitialAssignments for this Model. """ return _libsbml.Model_getListOfInitialAssignments(self, *args) def getListOfRules(self, *args): """ getListOfRules(Model self) -> ListOfRules getListOfRules(Model self) -> ListOfRules Get the ListOfRules object in this Model. Returns the list of Rules for this Model. """ return _libsbml.Model_getListOfRules(self, *args) def getListOfConstraints(self, *args): """ getListOfConstraints(Model self) -> ListOfConstraints getListOfConstraints(Model self) -> ListOfConstraints Get the ListOfConstraints object in this Model. Returns the list of Constraints for this Model. """ return _libsbml.Model_getListOfConstraints(self, *args) def getListOfReactions(self, *args): """ getListOfReactions(Model self) -> ListOfReactions getListOfReactions(Model self) -> ListOfReactions Get the ListOfReactions object in this Model. Returns the list of Reactions for this Model. """ return _libsbml.Model_getListOfReactions(self, *args) def getListOfEvents(self, *args): """ getListOfEvents(Model self) -> ListOfEvents getListOfEvents(Model self) -> ListOfEvents Get the ListOfEvents object in this Model. Returns the list of Events for this Model. """ return _libsbml.Model_getListOfEvents(self, *args) def getFunctionDefinition(self, *args): """ getFunctionDefinition(Model self, unsigned int n) -> FunctionDefinition getFunctionDefinition(Model self, unsigned int n) -> FunctionDefinition getFunctionDefinition(Model self, string sid) -> FunctionDefinition getFunctionDefinition(Model self, string sid) -> FunctionDefinition This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getFunctionDefinition(long n) Get the nth FunctionDefinitions object in this Model. Parameter 'n' is the index of the object to return. Returns the nth FunctionDefinition of this Model. If the index 'n' is invalid, 'None' is returned. ______________________________________________________________________ Method variant with the following signature: getFunctionDefinition(string sid) Get a FunctionDefinition object based on its identifier. Parameter 'sid' is the identifier to search for. Returns the FunctionDefinition in this Model with the identifier 'sid' or 'None' if no such FunctionDefinition exists. """ return _libsbml.Model_getFunctionDefinition(self, *args) def getUnitDefinition(self, *args): """ getUnitDefinition(Model self, unsigned int n) -> UnitDefinition getUnitDefinition(Model self, unsigned int n) -> UnitDefinition getUnitDefinition(Model self, string sid) -> UnitDefinition getUnitDefinition(Model self, string sid) -> UnitDefinition This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getUnitDefinition(long n) Get the nth UnitDefinition object in this Model. Parameter 'n' is the index of the object to return. Returns the nth UnitDefinition of this Model. If the index 'n' is invalid, 'None' is returned. ______________________________________________________________________ Method variant with the following signature: getUnitDefinition(string sid) Get a UnitDefinition based on its identifier. Parameter 'sid' is the identifier to search for. Returns the UnitDefinition in this Model with the identifier 'sid' or 'None' if no such UnitDefinition exists. """ return _libsbml.Model_getUnitDefinition(self, *args) def getCompartmentType(self, *args): """ getCompartmentType(Model self, unsigned int n) -> CompartmentType getCompartmentType(Model self, unsigned int n) -> CompartmentType getCompartmentType(Model self, string sid) -> CompartmentType getCompartmentType(Model self, string sid) -> CompartmentType This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getCompartmentType(long n) Get the nth CompartmentType object in this Model. Parameter 'n' is the index of the object to return. Returns the nth CompartmentType of this Model. If the index 'n' is invalid, 'None' is returned. Note: The CompartmentType object class is only available in SBML Level 2 Versions 2-4. It is not available in Level 1 nor Level 3. ______________________________________________________________________ Method variant with the following signature: getCompartmentType(string sid) Get a CompartmentType object based on its identifier. Parameter 'sid' is the identifier to search for. Returns the CompartmentType in this Model with the identifier 'sid' or 'None' if no such CompartmentType exists. Note: The CompartmentType object class is only available in SBML Level 2 Versions 2-4. It is not available in Level 1 nor Level 3. """ return _libsbml.Model_getCompartmentType(self, *args) def getSpeciesType(self, *args): """ getSpeciesType(Model self, unsigned int n) -> SpeciesType getSpeciesType(Model self, unsigned int n) -> SpeciesType getSpeciesType(Model self, string sid) -> SpeciesType getSpeciesType(Model self, string sid) -> SpeciesType This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getSpeciesType(long n) Get the nth SpeciesType object in this Model. Parameter 'n' is the index of the object to return. Returns the nth SpeciesType of this Model. If the index 'n' is invalid, 'None' is returned. Note: The SpeciesType object class is only available in SBML Level 2 Versions 2-4. It is not available in Level 1 nor Level 3. ______________________________________________________________________ Method variant with the following signature: getSpeciesType(string sid) Get a SpeciesType object based on its identifier. Parameter 'sid' is the identifier to search for. Returns the SpeciesType in this Model with the identifier 'sid' or 'None' if no such SpeciesType exists. Note: The SpeciesType object class is only available in SBML Level 2 Versions 2-4. It is not available in Level 1 nor Level 3. """ return _libsbml.Model_getSpeciesType(self, *args) def getCompartment(self, *args): """ getCompartment(Model self, unsigned int n) -> Compartment getCompartment(Model self, unsigned int n) -> Compartment getCompartment(Model self, string sid) -> Compartment getCompartment(Model self, string sid) -> Compartment This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getCompartment(long n) Get the nth Compartment object in this Model. Parameter 'n' is the index of the object to return. Returns the nth Compartment of this Model. If the index 'n' is invalid, 'None' is returned. ______________________________________________________________________ Method variant with the following signature: getCompartment(string sid) Get a Compartment object based on its identifier. Parameter 'sid' is the identifier to search for. Returns the Compartment in this Model with the identifier 'sid' or 'None' if no such Compartment exists. """ return _libsbml.Model_getCompartment(self, *args) def getSpecies(self, *args): """ getSpecies(Model self, unsigned int n) -> Species getSpecies(Model self, unsigned int n) -> Species getSpecies(Model self, string sid) -> Species getSpecies(Model self, string sid) -> Species This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getSpecies(long n) Get the nth Species object in this Model. Parameter 'n' is the index of the object to return. Returns the nth Species of this Model. If the index 'n' is invalid, 'None' is returned. ______________________________________________________________________ Method variant with the following signature: getSpecies(string sid) Get a Species object based on its identifier. Parameter 'sid' is the identifier to search for. Returns the Species in this Model with the identifier 'sid' or 'None' if no such Species exists. """ return _libsbml.Model_getSpecies(self, *args) def getParameter(self, *args): """ getParameter(Model self, unsigned int n) -> Parameter getParameter(Model self, unsigned int n) -> Parameter getParameter(Model self, string sid) -> Parameter getParameter(Model self, string sid) -> Parameter This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getParameter(long n) Get the nth Parameter object in this Model. Parameter 'n' is the index of the object to return. Returns the nth Parameter of this Model. If the index 'n' is invalid, 'None' is returned. ______________________________________________________________________ Method variant with the following signature: getParameter(string sid) Get a Parameter object based on its identifier. Parameter 'sid' is the identifier to search for. Returns the Parameter in this Model with the identifier 'sid' or 'None' if no such Parameter exists. """ return _libsbml.Model_getParameter(self, *args) def getInitialAssignment(self, *args): """ getInitialAssignment(Model self, unsigned int n) -> InitialAssignment getInitialAssignment(Model self, unsigned int n) -> InitialAssignment getInitialAssignment(Model self, string symbol) -> InitialAssignment getInitialAssignment(Model self, string symbol) -> InitialAssignment This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getInitialAssignment(string symbol) Get an InitialAssignment object based on the symbol to which it assigns a value. Parameter 'symbol' is the symbol to search for. Returns the InitialAssignment in this Model with the given 'symbol' attribute value or 'None' if no such InitialAssignment exists. ______________________________________________________________________ Method variant with the following signature: getInitialAssignment(long n) Get the nth InitialAssignment object in this Model. Parameter 'n' is the index of the object to return. Returns the nth InitialAssignment of this Model. If the index 'n' is invalid, 'None' is returned. """ return _libsbml.Model_getInitialAssignment(self, *args) def getInitialAssignmentBySymbol(self, *args): """ getInitialAssignmentBySymbol(Model self, string symbol) -> InitialAssignment getInitialAssignmentBySymbol(Model self, string symbol) -> InitialAssignment Get an InitialAssignment object based on the symbol to which it assigns a value. Parameter 'symbol' is the symbol to search for. Returns the InitialAssignment in this Model with the given 'symbol' attribute value or 'None' if no such InitialAssignment exists. """ return _libsbml.Model_getInitialAssignmentBySymbol(self, *args) def getRule(self, *args): """ getRule(Model self, unsigned int n) -> Rule getRule(Model self, unsigned int n) -> Rule getRule(Model self, string variable) -> Rule getRule(Model self, string variable) -> Rule This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getRule(string variable) Get a Rule object based on the variable to which it assigns a value. Parameter 'variable' is the variable to search for. Returns the Rule in this Model with the given 'variable' attribute value or 'None' if no such Rule exists. ______________________________________________________________________ Method variant with the following signature: getRule(long n) Get the nth Rule object in this Model. Parameter 'n' is the index of the object to return. Returns the nth Rule of this Model. If the index 'n' is invalid, 'None' is returned. """ return _libsbml.Model_getRule(self, *args) def getRuleByVariable(self, *args): """ getRuleByVariable(Model self, string variable) -> Rule getRuleByVariable(Model self, string variable) -> Rule Get a Rule object based on the variable to which it assigns a value. Parameter 'variable' is the variable to search for. Returns the Rule in this Model with the given 'variable' attribute value or 'None' if no such Rule exists. """ return _libsbml.Model_getRuleByVariable(self, *args) def getAssignmentRule(self, *args): """ getAssignmentRule(Model self, string variable) -> AssignmentRule getAssignmentRule(Model self, string variable) -> AssignmentRule Get a Rule object based on the variable to which it assigns a value. Parameter 'variable' is the variable to search for. Returns the Rule in this Model with the given 'variable' attribute value or 'None' if no such Rule exists. """ return _libsbml.Model_getAssignmentRule(self, *args) def getRateRule(self, *args): """ getRateRule(Model self, string variable) -> RateRule getRateRule(Model self, string variable) -> RateRule Get a Rule object based on the variable to which it assigns a value. Parameter 'variable' is the symbol to search for. Returns the Rule in this Model with the given 'variable' attribute value or 'None' if no such Rule exists. """ return _libsbml.Model_getRateRule(self, *args) def getAssignmentRuleByVariable(self, *args): """ getAssignmentRuleByVariable(Model self, string variable) -> AssignmentRule getAssignmentRuleByVariable(Model self, string variable) -> AssignmentRule Get a Rule object based on the variable to which it assigns a value. Parameter 'variable' is the variable to search for. Returns the Rule in this Model with the given 'variable' attribute value or 'None' if no such Rule exists. """ return _libsbml.Model_getAssignmentRuleByVariable(self, *args) def getRateRuleByVariable(self, *args): """ getRateRuleByVariable(Model self, string variable) -> RateRule getRateRuleByVariable(Model self, string variable) -> RateRule Get a Rule object based on the variable to which it assigns a value. Parameter 'variable' is the variable to search for. Returns the Rule in this Model with the given 'variable' attribute value or 'None' if no such Rule exists. """ return _libsbml.Model_getRateRuleByVariable(self, *args) def getConstraint(self, *args): """ getConstraint(Model self, unsigned int n) -> Constraint getConstraint(Model self, unsigned int n) -> Constraint Get the nth Constraint object in this Model. Parameter 'n' is the index of the object to return. Returns the nth Constraint of this Model. If the index 'n' is invalid, 'None' is returned. """ return _libsbml.Model_getConstraint(self, *args) def getReaction(self, *args): """ getReaction(Model self, unsigned int n) -> Reaction getReaction(Model self, unsigned int n) -> Reaction getReaction(Model self, string sid) -> Reaction getReaction(Model self, string sid) -> Reaction This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getReaction(long n) Get the nth Reaction object in this Model. Parameter 'n' is the index of the object to return. Returns the nth Reaction of this Model. If the index 'n' is invalid, 'None' is returned. ______________________________________________________________________ Method variant with the following signature: getReaction(string sid) Get a Reaction object based on its identifier. Parameter 'sid' is the identifier to search for. Returns the Reaction in this Model with the identifier 'sid' or 'None' if no such Reaction exists. """ return _libsbml.Model_getReaction(self, *args) def getSpeciesReference(self, *args): """ getSpeciesReference(Model self, string sid) -> SpeciesReference getSpeciesReference(Model self, string sid) -> SpeciesReference Get a SpeciesReference object based on its identifier. Parameter 'sid' is the identifier to search for. Returns the SpeciesReference in this Model with the identifier 'sid' or 'None' if no such SpeciesReference exists. """ return _libsbml.Model_getSpeciesReference(self, *args) def getModifierSpeciesReference(self, *args): """ getModifierSpeciesReference(Model self, string sid) -> ModifierSpeciesReference getModifierSpeciesReference(Model self, string sid) -> ModifierSpeciesReference Get a ModifierSpeciesReference object based on its identifier. Parameter 'sid' is the identifier to search for. Returns the ModifierSpeciesReference in this Model with the identifier 'sid' or 'None' if no such ModifierSpeciesReference exists. """ return _libsbml.Model_getModifierSpeciesReference(self, *args) def getEvent(self, *args): """ getEvent(Model self, unsigned int n) -> Event getEvent(Model self, unsigned int n) -> Event getEvent(Model self, string sid) -> Event getEvent(Model self, string sid) -> Event This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getEvent(long n) Get the nth Event object in this Model. Parameter 'n' is the index of the object to return. Returns the nth Event of this Model. If the index 'n' is invalid, 'None' is returned. ______________________________________________________________________ Method variant with the following signature: getEvent(string sid) Get an Event object based on its identifier. Parameter 'sid' is the identifier to search for. Returns the Event in this Model with the identifier 'sid' or 'None' if no such Event exists. """ return _libsbml.Model_getEvent(self, *args) def getNumFunctionDefinitions(self): """ getNumFunctionDefinitions(Model self) -> unsigned int Get the number of FunctionDefinition objects in this Model. Returns the number of FunctionDefinitions in this Model. """ return _libsbml.Model_getNumFunctionDefinitions(self) def getNumUnitDefinitions(self): """ getNumUnitDefinitions(Model self) -> unsigned int Get the number of UnitDefinition objects in this Model. Returns the number of UnitDefinitions in this Model. """ return _libsbml.Model_getNumUnitDefinitions(self) def getNumCompartmentTypes(self): """ getNumCompartmentTypes(Model self) -> unsigned int Get the number of CompartmentType objects in this Model. Returns the number of CompartmentTypes in this Model. Note: The CompartmentType object class is only available in SBML Level 2 Versions 2-4. It is not available in Level 1 nor Level 3. """ return _libsbml.Model_getNumCompartmentTypes(self) def getNumSpeciesTypes(self): """ getNumSpeciesTypes(Model self) -> unsigned int Get the number of SpeciesType objects in this Model. Returns the number of SpeciesTypes in this Model. Note: The SpeciesType object class is only available in SBML Level 2 Versions 2-4. It is not available in Level 1 nor Level 3. """ return _libsbml.Model_getNumSpeciesTypes(self) def getNumCompartments(self): """ getNumCompartments(Model self) -> unsigned int Get the number of Compartment objects in this Model. Returns the number of Compartments in this Model. """ return _libsbml.Model_getNumCompartments(self) def getNumSpecies(self): """ getNumSpecies(Model self) -> unsigned int Get the number of Species objects in this Model. Returns the number of Species in this Model. """ return _libsbml.Model_getNumSpecies(self) def getNumSpeciesWithBoundaryCondition(self): """ getNumSpeciesWithBoundaryCondition(Model self) -> unsigned int Get the number of Species in this Model having their 'boundaryCondition' attribute value set to 'True.' Returns the number of Species in this Model with boundaryCondition set to true. """ return _libsbml.Model_getNumSpeciesWithBoundaryCondition(self) def getNumParameters(self): """ getNumParameters(Model self) -> unsigned int Get the number of Parameter objects in this Model. Returns the number of Parameters in this Model. Parameters defined in KineticLaws are not included. """ return _libsbml.Model_getNumParameters(self) def getNumInitialAssignments(self): """ getNumInitialAssignments(Model self) -> unsigned int Get the number of InitialAssignment objects in this Model. Returns the number of InitialAssignments in this Model. """ return _libsbml.Model_getNumInitialAssignments(self) def getNumRules(self): """ getNumRules(Model self) -> unsigned int Get the number of Rule objects in this Model. Returns the number of Rules in this Model. """ return _libsbml.Model_getNumRules(self) def getNumConstraints(self): """ getNumConstraints(Model self) -> unsigned int Get the number of Constraint objects in this Model. Returns the number of Constraints in this Model. """ return _libsbml.Model_getNumConstraints(self) def getNumReactions(self): """ getNumReactions(Model self) -> unsigned int Get the number of Reaction objects in this Model. Returns the number of Reactions in this Model. """ return _libsbml.Model_getNumReactions(self) def getNumEvents(self): """ getNumEvents(Model self) -> unsigned int Get the number of Event objects in this Model. Returns the number of Events in this Model. """ return _libsbml.Model_getNumEvents(self) def removeFromParentAndDelete(self): """ removeFromParentAndDelete(Model self) -> int Remove this Model from its parent SBMLDocument object. This works by finding this Model's parent SBMLDocument and then calling setModel(None) on it, indirectly deleting itself. Overridden from the SBase function since the parent is not a ListOf. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.Model_removeFromParentAndDelete(self) def renameAllIds(self, idTransformer, filter=None): """ renameAllIds(Model self, IdentifierTransformer idTransformer, ElementFilter filter=None) -> int renameAllIds(Model self, IdentifierTransformer idTransformer) -> int Internal implementation method. """ return _libsbml.Model_renameAllIds(self, idTransformer, filter) def renameSIdRefs(self, oldid, newid): """ renameSIdRefs(Model self, string oldid, string newid) Replaces all uses of a given 'SIdRef' type attribute value with another value. In SBML, object identifiers are of a data type called SId. In SBML Level 3, an explicit data type called SIdRef was introduced for attribute values that refer to SId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to an identifier', but the effective data type was the same as SIdRef in Level 3. These and other methods of libSBML refer to the type SIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all attributes and (if appropriate) mathematical formulas in MathML content, comparing the referenced identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.Model_renameSIdRefs(self, oldid, newid) def renameUnitSIdRefs(self, oldid, newid): """ renameUnitSIdRefs(Model self, string oldid, string newid) Replaces all uses of a given 'UnitSIdRef' type attribute value with another value. In SBML, unit definitions have identifiers of type UnitSId. In SBML Level 3, an explicit data type called UnitSIdRef was introduced for attribute values that refer to UnitSId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to a unit identifier', but the effective data type was the same as UnitSIdRef in Level 3. These and other methods of libSBML refer to the type UnitSIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all unit identifier attribute values (including, if appropriate, inside mathematical formulas), comparing the referenced unit identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.Model_renameUnitSIdRefs(self, oldid, newid) def convertL1ToL2(self): """ convertL1ToL2(Model self) Internal implementation method. """ return _libsbml.Model_convertL1ToL2(self) def convertL1ToL3(self, addDefaultUnits=True): """ convertL1ToL3(Model self, bool addDefaultUnits=True) convertL1ToL3(Model self) Internal implementation method. """ return _libsbml.Model_convertL1ToL3(self, addDefaultUnits) def convertL2ToL3(self, strict=False, addDefaultUnits=True): """ convertL2ToL3(Model self, bool strict=False, bool addDefaultUnits=True) convertL2ToL3(Model self, bool strict=False) convertL2ToL3(Model self) Internal implementation method. """ return _libsbml.Model_convertL2ToL3(self, strict, addDefaultUnits) def convertL2ToL1(self, strict=False): """ convertL2ToL1(Model self, bool strict=False) convertL2ToL1(Model self) Internal implementation method. """ return _libsbml.Model_convertL2ToL1(self, strict) def convertL3ToL1(self, strict=False): """ convertL3ToL1(Model self, bool strict=False) convertL3ToL1(Model self) Internal implementation method. """ return _libsbml.Model_convertL3ToL1(self, strict) def convertL3ToL2(self, strict=False): """ convertL3ToL2(Model self, bool strict=False) convertL3ToL2(Model self) Internal implementation method. """ return _libsbml.Model_convertL3ToL2(self, strict) def convertFromL3V2(self, strict=False): """ convertFromL3V2(Model self, bool strict=False) convertFromL3V2(Model self) Internal implementation method. """ return _libsbml.Model_convertFromL3V2(self, strict) def dealWithFast(self): """ dealWithFast(Model self) Internal implementation method. """ return _libsbml.Model_dealWithFast(self) def dealWithL3Fast(self, targetVersion): """ dealWithL3Fast(Model self, unsigned int targetVersion) Internal implementation method. """ return _libsbml.Model_dealWithL3Fast(self, targetVersion) def addModifiers(self): """ addModifiers(Model self) Internal implementation method. """ return _libsbml.Model_addModifiers(self) def addConstantAttribute(self): """ addConstantAttribute(Model self) Internal implementation method. """ return _libsbml.Model_addConstantAttribute(self) def setSpatialDimensions(self, dims=3.0): """ setSpatialDimensions(Model self, double dims=3.0) setSpatialDimensions(Model self) Internal implementation method. """ return _libsbml.Model_setSpatialDimensions(self, dims) def addDefinitionsForDefaultUnits(self): """ addDefinitionsForDefaultUnits(Model self) Internal implementation method. """ return _libsbml.Model_addDefinitionsForDefaultUnits(self) def dealWithDefaultValues(self): """ dealWithDefaultValues(Model self) Internal implementation method. """ return _libsbml.Model_dealWithDefaultValues(self) def convertParametersToLocals(self, level, version): """ convertParametersToLocals(Model self, unsigned int level, unsigned int version) Internal implementation method. """ return _libsbml.Model_convertParametersToLocals(self, level, version) def setSpeciesReferenceConstantValueAndStoichiometry(self): """ setSpeciesReferenceConstantValueAndStoichiometry(Model self) Internal implementation method. """ return _libsbml.Model_setSpeciesReferenceConstantValueAndStoichiometry(self) def removeParameterRuleUnits(self, strict): """ removeParameterRuleUnits(Model self, bool strict) Internal implementation method. """ return _libsbml.Model_removeParameterRuleUnits(self, strict) def convertStoichiometryMath(self): """ convertStoichiometryMath(Model self) Internal implementation method. """ return _libsbml.Model_convertStoichiometryMath(self) def assignRequiredValues(self): """ assignRequiredValues(Model self) Internal implementation method. """ return _libsbml.Model_assignRequiredValues(self) def dealWithModelUnits(self, strict=False): """ dealWithModelUnits(Model self, bool strict=False) dealWithModelUnits(Model self) Internal implementation method. """ return _libsbml.Model_dealWithModelUnits(self, strict) def dealWithStoichiometry(self): """ dealWithStoichiometry(Model self) Internal implementation method. """ return _libsbml.Model_dealWithStoichiometry(self) def dealWithEvents(self, strict): """ dealWithEvents(Model self, bool strict) Internal implementation method. """ return _libsbml.Model_dealWithEvents(self, strict) def removeSpeciesTypes(self): """ removeSpeciesTypes(Model self) Internal implementation method. """ return _libsbml.Model_removeSpeciesTypes(self) def removeCompartmentTypes(self): """ removeCompartmentTypes(Model self) Internal implementation method. """ return _libsbml.Model_removeCompartmentTypes(self) def connectToChild(self): """connectToChild(Model self)""" return _libsbml.Model_connectToChild(self) def getTypeCode(self): """ getTypeCode(Model self) -> int Returns the libSBML type code for this SBML object. LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for this object: SBML_MODEL (default). WARNING: The specific integer values of the possible type codes may be reused by different libSBML plug-ins for SBML Level 3. packages, To fully identify the correct code, it is necessary to invoke both getPackageName() and getTypeCode() (or ListOf.getItemTypeCode()). See also getElementName(), getPackageName(). """ return _libsbml.Model_getTypeCode(self) def getElementName(self): """ getElementName(Model self) -> string Returns the XML element name of this object, which for Model, is always ''model'.' Returns the name of this element, i.e., ''model'.' """ return _libsbml.Model_getElementName(self) def populateListFormulaUnitsData(self): """ populateListFormulaUnitsData(Model self) Populates the internal list of derived units for this Model object. This method tells libSBML to (re)calculate all units for all components of the enclosing Model object. The result is stored in an internal list of unit data. Users can access the resulting data by calling the method SBase.getDerivedUnitDefinition() available on most objects. (The name 'formula units data' is drawn from the name of the internal objects libSBML uses to store the data; note that these internal objects are not exposed to callers, because callers can interact with the results using the ordinary SBML unit objects.) This method is used by libSBML itself in the validator concerned with unit consistency. The unit consistency validator (like all other validators in libSBML) is invoked by using SBMLDocument.checkConsistency(), with the consistency checks for the category LIBSBML_CAT_UNITS_CONSISTENCY turned on. The method populateListFormulaUnitsData() does not need to be called prior to invoking the validator if unit consistency checking has not been turned off. This method is only provided for cases when callers have a special need to force the unit data to be recalculated. For instance, during construction of a model, a caller may want to interrogate libSBML's inferred units without invoking full-blown model validation; this is a scenario in which calling populateListFormulaUnitsData() may be useful. WARNING: Computing and inferring units is a time-consuming operation. Callers may want to call isPopulatedListFormulaUnitsData() to determine whether the units may already have been computed, to save themselves the need of invoking unit inference unnecessarily. See also isPopulatedListFormulaUnitsData(). """ return _libsbml.Model_populateListFormulaUnitsData(self) def isPopulatedListFormulaUnitsData(self): """ isPopulatedListFormulaUnitsData(Model self) -> bool Predicate returning 'True' if libSBML has derived units for the components of this model. LibSBML can infer the units of measurement associated with different elements of a model. When libSBML does that, it builds a complex internal structure during a resource-intensive operation. This is done automatically only when callers invoke validation (via SBMLDocument.checkConsistency()) and have not turned off the unit validation option. Callers can force units to be recalculated by calling populateListFormulaUnitsData(). To avoid calling that method unnecessarily, calling programs may first want to invoke this method (isPopulatedListFormulaUnitsData()) to determine whether it is even necessary. Returns 'True' if the units have already been computed, 'False' otherwise. """ return _libsbml.Model_isPopulatedListFormulaUnitsData(self) def getFormulaUnitsDataForVariable(self, sid): """ getFormulaUnitsDataForVariable(Model self, string sid) -> FormulaUnitsData * Internal implementation method. """ return _libsbml.Model_getFormulaUnitsDataForVariable(self, sid) def getFormulaUnitsDataForAssignment(self, sid): """ getFormulaUnitsDataForAssignment(Model self, string sid) -> FormulaUnitsData * Internal implementation method. """ return _libsbml.Model_getFormulaUnitsDataForAssignment(self, sid) def populateAllElementIdList(self): """ populateAllElementIdList(Model self) Populates the internal list of the identifiers of all elements within this Model object. This method tells libSBML to retrieve the identifiers of all elements of the enclosing Model object. The result is stored in an internal list of ids. Users can access the resulting data by calling the method getAllElementIdList(). WARNING: Retrieving all elements within a model is a time-consuming operation. Callers may want to call isPopulatedAllElementIdList() to determine whether the id list may already have been populated. See also isPopulatedAllElementIdList(). """ return _libsbml.Model_populateAllElementIdList(self) def isPopulatedAllElementIdList(self): """ isPopulatedAllElementIdList(Model self) -> bool Predicate returning 'True' if libSBML has a list of the ids of all components of this model. Returns 'True' if the id list has already been populated, 'False' otherwise. """ return _libsbml.Model_isPopulatedAllElementIdList(self) def getAllElementIdList(self): """ getAllElementIdList(Model self) -> IdList Returns the internal list of the identifiers of all elements within this Model object. Returns an IdList of all the identifiers in the model. See also populateAllElementIdList(), isPopulatedAllElementIdList(). """ return _libsbml.Model_getAllElementIdList(self) def clearAllElementIdList(self): """ clearAllElementIdList(Model self) Clears the internal list of the identifiers of all elements within this Model object. See also populateAllElementIdList(), isPopulatedAllElementIdList(). """ return _libsbml.Model_clearAllElementIdList(self) def populateAllElementMetaIdList(self): """ populateAllElementMetaIdList(Model self) Populates the internal list of the metaids of all elements within this Model object. This method tells libSBML to retrieve the identifiers of all elements of the enclosing Model object. The result is stored in an internal list of metaids. Users can access the resulting data by calling the method getAllElementMetaIdList(). WARNING: Retrieving all elements within a model is a time-consuming operation. Callers may want to call isPopulatedAllElementMetaIdList() to determine whether the metaid list may already have been populated. See also isPopulatedAllElementMetaIdList(). """ return _libsbml.Model_populateAllElementMetaIdList(self) def isPopulatedAllElementMetaIdList(self): """ isPopulatedAllElementMetaIdList(Model self) -> bool Predicate returning 'True' if libSBML has a list of the metaids of all components of this model. Returns 'True' if the metaid list has already been populated, 'False' otherwise. """ return _libsbml.Model_isPopulatedAllElementMetaIdList(self) def getAllElementMetaIdList(self): """ getAllElementMetaIdList(Model self) -> IdList Returns the internal list of the metaids of all elements within this Model object. Returns an IdList of all the metaids in the model. See also populateAllElementMetaIdList(), isPopulatedAllElementMetaIdList(). """ return _libsbml.Model_getAllElementMetaIdList(self) def clearAllElementMetaIdList(self): """ clearAllElementMetaIdList(Model self) Clears the internal list of the metaids of all elements within this Model object. See also populateAllElementMetaIdList(), isPopulatedAllElementMetaIdList(). """ return _libsbml.Model_clearAllElementMetaIdList(self) def hasRequiredElements(self): """ hasRequiredElements(Model self) -> bool Predicate returning 'True' if all the required elements for this Model object have been set. Returns a boolean value indicating whether all the required elements for this object have been defined. """ return _libsbml.Model_hasRequiredElements(self) def removeFunctionDefinition(self, *args): """ removeFunctionDefinition(Model self, unsigned int n) -> FunctionDefinition removeFunctionDefinition(Model self, string sid) -> FunctionDefinition This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: removeFunctionDefinition(long n) Removes the nth FunctionDefinition object from this Model object and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. Parameter 'n' is the index of the FunctionDefinition object to remove. Returns the FunctionDefinition object removed, or 'None' if the given index is out of range. ______________________________________________________________________ Method variant with the following signature: removeFunctionDefinition(string sid) Removes the FunctionDefinition object with the given identifier from this Model object and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. Parameter 'sid' is the identifier of the FunctionDefinition object to remove. Returns the FunctionDefinition object removed, or 'None' if no FunctionDefinition object with the identifier exists in this Model object. """ return _libsbml.Model_removeFunctionDefinition(self, *args) def removeUnitDefinition(self, *args): """ removeUnitDefinition(Model self, unsigned int n) -> UnitDefinition removeUnitDefinition(Model self, string sid) -> UnitDefinition This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: removeUnitDefinition(long n) Removes the nth UnitDefinition object from this Model object and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. Parameter 'n' is the index of the UnitDefinition object to remove. Returns the UnitDefinition object removed., or 'None' if the given index is out of range. ______________________________________________________________________ Method variant with the following signature: removeUnitDefinition(string sid) Removes the UnitDefinition object with the given identifier from this Model object and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. Parameter 'sid' is the identifier of the UnitDefinition object to remove. Returns the UnitDefinition object removed, or 'None' if no UnitDefinition object with the identifier exists in this Model object. """ return _libsbml.Model_removeUnitDefinition(self, *args) def removeCompartmentType(self, *args): """ removeCompartmentType(Model self, unsigned int n) -> CompartmentType removeCompartmentType(Model self, string sid) -> CompartmentType This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: removeCompartmentType(long n) Removes the nth CompartmentType object from this Model object and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. Parameter 'n' is the index of the CompartmentType object to remove. Returns the ComapartmentType object removed, or 'None' if the given index is out of range. ______________________________________________________________________ Method variant with the following signature: removeCompartmentType(string sid) Removes the CompartmentType object with the given identifier from this Model object and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. Parameter 'sid' is the identifier of the object to remove. Returns the CompartmentType object removed, or 'None' if no CompartmentType object with the identifier exists in this Model object. """ return _libsbml.Model_removeCompartmentType(self, *args) def removeSpeciesType(self, *args): """ removeSpeciesType(Model self, unsigned int n) -> SpeciesType removeSpeciesType(Model self, string sid) -> SpeciesType This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: removeSpeciesType(long n) Removes the nth SpeciesType object from this Model object and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. Parameter 'n' is the index of the SpeciesType object to remove. Returns the SpeciesType object removed, or 'None' if the given index is out of range. ______________________________________________________________________ Method variant with the following signature: removeSpeciesType(string sid) Removes the SpeciesType object with the given identifier from this Model object and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. Parameter 'sid' is the identifier of the SpeciesType object to remove. Returns the SpeciesType object removed, or 'None' if no SpeciesType object with the identifier exists in this Model object. """ return _libsbml.Model_removeSpeciesType(self, *args) def removeCompartment(self, *args): """ removeCompartment(Model self, unsigned int n) -> Compartment removeCompartment(Model self, string sid) -> Compartment This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: removeCompartment(long n) Removes the nth Compartment object from this Model object and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. Parameter 'n' is the index of the Compartment object to remove. Returns the Compartment object removed, or 'None' if the given index is out of range. ______________________________________________________________________ Method variant with the following signature: removeCompartment(string sid) Removes the Compartment object with the given identifier from this Model object and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. Parameter 'sid' is the identifier of the Compartment object to remove. Returns the Compartment object removed, or 'None' if no Compartment object with the identifier exists in this Model object. """ return _libsbml.Model_removeCompartment(self, *args) def removeSpecies(self, *args): """ removeSpecies(Model self, unsigned int n) -> Species removeSpecies(Model self, string sid) -> Species This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: removeSpecies(long n) Removes the nth Species object from this Model object and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. Parameter 'n' is the index of the Species object to remove. Returns the Species object removed, or 'None' if the given index is out of range. ______________________________________________________________________ Method variant with the following signature: removeSpecies(string sid) Removes the Species object with the given identifier from this Model object and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. Parameter 'sid' is the identifier of the Species object to remove. Returns the Species object removed, or 'None' if no Species object with the identifier exists in this Model object. """ return _libsbml.Model_removeSpecies(self, *args) def removeParameter(self, *args): """ removeParameter(Model self, unsigned int n) -> Parameter removeParameter(Model self, string sid) -> Parameter This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: removeParameter(long n) Removes the nth Parameter object from this Model object and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. Parameter 'n' is the index of the Parameter object to remove. Returns the Parameter object removed, or 'None' if the given index is out of range. ______________________________________________________________________ Method variant with the following signature: removeParameter(string sid) Removes the Parameter object with the given identifier from this Model object and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. Parameter 'sid' is the identifier of the Parameter object to remove. Returns the Parameter object removed, or 'None' if no Parameter object with the identifier exists in this Model object. """ return _libsbml.Model_removeParameter(self, *args) def removeInitialAssignment(self, *args): """ removeInitialAssignment(Model self, unsigned int n) -> InitialAssignment removeInitialAssignment(Model self, string symbol) -> InitialAssignment This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: removeInitialAssignment(string symbol) Removes the InitialAssignment object with the given 'symbol' attribute from this Model object and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. Parameter 'symbol' is the 'symbol' attribute of the InitialAssignment object to remove. Returns the InitialAssignment object removed, or 'None' if no InitialAssignment object with the 'symbol' attribute exists in this Model object. ______________________________________________________________________ Method variant with the following signature: removeInitialAssignment(long n) Removes the nth InitialAssignment object from this Model object and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. Parameter 'n' is the index of the InitialAssignment object to remove. Returns the InitialAssignment object removed, or 'None' if the given index is out of range. """ return _libsbml.Model_removeInitialAssignment(self, *args) def removeRule(self, *args): """ removeRule(Model self, unsigned int n) -> Rule removeRule(Model self, string variable) -> Rule This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: removeRule(string variable) Removes the Rule object with the given 'variable' attribute from this Model object and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. Parameter 'variable' is the 'variable' attribute of the Rule object to remove. Returns the Rule object removed, or 'None' if no Rule object with the 'variable' attribute exists in this Model object. ______________________________________________________________________ Method variant with the following signature: removeRule(long n) Removes the nth Rule object from this Model object and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. Parameter 'n' is the index of the Rule object to remove. Returns the Rule object removed, or 'None' if the given index is out of range. """ return _libsbml.Model_removeRule(self, *args) def removeRuleByVariable(self, variable): """ removeRuleByVariable(Model self, string variable) -> Rule Removes the Rule object with the given 'variable' attribute from this Model object and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. Parameter 'variable' is the 'variable' attribute of the Rule object to remove. Returns the Rule object removed, or 'None' if no Rule object with the 'variable' attribute exists in this Model object. """ return _libsbml.Model_removeRuleByVariable(self, variable) def removeConstraint(self, n): """ removeConstraint(Model self, unsigned int n) -> Constraint Removes the nth Constraint object from this Model object and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. Parameter 'n' is the index of the Constraint object to remove. Returns the Constraint object removed, or 'None' if the given index is out of range. """ return _libsbml.Model_removeConstraint(self, n) def removeReaction(self, *args): """ removeReaction(Model self, unsigned int n) -> Reaction removeReaction(Model self, string sid) -> Reaction This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: removeReaction(long n) Removes the nth Reaction object from this Model object and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. Parameter 'n' is the index of the Reaction object to remove. Returns the Reaction object removed, or 'None' if the given index is out of range. ______________________________________________________________________ Method variant with the following signature: removeReaction(string sid) Removes the Reaction object with the given identifier from this Model object and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. Parameter 'sid' is the identifier of the Reaction object to remove. Returns the Reaction object removed, or 'None' if no Reaction object with the identifier exists in this Model object. """ return _libsbml.Model_removeReaction(self, *args) def removeEvent(self, *args): """ removeEvent(Model self, unsigned int n) -> Event removeEvent(Model self, string sid) -> Event This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: removeEvent(long n) Removes the nth Event object from this Model object and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. Parameter 'n' is the index of the Event object to remove. Returns the Event object removed, or 'None' if the given index is out of range. ______________________________________________________________________ Method variant with the following signature: removeEvent(string sid) Removes the Event object with the given identifier from this Model object and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. Parameter 'sid' is the identifier of the Event object to remove. Returns the Event object removed, or 'None' if no Event object with the identifier exists in this Model object. """ return _libsbml.Model_removeEvent(self, *args) def appendFrom(self, model): """ appendFrom(Model self, Model model) -> int Copies a given Model object's subcomponents and appends the copies to the appropriate places in this Model. This method also calls the appendFrom method on all libSBML plug-in objects. SBML Level 3 consists of a Core definition that can be extended via optional SBML Level 3 packages. A given model may indicate that it uses one or more SBML packages, and likewise, a software tool may be able to support one or more packages. LibSBML does not come preconfigured with all possible packages included and enabled, in part because not all package specifications have been finalized. To support the ability for software systems to enable support for the Level 3 packages they choose, libSBML features a plug-in mechanism. Each SBML Level 3 package is implemented in a separate code plug-in that can be enabled by the application to support working with that SBML package. A given SBML model may thus contain not only objects defined by SBML Level 3 Core, but also objects created by libSBML plug-ins supporting additional Level 3 packages. Parameter 'model' is the Model to merge with this one. """ return _libsbml.Model_appendFrom(self, model) def enablePackageInternal(self, pkgURI, pkgPrefix, flag): """ enablePackageInternal(Model self, string pkgURI, string pkgPrefix, bool flag) Internal implementation method. """ return _libsbml.Model_enablePackageInternal(self, pkgURI, pkgPrefix, flag) def updateSBMLNamespace(self, package, level, version): """ updateSBMLNamespace(Model self, string package, unsigned int level, unsigned int version) Internal implementation method. """ return _libsbml.Model_updateSBMLNamespace(self, package, level, version) def renameIDs(self, elements, idTransformer): """ renameIDs(Model self, SBaseList elements, IdentifierTransformer idTransformer) Internal implementation method. """ return _libsbml.Model_renameIDs(self, elements, idTransformer) Model_swigregister = _libsbml.Model_swigregister Model_swigregister(Model) IdCheckON = _libsbml.IdCheckON IdCheckOFF = _libsbml.IdCheckOFF SBMLCheckON = _libsbml.SBMLCheckON SBMLCheckOFF = _libsbml.SBMLCheckOFF SBOCheckON = _libsbml.SBOCheckON SBOCheckOFF = _libsbml.SBOCheckOFF MathCheckON = _libsbml.MathCheckON MathCheckOFF = _libsbml.MathCheckOFF UnitsCheckON = _libsbml.UnitsCheckON UnitsCheckOFF = _libsbml.UnitsCheckOFF OverdeterCheckON = _libsbml.OverdeterCheckON OverdeterCheckOFF = _libsbml.OverdeterCheckOFF PracticeCheckON = _libsbml.PracticeCheckON PracticeCheckOFF = _libsbml.PracticeCheckOFF AllChecksON = _libsbml.AllChecksON class SBMLDocument(SBase): """ Overall SBML container object. LibSBML uses the class SBMLDocument as a top-level container for storing SBML content and data associated with it (such as warnings and error messages). The two primary means of reading an SBML model, SBMLReader.readSBML() and SBMLReader.readSBMLFromString(), both return a pointer to an SBMLDocument object. From there, callers can inquire about any errors encountered (e.g., using SBMLDocument.getNumErrors()), access the Model object, and perform other actions such as consistency-checking and model translation. When creating fresh models programmatically, the starting point is typically the creation of an SBMLDocument object instance. The SBMLDocument constructor accepts arguments for the SBML Level and Version of the model to be created. After creating the SBMLDocument object, calling programs then typically call SBMLDocument.createModel() almost immediately, and then proceed to call the methods on the Model object to fill out the model's contents. SBMLDocument corresponds roughly to the class Sbml defined in the SBML Level 2 specification and SBML in the Level 3 specification. It does not have a direct correspondence in SBML Level 1. (However, to make matters simpler for applications, libSBML creates an SBMLDocument no matter whether the model is Level 1, Level 2 or Level 3.) In its barest form, when written out in XML format for (e.g.) SBML Level 2 Version 4, the corresponding structure is the following: ... SBMLDocument is derived from SBase, and therefore contains the usual SBase attributes (in SBML Level 2 and Level 3) of 'metaid' and 'sboTerm', as well as the subelements 'notes' and 'annotation'. It also contains the attributes 'level' and 'version' indicating the Level and Version of the SBML data structure. These can be accessed using the methods defined by the SBase class for that purpose. Checking consistency and adherence to SBML specifications ====================================================================== One of the most important features of libSBML is its ability to perform SBML validation to ensure that a model adheres to the SBML specification for whatever Level+Version combination the model uses. SBMLDocument provides the methods for running consistency-checking and validation rules on the SBML content. First, a brief explanation of the rationale is in order. In libSBML versions up to and including the version 3.3.x series, the individual methods for creating and setting attributes and other components were quite lenient, and allowed a caller to compose SBML entities that might not, in the end, represent valid SBML. This allowed applications the freedom to do things such as save incomplete models (which is useful when models are being developed over long periods of time). In the version 4.x series, libSBML is somewhat stricter, but still permits structures to be created independently and the results to be combined in a separate step. In all these cases, it means that a separate validation step is necessary when a calling program finally wants to finish a complete SBML document. The primary interface to this validation facility is SBMLDocument's SBMLDocument.checkInternalConsistency() and SBMLDocument.checkConsistency(). The former verifies the basic internal consistency and syntax of an SBML document, and the latter implements more elaborate validation rules (both those defined by the SBML specifications, as well as additional rules offered by libSBML). The checks performed by SBMLDocument.checkInternalConsistency() are hardwired and cannot be changed by calling programs, but the validation performed by SBMLDocument.checkConsistency() is under program control using the method SBMLDocument.setConsistencyChecks(). Applications can selectively disable specific kinds of checks that they may not be interested in, by calling SBMLDocument.setConsistencyChecks() with appropriate parameters. These methods have slightly different relevance depending on whether a model is created programmaticaly from scratch, or whether it is read in from a file or data stream. The following list summarizes the possible scenarios. Scenario 1: Creating a model from scratch. Before writing out the model, * Call SBMLDocument.checkInternalConsistency(), then inquire about the results by calling SBMLDocument.getNumErrors() * Call SBMLDocument.setConsistencyChecks() to configure which checks will be performed by SBMLDocument.checkConsistency() * Call SBMLDocument.checkConsistency(), then inquire about the results by calling SBMLDocument.getNumErrors() Scenario 2: Reading a model from a file or data stream. After reading the model, * Basic consistency checks will have been performed automatically by libSBML upon reading the content, so you only need to inquire about the results by using SBMLDocument.getNumErrors() * Call SBMLDocument.setConsistencyChecks() to configure which checks are performed by SBMLDocument.checkConsistency() * Call SBMLDocument.checkConsistency(), then inquire about the results by calling SBMLDocument.getNumErrors() It should be noted that as of SBML Level 3 Version 2, the Model became an optional child of SBMLDocument, instead of being required. This means that one can no longer use SBMLDocument.getModel() as a cheap method of checking if an SBML document was read in properly: the more robust getError methods detailed above must be used instead. Converting documents between Levels and Versions of SBML ====================================================================== LibSBML provides facilities for limited translation of SBML between Levels and Versions of the SBML specifications. The method for doing is is setLevelAndVersion() . In general, models can be converted upward without difficulty (e.g., from SBML Level 1 to Level 2, or from an earlier Version of Level 2 to the latest Version of Level 2). Sometimes models can be translated downward as well, if they do not use constructs specific to more advanced Levels of SBML. Calling SBMLDocument.setLevelAndVersion() will not necessarily lead to a successful conversion. The method will return a boolean value to indicate success or failure. Callers must check the error log (see next section) attached to the SBMLDocument object after calling SBMLDocument.setLevelAndVersion() in order to assess whether any problems arose. If an application is interested in translating to a lower Level and/or Version of SBML within a Level, the following methods allow for prior assessment of whether there is sufficient compatibility to make a translation possible: * SBMLDocument.checkL1Compatibility(), * SBMLDocument.checkL2v1Compatibility(), * SBMLDocument.checkL2v2Compatibility(), * SBMLDocument.checkL2v3Compatibility(), * SBMLDocument.checkL2v4Compatibility(), * SBMLDocument.checkL2v5Compatibility(), and * SBMLDocument.checkL3v1Compatibility(). Some changes between Versions of SBML Level 2 may lead to unexpected behaviors when attempting conversions in either direction. For example, SBML Level 2 Version 4 relaxed the requirement for consistency in units of measurement between expressions annd quantities in a model. As a result, a model written in Version 4, if converted to Version 3 with no other changes, may fail validation as a Version 3 model because Version 3 imposed stricter requirements on unit consistency. Other changes between SBML Level 2 and Level 3 make downward conversions challenging. In some cases, it means that a model converted to Level 2 from Level 3 will contain attributes that were not explicitly given in the Level 3 model, because in Level 2 these attributes may have been optional or have default values. Error handling ====================================================================== Upon reading a model, SBMLDocument logs any problems encountered while reading the model from the file or data stream. The log contains objects that record diagnostic information about any notable issues that arose. Whether the problems are warnings or errors, they are both reported through a single common interface involving the object class SBMLError. The methods SBMLDocument.getNumErrors(), SBMLDocument.getError() and SBMLDocument.printErrors() allow callers to interact with the warnings or errors logged. Alternatively, callers may retrieve the entire log as an SBMLErrorLog object using the method SBMLDocument.getErrorLog(). The SBMLErrorLog object provides some alternative methods for interacting with the set of errors and warnings. In either case, applications typically should first call SBMLDocument.getNumErrors() to find out if any issues have been logged after specific libSBML operations such as the ones discussed in the sections above. If they have, then an application will should proceed to inspect the individual reports using either the direct interfaces on SBMLDocument or using the methods on the SBMLErrorLog object. """ __swig_setmethods__ = {} for _s in [SBase]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLDocument, name, value) __swig_getmethods__ = {} for _s in [SBase]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, SBMLDocument, name) __repr__ = _swig_repr def getDefaultLevel(): """ getDefaultLevel() -> unsigned int The default SBML Level of new SBMLDocument objects. This 'default Level' corresponds to the most recent SBML specification Level available at the time libSBML version 5.17.2 was released. The default Level is used by SBMLDocument if no Level is explicitly specified at the time of the construction of an SBMLDocument instance. Returns an integer indicating the most recent SBML specification Level. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also SBMLDocument.getDefaultVersion() . """ return _libsbml.SBMLDocument_getDefaultLevel() getDefaultLevel = staticmethod(getDefaultLevel) def getDefaultVersion(): """ getDefaultVersion() -> unsigned int The default Version of new SBMLDocument objects. This 'default Version' corresponds to the most recent Version within the most recent Level of SBML available at the time libSBML version 5.17.2 was released. The default Version is used by SBMLDocument if no Version is explicitly specified at the time of the construction of an SBMLDocument instance. Returns an integer indicating the most recent SBML specification Version. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also SBMLDocument.getDefaultLevel() . """ return _libsbml.SBMLDocument_getDefaultVersion() getDefaultVersion = staticmethod(getDefaultVersion) __swig_destroy__ = _libsbml.delete_SBMLDocument __del__ = lambda self: None def __init__(self, *args): """ __init__(SBMLDocument self, unsigned int level=0, unsigned int version=0) -> SBMLDocument __init__(SBMLDocument self, unsigned int level=0) -> SBMLDocument __init__(SBMLDocument self) -> SBMLDocument __init__(SBMLDocument self, SBMLNamespaces sbmlns) -> SBMLDocument __init__(SBMLDocument self, SBMLDocument orig) -> SBMLDocument This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: SBMLDocument(SBMLNamespaces sbmlns) Creates a new SBMLDocument using the given SBMLNamespaces object 'sbmlns'. The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments. Parameter 'sbmlns' is an SBMLNamespaces object. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. ______________________________________________________________________ Method variant with the following signature: SBMLDocument(long level = 0, long version = 0) Creates a new SBMLDocument, optionally with given values for the SBML Level and Version. If both the SBML Level and Version attributes are not specified, the SBML document is treated as having the latest Level and Version of SBML as determined by SBMLDocument.getDefaultLevel() and SBMLDocument.getDefaultVersion(); however, the SBMLDocument object is otherwise left blank. In particular, the blank SBMLDocument object has no associated XML attributes, including (but not limited to) an XML namespace declaration. The XML namespace declaration is not added until the model is written out, or the method SBMLDocument.setLevelAndVersion() is called. This may be important to keep in mind if an application needs to add additional XML namespace declarations on the element. Application writers should either provide values for 'level' and 'version' on the call to this constructor, or else call SBMLDocument.setLevelAndVersion() shortly after creating the SBMLDocument object. Parameter 'level' is an integer for the SBML Level. Parameter 'version' is an integer for the Version within the SBML Level. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version.
Documentation note:
The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation.
See also SBMLDocument.setLevelAndVersion(), getDefaultLevel(), getDefaultVersion(). Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. ______________________________________________________________________ Method variant with the following signature: SBMLDocument(SBMLDocument orig) Copy constructor; creates a copy of this SBMLDocument. Parameter 'orig' is the object to copy. """ this = _libsbml.new_SBMLDocument(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(SBMLDocument self) -> SBMLDocument Creates and returns a deep copy of this SBMLDocument object. Returns the (deep) copy of this SBMLDocument object. """ return _libsbml.SBMLDocument_clone(self) def isSetModel(self): """ isSetModel(SBMLDocument self) -> bool Returns 'True' if the Model object has been set, otherwise returns 'False.' Returns 'True' if the Model object has been set """ return _libsbml.SBMLDocument_isSetModel(self) def getModel(self, *args): """ getModel(SBMLDocument self) -> Model getModel(SBMLDocument self) -> Model Returns the Model object stored in this SBMLDocument. It is important to note that this method does not create a Model instance. The model in the SBMLDocument must have been created at some prior time, for example using SBMLDocument.createModel() or SBMLDocument.setModel(). This method returns 'None' if a model does not yet exist. Returns the Model contained in this SBMLDocument, or 'None' if no such model exists. See also createModel(). """ model = _libsbml.SBMLDocument_getModel(self, *args) if model is not None: model.__parent_ref__ = self return model def getElementBySId(self, id): """ getElementBySId(SBMLDocument self, string id) -> SBase Returns the first child element found that has the given 'id' in the model-wide SId namespace, or 'None' if no such object is found. Parameter 'id' is string representing the id of the object to find. Returns pointer to the first element found with the given 'id'. """ return _libsbml.SBMLDocument_getElementBySId(self, id) def getElementByMetaId(self, metaid): """ getElementByMetaId(SBMLDocument self, string metaid) -> SBase Returns the first child element it can find with the given 'metaid', or itself if it has the given 'metaid', or 'None' if no such object is found. Parameter 'metaid' is string representing the metaid of the object to find. Returns pointer to the first element found with the given 'metaid'. """ return _libsbml.SBMLDocument_getElementByMetaId(self, metaid) def expandFunctionDefinitions(self): """ expandFunctionDefinitions(SBMLDocument self) -> bool Removes FunctionDefinition constructs from the document and expands any instances of their use within elements. For example, suppose a Model contains a FunctionDefinition with identifier ''f'' representing the math expression: f(x, y) = x * y. Suppose further that there is a reaction in which the element of the KineticLaw object contains f(s, p), where 's' and 'p' are other identifiers defined in the model. The outcome of invoking this method is that the of the KineticLaw now represents the expression s * p and the model no longer contains any FunctionDefinition objects. Returns bool 'True' if the transformation was successful, 'False,' otherwise. Note: This function will check the consistency of a model before attemptimg the transformation. If the model is not valid SBML, the transformation will not be performed and the function will return 'False.' """ return _libsbml.SBMLDocument_expandFunctionDefinitions(self) def expandInitialAssignments(self): """ expandInitialAssignments(SBMLDocument self) -> bool Removes InitialAssignment constructs from the document and replaces them with appropriate values. For example, suppose a Model contains a InitialAssignment to a symbol ''k'' where ''k'' is the identifier of a Parameter. The outcome of invoking this method is that the 'value' attribute of the Parameter definition is set to the result calculated using the InitialAssignment object's formula, and the corresponding InitialAssignment is then removed from the Model. Returns bool 'True' if the transformation was successful, 'False,' otherwise. Note: This function will check the consistency of a model before attemptimg the transformation. If the model is not valid SBML, the transformation will not be performed and the function will return 'False.' As part of that process, this method will check that it has values for any components referred to by the elements of InitialAssignment objects. In cases where not all of the values have been declared (e.g., if the mathematical expression refers to model entities that have no declared values), the InitialAssignment in question will not be removed and this method will return 'False.' """ return _libsbml.SBMLDocument_expandInitialAssignments(self) def setLevelAndVersion(self, level, version, strict=True, ignorePackages=False): """ setLevelAndVersion(SBMLDocument self, unsigned int level, unsigned int version, bool strict=True, bool ignorePackages=False) -> bool setLevelAndVersion(SBMLDocument self, unsigned int level, unsigned int version, bool strict=True) -> bool setLevelAndVersion(SBMLDocument self, unsigned int level, unsigned int version) -> bool Sets the SBML Level and Version of this SBMLDocument instance, attempting to convert the model as needed. This method is the principal way in libSBML to convert models between Levels and Versions of SBML. Generally, models can be converted upward without difficulty (e.g., from SBML Level 1 to Level 2, or from an earlier Version of Level 2 to the latest Version of Level 2). Sometimes models can be translated downward as well, if they do not use constructs specific to more advanced Levels of SBML. Before calling this method, callers may check compatibility directly using the methods SBMLDocument.checkL1Compatibility(), SBMLDocument.checkL2v1Compatibility(), SBMLDocument.checkL2v2Compatibility(), SBMLDocument.checkL2v3Compatibility(), SBMLDocument.checkL2v4Compatibility(), SBMLDocument.checkL2v5Compatibility(), SBMLDocument.checkL3v1Compatibility(), and SBMLDocument.checkL3v2Compatibility(). The valid combinations of SBML Level and Version as of this release of libSBML are the following: * Level 1 Version 2 * Level 2 Version 1 * Level 2 Version 2 * Level 2 Version 3 * Level 2 Version 4 * Level 2 Version 5 * Level 3 Version 1 * Level 3 Version 2 Strict conversion applies the additional criteria that both the source and the target model must be consistent SBML. Users can control the consistency checks that are applied using the SBMLDocument.setConsistencyChecksForConversion() method. If either the source or the potential target model have validation errors, the conversion is not performed. When a strict conversion is successful, the underlying SBML object model is altered to reflect the new level and version. Thus, information that cannot be converted (e.g. sboTerms) will be lost. Parameter 'level' is the desired SBML Level. Parameter 'version' is the desired Version within the SBML Level. Parameter 'strict' is boolean indicating whether to check consistency of both the source and target model when performing conversion (defaults to true ). Parameter 'ignorePackages' is boolean indicating whether the presence of packages should be ignored by the conversion routine (defaults to false ). Returns 'True' if the level and version of the document were successfully set to the requested values (which may have required conversion of the model), 'False' otherwise. Note: Calling this method will not necessarily lead to a successful conversion. If the conversion fails, it will be logged in the error list associated with this SBMLDocument. Callers should consult getNumErrors() to find out if the conversion succeeded without problems. For conversions from Level 2 to Level 1, callers can also check the Level of the model after calling this method to find out whether it is Level 1. (If the conversion to Level 1 failed, the Level of this model will be left unchanged.)
Documentation note:
The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation.
See also checkL1Compatibility(), checkL2v1Compatibility(), checkL2v2Compatibility(), checkL2v3Compatibility(), checkL2v4Compatibility(), checkL2v5Compatibility(), checkL3v1Compatibility(). Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.SBMLDocument_setLevelAndVersion(self, level, version, strict, ignorePackages) def updateSBMLNamespace(self, package, level, version): """ updateSBMLNamespace(SBMLDocument self, string package, unsigned int level, unsigned int version) Internal implementation method. """ return _libsbml.SBMLDocument_updateSBMLNamespace(self, package, level, version) def setModel(self, m): """ setModel(SBMLDocument self, Model m) -> int Sets the Model for this SBMLDocument to a copy of the given Model. Parameter 'm' is the new Model to use. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_LEVEL_MISMATCH * LIBSBML_VERSION_MISMATCH See also createModel(), getModel(). """ return _libsbml.SBMLDocument_setModel(self, m) def createModel(self, *args): """ createModel(SBMLDocument self, string sid) -> Model createModel(SBMLDocument self) -> Model Creates a new Model inside this SBMLDocument, and returns a pointer to it. In SBML Level 2, the use of an identifier on a Model object is optional. This method takes an optional argument, 'sid', for setting the identifier. If not supplied, the identifier attribute on the Model instance is not set. Parameter 'sid' is the identifier of the new Model to create.
Documentation note:
The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation.
See also getModel(), SBMLDocument.setModel(). Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.SBMLDocument_createModel(self, *args) def setLocationURI(self, uri): """ setLocationURI(SBMLDocument self, string uri) Sets the location of this SBMLDocument. Called automatically when readSBMLFromFile is used, but may be set manually as well. """ return _libsbml.SBMLDocument_setLocationURI(self, uri) def getLocationURI(self, *args): """ getLocationURI(SBMLDocument self) -> string getLocationURI(SBMLDocument self) -> string Get the location of this SBMLDocument. If this document was read from a file or had its location set manually, that filename or set location will be returned, otherwise, an empty string is returned. """ return _libsbml.SBMLDocument_getLocationURI(self, *args) def setConsistencyChecks(self, category, apply): """ setConsistencyChecks(SBMLDocument self, SBMLErrorCategory_t category, bool apply) Controls the consistency checks that are performed when SBMLDocument.checkConsistency() is called. This method works by adding or subtracting consistency checks from the set of all possible checks that SBMLDocument.checkConsistency() knows how to perform. This method may need to be called multiple times in order to achieve the desired combination of checks. The first argument ('category') in a call to this method indicates the category of consistency/error checks that are to be turned on or off, and the second argument ('apply', a boolean) indicates whether to turn it on (value of 'True)' or off (value of 'False).' The possible categories (values to the argument 'category') are the set of constants whose names begin with the characters LIBSBML_CAT_ in the interface class libsbml. The following are the possible choices: * LIBSBML_CAT_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. * LIBSBML_CAT_IDENTIFIER_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. * LIBSBML_CAT_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. * LIBSBML_CAT_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. * LIBSBML_CAT_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. * LIBSBML_CAT_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. * LIBSBML_CAT_MODELING_PRACTICE: 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. Parameter 'category' is a value drawn from the set of SBML error categories indicating the consistency checking/validation to be turned on or off. Parameter 'apply' is a boolean indicating whether the checks indicated by 'category' should be applied or not. See also SBMLDocument.checkConsistency(). """ return _libsbml.SBMLDocument_setConsistencyChecks(self, category, apply) def setConsistencyChecksForConversion(self, category, apply): """ setConsistencyChecksForConversion(SBMLDocument self, SBMLErrorCategory_t category, bool apply) Controls the consistency checks that are performed when SBMLDocument.setLevelAndVersion() is called. This method works by adding or subtracting consistency checks from the set of all possible checks that may be performed to avoid conversion to or from an invalid document. This method may need to be called multiple times in order to achieve the desired combination of checks. The first argument ('category') in a call to this method indicates the category of consistency/error checks that are to be turned on or off, and the second argument ('apply', a boolean) indicates whether to turn it on (value of 'True)' or off (value of 'False).' The possible categories (values to the argument 'category') are the set of constants whose names begin with the characters LIBSBML_CAT_ in the interface class libsbml. The following are the possible choices: * LIBSBML_CAT_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. * LIBSBML_CAT_IDENTIFIER_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. * LIBSBML_CAT_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. * LIBSBML_CAT_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. * LIBSBML_CAT_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. * LIBSBML_CAT_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. * LIBSBML_CAT_MODELING_PRACTICE: 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. Parameter 'category' is a value drawn from the set of SBML error categories indicating the consistency checking/validation to be turned on or off. Parameter 'apply' is a boolean indicating whether the checks indicated by 'category' should be applied or not. See also SBMLDocument.setLevelAndVersion(). """ return _libsbml.SBMLDocument_setConsistencyChecksForConversion(self, category, apply) def checkConsistency(self): """ checkConsistency(SBMLDocument self) -> unsigned int Performs consistency checking and validation on this SBML document. If this method returns a nonzero value (meaning, one or more consistency checks have failed for SBML document), the failures may be due to warnings or errors. Callers should inspect the severity flag in the individual SBMLError objects returned by SBMLDocument.getError() to determine the nature of the failures. Returns the number of failed checks (errors) encountered. See also SBMLDocument.checkInternalConsistency(). """ return _libsbml.SBMLDocument_checkConsistency(self) def checkConsistencyWithStrictUnits(self): """ checkConsistencyWithStrictUnits(SBMLDocument self) -> unsigned int Performs consistency checking and validation on this SBML document using the ultra strict units validator that assumes that there are no hidden numerical conversion factors. If this method returns a nonzero value (meaning, one or more consistency checks have failed for SBML document), the failures may be due to warnings or errors. Callers should inspect the severity flag in the individual SBMLError objects returned by SBMLDocument.getError() to determine the nature of the failures. Returns the number of failed checks (errors) encountered. See also SBMLDocument.checkInternalConsistency(). """ return _libsbml.SBMLDocument_checkConsistencyWithStrictUnits(self) def validateSBML(self): """ validateSBML(SBMLDocument self) -> unsigned int Performs consistency checking and validation on this SBML document. If this method returns a nonzero value (meaning, one or more consistency checks have failed for SBML document), the failures may be due to warnings or errors. Callers should inspect the severity flag in the individual SBMLError objects returned by SBMLDocument.getError() to determine the nature of the failures. Note: unlike checkConsistency this method will write the document in order to determine all errors for the document. This will also clear the error log. Returns the number of failed checks (errors) encountered. See also SBMLDocument.checkConsistency(). """ return _libsbml.SBMLDocument_validateSBML(self) def checkInternalConsistency(self): """ checkInternalConsistency(SBMLDocument self) -> unsigned int Performs consistency checking on libSBML's internal representation of an SBML Model. Callers should query the results of the consistency check by calling SBMLDocument.getError(). Returns the number of failed checks (errors) encountered. The distinction between this method and SBMLDocument.checkConsistency() is that this method reports on fundamental syntactic and structural errors that violate the XML Schema for SBML; by contrast, SBMLDocument.checkConsistency() performs more elaborate model verifications and also validation according to the validation rules written in the appendices of the SBML Level 2 Versions 2-4 specification documents. See also SBMLDocument.checkConsistency(). """ return _libsbml.SBMLDocument_checkInternalConsistency(self) def checkL1Compatibility(self, inConversion=False): """ checkL1Compatibility(SBMLDocument self, bool inConversion=False) -> unsigned int checkL1Compatibility(SBMLDocument self) -> unsigned int Performs a set of consistency checks on the document to establish whether it is compatible with SBML Level 1 and can be converted to Level 1. Callers should query the results of the consistency check by calling SBMLDocument.getError(). Returns the number of failed checks (errors) encountered. Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.SBMLDocument_checkL1Compatibility(self, inConversion) def checkL2v1Compatibility(self, inConversion=False): """ checkL2v1Compatibility(SBMLDocument self, bool inConversion=False) -> unsigned int checkL2v1Compatibility(SBMLDocument self) -> unsigned int Performs a set of consistency checks on the document to establish whether it is compatible with SBML Level 2 Version 1 and can be converted to Level 2 Version 1. Callers should query the results of the consistency check by calling SBMLDocument.getError(). Returns the number of failed checks (errors) encountered. Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.SBMLDocument_checkL2v1Compatibility(self, inConversion) def checkL2v2Compatibility(self, inConversion=False): """ checkL2v2Compatibility(SBMLDocument self, bool inConversion=False) -> unsigned int checkL2v2Compatibility(SBMLDocument self) -> unsigned int Performs a set of consistency checks on the document to establish whether it is compatible with SBML Level 2 Version 2 and can be converted to Level 2 Version 2. Callers should query the results of the consistency check by calling SBMLDocument.getError(). Returns the number of failed checks (errors) encountered. Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.SBMLDocument_checkL2v2Compatibility(self, inConversion) def checkL2v3Compatibility(self, inConversion=False): """ checkL2v3Compatibility(SBMLDocument self, bool inConversion=False) -> unsigned int checkL2v3Compatibility(SBMLDocument self) -> unsigned int Performs a set of consistency checks on the document to establish whether it is compatible with SBML Level 2 Version 3 and can be converted to Level 2 Version 3. Callers should query the results of the consistency check by calling SBMLDocument.getError(). Returns the number of failed checks (errors) encountered. Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.SBMLDocument_checkL2v3Compatibility(self, inConversion) def checkL2v4Compatibility(self): """ checkL2v4Compatibility(SBMLDocument self) -> unsigned int Performs a set of consistency checks on the document to establish whether it is compatible with SBML Level 2 Version 4 and can be converted to Level 2 Version 4. Callers should query the results of the consistency check by calling SBMLDocument.getError(). Returns the number of failed checks (errors) encountered. """ return _libsbml.SBMLDocument_checkL2v4Compatibility(self) def checkL2v5Compatibility(self): """ checkL2v5Compatibility(SBMLDocument self) -> unsigned int Performs a set of consistency checks on the document to establish whether it is compatible with SBML Level 2 Version 5 and can be converted to Level 2 Version 5. Callers should query the results of the consistency check by calling SBMLDocument.getError(). Returns the number of failed checks (errors) encountered. """ return _libsbml.SBMLDocument_checkL2v5Compatibility(self) def checkL3v1Compatibility(self): """ checkL3v1Compatibility(SBMLDocument self) -> unsigned int Performs a set of consistency checks on the document to establish whether it is compatible with SBML Level 3 Version 1 and can be converted to Level 3 Version 1. Callers should query the results of the consistency check by calling SBMLDocument.getError(). Returns the number of failed checks (errors) encountered. """ return _libsbml.SBMLDocument_checkL3v1Compatibility(self) def checkL3v2Compatibility(self): """ checkL3v2Compatibility(SBMLDocument self) -> unsigned int Performs a set of consistency checks on the document to establish whether it is compatible with SBML Level 3 Version 2 and can be converted to Level 3 Version 2. Callers should query the results of the consistency check by calling SBMLDocument.getError(). Returns the number of failed checks (errors) encountered. """ return _libsbml.SBMLDocument_checkL3v2Compatibility(self) def getError(self, n): """ getError(SBMLDocument self, unsigned int n) -> SBMLError Returns the nth error or warning encountered during parsing, consistency checking, or attempted translation of this model. Callers can use method XMLError.getSeverity() on the result to assess the severity of the problem. The possible severity levels range from informational messages to fatal errors. Returns the error or warning indexed by integer 'n', or return 'None' if n > (getNumErrors() - 1). Parameter 'n' is the integer index of the error sought. See also SBMLDocument.getNumErrors(). """ return _libsbml.SBMLDocument_getError(self, n) def getErrorWithSeverity(self, n, severity): """ getErrorWithSeverity(SBMLDocument self, unsigned int n, unsigned int severity) -> SBMLError Returns the nth error or warning with the given severity encountered during parsing, consistency checking, or attempted translation of this model. Returns the error or warning indexed by integer 'n', or return 'None' if n > (getNumErrors(severity) - 1). Parameter 'n' is the integer index of the error sought. Parameter 'severity' is the severity of the error sought. See also SBMLDocument.getNumErrors(). """ return _libsbml.SBMLDocument_getErrorWithSeverity(self, n, severity) def getNumErrors(self, *args): """ getNumErrors(SBMLDocument self) -> unsigned int getNumErrors(SBMLDocument self, unsigned int severity) -> unsigned int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getNumErrors(long severity) Returns the number of errors or warnings encountered with the given severity during parsing, consistency checking, or attempted translation of this model. Parameter 'severity' is the severity of the error sought. Returns the number of errors or warnings encountered. See also SBMLDocument.getError(). ______________________________________________________________________ Method variant with the following signature: getNumErrors() Returns the number of errors or warnings encountered during parsing, consistency checking, or attempted translation of this model. Returns the number of errors or warnings encountered. See also SBMLDocument.getError(). """ return _libsbml.SBMLDocument_getNumErrors(self, *args) def printErrors(self, *args): """ printErrors(SBMLDocument self, ostream stream) printErrors(SBMLDocument self) printErrors(SBMLDocument self, ostream stream, unsigned int severity) This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: printErrors(std::ostream stream, long severity) Prints all the errors or warnings with the given severity encountered trying to parse, check, or translate this SBML document. It prints the text to the stream given by the parameter 'stream'. If no errors have occurred, i.e., getNumErrors(severity) == 0, no output will be sent to the stream. The format of the output is: N error(s): line NNN: (id) message Parameter 'stream' is the ostream or ostringstream object indicating where the output should be printed. Parameter 'severity' is of the errors sought. See also getNumErrors(), getErrorLog(), SBMLDocument.getErrorWithSeverity(). ______________________________________________________________________ Method variant with the following signature: printErrors(std::ostream stream = std::cerr) Prints all the errors or warnings encountered trying to parse, check, or translate this SBML document. It prints the text to the stream given by the optional parameter 'stream'. If no parameter is given, it prints the output to the standard error stream. If no errors have occurred, i.e., getNumErrors() == 0, no output will be sent to the stream. The format of the output is: N error(s): line NNN: (id) message Parameter 'stream' is the ostream or ostringstream object indicating where the output should be printed.
Documentation note:
The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation.
See also getNumErrors(), getErrorLog(), SBMLDocument.getError(). Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.SBMLDocument_printErrors(self, *args) def connectToChild(self): """connectToChild(SBMLDocument self)""" return _libsbml.SBMLDocument_connectToChild(self) def convert(self, props): """ convert(SBMLDocument self, ConversionProperties props) -> int Converts this document using the converter that best matches the given conversion properties. Parameter 'props' is the conversion properties to use. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_CONV_CONVERSION_NOT_AVAILABLE """ return _libsbml.SBMLDocument_convert(self, props) def enablePackageInternal(self, pkgURI, pkgPrefix, flag): """ enablePackageInternal(SBMLDocument self, string pkgURI, string pkgPrefix, bool flag) Internal implementation method. """ return _libsbml.SBMLDocument_enablePackageInternal(self, pkgURI, pkgPrefix, flag) def getTypeCode(self): """ getTypeCode(SBMLDocument self) -> int Returns the libSBML type code for this SBML object. LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for this object: SBML_DOCUMENT (default). WARNING: The specific integer values of the possible type codes may be reused by different libSBML plug-ins for SBML Level 3. packages, To fully identify the correct code, it is necessary to invoke both getPackageName() and getTypeCode() (or ListOf.getItemTypeCode()). See also SBMLDocument.getElementName(), getPackageName(). """ return _libsbml.SBMLDocument_getTypeCode(self) def getElementName(self): """ getElementName(SBMLDocument self) -> string Returns the XML element name of this object, which for SBMLDocument, is always ''sbml'.' Returns the name of this element, i.e., ''sbml'.' """ return _libsbml.SBMLDocument_getElementName(self) def getErrorLog(self, *args): """ getErrorLog(SBMLDocument self) -> SBMLErrorLog getErrorLog(SBMLDocument self) -> SBMLErrorLog Returns the list of errors or warnings logged during parsing, consistency checking, or attempted translation of this model. Returns the SBMLErrorLog used for this SBMLDocument. See also SBMLDocument.getNumErrors(). """ return _libsbml.SBMLDocument_getErrorLog(self, *args) def getNamespaces(self): """ getNamespaces(SBMLDocument self) -> XMLNamespaces Returns a list of XML Namespaces associated with the XML content of this SBML document. Returns the XML Namespaces associated with this SBML object. """ return _libsbml.SBMLDocument_getNamespaces(self) def enableDefaultNS(self, package, flag): """ enableDefaultNS(SBMLDocument self, string package, bool flag) -> int Set/unset default namespace to each top-level element defined in the given package extension. This works by adding a xmlns="..." attribute. No prefix will be written when writing elements defined in the given package extension if 'True' is given as second argument. Parameter 'package' is the name or URI of the package extension. Parameter 'flag' is boolean value to indicate whether to write a namespace prefix. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_PKG_UNKNOWN_VERSION """ return _libsbml.SBMLDocument_enableDefaultNS(self, package, flag) def isEnabledDefaultNS(self, package): """ isEnabledDefaultNS(SBMLDocument self, string package) -> bool Returns 'True' if a default namespace is added to each top-level element defined in the given package extension, otherwise returns 'False.' This basically checks if the attribute xmlns="..." is present. Parameter 'package' is the name or URI of the package extension. Returns a boolean indicating whether the given package's default namespace is enabled. """ return _libsbml.SBMLDocument_isEnabledDefaultNS(self, package) def setPackageRequired(self, package, flag): """ setPackageRequired(SBMLDocument self, string package, bool flag) -> int Sets the required attribute value of the given package extension. Parameter 'package' is the name or URI of the package extension. Parameter 'flag' is Boolean value indicating whether the package is required. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_PKG_UNKNOWN_VERSION """ return _libsbml.SBMLDocument_setPackageRequired(self, package, flag) def getPackageRequired(self, package): """ getPackageRequired(SBMLDocument self, string package) -> bool Returns the required attribute of the given package extension. Parameter 'package' is the name or URI of the package extension. Returns Boolean flag indicating whether the package is flagged as being required. """ return _libsbml.SBMLDocument_getPackageRequired(self, package) def isSetPackageRequired(self, package): """ isSetPackageRequired(SBMLDocument self, string package) -> bool Returns 'True' if the required attribute of the given package extension is defined, otherwise returns 'False.' Parameter 'package' is the name or URI of the package extension. Returns a Boolean indicating whether the package's 'required' flag is set. """ return _libsbml.SBMLDocument_isSetPackageRequired(self, package) def isIgnoredPackage(self, pkgURI): """ isIgnoredPackage(SBMLDocument self, string pkgURI) -> bool Returns 'True' if the given package extension is one of an ignored packages, otherwise returns 'False.' An ignored package is one that is defined to be used in this SBML document, but the package is not enabled in this copy of libSBML. Parameter 'pkgURI' is the URI of the package extension. Returns a Boolean, 'True' if the package is being ignored and 'False' otherwise. """ return _libsbml.SBMLDocument_isIgnoredPackage(self, pkgURI) def isDisabledIgnoredPackage(self, pkgURI): """ isDisabledIgnoredPackage(SBMLDocument self, string pkgURI) -> bool Returns 'True' if the given package extension is one of an ignored packages that has been disabled, otherwise returns 'False.' An ignored package is one that is defined to be used in this SBML document, but the package is not enabled in this copy of libSBML. It may have been disabled to avoid reproducing the package information when writing out the file. Parameter 'pkgURI' is the URI of the package extension. Returns a Boolean, 'True' if the package is being ignored and 'False' otherwise. """ return _libsbml.SBMLDocument_isDisabledIgnoredPackage(self, pkgURI) def setPkgRequired(self, package, flag): """ setPkgRequired(SBMLDocument self, string package, bool flag) -> int Sets the value of the required attribute for the given package. Parameter 'package' is the name or URI of the package extension. Parameter 'flag' is a Boolean value. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_PKG_UNKNOWN_VERSION DEPRECATED. Replaced in libSBML 5.2.0 by setPackageRequired() """ return _libsbml.SBMLDocument_setPkgRequired(self, package, flag) def getPkgRequired(self, package): """ getPkgRequired(SBMLDocument self, string package) -> bool Returns the required attribute of the given package extension. Parameter 'package' is the name or URI of the package extension. Returns a Boolean value indicating whether the package is flagged as being required in this SBML document. DEPRECATED. Replaced in libSBML 5.2.0 by getPackageRequired() """ return _libsbml.SBMLDocument_getPkgRequired(self, package) def isSetPkgRequired(self, package): """ isSetPkgRequired(SBMLDocument self, string package) -> bool Returns 'True' if the required attribute of the given package extension is defined, otherwise returns 'False.' Parameter 'package' is the name or URI of the package extension. Returns a Boolean value. DEPRECATED. Replaced in libSBML 5.2.0 by isSetPackageRequired() """ return _libsbml.SBMLDocument_isSetPkgRequired(self, package) def isIgnoredPkg(self, pkgURI): """ isIgnoredPkg(SBMLDocument self, string pkgURI) -> bool Returns 'True' if the given package extension is one of ignored packages, otherwise returns 'False.' An ignored package is one that is defined to be used in this SBML document, but the package is not enabled in this copy of libSBML. Parameter 'pkgURI' is the URI of the package extension. Returns a boolean indicating whether the given package is being ignored. DEPRECATED. Replaced in libSBML 5.2.0 by isIgnoredPackage() """ return _libsbml.SBMLDocument_isIgnoredPkg(self, pkgURI) def getApplicableValidators(self): """ getApplicableValidators(SBMLDocument self) -> unsigned char Internal implementation method. """ return _libsbml.SBMLDocument_getApplicableValidators(self) def getConversionValidators(self): """ getConversionValidators(SBMLDocument self) -> unsigned char Internal implementation method. """ return _libsbml.SBMLDocument_getConversionValidators(self) def setApplicableValidators(self, appl): """ setApplicableValidators(SBMLDocument self, unsigned char appl) Internal implementation method. """ return _libsbml.SBMLDocument_setApplicableValidators(self, appl) def setConversionValidators(self, appl): """ setConversionValidators(SBMLDocument self, unsigned char appl) Internal implementation method. """ return _libsbml.SBMLDocument_setConversionValidators(self, appl) def getNumValidators(self): """ getNumValidators(SBMLDocument self) -> unsigned int Internal implementation method. """ return _libsbml.SBMLDocument_getNumValidators(self) def clearValidators(self): """ clearValidators(SBMLDocument self) -> int Internal implementation method. """ return _libsbml.SBMLDocument_clearValidators(self) def addValidator(self, validator): """ addValidator(SBMLDocument self, SBMLValidator validator) -> int Internal implementation method. """ return _libsbml.SBMLDocument_addValidator(self, validator) def getValidator(self, index): """ getValidator(SBMLDocument self, unsigned int index) -> SBMLValidator Internal implementation method. """ return _libsbml.SBMLDocument_getValidator(self, index) def addUnknownPackageRequired(self, pkgURI, prefix, flag): """ addUnknownPackageRequired(SBMLDocument self, string pkgURI, string prefix, bool flag) -> int Internal implementation method. """ return _libsbml.SBMLDocument_addUnknownPackageRequired(self, pkgURI, prefix, flag) def hasUnknownPackage(self, pkgURI): """ hasUnknownPackage(SBMLDocument self, string pkgURI) -> bool Internal implementation method. """ return _libsbml.SBMLDocument_hasUnknownPackage(self, pkgURI) def getNumUnknownPackages(self): """ getNumUnknownPackages(SBMLDocument self) -> int Internal implementation method. """ return _libsbml.SBMLDocument_getNumUnknownPackages(self) def getUnknownPackageURI(self, index): """ getUnknownPackageURI(SBMLDocument self, int index) -> string Internal implementation method. """ return _libsbml.SBMLDocument_getUnknownPackageURI(self, index) def getUnknownPackagePrefix(self, index): """ getUnknownPackagePrefix(SBMLDocument self, int index) -> string Internal implementation method. """ return _libsbml.SBMLDocument_getUnknownPackagePrefix(self, index) SBMLDocument_swigregister = _libsbml.SBMLDocument_swigregister SBMLDocument_swigregister(SBMLDocument) def SBMLDocument_getDefaultLevel(): """ SBMLDocument_getDefaultLevel() -> unsigned int The default SBML Level of new SBMLDocument objects. This 'default Level' corresponds to the most recent SBML specification Level available at the time libSBML version 5.17.2 was released. The default Level is used by SBMLDocument if no Level is explicitly specified at the time of the construction of an SBMLDocument instance. Returns an integer indicating the most recent SBML specification Level. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also SBMLDocument.getDefaultVersion() . """ return _libsbml.SBMLDocument_getDefaultLevel() def SBMLDocument_getDefaultVersion(): """ SBMLDocument_getDefaultVersion() -> unsigned int The default Version of new SBMLDocument objects. This 'default Version' corresponds to the most recent Version within the most recent Level of SBML available at the time libSBML version 5.17.2 was released. The default Version is used by SBMLDocument if no Version is explicitly specified at the time of the construction of an SBMLDocument instance. Returns an integer indicating the most recent SBML specification Version. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also SBMLDocument.getDefaultLevel() . """ return _libsbml.SBMLDocument_getDefaultVersion() class FunctionDefinition(SBase): """ A user-defined function in an SBML model. The FunctionDefinition structure associates an identifier with a function definition. This identifier can then be used as the function called in subsequent MathML content elsewhere in an SBML model. FunctionDefinition has one required attribute, 'id', to give the function a unique identifier by which other parts of an SBML model definition can refer to it. A FunctionDefinition instance can also have an optional 'name' attribute of type 'string.' Identifiers and names must be used according to the guidelines described in the SBML specification (e.g., Section 3.3 in the Level 2 Version 4 specification). FunctionDefinition has a 'math' subelement containing a MathML expression defining the function body. In SBML Level 2 and SBML Level 3 Version 1, that 'math' subelement is required; in SBML Level 3 Version 2, this restriction was relaxed, making the 'math' subelement optional. The content of this element can only be a MathML 'lambda' element. The 'lambda' element must begin with zero or more 'bvar' elements, followed by any other of the elements in the MathML subset allowed in SBML Level 2 except 'lambda' (i.e., a 'lambda' element cannot contain another 'lambda' element). This is the only place in SBML where a 'lambda' element can be used. The function defined by a FunctionDefinition is only available for use in other MathML elements that follow the FunctionDefinition definition in the model. (These restrictions prevent recursive and mutually-recursive functions from being expressed.) A further restriction on the content of 'math' is that it cannot contain references to variables other than the variables declared to the 'lambda' itself. That is, the contents of MathML 'ci' elements inside the body of the 'lambda' can only be the variables declared by its 'bvar' elements, or the identifiers of other FunctionDefinition instances in the model. This means must be written so that all variables or parameters used in the MathML content are passed to them via their function parameters. In SBML Level 2, this restriction applies also to the MathML 'csymbol' elements for time and delay; in SBML Level 3, it additionally applies to the 'csymbol' element for avogadro. In SBML Level 3 Version 2, if no math element is present in the FunctionDefinition, the function has no mathematical meaning defined in SBML Level 3 Core. This situation may arise when models are incomplete, or when additional meanings are provided by an SBML Level 3 package. Note: Function definitions (also informally known as user-defined functions) were introduced in SBML Level 2. They have purposefully limited capabilities. A function cannot reference parameters or other model quantities outside of itself; values must be passed as parameters to the function. Moreover, recursive and mutually- recursive functions are not permitted. The purpose of these limitations is to balance power against complexity of implementation. With the restrictions as they are, function definitions could be implemented as textual substitutions---they are simply macros. Software implementations therefore do not need the full function- definition machinery typically associated with programming languages. Another important point to note is FunctionDefinition does not have a separate attribute for defining the units of the value returned by the function. The units associated with the function's return value, when the function is called from within MathML expressions elsewhere in SBML, are simply the overall units of the expression in FunctionDefinition's 'math' subelement when applied to the arguments supplied in the call to the function. Ascertaining these units requires performing dimensional analysis on the expression. (Readers may wonder why there is no attribute. The reason is that having a separate attribute for declaring the units would not only be redundant, but also lead to the potential for having conflicting information. In the case of a conflict between the declared units and those of the value actually returned by the function, the only logical resolution rule would be to assume that the correct units are those of the expression anyway.) """ __swig_setmethods__ = {} for _s in [SBase]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, FunctionDefinition, name, value) __swig_getmethods__ = {} for _s in [SBase]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, FunctionDefinition, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_FunctionDefinition __del__ = lambda self: None def __init__(self, *args): """ __init__(FunctionDefinition self, unsigned int level, unsigned int version) -> FunctionDefinition __init__(FunctionDefinition self, SBMLNamespaces sbmlns) -> FunctionDefinition __init__(FunctionDefinition self, FunctionDefinition orig) -> FunctionDefinition This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: FunctionDefinition(SBMLNamespaces sbmlns) Creates a new FunctionDefinition using the given SBMLNamespaces object 'sbmlns'. The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments. Parameter 'sbmlns' is an SBMLNamespaces object. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: FunctionDefinition(long level, long version) Creates a new FunctionDefinition using the given SBML 'level' and 'version' values. Parameter 'level' is a long integer, the SBML Level to assign to this FunctionDefinition. Parameter 'version' is a long integer, the SBML Version to assign to this FunctionDefinition. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: FunctionDefinition(FunctionDefinition orig) Copy constructor; creates a copy of this FunctionDefinition. Parameter 'orig' is the object to copy. """ this = _libsbml.new_FunctionDefinition(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(FunctionDefinition self) -> FunctionDefinition Creates and returns a deep copy of this FunctionDefinition object. Returns the (deep) copy of this FunctionDefinition object. """ return _libsbml.FunctionDefinition_clone(self) def getId(self): """ getId(FunctionDefinition self) -> string Returns the value of the 'id' attribute of this FunctionDefinition. Note: Because of the inconsistent behavior of this function with respect to assignments and rules, it is now recommended to use the getIdAttribute() function instead. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Returns the id of this FunctionDefinition. See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(). """ return _libsbml.FunctionDefinition_getId(self) def getName(self): """ getName(FunctionDefinition self) -> string Returns the value of the 'name' attribute of this FunctionDefinition object. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns the name of this SBML object, or the empty string if not set or unsettable. See also getIdAttribute(), isSetName(), setName(), unsetName(). """ return _libsbml.FunctionDefinition_getName(self) def getMath(self): """ getMath(FunctionDefinition self) -> ASTNode Get the mathematical formula of this FunctionDefinition. Returns an ASTNode, the value of the 'math' subelement of this FunctionDefinition, or 'None' if the math is not set. """ return _libsbml.FunctionDefinition_getMath(self) def isSetId(self): """ isSetId(FunctionDefinition self) -> bool Predicate returning 'True' if this FunctionDefinition's 'id' attribute is set. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Returns 'True' if the 'id' attribute of this SBML object is set, 'False' otherwise. Note: Because of the inconsistent behavior of this function with respect to assignments and rules, it is recommended that callers use isSetIdAttribute() instead. See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(), isSetIdAttribute(). """ return _libsbml.FunctionDefinition_isSetId(self) def isSetName(self): """ isSetName(FunctionDefinition self) -> bool Predicate returning 'True' if this FunctionDefinition's 'name' attribute is set. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns 'True' if the 'name' attribute of this SBML object is set, 'False' otherwise. See also getName(), setName(), unsetName(). """ return _libsbml.FunctionDefinition_isSetName(self) def isSetMath(self): """ isSetMath(FunctionDefinition self) -> bool Predicate returning 'True' if this FunctionDefinition's 'math' subelement contains a value. Returns 'True' if the 'math' for this FunctionDefinition is set, 'False' otherwise. """ return _libsbml.FunctionDefinition_isSetMath(self) def setId(self, sid): """ setId(FunctionDefinition self, string sid) -> int Sets the value of the 'id' attribute of this FunctionDefinition. The string 'sid' is copied. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Parameter 'sid' is the string to use as the identifier of this object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE * LIBSBML_UNEXPECTED_ATTRIBUTE See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(). """ return _libsbml.FunctionDefinition_setId(self, sid) def setName(self, name): """ setName(FunctionDefinition self, string name) -> int Sets the value of the 'name' attribute of this FunctionDefinition. The string in 'name' is copied. Parameter 'name' is the new name for the SBML object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.FunctionDefinition_setName(self, name) def setMath(self, math): """ setMath(FunctionDefinition self, ASTNode math) -> int Sets the 'math' subelement of this FunctionDefinition to the Abstract Syntax Tree given in 'math'. Parameter 'math' is an AST containing the mathematical expression to be used as the formula for this FunctionDefinition. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT """ return _libsbml.FunctionDefinition_setMath(self, math) def unsetName(self): """ unsetName(FunctionDefinition self) -> int Unsets the value of the 'name' attribute of this FunctionDefinition. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also getName(), setName(), isSetName(). """ return _libsbml.FunctionDefinition_unsetName(self) def getArgument(self, *args): """ getArgument(FunctionDefinition self, unsigned int n) -> ASTNode getArgument(FunctionDefinition self, string name) -> ASTNode This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getArgument(long n) Get the nth argument to this function. Callers should first find out the number of arguments to the function by calling getNumArguments(). Parameter 'n' is an integer index for the argument sought. Returns the nth argument (bound variable) passed to this FunctionDefinition. If the index 'n' is invalid, 'None' is returned. See also getNumArguments(). ______________________________________________________________________ Method variant with the following signature: getArgument(string name) Get the argument named 'name' to this FunctionDefinition. Parameter 'name' is the exact name (case-sensitive) of the sought- after argument. Returns the argument (bound variable) having the given name, or 'None' if no such argument exists. """ return _libsbml.FunctionDefinition_getArgument(self, *args) def getBody(self, *args): """ getBody(FunctionDefinition self) -> ASTNode getBody(FunctionDefinition self) -> ASTNode Get the mathematical expression that is the body of this FunctionDefinition object. Returns the body of this FunctionDefinition as an Abstract Syntax Tree, or 'None' if no body is defined. """ return _libsbml.FunctionDefinition_getBody(self, *args) def isSetBody(self): """ isSetBody(FunctionDefinition self) -> bool Predicate returning 'True' if the body of this FunctionDefinition has set. Returns 'True' if the body of this FunctionDefinition is set, 'False' otherwise. """ return _libsbml.FunctionDefinition_isSetBody(self) def getNumArguments(self): """ getNumArguments(FunctionDefinition self) -> unsigned int Get the number of arguments (bound variables) taken by this FunctionDefinition. Returns the number of arguments (bound variables) that must be passed to this FunctionDefinition. """ return _libsbml.FunctionDefinition_getNumArguments(self) def getTypeCode(self): """ getTypeCode(FunctionDefinition self) -> int Returns the libSBML type code for this SBML object. LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for this object: SBML_FUNCTION_DEFINITION (default). WARNING: The specific integer values of the possible type codes may be reused by different libSBML plug-ins for SBML Level 3. packages, To fully identify the correct code, it is necessary to invoke both getPackageName() and getTypeCode() (or ListOf.getItemTypeCode()). See also getElementName(), getPackageName(). """ return _libsbml.FunctionDefinition_getTypeCode(self) def getElementName(self): """ getElementName(FunctionDefinition self) -> string Returns the XML element name of this object, which for FunctionDefinition, is always ''functionDefinition'.' Returns the name of this element, i.e., ''functionDefinition'.' """ return _libsbml.FunctionDefinition_getElementName(self) def hasRequiredAttributes(self): """ hasRequiredAttributes(FunctionDefinition self) -> bool Predicate returning 'True' if all the required attributes for this FunctionDefinition object have been set. The required attributes for a FunctionDefinition object are: * 'id' Returns 'True' if the required attributes have been set, 'False' otherwise. """ return _libsbml.FunctionDefinition_hasRequiredAttributes(self) def hasRequiredElements(self): """ hasRequiredElements(FunctionDefinition self) -> bool Predicate returning 'True' if all the required elements for this FunctionDefinition object have been set. Note: The required elements for a FunctionDefinition object are: * 'math' inSBML Level 2 and Level 3 Version 1. (In SBML Level 3 Version 2+, it is no longer required.) Returns a boolean value indicating whether all the required elements for this object have been defined. """ return _libsbml.FunctionDefinition_hasRequiredElements(self) def renameUnitSIdRefs(self, oldid, newid): """ renameUnitSIdRefs(FunctionDefinition self, string oldid, string newid) Renames all the 'UnitSIdRef' attributes on this element. In SBML, unit definitions have identifiers of type UnitSId. In SBML Level 3, an explicit data type called UnitSIdRef was introduced for attribute values that refer to UnitSId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to a unit identifier', but the effective data type was the same as UnitSIdRef in Level 3. These and other methods of libSBML refer to the type UnitSIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all unit identifier attribute values (including, if appropriate, inside mathematical formulas), comparing the unit identifiers to the value of 'oldid'. If any matches are found, the matching identifiers are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.FunctionDefinition_renameUnitSIdRefs(self, oldid, newid) FunctionDefinition_swigregister = _libsbml.FunctionDefinition_swigregister FunctionDefinition_swigregister(FunctionDefinition) class ListOfFunctionDefinitions(ListOf): """ A list of FunctionDefinition objects. The various ListOf___ classes in SBML are merely containers used for organizing the main components of an SBML model. In libSBML's implementation, ListOf___ classes are derived from the intermediate utility class ListOf, which is not defined by the SBML specifications but serves as a useful programmatic construct. ListOf is itself is in turn derived from SBase, which provides all of the various ListOf___ classes with common features defined by the SBML specification, such as 'metaid' attributes and annotations. The relationship between the lists and the rest of an SBML model is illustrated by the following (for SBML Level 2 Version 4): ... ... ... ... ... ... ... elements of subclasses of Rule ... ... ... ... SBML Level 3 Version 1 has essentially the same structure as Level 2 Version 4, depicted above, but SBML Level 3 Version 2 allows containers to contain zero or more of the relevant object, instead of requiring at least one. As such, libsbml will write out an otherwise-empty ListOf___ element that has any optional attribute set (such as 'id' or 'metaid'), that has an optional child (such as a 'notes' or 'annotation'), or that has attributes or children set from any SBML Level 3 package, whether or not the ListOf___ has any other children. Readers may wonder about the motivations for using the ListOf___ containers in SBML. A simpler approach in XML might be to place the components all directly at the top level of the model definition. The choice made in SBML is to group them within XML elements named after ListOfClassname, in part because it helps organize the components. More importantly, the fact that the container classes are derived from SBase means that software tools can add information about the lists themselves into each list container's 'annotation'. See also ListOfFunctionDefinitions, ListOfUnitDefinitions, ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments, ListOfSpecies, ListOfParameters, ListOfInitialAssignments, ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents. """ __swig_setmethods__ = {} for _s in [ListOf]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfFunctionDefinitions, name, value) __swig_getmethods__ = {} for _s in [ListOf]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, ListOfFunctionDefinitions, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(ListOfFunctionDefinitions self, unsigned int level, unsigned int version) -> ListOfFunctionDefinitions __init__(ListOfFunctionDefinitions self, SBMLNamespaces sbmlns) -> ListOfFunctionDefinitions This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: ListOfFunctionDefinitions(SBMLNamespaces sbmlns) Creates a new ListOfFunctionDefinitions object. The object is constructed such that it is valid for the SBML Level and Version combination determined by the SBMLNamespaces object in 'sbmlns'. Parameter 'sbmlns' is an SBMLNamespaces object that is used to determine the characteristics of the ListOfFunctionDefinitions object to be created. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: ListOfFunctionDefinitions(long level, long version) Creates a new ListOfFunctionDefinitions object. The object is constructed such that it is valid for the given SBML Level and Version combination. Parameter 'level' is the SBML Level. Parameter 'version' is the Version within the SBML Level. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. """ this = _libsbml.new_ListOfFunctionDefinitions(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(ListOfFunctionDefinitions self) -> ListOfFunctionDefinitions Creates and returns a deep copy of this ListOfFunctionDefinitions object. Returns the (deep) copy of this ListOfFunctionDefinitions object. """ return _libsbml.ListOfFunctionDefinitions_clone(self) def getItemTypeCode(self): """ getItemTypeCode(ListOfFunctionDefinitions self) -> int Returns the libSBML type code for the objects contained in this ListOf (i.e., FunctionDefinition objects, if the list is non-empty). LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for the objects contained in this ListOf: SBML_FUNCTION_DEFINITION (default). See also getElementName(), getPackageName(). """ return _libsbml.ListOfFunctionDefinitions_getItemTypeCode(self) def getElementName(self): """ getElementName(ListOfFunctionDefinitions self) -> string Returns the XML element name of this object. For ListOfFunctionDefinitions, the XML element name is ''listOfFunctionDefinitions'.' Returns the name of this element, i.e., ''listOfFunctionDefinitions'.' """ return _libsbml.ListOfFunctionDefinitions_getElementName(self) def get(self, *args): """ get(ListOfFunctionDefinitions self, unsigned int n) -> FunctionDefinition get(ListOfFunctionDefinitions self, unsigned int n) -> FunctionDefinition get(ListOfFunctionDefinitions self, string sid) -> FunctionDefinition get(ListOfFunctionDefinitions self, string sid) -> FunctionDefinition This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: get(long n) Get a FunctionDefinition from the ListOfFunctionDefinitions. Parameter 'n' is the index number of the FunctionDefinition to get. Returns the nth FunctionDefinition in this ListOfFunctionDefinitions. If the index 'n' is invalid, 'None' is returned. See also size(). ______________________________________________________________________ Method variant with the following signature: get(string sid) Get a FunctionDefinition from the ListOfFunctionDefinitions based on its identifier. Parameter 'sid' is a string representing the identifier of the FunctionDefinition to get. Returns FunctionDefinition in this ListOfFunctionDefinitions with the given 'sid' or 'None' if no such FunctionDefinition exists. See also get(), size(). """ return _libsbml.ListOfFunctionDefinitions_get(self, *args) def remove(self, *args): """ remove(ListOfFunctionDefinitions self, unsigned int n) -> FunctionDefinition remove(ListOfFunctionDefinitions self, string sid) -> FunctionDefinition This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: remove(long n) Removes the nth item from this ListOfFunctionDefinitions items and returns a pointer to it. The caller owns the returned item and is responsible for deleting it. Parameter 'n' is the index of the item to remove. See also size(). ______________________________________________________________________ Method variant with the following signature: remove(string sid) Removes item in this ListOfFunctionDefinitions items with the given identifier. The caller owns the returned item and is responsible for deleting it. If none of the items in this list have the identifier 'sid', then 'None' is returned. Parameter 'sid' is the identifier of the item to remove. Returns the item removed. As mentioned above, the caller owns the returned item. """ return _libsbml.ListOfFunctionDefinitions_remove(self, *args) __swig_destroy__ = _libsbml.delete_ListOfFunctionDefinitions __del__ = lambda self: None ListOfFunctionDefinitions_swigregister = _libsbml.ListOfFunctionDefinitions_swigregister ListOfFunctionDefinitions_swigregister(ListOfFunctionDefinitions) UNIT_KIND_AMPERE = _libsbml.UNIT_KIND_AMPERE UNIT_KIND_AVOGADRO = _libsbml.UNIT_KIND_AVOGADRO UNIT_KIND_BECQUEREL = _libsbml.UNIT_KIND_BECQUEREL UNIT_KIND_CANDELA = _libsbml.UNIT_KIND_CANDELA UNIT_KIND_CELSIUS = _libsbml.UNIT_KIND_CELSIUS UNIT_KIND_COULOMB = _libsbml.UNIT_KIND_COULOMB UNIT_KIND_DIMENSIONLESS = _libsbml.UNIT_KIND_DIMENSIONLESS UNIT_KIND_FARAD = _libsbml.UNIT_KIND_FARAD UNIT_KIND_GRAM = _libsbml.UNIT_KIND_GRAM UNIT_KIND_GRAY = _libsbml.UNIT_KIND_GRAY UNIT_KIND_HENRY = _libsbml.UNIT_KIND_HENRY UNIT_KIND_HERTZ = _libsbml.UNIT_KIND_HERTZ UNIT_KIND_ITEM = _libsbml.UNIT_KIND_ITEM UNIT_KIND_JOULE = _libsbml.UNIT_KIND_JOULE UNIT_KIND_KATAL = _libsbml.UNIT_KIND_KATAL UNIT_KIND_KELVIN = _libsbml.UNIT_KIND_KELVIN UNIT_KIND_KILOGRAM = _libsbml.UNIT_KIND_KILOGRAM UNIT_KIND_LITER = _libsbml.UNIT_KIND_LITER UNIT_KIND_LITRE = _libsbml.UNIT_KIND_LITRE UNIT_KIND_LUMEN = _libsbml.UNIT_KIND_LUMEN UNIT_KIND_LUX = _libsbml.UNIT_KIND_LUX UNIT_KIND_METER = _libsbml.UNIT_KIND_METER UNIT_KIND_METRE = _libsbml.UNIT_KIND_METRE UNIT_KIND_MOLE = _libsbml.UNIT_KIND_MOLE UNIT_KIND_NEWTON = _libsbml.UNIT_KIND_NEWTON UNIT_KIND_OHM = _libsbml.UNIT_KIND_OHM UNIT_KIND_PASCAL = _libsbml.UNIT_KIND_PASCAL UNIT_KIND_RADIAN = _libsbml.UNIT_KIND_RADIAN UNIT_KIND_SECOND = _libsbml.UNIT_KIND_SECOND UNIT_KIND_SIEMENS = _libsbml.UNIT_KIND_SIEMENS UNIT_KIND_SIEVERT = _libsbml.UNIT_KIND_SIEVERT UNIT_KIND_STERADIAN = _libsbml.UNIT_KIND_STERADIAN UNIT_KIND_TESLA = _libsbml.UNIT_KIND_TESLA UNIT_KIND_VOLT = _libsbml.UNIT_KIND_VOLT UNIT_KIND_WATT = _libsbml.UNIT_KIND_WATT UNIT_KIND_WEBER = _libsbml.UNIT_KIND_WEBER UNIT_KIND_INVALID = _libsbml.UNIT_KIND_INVALID def UnitKind_equals(uk1, uk2): """ UnitKind_equals(UnitKind_t uk1, UnitKind_t uk2) -> int Tests for logical equality between two given UNIT_KIND_ code values. This function behaves exactly like C's == operator, except for the following two cases: * UNIT_KIND_LITER == UNIT_KIND_LITRE * UNIT_KIND_METER == UNIT_KIND_METRE In the two cases above, C equality comparison would yield '0' (false) (because each of the above is a distinct enumeration value), but this function returns 'True.' Parameter 'uk1' is a UNIT_KIND_ value. Parameter 'uk2' is a second UNIT_KIND_ value to compare to 'uk1'. Returns '1' (true) if 'uk1' is logically equivalent to 'uk2', '0' (false) otherwise. Note: For more information about the libSBML unit codes, please refer to the class documentation for Unit. """ return _libsbml.UnitKind_equals(uk1, uk2) def UnitKind_forName(name): """ UnitKind_forName(char const * name) -> UnitKind_t Converts a text string naming a kind of unit to its corresponding libSBML UNIT_KIND_ constant/enumeration value. Parameter 'name' is a string, the name of a predefined base unit in SBML. Returns a value the set of UNIT_KIND_ codes defined in class libsbml, corresponding to the string 'name' (determined in a case-insensitive manner). Note: For more information about the libSBML unit codes, please refer to the class documentation for Unit. """ return _libsbml.UnitKind_forName(name) def UnitKind_toString(uk): """ UnitKind_toString(UnitKind_t uk) -> char const * Converts a unit code to a text string equivalent. Parameter 'uk' is a value from the set of UNIT_KIND_ codes defined in the class libsbml Returns the name corresponding to the given unit code. Note: For more information about the libSBML unit codes, please refer to the class documentation for Unit. WARNING: The string returned is a static data value. The caller does not own the returned string and is therefore not allowed to modify it. """ return _libsbml.UnitKind_toString(uk) def UnitKind_isValidUnitKindString(str, level, version): """ UnitKind_isValidUnitKindString(char const * str, unsigned int level, unsigned int version) -> int Predicate for testing whether a given string corresponds to a predefined libSBML unit code. Parameter 'str' is a text string naming a base unit defined by SBML. Parameter 'level' is the Level of SBML. Parameter 'version' is the Version within the Level of SBML. Returns 1 (true) if string is the name of a valid UNIT_KIND_ value, '0' (false) otherwise. Note: For more information about the libSBML unit codes, please refer to the class documentation for Unit. """ return _libsbml.UnitKind_isValidUnitKindString(str, level, version) class Unit(SBase): """ A single unit referenced in an SBML unit definition. The SBML unit definition facility uses two classes of objects, UnitDefinition and Unit. The approach to defining units in SBML is compositional; for example, meter second^-2 is constructed by combining a Unit object representing meter with another Unit object representing second^-2. The combination is wrapped inside a UnitDefinition, which provides for assigning an identifier and optional name to the combination. The identifier can then be referenced from elsewhere in a model. Thus, the UnitDefinition class is the container, and Unit instances are placed inside UnitDefinition instances. A Unit has four attributes named 'kind', 'exponent', 'scale' and 'multiplier'. It represents a (possibly transformed) reference to a base unit. The attribute 'kind' on Unit indicates the chosen base unit. Its value must be one of the text strings listed below; this list corresponds to SBML Level 3: 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 A few small differences exist between the Level 3 list of base units and the list defined in other Level/Version combinations of SBML. Specifically, Levels of SBML before Level 3 do not define 'avogadro;' conversely, Level 2 Version 1 defines 'Celsius,' and Level 1 defines 'celsius,' 'meter,' and 'liter,' none of which are available in Level 3. In libSBML, each of the predefined base unit names is represented by an enumeration value whose name begins with the characters UNIT_KIND_, discussed in a separate section below. The attribute named 'exponent' on Unit represents an exponent on the unit. In SBML Level 2, the attribute is optional and has a default value of '1' (one); in SBML Level 3, the attribute is mandatory and there is no default value. A Unit also has an attribute called 'scale'; its value must be an integer exponent for a power-of-ten multiplier used to set the scale of the unit. For example, a unit having a 'kind' value of 'gram' and a 'scale' value of '-3' signifies 10^-3 * gram, or milligrams. In SBML Level 2, the attribute is optional and has a default value of '0' (zero), because 10^0 = 1; in SBML Level 3, the attribute is mandatory and has no default value. Lastly, the attribute named 'multiplier' can be used to multiply the unit by a real-numbered factor; this enables the definition of units that are not power-of-ten multiples of SI units. For instance, a multiplier of 0.3048 could be used to define 'foot' as a measure of length in terms of a 'metre.' The 'multiplier' attribute is optional in SBML Level 2, where it has a default value of '1' (one); in SBML Level 3, the attribute is mandatory and has no default value. Unit identification codes ...................................................................... As discussed above, SBML defines a set of base units which serves as the starting point for new unit definitions. This set of base units consists of the SI units and a small number of additional convenience units. In SBML Level 2 Versions before Version 3, there existed an enumeration of units called 'UnitKind.' In Version 3, this enumeration was removed and the identifier class 'UnitSId' redefined to include the previous 'UnitKind' values as reserved symbols. This change has no net effect on permissible models, their representation or their syntax. The purpose of the change in the SBML specification was simply to clean up an inconsistency about the contexts in which these values were usable. However, libSBML maintains UnitKind in the form of of a set of static integer constants whose names begin with the characters UNIT_KIND_. These constants are defined in the class libsbml. As a consequence of the fact that libSBML supports models in all Levels and Versions of SBML, libSBML's set of 'UNIT_KIND_' values is a union of all the possible base unit names defined in the different SBML specifications. However, not every base unit is allowed in every Level+Version combination of SBML. Note in particular the following exceptions: * The alternate spelling ''meter'' is included in addition to the official SI spelling ''metre'.' This spelling is only permitted in SBML Level 1 models. * The alternate spelling ''liter'' is included in addition to the official SI spelling ''litre'.' This spelling is only permitted in SBML Level 1 models. * The unit ''Celsius'' is included because of its presence in specifications of SBML prior to SBML Level 2 Version 2. * The unit 'avogadro' was introduced in SBML Level 3, and is only permitted for use in SBML Level 3 models. The table below lists the unit constants defined in libSBML, and their meanings. Enumerator Meaning --------- --------- UNIT_KIND_AMPERE The ampere unit. UNIT_KIND_AVOGADRO 'dimensionless' multiplied by the value of Avogadro's constant. UNIT_KIND_BECQUEREL The becquerel unit. UNIT_KIND_CANDELA The candela unit. UNIT_KIND_CELSIUS The Celsius unit. UNIT_KIND_COULOMB The coulomb unit. UNIT_KIND_DIMENSIONLESS A pseudo-unit indicating a dimensionless quantity. UNIT_KIND_FARAD The farad unit. UNIT_KIND_GRAM The gram unit. UNIT_KIND_GRAY The gray unit. UNIT_KIND_HENRY The henry unit. UNIT_KIND_HERTZ The hertz unit. UNIT_KIND_ITEM A pseudo-unit representing a single "thing". UNIT_KIND_JOULE The joule unit. UNIT_KIND_KATAL The katal unit. UNIT_KIND_KELVIN The kelvin unit. UNIT_KIND_KILOGRAM The kilogram unit. UNIT_KIND_LITER Alternate spelling of litre. UNIT_KIND_LITRE The litre unit. UNIT_KIND_LUMEN The lumen unit. UNIT_KIND_LUX The lux unit. UNIT_KIND_METER Alternate spelling of metre. UNIT_KIND_METRE The metre unit. UNIT_KIND_MOLE The mole unit. UNIT_KIND_NEWTON The newton unit. UNIT_KIND_OHM The ohm unit. UNIT_KIND_PASCAL The pascal unit. UNIT_KIND_RADIAN The radian unit. UNIT_KIND_SECOND The second unit. UNIT_KIND_SIEMENS The siemens unit. UNIT_KIND_SIEVERT The sievert unit. UNIT_KIND_STERADIAN The steradian unit. UNIT_KIND_TESLA The tesla unit. UNIT_KIND_VOLT The volt unit. UNIT_KIND_WATT The watt unit. UNIT_KIND_WEBER The weber unit. UNIT_KIND_INVALID Marker used by libSBML to indicate an invalid or unset unit. """ __swig_setmethods__ = {} for _s in [SBase]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, Unit, name, value) __swig_getmethods__ = {} for _s in [SBase]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, Unit, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_Unit __del__ = lambda self: None def __init__(self, *args): """ __init__(Unit self, unsigned int level, unsigned int version) -> Unit __init__(Unit self, SBMLNamespaces sbmlns) -> Unit __init__(Unit self, Unit orig) -> Unit This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: Unit(SBMLNamespaces sbmlns) Creates a new Unit using the given SBMLNamespaces object 'sbmlns'. The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments. Parameter 'sbmlns' is an SBMLNamespaces object. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: Unit(long level, long version) Creates a new Unit using the given SBML 'level' and 'version' values. Parameter 'level' is a long integer, the SBML Level to assign to this Unit. Parameter 'version' is a long integer, the SBML Version to assign to this Unit. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: Unit(Unit orig) Copy constructor; creates a copy of this Unit. Parameter 'orig' is the object to copy. """ this = _libsbml.new_Unit(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(Unit self) -> Unit Creates and returns a deep copy of this Unit object. Returns the (deep) copy of this Unit object. """ return _libsbml.Unit_clone(self) def initDefaults(self): """ initDefaults(Unit self) Initializes the fields of this Unit object to 'typical' default values. The SBML Unit component has slightly different aspects and default attribute values in different SBML Levels and Versions. This method sets the values to certain common defaults, based mostly on what they are in SBML Level 2. Specifically: * Sets attribute 'exponent' to '1' * Sets attribute 'scale' to '0' * Sets attribute 'multiplier' to '1.0' The 'kind' attribute is left unchanged. """ return _libsbml.Unit_initDefaults(self) def getKind(self): """ getKind(Unit self) -> UnitKind_t Returns the 'kind' of Unit this is. Returns the value of the 'kind' attribute of this Unit as a value from the set of constants whose names begin with UNIT_KIND_ defined in the class libsbml. """ return _libsbml.Unit_getKind(self) def getExponent(self): """ getExponent(Unit self) -> int Returns the value of the 'exponent' attribute of this unit. Returns the 'exponent' value of this Unit, as an integer. """ return _libsbml.Unit_getExponent(self) def getExponentAsDouble(self): """ getExponentAsDouble(Unit self) -> double Returns the value of the 'exponent' attribute of this unit. Returns the 'exponent' value of this Unit, as a double. """ return _libsbml.Unit_getExponentAsDouble(self) def getScale(self): """ getScale(Unit self) -> int Returns the value of the 'scale' attribute of this unit. Returns the 'scale' value of this Unit, as an integer. """ return _libsbml.Unit_getScale(self) def getMultiplier(self): """ getMultiplier(Unit self) -> double Returns the value of the 'multiplier' attribute of this Unit. Returns the 'multiplier' value of this Unit, as a double. """ return _libsbml.Unit_getMultiplier(self) def getOffset(self): """ getOffset(Unit self) -> double Returns the value of the 'offset' attribute of this Unit. Returns the 'offset' value of this Unit, as a double. WARNING: The 'offset' attribute is only available in SBML Level 2 Version 1. This attribute is not present in SBML Level 2 Version 2 or above. When producing SBML models using these later specifications, modelers and software tools need to account for units with offsets explicitly. The SBML specification document offers a number of suggestions for how to achieve this. LibSBML methods such as this one related to 'offset' are retained for compatibility with earlier versions of SBML Level 2, but their use is strongly discouraged. """ return _libsbml.Unit_getOffset(self) def isAmpere(self): """ isAmpere(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'ampere.' Returns 'True' if the kind of this Unit is 'ampere,' 'False' otherwise. """ return _libsbml.Unit_isAmpere(self) def isAvogadro(self): """ isAvogadro(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'avogadro.' Returns 'True' if the kind of this Unit is 'avogadro,' 'False' otherwise. Note: The unit 'avogadro' was introduced in SBML Level 3, and is only permitted for use in SBML Level 3 models. """ return _libsbml.Unit_isAvogadro(self) def isBecquerel(self): """ isBecquerel(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'becquerel' Returns 'True' if the kind of this Unit is 'becquerel,' 'False' otherwise. """ return _libsbml.Unit_isBecquerel(self) def isCandela(self): """ isCandela(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'candela' Returns 'True' if the kind of this Unit is 'candela,' 'False' otherwise. """ return _libsbml.Unit_isCandela(self) def isCelsius(self): """ isCelsius(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'Celsius' Returns 'True' if the kind of this Unit is 'Celsius,' 'False' otherwise. WARNING: The predefined unit 'Celsius' was removed from the list of predefined units in SBML Level 2 Version 2 at the same time that the 'offset' attribute was removed from Unit definitions. LibSBML methods such as this one related to 'Celsius' are retained in order to support SBML Level 2 Version 1, but their use is strongly discouraged. """ return _libsbml.Unit_isCelsius(self) def isCoulomb(self): """ isCoulomb(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'coulomb' Returns 'True' if the kind of this Unit is 'coulomb,' 'False' otherwise. """ return _libsbml.Unit_isCoulomb(self) def isDimensionless(self): """ isDimensionless(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'dimensionless.' Returns 'True' if the kind of this Unit is 'dimensionless,' 'False' otherwise. """ return _libsbml.Unit_isDimensionless(self) def isFarad(self): """ isFarad(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'farad' Returns 'True' if the kind of this Unit is 'farad,' 'False' otherwise. """ return _libsbml.Unit_isFarad(self) def isGram(self): """ isGram(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'gram' Returns 'True' if the kind of this Unit is 'gram,' 'False' otherwise. """ return _libsbml.Unit_isGram(self) def isGray(self): """ isGray(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'gray' Returns 'True' if the kind of this Unit is 'gray,' 'False' otherwise. """ return _libsbml.Unit_isGray(self) def isHenry(self): """ isHenry(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'henry' Returns 'True' if the kind of this Unit is 'henry,' 'False' otherwise. """ return _libsbml.Unit_isHenry(self) def isHertz(self): """ isHertz(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'hertz' Returns 'True' if the kind of this Unit is 'hertz,' 'False' otherwise. """ return _libsbml.Unit_isHertz(self) def isItem(self): """ isItem(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'item' Returns 'True' if the kind of this Unit is 'item,' 'False' otherwise. """ return _libsbml.Unit_isItem(self) def isJoule(self): """ isJoule(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'joule' Returns 'True' if the kind of this Unit is 'joule,' 'False' otherwise. """ return _libsbml.Unit_isJoule(self) def isKatal(self): """ isKatal(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'katal' Returns 'True' if the kind of this Unit is 'katal,' 'False' otherwise. """ return _libsbml.Unit_isKatal(self) def isKelvin(self): """ isKelvin(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'kelvin' Returns 'True' if the kind of this Unit is 'kelvin,' 'False' otherwise. """ return _libsbml.Unit_isKelvin(self) def isKilogram(self): """ isKilogram(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'kilogram' Returns 'True' if the kind of this Unit is 'kilogram,' 'False' otherwise. """ return _libsbml.Unit_isKilogram(self) def isLitre(self): """ isLitre(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'litre' Returns 'True' if the kind of this Unit is 'litre' or 'liter', 'False' otherwise. """ return _libsbml.Unit_isLitre(self) def isLumen(self): """ isLumen(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'lumen' Returns 'True' if the kind of this Unit is 'lumen,' 'False' otherwise. """ return _libsbml.Unit_isLumen(self) def isLux(self): """ isLux(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'lux' Returns 'True' if the kind of this Unit is 'lux,' 'False' otherwise. """ return _libsbml.Unit_isLux(self) def isMetre(self): """ isMetre(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'metre' Returns 'True' if the kind of this Unit is 'metre' or 'meter', 'False' otherwise. """ return _libsbml.Unit_isMetre(self) def isMole(self): """ isMole(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'mole' Returns 'True' if the kind of this Unit is 'mole,' 'False' otherwise. """ return _libsbml.Unit_isMole(self) def isNewton(self): """ isNewton(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'newton' Returns 'True' if the kind of this Unit is 'newton,' 'False' otherwise. """ return _libsbml.Unit_isNewton(self) def isOhm(self): """ isOhm(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'ohm' Returns 'True' if the kind of this Unit is 'ohm,' 'False' otherwise. """ return _libsbml.Unit_isOhm(self) def isPascal(self): """ isPascal(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'pascal' Returns 'True' if the kind of this Unit is 'pascal,' 'False' otherwise. """ return _libsbml.Unit_isPascal(self) def isRadian(self): """ isRadian(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'radian' Returns 'True' if the kind of this Unit is 'radian,' 'False' otherwise. """ return _libsbml.Unit_isRadian(self) def isSecond(self): """ isSecond(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'second' Returns 'True' if the kind of this Unit is 'second,' 'False' otherwise. """ return _libsbml.Unit_isSecond(self) def isSiemens(self): """ isSiemens(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'siemens' Returns 'True' if the kind of this Unit is 'siemens,' 'False' otherwise. """ return _libsbml.Unit_isSiemens(self) def isSievert(self): """ isSievert(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'sievert' Returns 'True' if the kind of this Unit is 'sievert,' 'False' otherwise. """ return _libsbml.Unit_isSievert(self) def isSteradian(self): """ isSteradian(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'steradian' Returns 'True' if the kind of this Unit is 'steradian,' 'False' otherwise. """ return _libsbml.Unit_isSteradian(self) def isTesla(self): """ isTesla(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'tesla' Returns 'True' if the kind of this Unit is 'tesla,' 'False' otherwise. """ return _libsbml.Unit_isTesla(self) def isVolt(self): """ isVolt(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'volt' Returns 'True' if the kind of this Unit is 'volt,' 'False' otherwise. """ return _libsbml.Unit_isVolt(self) def isWatt(self): """ isWatt(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'watt' Returns 'True' if the kind of this Unit is 'watt,' 'False' otherwise. """ return _libsbml.Unit_isWatt(self) def isWeber(self): """ isWeber(Unit self) -> bool Predicate for testing whether this Unit is of the kind 'weber' Returns 'True' if the kind of this Unit is 'weber,' 'False' otherwise. """ return _libsbml.Unit_isWeber(self) def isSetKind(self): """ isSetKind(Unit self) -> bool Predicate to test whether the 'kind' attribute of this Unit is set. Returns 'True' if the 'kind' attribute of this Unit is set, 'False' otherwise. """ return _libsbml.Unit_isSetKind(self) def isSetExponent(self): """ isSetExponent(Unit self) -> bool Predicate to test whether the 'exponent' attribute of this Unit is set. Returns 'True' if the 'exponent' attribute of this Unit is set, 'False' otherwise. """ return _libsbml.Unit_isSetExponent(self) def isSetScale(self): """ isSetScale(Unit self) -> bool Predicate to test whether the 'scale' attribute of this Unit is set. Returns 'True' if the 'scale' attribute of this Unit is set, 'False' otherwise. """ return _libsbml.Unit_isSetScale(self) def isSetMultiplier(self): """ isSetMultiplier(Unit self) -> bool Predicate to test whether the 'multiplier' attribute of this Unit is set. Returns 'True' if the 'multiplier' attribute of this Unit is set, 'False' otherwise. """ return _libsbml.Unit_isSetMultiplier(self) def isSetOffset(self): """ isSetOffset(Unit self) -> bool Predicate to test whether the 'offset' attribute of this Unit is set. Returns 'True' if the 'offset' attribute of this Unit is set, 'False' otherwise. WARNING: The 'offset' attribute is only available in SBML Level 2 Version 1. This attribute is not present in SBML Level 2 Version 2 or above. When producing SBML models using these later specifications, modelers and software tools need to account for units with offsets explicitly. The SBML specification document offers a number of suggestions for how to achieve this. LibSBML methods such as this one related to 'offset' are retained for compatibility with earlier versions of SBML Level 2, but their use is strongly discouraged. """ return _libsbml.Unit_isSetOffset(self) def setKind(self, kind): """ setKind(Unit self, UnitKind_t kind) -> int Sets the 'kind' attribute value of this Unit. Parameter 'kind' is a unit identifier chosen from the set of constants whose names begin with UNIT_KIND_ in libsbml. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.Unit_setKind(self, kind) def setExponent(self, *args): """ setExponent(Unit self, int value) -> int setExponent(Unit self, double value) -> int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: setExponent(int value) Sets the 'exponent' attribute value of this Unit. Parameter 'value' is the integer to which the attribute 'exponent' should be set. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE ______________________________________________________________________ Method variant with the following signature: setExponent(double value) Sets the 'exponent' attribute value of this Unit. Parameter 'value' is the double to which the attribute 'exponent' should be set. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS """ return _libsbml.Unit_setExponent(self, *args) def setScale(self, value): """ setScale(Unit self, int value) -> int Sets the 'scale' attribute value of this Unit. Parameter 'value' is the integer to which the attribute 'scale' should be set. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS """ return _libsbml.Unit_setScale(self, value) def setMultiplier(self, value): """ setMultiplier(Unit self, double value) -> int Sets the 'multipler' attribute value of this Unit. Parameter 'value' is the floating-point value to which the attribute 'multiplier' should be set. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE """ return _libsbml.Unit_setMultiplier(self, value) def setOffset(self, value): """ setOffset(Unit self, double value) -> int Sets the 'offset' attribute value of this Unit. Parameter 'value' is the floating point value to which the attribute 'offset' should set. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE WARNING: The 'offset' attribute is only available in SBML Level 2 Version 1. This attribute is not present in SBML Level 2 Version 2 or above. When producing SBML models using these later specifications, modelers and software tools need to account for units with offsets explicitly. The SBML specification document offers a number of suggestions for how to achieve this. LibSBML methods such as this one related to 'offset' are retained for compatibility with earlier versions of SBML Level 2, but their use is strongly discouraged. """ return _libsbml.Unit_setOffset(self, value) def unsetKind(self): """ unsetKind(Unit self) -> int Unsets the 'kind' attribute value of this Unit. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.Unit_unsetKind(self) def unsetExponent(self): """ unsetExponent(Unit self) -> int Unsets the 'exponent' attribute value of this Unit. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.Unit_unsetExponent(self) def unsetScale(self): """ unsetScale(Unit self) -> int Unsets the 'scale' attribute value of this Unit. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS """ return _libsbml.Unit_unsetScale(self) def unsetMultiplier(self): """ unsetMultiplier(Unit self) -> int Unsets the 'multipler' attribute value of this Unit. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE """ return _libsbml.Unit_unsetMultiplier(self) def unsetOffset(self): """ unsetOffset(Unit self) -> int Unsets the 'offset' attribute value of this Unit. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE WARNING: The 'offset' attribute is only available in SBML Level 2 Version 1. This attribute is not present in SBML Level 2 Version 2 or above. When producing SBML models using these later specifications, modelers and software tools need to account for units with offsets explicitly. The SBML specification document offers a number of suggestions for how to achieve this. LibSBML methods such as this one related to 'offset' are retained for compatibility with earlier versions of SBML Level 2, but their use is strongly discouraged. """ return _libsbml.Unit_unsetOffset(self) def getTypeCode(self): """ getTypeCode(Unit self) -> int Returns the libSBML type code of this object instance. LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for this object: SBML_UNIT (default). WARNING: The specific integer values of the possible type codes may be reused by different libSBML plug-ins for SBML Level 3. packages, To fully identify the correct code, it is necessary to invoke both getPackageName() and getTypeCode() (or ListOf.getItemTypeCode()). See also getPackageName(), getElementName(). """ return _libsbml.Unit_getTypeCode(self) def getElementName(self): """ getElementName(Unit self) -> string Returns the XML element name of this object, which for Unit, is always ''unit'.' Returns the name of this element, i.e., ''unit'.' """ return _libsbml.Unit_getElementName(self) def isBuiltIn(name, level): """ isBuiltIn(string name, unsigned int level) -> bool Predicate to test whether a given string is the name of a built-in SBML unit, depending on the SBML level, since new predefined units were added between level 2 versions 1 and 2, and then all predefined units were removed again in SBML Level 3. Parameter 'name' is a string to be tested against the built-in unit names. Parameter 'level' is the level of SBML one is checking. Returns 'True' if 'name' is one of ''substance',' ''volume',' or ''time'' and the 'level' is '1;' or if 'name' is one of ''substance',' ''volume',' ''area',' ''length',' or ''time'' and the 'level' is '2;' 'False' otherwise (including all values when 'level' is '3).' Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.Unit_isBuiltIn(name, level) isBuiltIn = staticmethod(isBuiltIn) def isUnitKind(name, level, version): """ isUnitKind(string name, unsigned int level, unsigned int version) -> bool Predicate to test whether a given string is the name of a valid base unit in SBML (such as ''gram'' or ''mole').' This method exists because prior to SBML Level 2 Version 3, an enumeration called 'UnitKind' was defined by SBML. This enumeration was removed in SBML Level 2 Version 3 and its values were folded into the space of values of a type called 'UnitSId.' This method therefore has less significance in SBML Level 2 Version 3 and Level 2 Version 4, but remains for backward compatibility and support for reading models in older Versions of Level 2. Parameter 'name' is a string to be tested. Parameter 'level' is a long integer representing the SBML specification Level. Parameter 'version' is a long integer representing the SBML specification Version. Returns 'True' if name is a valid SBML UnitKind, 'False' otherwise. Note: The allowed unit names differ between SBML Levels 1 and 2 and again slightly between Level 2 Versions 1 and 2. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.Unit_isUnitKind(name, level, version) isUnitKind = staticmethod(isUnitKind) def areIdentical(unit1, unit2): """ areIdentical(Unit unit1, Unit unit2) -> bool Predicate returning 'True' if two Unit objects are identical. Two Unit objects are considered to be identical if they match in all attributes. (Contrast this to the method areEquivalent(), which compares Unit objects only with respect to certain attributes.) Parameter 'unit1' is the first Unit object to compare. Parameter 'unit2' is the second Unit object to compare. Returns 'True' if all the attributes of unit1 are identical to the attributes of unit2, 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also Unit.areEquivalent() . """ return _libsbml.Unit_areIdentical(unit1, unit2) areIdentical = staticmethod(areIdentical) def areEquivalent(unit1, unit2): """ areEquivalent(Unit unit1, Unit unit2) -> bool Predicate returning 'True' if Unit objects are equivalent. Two Unit objects are considered to be equivalent either if (1) both have a 'kind' attribute value of 'dimensionless,' or (2) their 'kind', 'exponent' and (for SBML Level 2 Version 1) 'offset' attribute values are equal. (Contrast this to the method areIdentical(), which compares Unit objects with respect to all attributes, not just the 'kind' and 'exponent'.) Parameter 'unit1' is the first Unit object to compare. Parameter 'unit2' is the second Unit object to compare. Returns 'True' if the 'kind' and 'exponent' attributes of unit1 are identical to the kind and exponent attributes of unit2, or if the kind attributes of both are 'dimensionless;' 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also Unit.areIdentical() . """ return _libsbml.Unit_areEquivalent(unit1, unit2) areEquivalent = staticmethod(areEquivalent) def removeScale(unit): """ removeScale(Unit unit) -> int Manipulates the attributes of the Unit to express the unit with the value of the scale attribute reduced to zero. For example, 1 millimetre can be expressed as a Unit with kind= ''metre'' multiplier=''1'' scale=''-3'' exponent=''1'.' It can also be expressed as a Unit with kind=''metre'' multiplier='0.001' scale=''0'' exponent=''1'.' Parameter 'unit' is the Unit object to manipulate. Returns integer value indicating success/failure of the function. This particular function only does one thing irrespective of user input or object state, and thus will only return a single value: * LIBSBML_OPERATION_SUCCESS Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also Unit.convertToSI() , Unit.merge() . """ return _libsbml.Unit_removeScale(unit) removeScale = staticmethod(removeScale) def merge(unit1, unit2): """ merge(Unit unit1, Unit unit2) Merges two Unit objects with the same 'kind' attribute value into a single Unit. For example, the following, would be merged to become Parameter 'unit1' is the first Unit object; the result of the operation is left as a new version of this unit, modified in-place. Not modified if the two units have different kinds. Parameter 'unit2' is the second Unit object to merge with the first. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also Unit.convertToSI() , Unit.removeScale() . """ return _libsbml.Unit_merge(unit1, unit2) merge = staticmethod(merge) def convertToSI(unit): """ convertToSI(Unit unit) -> UnitDefinition Returns a UnitDefinition object containing the given 'unit' converted to the appropriate SI unit. This method exists because some units can be expressed in terms of others when the same physical dimension is involved. For example, one hertz is identical to 1 sec^-1, one litre is equivalent to 1 cubic decametre, and so on. Parameter 'unit' is the Unit object to convert to SI. Returns a UnitDefinition object containing the SI unit. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also Unit.merge() . """ return _libsbml.Unit_convertToSI(unit) convertToSI = staticmethod(convertToSI) def hasRequiredAttributes(self): """ hasRequiredAttributes(Unit self) -> bool Predicate returning 'True' if all the required attributes for this Unit object have been set. The required attributes for a Unit object are: * 'kind' * 'exponent' (required in SBML Level 3; optional in Level 2) * 'multiplier' (required in SBML Level 3; optional in Level 2) * 'scale' (required in SBML Level 3; optional in Level 2) Returns 'True' if the required attributes have been set, 'False' otherwise. """ return _libsbml.Unit_hasRequiredAttributes(self) def setExponentUnitChecking(self, value): """ setExponentUnitChecking(Unit self, double value) Internal implementation method. """ return _libsbml.Unit_setExponentUnitChecking(self, value) def getExponentUnitChecking(self, *args): """ getExponentUnitChecking(Unit self) -> double getExponentUnitChecking(Unit self) -> double Internal implementation method. """ return _libsbml.Unit_getExponentUnitChecking(self, *args) def isUnitChecking(self, *args): """ isUnitChecking(Unit self) -> bool isUnitChecking(Unit self) -> bool Internal implementation method. """ return _libsbml.Unit_isUnitChecking(self, *args) Unit_swigregister = _libsbml.Unit_swigregister Unit_swigregister(Unit) def Unit_isBuiltIn(name, level): """ Unit_isBuiltIn(string name, unsigned int level) -> bool Predicate to test whether a given string is the name of a built-in SBML unit, depending on the SBML level, since new predefined units were added between level 2 versions 1 and 2, and then all predefined units were removed again in SBML Level 3. Parameter 'name' is a string to be tested against the built-in unit names. Parameter 'level' is the level of SBML one is checking. Returns 'True' if 'name' is one of ''substance',' ''volume',' or ''time'' and the 'level' is '1;' or if 'name' is one of ''substance',' ''volume',' ''area',' ''length',' or ''time'' and the 'level' is '2;' 'False' otherwise (including all values when 'level' is '3).' Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.Unit_isBuiltIn(name, level) def Unit_isUnitKind(name, level, version): """ Unit_isUnitKind(string name, unsigned int level, unsigned int version) -> bool Predicate to test whether a given string is the name of a valid base unit in SBML (such as ''gram'' or ''mole').' This method exists because prior to SBML Level 2 Version 3, an enumeration called 'UnitKind' was defined by SBML. This enumeration was removed in SBML Level 2 Version 3 and its values were folded into the space of values of a type called 'UnitSId.' This method therefore has less significance in SBML Level 2 Version 3 and Level 2 Version 4, but remains for backward compatibility and support for reading models in older Versions of Level 2. Parameter 'name' is a string to be tested. Parameter 'level' is a long integer representing the SBML specification Level. Parameter 'version' is a long integer representing the SBML specification Version. Returns 'True' if name is a valid SBML UnitKind, 'False' otherwise. Note: The allowed unit names differ between SBML Levels 1 and 2 and again slightly between Level 2 Versions 1 and 2. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.Unit_isUnitKind(name, level, version) def Unit_areIdentical(unit1, unit2): """ Unit_areIdentical(Unit unit1, Unit unit2) -> bool Predicate returning 'True' if two Unit objects are identical. Two Unit objects are considered to be identical if they match in all attributes. (Contrast this to the method areEquivalent(), which compares Unit objects only with respect to certain attributes.) Parameter 'unit1' is the first Unit object to compare. Parameter 'unit2' is the second Unit object to compare. Returns 'True' if all the attributes of unit1 are identical to the attributes of unit2, 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also Unit.areEquivalent() . """ return _libsbml.Unit_areIdentical(unit1, unit2) def Unit_areEquivalent(unit1, unit2): """ Unit_areEquivalent(Unit unit1, Unit unit2) -> bool Predicate returning 'True' if Unit objects are equivalent. Two Unit objects are considered to be equivalent either if (1) both have a 'kind' attribute value of 'dimensionless,' or (2) their 'kind', 'exponent' and (for SBML Level 2 Version 1) 'offset' attribute values are equal. (Contrast this to the method areIdentical(), which compares Unit objects with respect to all attributes, not just the 'kind' and 'exponent'.) Parameter 'unit1' is the first Unit object to compare. Parameter 'unit2' is the second Unit object to compare. Returns 'True' if the 'kind' and 'exponent' attributes of unit1 are identical to the kind and exponent attributes of unit2, or if the kind attributes of both are 'dimensionless;' 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also Unit.areIdentical() . """ return _libsbml.Unit_areEquivalent(unit1, unit2) def Unit_removeScale(unit): """ Unit_removeScale(Unit unit) -> int Manipulates the attributes of the Unit to express the unit with the value of the scale attribute reduced to zero. For example, 1 millimetre can be expressed as a Unit with kind= ''metre'' multiplier=''1'' scale=''-3'' exponent=''1'.' It can also be expressed as a Unit with kind=''metre'' multiplier='0.001' scale=''0'' exponent=''1'.' Parameter 'unit' is the Unit object to manipulate. Returns integer value indicating success/failure of the function. This particular function only does one thing irrespective of user input or object state, and thus will only return a single value: * LIBSBML_OPERATION_SUCCESS Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also Unit.convertToSI() , Unit.merge() . """ return _libsbml.Unit_removeScale(unit) def Unit_merge(unit1, unit2): """ Unit_merge(Unit unit1, Unit unit2) Merges two Unit objects with the same 'kind' attribute value into a single Unit. For example, the following, would be merged to become Parameter 'unit1' is the first Unit object; the result of the operation is left as a new version of this unit, modified in-place. Not modified if the two units have different kinds. Parameter 'unit2' is the second Unit object to merge with the first. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also Unit.convertToSI() , Unit.removeScale() . """ return _libsbml.Unit_merge(unit1, unit2) def Unit_convertToSI(unit): """ Unit_convertToSI(Unit unit) -> UnitDefinition Returns a UnitDefinition object containing the given 'unit' converted to the appropriate SI unit. This method exists because some units can be expressed in terms of others when the same physical dimension is involved. For example, one hertz is identical to 1 sec^-1, one litre is equivalent to 1 cubic decametre, and so on. Parameter 'unit' is the Unit object to convert to SI. Returns a UnitDefinition object containing the SI unit. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also Unit.merge() . """ return _libsbml.Unit_convertToSI(unit) class ListOfUnits(ListOf): """ A list of Unit objects. ListOfUnits is entirely contained within UnitDefinition. The various ListOf___ classes in SBML are merely containers used for organizing the main components of an SBML model. In libSBML's implementation, ListOf___ classes are derived from the intermediate utility class ListOf, which is not defined by the SBML specifications but serves as a useful programmatic construct. ListOf is itself is in turn derived from SBase, which provides all of the various ListOf___ classes with common features defined by the SBML specification, such as 'metaid' attributes and annotations. The relationship between the lists and the rest of an SBML model is illustrated by the following (for SBML Level 2 Version 4): ... ... ... ... ... ... ... elements of subclasses of Rule ... ... ... ... SBML Level 3 Version 1 has essentially the same structure as Level 2 Version 4, depicted above, but SBML Level 3 Version 2 allows containers to contain zero or more of the relevant object, instead of requiring at least one. As such, libsbml will write out an otherwise-empty ListOf___ element that has any optional attribute set (such as 'id' or 'metaid'), that has an optional child (such as a 'notes' or 'annotation'), or that has attributes or children set from any SBML Level 3 package, whether or not the ListOf___ has any other children. Readers may wonder about the motivations for using the ListOf___ containers in SBML. A simpler approach in XML might be to place the components all directly at the top level of the model definition. The choice made in SBML is to group them within XML elements named after ListOfClassname, in part because it helps organize the components. More importantly, the fact that the container classes are derived from SBase means that software tools can add information about the lists themselves into each list container's 'annotation'. See also ListOfFunctionDefinitions, ListOfUnitDefinitions, ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments, ListOfSpecies, ListOfParameters, ListOfInitialAssignments, ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents. """ __swig_setmethods__ = {} for _s in [ListOf]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfUnits, name, value) __swig_getmethods__ = {} for _s in [ListOf]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, ListOfUnits, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(ListOfUnits self, unsigned int level, unsigned int version) -> ListOfUnits __init__(ListOfUnits self, SBMLNamespaces sbmlns) -> ListOfUnits This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: ListOfUnits(SBMLNamespaces sbmlns) Creates a new ListOfUnits object. The object is constructed such that it is valid for the SBML Level and Version combination determined by the SBMLNamespaces object in 'sbmlns'. Parameter 'sbmlns' is an SBMLNamespaces object that is used to determine the characteristics of the ListOfUnits object to be created. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: ListOfUnits(long level, long version) Creates a new ListOfUnits object. The object is constructed such that it is valid for the given SBML Level and Version combination. Parameter 'level' is the SBML Level. Parameter 'version' is the Version within the SBML Level. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. """ this = _libsbml.new_ListOfUnits(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(ListOfUnits self) -> ListOfUnits Creates and returns a deep copy of this ListOfUnits object. Returns the (deep) copy of this ListOfUnits object. """ return _libsbml.ListOfUnits_clone(self) def getItemTypeCode(self): """ getItemTypeCode(ListOfUnits self) -> int Returns the libSBML type code for the objects contained in this ListOf (i.e., Unit objects, if the list is non-empty). LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for objects contained in this list: SBML_UNIT (default). See also getElementName(), getPackageName(). """ return _libsbml.ListOfUnits_getItemTypeCode(self) def getElementName(self): """ getElementName(ListOfUnits self) -> string Returns the XML element name of this object. For ListOfUnits, the XML element name is ''listOfUnits'.' Returns the name of this element, i.e., ''listOfUnits'.' """ return _libsbml.ListOfUnits_getElementName(self) def get(self, *args): """ get(ListOfUnits self, unsigned int n) -> Unit get(ListOfUnits self, unsigned int n) -> Unit Get a Unit from the ListOfUnits. Parameter 'n' is the index number of the Unit to get. Returns the nth Unit in this ListOfUnits. If the index 'n' is invalid, 'None' is returned. See also size(). """ return _libsbml.ListOfUnits_get(self, *args) def remove(self, n): """ remove(ListOfUnits self, unsigned int n) -> Unit Removes the nth item from this ListOfUnits items and returns a pointer to it. The caller owns the returned item and is responsible for deleting it. Parameter 'n' is the index of the item to remove. See also size(). """ return _libsbml.ListOfUnits_remove(self, n) __swig_destroy__ = _libsbml.delete_ListOfUnits __del__ = lambda self: None ListOfUnits_swigregister = _libsbml.ListOfUnits_swigregister ListOfUnits_swigregister(ListOfUnits) class UnitDefinition(SBase): """ A definition of a unit used in an SBML model. Units of measurement may be supplied in a number of contexts in an SBML model. The SBML unit definition facility uses two classes of objects, UnitDefinition and Unit. The approach to defining units in SBML is compositional; for example, meter second^-2 is constructed by combining a Unit object representing meter with another Unit object representing second^-2. The combination is wrapped inside a UnitDefinition, which provides for assigning an identifier and optional name to the combination. The identifier can then be referenced from elsewhere in a model. Thus, the UnitDefinition class is the container, and Unit instances are placed inside UnitDefinition instances. Two points are worth discussing in the context of SBML units. First, unit declarations in SBML models are optional. The consequence of this is that a model must be numerically self-consistent independently of unit declarations, for the benefit of software tools that cannot interpret or manipulate units. Unit declarations in SBML are thus more akin to a type of annotation; they can indicate intentions, and can be used by model readers for checking the consistency of the model, labeling simulation output, etc., but any transformations of values implied by different units must be incorporated explicitly into a model. Second, the vast majority of situations that require new SBML unit definitions involve simple multiplicative combinations of base units and factors. An example is moles per litre per second. What distinguishes these sorts of unit definitions from more complex ones is that they may be expressed without the use of an additive offset from a zero point. The use of offsets complicates all unit definition systems, yet in the domain of SBML, the real-life cases requiring offsets are few (and in fact, to the best of our knowledge, only involve temperature). Consequently, the SBML unit system has been consciously designed to simplify implementation of unit support for the most common cases in systems biology. The cost of this simplification is to require units with offsets to be handled explicitly by the modeler. Summary of the UnitDefinition construct ====================================================================== UnitDefinition has two attributes and one subelement. The two attributes are 'id' and 'name', and the subelement is ListOfUnits. The required attribute 'id' and optional attribute 'name' are both strings. The 'id' attribute is used to give the defined unit a unique identifier by which other parts of an SBML model definition can refer to it. The 'name' attribute is intended to be used for giving the unit definition an optional human-readable name. Please see the next section for information about the values permitted for 'id'. A UnitDefinition may contain exactly one ListOfUnits, and this list may contain one or more Unit definitions; see the definitions of these other object classes for more information about them. In SBML Level 2 and SBML Level 3 Version 1, if the ListOfUnits was present, it must have one or more Unit definitions. In SBML Level 3 Version 2, this restriction was relaxed, and a ListOfUnits was allowed to be empty. In either case, if a UnitDefinition had no child Unit elements, the unit was considered to be undefined. The following example illustrates a complete unit definition (when written in XML) when all the pieces are combined together. This defines 'mmls' to be millimoles per litre per second. Special considerations for Unit object identifiers ====================================================================== The attribute 'id' in UnitDefinition cannot be given simply any value, and the precise details of the values permitted differ slightly between Levels of SBML: * The 'id' of a UnitDefinition must not contain a value from the list of SBML's predefined base unit names (i.e., the strings 'gram,' 'litre,' etc.). In SBML Level 3, this list consists of the following: 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 This list of predefined base units is nearly identical in SBML Level 2 Version 4, the exception being that Level 2 does not define 'avogadro.' SBML Level 2 Version 1 (and only this Level+Version combination) provides an additional predefined unit name, 'Celsius,' not available in Level 3. Finally, SBML Level 1 Versions 2-3 provide two more additional predefined unit names, 'meter' and 'liter.' This is explained in somewhat greater detail in the description of the Unit class. * In SBML Level 2 (all Versions), there is an additional set of reserved identifiers: 'substance,' 'volume,' 'area,' 'length,' and 'time.' Using one of these values for the attribute 'id' of a UnitDefinition has the effect of redefining the model-wide default units for the corresponding quantities. The list of special unit names in SBML Level 2 is given in the table below: +------------+-------------------------------------------+---------------+ | Identifier | Possible scalable units | Default units | +------------+-------------------------------------------+---------------+ | substance | mole, item, gram, kilogram, dimensionless | mole | | volume | litre, cubic metre, dimensionless | litre | | area | square metre, dimensionless | square metre | | length | metre, dimensionless | metre | | time | second, dimensionless | second | +------------+-------------------------------------------+---------------+ Also, SBML Level 2 imposes two limitations on redefining the predefined unit 'substance,' 'volume,' 'area,' 'length,' and 'time:' (1) The UnitDefinition of a predefined SBML unit can only contain a single Unit object within it. (2) The value of the 'kind' attribute in a Unit instance must be drawn from one of the values in the second column of the table above. The special unit names 'substance,' 'volume,' 'area,' 'length,' and 'time' are not defined by SBML Level 3, which uses a different approach to setting model-wide inherited units. Further comments about SBML's unit definition system ====================================================================== The vast majority of modeling situations requiring new SBML unit definitions involve simple multiplicative combinations of base units and factors. An example of this might be moles per litre per second. What distinguishes these sorts of simpler unit definitions from more complex ones is that they may be expressed without the use of an additive offset from a zero point. The use of offsets complicates all unit definition systems, yet in the domain of SBML the real-life cases requiring offsets are few (and in fact, to the best of our knowledge, only involve temperature). Consequently, the SBML unit system has been consciously designed in a way that attempts to simplify implementation of unit support for the most common cases in systems biology. As of SBML Level 2 Version 2, Unit no longer has the attribute called 'offset' introduced in SBML Level 2 Version 1. It turned out that the general case involving units with offsets was incorrectly defined, and few (if any) developers even attempted to support offset-based units in their software. In the development of Level 2 Version 2, a consensus among SBML developers emerged that a fully generalized unit scheme is so confusing and complicated that it actually impedes interoperability. SBML Level 2 Version 2, Version 3 and Version 4 acknowledge this reality by reducing and simplifying the unit system, specifically by removing the 'offset' attribute on Unit and 'Celsius' as a pre-defined unit. The following guidelines suggest methods for handling units that do require the use of zero offsets for their definitions: * Handling Celsius. A model in which certain quantities are temperatures measured in degrees Celsius can be converted straightforwardly to a model in which those temperatures are in kelvin. A software tool could do this by performing a straightforward substitution using the following relationship: T_ kelvin = T_Celsius + 273.15. In every mathematical formula of the model where a quantity (call it x) in degrees Celsius appears, replace x with x_k+ 273.15, where x_k is now in kelvin. An alternative approach would be to use a FunctionDefinition object to define a function encapsulating this relationship above and then using that in the rest of the model as needed. Since Celsius is a commonly-used unit, software tools could help users by providing users with the ability to express temperatures in Celsius in the tools' interfaces, and making substitutions automatically when writing out the SBML. * Other units requiring offsets. One approach to handling other kinds of units is to use a FunctionDefinition to define a function encapsulating the necessary mathematical relationship, then substituting a call to this function wherever the original quantity appeared in the model. For example, here is a possible definition for converting Fahrenheit to Celsius degrees: temp_in_fahrenheit temp_in_fahrenheit 459.67 1.8 * An alternative approach not requiring the use of function definitions is to use an AssignmentRule for each variable in Fahrenheit units. The AssignmentRule could compute the conversion from Fahrenheit to (say) kelvin, assign its value to a variable (in Kelvin units), and then that variable could be used elsewhere in the model. * Still another approach is to rewrite the mathematical formulas of a model to directly incorporate the conversion formula wherever the original quantity appeared. Please consult the SBML specifications for more information about this and other issues involving units. """ __swig_setmethods__ = {} for _s in [SBase]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, UnitDefinition, name, value) __swig_getmethods__ = {} for _s in [SBase]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, UnitDefinition, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_UnitDefinition __del__ = lambda self: None def __init__(self, *args): """ __init__(UnitDefinition self, unsigned int level, unsigned int version) -> UnitDefinition __init__(UnitDefinition self, SBMLNamespaces sbmlns) -> UnitDefinition __init__(UnitDefinition self, UnitDefinition orig) -> UnitDefinition This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: UnitDefinition(SBMLNamespaces sbmlns) Creates a new UnitDefinition using the given SBMLNamespaces object 'sbmlns'. The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments. Parameter 'sbmlns' is an SBMLNamespaces object. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: UnitDefinition(long level, long version) Creates a new UnitDefinition using the given SBML 'level' and 'version' values. Parameter 'level' is a long integer, the SBML Level to assign to this UnitDefinition. Parameter 'version' is a long integer, the SBML Version to assign to this UnitDefinition. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: UnitDefinition(UnitDefinition orig) Copy constructor; creates a copy of this UnitDefinition. Parameter 'orig' is the object to copy. """ this = _libsbml.new_UnitDefinition(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(UnitDefinition self) -> UnitDefinition Creates and returns a deep copy of this UnitDefinition object. Returns the (deep) copy of this UnitDefinition object. """ return _libsbml.UnitDefinition_clone(self) def getElementBySId(self, id): """ getElementBySId(UnitDefinition self, string id) -> SBase Returns the first child element found that has the given 'id' in the model-wide SId namespace, or 'None' if no such object is found. Parameter 'id' is string representing the id of the object to find. Returns pointer to the first element found with the given 'id'. """ return _libsbml.UnitDefinition_getElementBySId(self, id) def getElementByMetaId(self, metaid): """ getElementByMetaId(UnitDefinition self, string metaid) -> SBase Returns the first child element it can find with the given 'metaid', or 'None' if no such object is found. Parameter 'metaid' is string representing the metaid of the object to find. Returns pointer to the first element found with the given 'metaid'. """ return _libsbml.UnitDefinition_getElementByMetaId(self, metaid) def getId(self): """ getId(UnitDefinition self) -> string Returns the value of the 'id' attribute of this UnitDefinition. Note: Because of the inconsistent behavior of this function with respect to assignments and rules, it is now recommended to use the getIdAttribute() function instead. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Returns the id of this UnitDefinition. See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(). """ return _libsbml.UnitDefinition_getId(self) def getName(self): """ getName(UnitDefinition self) -> string Returns the value of the 'name' attribute of this UnitDefinition object. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns the name of this SBML object, or the empty string if not set or unsettable. See also getIdAttribute(), isSetName(), setName(), unsetName(). """ return _libsbml.UnitDefinition_getName(self) def isSetId(self): """ isSetId(UnitDefinition self) -> bool Predicate returning 'True' if this UnitDefinition's 'id' attribute is set. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Returns 'True' if the 'id' attribute of this SBML object is set, 'False' otherwise. Note: Because of the inconsistent behavior of this function with respect to assignments and rules, it is recommended that callers use isSetIdAttribute() instead. See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(), isSetIdAttribute(). """ return _libsbml.UnitDefinition_isSetId(self) def isSetName(self): """ isSetName(UnitDefinition self) -> bool Predicate returning 'True' if this UnitDefinition's 'name' attribute is set. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns 'True' if the 'name' attribute of this SBML object is set, 'False' otherwise. See also getName(), setName(), unsetName(). """ return _libsbml.UnitDefinition_isSetName(self) def setId(self, sid): """ setId(UnitDefinition self, string sid) -> int Sets the value of the 'id' attribute of this UnitDefinition. The string 'sid' is copied. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Parameter 'sid' is the string to use as the identifier of this object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE * LIBSBML_UNEXPECTED_ATTRIBUTE See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(). """ return _libsbml.UnitDefinition_setId(self, sid) def setName(self, name): """ setName(UnitDefinition self, string name) -> int Sets the value of the 'name' attribute of this UnitDefinition. The string in 'name' is copied. Parameter 'name' is the new name for the SBML object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.UnitDefinition_setName(self, name) def unsetName(self): """ unsetName(UnitDefinition self) -> int Unsets the value of the 'name' attribute of this UnitDefinition. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also getName(), setName(), isSetName(). """ return _libsbml.UnitDefinition_unsetName(self) def isVariantOfArea(self, relaxed=False): """ isVariantOfArea(UnitDefinition self, bool relaxed=False) -> bool isVariantOfArea(UnitDefinition self) -> bool Convenience function for testing if a given unit definition is a variant of the predefined unit identifier ''area'.' Returns 'True' if this UnitDefinition is a variant of the predefined unit 'area,' meaning square metres with only arbitrary variations in scale or multiplier values; 'False' otherwise. Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.UnitDefinition_isVariantOfArea(self, relaxed) def isVariantOfLength(self, relaxed=False): """ isVariantOfLength(UnitDefinition self, bool relaxed=False) -> bool isVariantOfLength(UnitDefinition self) -> bool Convenience function for testing if a given unit definition is a variant of the predefined unit identifier ''length'.' Returns 'True' if this UnitDefinition is a variant of the predefined unit 'length,' meaning metres with only arbitrary variations in scale or multiplier values; 'False' otherwise. Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.UnitDefinition_isVariantOfLength(self, relaxed) def isVariantOfSubstance(self, relaxed=False): """ isVariantOfSubstance(UnitDefinition self, bool relaxed=False) -> bool isVariantOfSubstance(UnitDefinition self) -> bool Convenience function for testing if a given unit definition is a variant of the predefined unit identifier ''substance'.' Returns 'True' if this UnitDefinition is a variant of the predefined unit 'substance,' meaning moles or items (and grams or kilograms from SBML Level 2 Version 2 onwards) with only arbitrary variations in scale or multiplier values; 'False' otherwise. Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.UnitDefinition_isVariantOfSubstance(self, relaxed) def isVariantOfTime(self, relaxed=False): """ isVariantOfTime(UnitDefinition self, bool relaxed=False) -> bool isVariantOfTime(UnitDefinition self) -> bool Convenience function for testing if a given unit definition is a variant of the predefined unit identifier ''time'.' Returns 'True' if this UnitDefinition is a variant of the predefined unit 'time,' meaning seconds with only arbitrary variations in scale or multiplier values; 'False' otherwise. Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.UnitDefinition_isVariantOfTime(self, relaxed) def isVariantOfVolume(self, relaxed=False): """ isVariantOfVolume(UnitDefinition self, bool relaxed=False) -> bool isVariantOfVolume(UnitDefinition self) -> bool Convenience function for testing if a given unit definition is a variant of the predefined unit identifier ''volume'.' Returns 'True' if this UnitDefinition is a variant of the predefined unit 'volume,' meaning litre or cubic metre with only arbitrary variations in scale or multiplier values; 'False' otherwise. Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.UnitDefinition_isVariantOfVolume(self, relaxed) def isVariantOfDimensionless(self, relaxed=False): """ isVariantOfDimensionless(UnitDefinition self, bool relaxed=False) -> bool isVariantOfDimensionless(UnitDefinition self) -> bool Convenience function for testing if a given unit definition is a variant of the unit ''dimensionless'.' Returns 'True' if this UnitDefinition is a variant of 'dimensionless,' meaning dimensionless with only arbitrary variations in scale or multiplier values; 'False' otherwise. Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.UnitDefinition_isVariantOfDimensionless(self, relaxed) def isVariantOfMass(self, relaxed=False): """ isVariantOfMass(UnitDefinition self, bool relaxed=False) -> bool isVariantOfMass(UnitDefinition self) -> bool Convenience function for testing if a given unit definition is a variant of the predefined unit identifier ''mass'.' Returns 'True' if this UnitDefinition is a variant of mass units, meaning gram or kilogram with only arbitrary variations in scale or multiplier values; 'False' otherwise. Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.UnitDefinition_isVariantOfMass(self, relaxed) def isVariantOfSubstancePerTime(self, relaxed=False): """ isVariantOfSubstancePerTime(UnitDefinition self, bool relaxed=False) -> bool isVariantOfSubstancePerTime(UnitDefinition self) -> bool Convenience function for testing if a given unit definition is a variant of the predefined unit ''substance'' divided by the predefined unit ''time'.' Returns 'True' if this UnitDefinition is a variant of the predefined unit 'substance' per predefined unit 'time,' meaning it contains two units one of which is a variant of substance and the other is a variant of time which an exponent of -1; 'False' otherwise. Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.UnitDefinition_isVariantOfSubstancePerTime(self, relaxed) def addUnit(self, u): """ addUnit(UnitDefinition self, Unit u) -> int Adds a copy of the given Unit to this UnitDefinition. Parameter 'u' is the Unit instance to add to this UnitDefinition. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_LEVEL_MISMATCH * LIBSBML_VERSION_MISMATCH * LIBSBML_INVALID_OBJECT * LIBSBML_OPERATION_FAILED Note: This method should be used with some caution. The fact that this method copies the object passed to it means that the caller will be left holding a physically different object instance than the one contained inside this object. Changes made to the original object instance (such as resetting attribute values) will not affect the instance in this object. In addition, the caller should make sure to free the original object if it is no longer being used, or else a memory leak will result. Please see other methods on this class (particularly a corresponding method whose name begins with the word create) for alternatives that do not lead to these issues. See also createUnit(). """ return _libsbml.UnitDefinition_addUnit(self, u) def createUnit(self): """ createUnit(UnitDefinition self) -> Unit Creates a new and empty Unit, adds it to this UnitDefinition's list of units, and returns it. Returns a newly constructed (and empty) Unit instance. Note: It is worth emphasizing that the attribute 'kind' value of a Unit is a required attribute for a valid Unit definition. The createUnit() method does not assign a valid kind to the constructed unit (instead, it sets the 'kind' to UNIT_KIND_INVALID). Callers are cautioned to set the newly-constructed Unit's kind using Unit.setKind() soon after calling this method. See also addUnit(). """ return _libsbml.UnitDefinition_createUnit(self) def getListOfUnits(self, *args): """ getListOfUnits(UnitDefinition self) -> ListOfUnits getListOfUnits(UnitDefinition self) -> ListOfUnits Returns the list of Units for this UnitDefinition instance. Returns the ListOfUnits value for this UnitDefinition. """ return _libsbml.UnitDefinition_getListOfUnits(self, *args) def getUnit(self, *args): """ getUnit(UnitDefinition self, unsigned int n) -> Unit getUnit(UnitDefinition self, unsigned int n) -> Unit Returns a specific Unit instance belonging to this UnitDefinition. Parameter 'n' is an integer, the index of the Unit to be returned. Returns the nth Unit of this UnitDefinition. If the index 'n' is invalid, 'None' is returned. See also getNumUnits(). """ return _libsbml.UnitDefinition_getUnit(self, *args) def getNumUnits(self): """ getNumUnits(UnitDefinition self) -> unsigned int Returns the number of Unit objects contained within this UnitDefinition. Returns an integer representing the number of Units in this UnitDefinition. """ return _libsbml.UnitDefinition_getNumUnits(self) def removeUnit(self, n): """ removeUnit(UnitDefinition self, unsigned int n) -> Unit Removes the nth Unit object from this UnitDefinition object and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. Parameter 'n' is the index of the Unit object to remove. Returns the Unit object removed, or 'None' if the given index is out of range. """ return _libsbml.UnitDefinition_removeUnit(self, n) def connectToChild(self): """connectToChild(UnitDefinition self)""" return _libsbml.UnitDefinition_connectToChild(self) def enablePackageInternal(self, pkgURI, pkgPrefix, flag): """ enablePackageInternal(UnitDefinition self, string pkgURI, string pkgPrefix, bool flag) Internal implementation method. """ return _libsbml.UnitDefinition_enablePackageInternal(self, pkgURI, pkgPrefix, flag) def updateSBMLNamespace(self, package, level, version): """ updateSBMLNamespace(UnitDefinition self, string package, unsigned int level, unsigned int version) Internal implementation method. """ return _libsbml.UnitDefinition_updateSBMLNamespace(self, package, level, version) def getTypeCode(self): """ getTypeCode(UnitDefinition self) -> int Returns the libSBML type code for this object instance. LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for this object: SBML_UNIT_DEFINITION (default). WARNING: The specific integer values of the possible type codes may be reused by different libSBML plug-ins for SBML Level 3. packages, To fully identify the correct code, it is necessary to invoke both getPackageName() and getTypeCode() (or ListOf.getItemTypeCode()). See also getPackageName(), getElementName(). """ return _libsbml.UnitDefinition_getTypeCode(self) def getElementName(self): """ getElementName(UnitDefinition self) -> string Returns the XML element name of this object, which for UnitDefinition, is always ''unitDefinition'.' Returns the name of this element, i.e., ''unitDefinition'.' """ return _libsbml.UnitDefinition_getElementName(self) def simplify(ud): """ simplify(UnitDefinition ud) Simplifies the UnitDefinition such that any given kind of Unit object occurs only once in the ListOfUnits. For example, the following definition, will be simplified to Parameter 'ud' is the UnitDefinition object to be simplified. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.UnitDefinition_simplify(ud) simplify = staticmethod(simplify) def reorder(ud): """ reorder(UnitDefinition ud) Alphabetically orders the Unit objects within the ListOfUnits of a UnitDefinition. Parameter 'ud' is the UnitDefinition object whose units are to be reordered. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.UnitDefinition_reorder(ud) reorder = staticmethod(reorder) def convertToSI(ud): """ convertToSI(UnitDefinition ud) -> UnitDefinition Convert a given UnitDefinition into a new UnitDefinition object that uses SI units. Parameter 'ud' is the UnitDefinition object to convert to SI. Returns a new UnitDefinition object representing the results of the conversion. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.UnitDefinition_convertToSI(ud) convertToSI = staticmethod(convertToSI) def areIdentical(ud1, ud2): """ areIdentical(UnitDefinition ud1, UnitDefinition ud2) -> bool Predicate returning 'True' if two UnitDefinition objects are identical. For the purposes of performing this comparison, two UnitDefinition objects are considered identical when they contain identical lists of Unit objects. Pairs of Unit objects in the lists are in turn considered identical if they satisfy the predicate Unit.areIdentical(). The predicate compares every attribute of the Unit objects. Parameter 'ud1' is the first UnitDefinition object to compare. Parameter 'ud2' is the second UnitDefinition object to compare. Returns 'True' if all the Unit objects in 'ud1' are identical to the Unit objects of 'ud2', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also UnitDefinition.areEquivalent(), Unit.areIdentical(). """ return _libsbml.UnitDefinition_areIdentical(ud1, ud2) areIdentical = staticmethod(areIdentical) def areEquivalent(ud1, ud2): """ areEquivalent(UnitDefinition ud1, UnitDefinition ud2) -> bool Predicate returning 'True' if two UnitDefinition objects are equivalent. For the purposes of performing this comparison, two UnitDefinition objects are considered equivalent when they contain equivalent list of Unit objects. Unit objects are in turn considered equivalent if they satisfy the predicate Unit.areEquivalent(). The predicate tests a subset of the objects's attributes. Parameter 'ud1' is the first UnitDefinition object to compare. Parameter 'ud2' is the second UnitDefinition object to compare. Returns 'True' if all the Unit objects in 'ud1' are equivalent to the Unit objects in 'ud2', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also UnitDefinition.areIdentical(), Unit.areEquivalent(). """ return _libsbml.UnitDefinition_areEquivalent(ud1, ud2) areEquivalent = staticmethod(areEquivalent) def combine(ud1, ud2): """ combine(UnitDefinition ud1, UnitDefinition ud2) -> UnitDefinition Combines two UnitDefinition objects into a single UnitDefinition. This takes UnitDefinition objects 'ud1' and 'ud2', and creates a UnitDefinition object that expresses the product of the units of 'ud1' and 'ud2'. Parameter 'ud1' is the first UnitDefinition object. Parameter 'ud2' is the second UnitDefinition object. Returns a UnitDefinition which represents the product of the units of the two argument UnitDefinitions. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.UnitDefinition_combine(ud1, ud2) combine = staticmethod(combine) def divide(ud1, ud2): """ divide(UnitDefinition ud1, UnitDefinition ud2) -> UnitDefinition Combines two UnitDefinition objects into a single UnitDefinition as a division. This takes UnitDefinition objects 'ud1' and 'ud2', and creates a UnitDefinition object that expresses the division of the units of 'ud1' and 'ud2'. Parameter 'ud1' is the first UnitDefinition object. Parameter 'ud2' is the second UnitDefinition object. Returns a UnitDefinition which represents the division of the units of the two argument UnitDefinitions. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.UnitDefinition_divide(ud1, ud2) divide = staticmethod(divide) def printUnits(ud, compact=False): """ printUnits(UnitDefinition ud, bool compact=False) -> string printUnits(UnitDefinition ud) -> string Expresses the given definition in a plain-text form. For example, UnitDefinition.printUnits() applied to will return the string 'metre (exponent = 1, multiplier = 1, scale = 0) second (exponent = -2, multiplier = 1, scale = 0)' or, if the optional parameter 'compact' is given the value 'True,' the string '(1 metre)^1 (1 second)^-2'. This method may be useful for printing unit information to human users, or in debugging software, or other situations. Parameter 'ud' is the UnitDefinition object. Parameter 'compact' is boolean indicating whether the compact form should be used (defaults to false). Returns a string expressing the unit definition defined by the given UnitDefinition object 'ud'. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.UnitDefinition_printUnits(ud, compact) printUnits = staticmethod(printUnits) def hasRequiredAttributes(self): """ hasRequiredAttributes(UnitDefinition self) -> bool Predicate returning 'True' if all the required attributes for this UnitDefinition object have been set. The required attributes for a UnitDefinition object are: * 'id' Returns 'True' if the required attributes have been set, 'False' otherwise. """ return _libsbml.UnitDefinition_hasRequiredAttributes(self) def hasRequiredElements(self): """ hasRequiredElements(UnitDefinition self) -> bool Predicate returning 'True' if all the required elements for this UnitDefinition object have been set. Note: The required elements for a Constraint object are: * 'listOfUnits' (required in SBML Level 2 only, optional in Level 3) Returns a boolean value indicating whether all the required elements for this object have been defined. """ return _libsbml.UnitDefinition_hasRequiredElements(self) UnitDefinition_swigregister = _libsbml.UnitDefinition_swigregister UnitDefinition_swigregister(UnitDefinition) def UnitDefinition_simplify(ud): """ UnitDefinition_simplify(UnitDefinition ud) Simplifies the UnitDefinition such that any given kind of Unit object occurs only once in the ListOfUnits. For example, the following definition, will be simplified to Parameter 'ud' is the UnitDefinition object to be simplified. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.UnitDefinition_simplify(ud) def UnitDefinition_reorder(ud): """ UnitDefinition_reorder(UnitDefinition ud) Alphabetically orders the Unit objects within the ListOfUnits of a UnitDefinition. Parameter 'ud' is the UnitDefinition object whose units are to be reordered. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.UnitDefinition_reorder(ud) def UnitDefinition_convertToSI(ud): """ UnitDefinition_convertToSI(UnitDefinition ud) -> UnitDefinition Convert a given UnitDefinition into a new UnitDefinition object that uses SI units. Parameter 'ud' is the UnitDefinition object to convert to SI. Returns a new UnitDefinition object representing the results of the conversion. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.UnitDefinition_convertToSI(ud) def UnitDefinition_areIdentical(ud1, ud2): """ UnitDefinition_areIdentical(UnitDefinition ud1, UnitDefinition ud2) -> bool Predicate returning 'True' if two UnitDefinition objects are identical. For the purposes of performing this comparison, two UnitDefinition objects are considered identical when they contain identical lists of Unit objects. Pairs of Unit objects in the lists are in turn considered identical if they satisfy the predicate Unit.areIdentical(). The predicate compares every attribute of the Unit objects. Parameter 'ud1' is the first UnitDefinition object to compare. Parameter 'ud2' is the second UnitDefinition object to compare. Returns 'True' if all the Unit objects in 'ud1' are identical to the Unit objects of 'ud2', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also UnitDefinition.areEquivalent(), Unit.areIdentical(). """ return _libsbml.UnitDefinition_areIdentical(ud1, ud2) def UnitDefinition_areEquivalent(ud1, ud2): """ UnitDefinition_areEquivalent(UnitDefinition ud1, UnitDefinition ud2) -> bool Predicate returning 'True' if two UnitDefinition objects are equivalent. For the purposes of performing this comparison, two UnitDefinition objects are considered equivalent when they contain equivalent list of Unit objects. Unit objects are in turn considered equivalent if they satisfy the predicate Unit.areEquivalent(). The predicate tests a subset of the objects's attributes. Parameter 'ud1' is the first UnitDefinition object to compare. Parameter 'ud2' is the second UnitDefinition object to compare. Returns 'True' if all the Unit objects in 'ud1' are equivalent to the Unit objects in 'ud2', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also UnitDefinition.areIdentical(), Unit.areEquivalent(). """ return _libsbml.UnitDefinition_areEquivalent(ud1, ud2) def UnitDefinition_combine(ud1, ud2): """ UnitDefinition_combine(UnitDefinition ud1, UnitDefinition ud2) -> UnitDefinition Combines two UnitDefinition objects into a single UnitDefinition. This takes UnitDefinition objects 'ud1' and 'ud2', and creates a UnitDefinition object that expresses the product of the units of 'ud1' and 'ud2'. Parameter 'ud1' is the first UnitDefinition object. Parameter 'ud2' is the second UnitDefinition object. Returns a UnitDefinition which represents the product of the units of the two argument UnitDefinitions. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.UnitDefinition_combine(ud1, ud2) def UnitDefinition_divide(ud1, ud2): """ UnitDefinition_divide(UnitDefinition ud1, UnitDefinition ud2) -> UnitDefinition Combines two UnitDefinition objects into a single UnitDefinition as a division. This takes UnitDefinition objects 'ud1' and 'ud2', and creates a UnitDefinition object that expresses the division of the units of 'ud1' and 'ud2'. Parameter 'ud1' is the first UnitDefinition object. Parameter 'ud2' is the second UnitDefinition object. Returns a UnitDefinition which represents the division of the units of the two argument UnitDefinitions. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.UnitDefinition_divide(ud1, ud2) def UnitDefinition_printUnits(ud, compact=False): """ printUnits(UnitDefinition ud, bool compact=False) -> string UnitDefinition_printUnits(UnitDefinition ud) -> string Expresses the given definition in a plain-text form. For example, UnitDefinition.printUnits() applied to will return the string 'metre (exponent = 1, multiplier = 1, scale = 0) second (exponent = -2, multiplier = 1, scale = 0)' or, if the optional parameter 'compact' is given the value 'True,' the string '(1 metre)^1 (1 second)^-2'. This method may be useful for printing unit information to human users, or in debugging software, or other situations. Parameter 'ud' is the UnitDefinition object. Parameter 'compact' is boolean indicating whether the compact form should be used (defaults to false). Returns a string expressing the unit definition defined by the given UnitDefinition object 'ud'. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.UnitDefinition_printUnits(ud, compact) class ListOfUnitDefinitions(ListOf): """ A list of UnitDefinition objects. The various ListOf___ classes in SBML are merely containers used for organizing the main components of an SBML model. In libSBML's implementation, ListOf___ classes are derived from the intermediate utility class ListOf, which is not defined by the SBML specifications but serves as a useful programmatic construct. ListOf is itself is in turn derived from SBase, which provides all of the various ListOf___ classes with common features defined by the SBML specification, such as 'metaid' attributes and annotations. The relationship between the lists and the rest of an SBML model is illustrated by the following (for SBML Level 2 Version 4): ... ... ... ... ... ... ... elements of subclasses of Rule ... ... ... ... SBML Level 3 Version 1 has essentially the same structure as Level 2 Version 4, depicted above, but SBML Level 3 Version 2 allows containers to contain zero or more of the relevant object, instead of requiring at least one. As such, libsbml will write out an otherwise-empty ListOf___ element that has any optional attribute set (such as 'id' or 'metaid'), that has an optional child (such as a 'notes' or 'annotation'), or that has attributes or children set from any SBML Level 3 package, whether or not the ListOf___ has any other children. Readers may wonder about the motivations for using the ListOf___ containers in SBML. A simpler approach in XML might be to place the components all directly at the top level of the model definition. The choice made in SBML is to group them within XML elements named after ListOfClassname, in part because it helps organize the components. More importantly, the fact that the container classes are derived from SBase means that software tools can add information about the lists themselves into each list container's 'annotation'. See also ListOfFunctionDefinitions, ListOfUnitDefinitions, ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments, ListOfSpecies, ListOfParameters, ListOfInitialAssignments, ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents. """ __swig_setmethods__ = {} for _s in [ListOf]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfUnitDefinitions, name, value) __swig_getmethods__ = {} for _s in [ListOf]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, ListOfUnitDefinitions, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(ListOfUnitDefinitions self, unsigned int level, unsigned int version) -> ListOfUnitDefinitions __init__(ListOfUnitDefinitions self, SBMLNamespaces sbmlns) -> ListOfUnitDefinitions This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: ListOfUnitDefinitions(SBMLNamespaces sbmlns) Creates a new ListOfUnitDefinitions object. The object is constructed such that it is valid for the SBML Level and Version combination determined by the SBMLNamespaces object in 'sbmlns'. Parameter 'sbmlns' is an SBMLNamespaces object that is used to determine the characteristics of the ListOfUnitDefinitions object to be created. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: ListOfUnitDefinitions(long level, long version) Creates a new ListOfUnitDefinitions object. The object is constructed such that it is valid for the given SBML Level and Version combination. Parameter 'level' is the SBML Level. Parameter 'version' is the Version within the SBML Level. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. """ this = _libsbml.new_ListOfUnitDefinitions(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(ListOfUnitDefinitions self) -> ListOfUnitDefinitions Creates and returns a deep copy of this ListOfUnitDefinitions object. Returns the (deep) copy of this ListOfUnitDefinitions object. """ return _libsbml.ListOfUnitDefinitions_clone(self) def getItemTypeCode(self): """ getItemTypeCode(ListOfUnitDefinitions self) -> int Returns the libSBML type code for the objects contained in this ListOf (i.e., UnitDefinition objects, if the list is non-empty). LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for objects contained in this list: SBML_UNIT_DEFINITION (default). See also getElementName(), getPackageName(). """ return _libsbml.ListOfUnitDefinitions_getItemTypeCode(self) def getElementName(self): """ getElementName(ListOfUnitDefinitions self) -> string Returns the XML element name of this object. For ListOfUnitDefinitions, the XML element name is ''listOfUnitDefinitions'.' Returns the name of this element, i.e., ''listOfUnitDefinitions'.' """ return _libsbml.ListOfUnitDefinitions_getElementName(self) def get(self, *args): """ get(ListOfUnitDefinitions self, unsigned int n) -> UnitDefinition get(ListOfUnitDefinitions self, unsigned int n) -> UnitDefinition get(ListOfUnitDefinitions self, string sid) -> UnitDefinition get(ListOfUnitDefinitions self, string sid) -> UnitDefinition This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: get(long n) Get a UnitDefinition from the ListOfUnitDefinitions. Parameter 'n' is the index number of the UnitDefinition to get. Returns the nth UnitDefinition in this ListOfUnitDefinitions. If the index 'n' is invalid, 'None' is returned. See also size(). ______________________________________________________________________ Method variant with the following signature: get(string sid) Get a UnitDefinition from the ListOfUnitDefinitions based on its identifier. Parameter 'sid' is a string representing the identifier of the UnitDefinition to get. Returns UnitDefinition in this ListOfUnitDefinitions with the given 'sid' or 'None' if no such UnitDefinition exists. See also get(), size(). """ return _libsbml.ListOfUnitDefinitions_get(self, *args) def getElementBySId(self, id): """ getElementBySId(ListOfUnitDefinitions self, string id) -> SBase Returns the first child element found that has the given 'id' in the model-wide SId namespace, or 'None' if no such object is found. Note that UnitDefinitions themselves are in the UnitId namespace, not the SId namespace, so no UnitDefinition object will be returned from this function (and is the reason we override the base ListOf::getElementBySId function here). Parameter 'id' is string representing the id of the object to find. Returns pointer to the first element found with the given 'id'. """ return _libsbml.ListOfUnitDefinitions_getElementBySId(self, id) def remove(self, *args): """ remove(ListOfUnitDefinitions self, unsigned int n) -> UnitDefinition remove(ListOfUnitDefinitions self, string sid) -> UnitDefinition This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: remove(long n) Removes the nth item from this ListOfUnitDefinitions items and returns a pointer to it. The caller owns the returned item and is responsible for deleting it. Parameter 'n' is the index of the item to remove. See also size(). ______________________________________________________________________ Method variant with the following signature: remove(string sid) Removes item in this ListOfUnitDefinitions items with the given identifier. The caller owns the returned item and is responsible for deleting it. If none of the items in this list have the identifier 'sid', then 'None' is returned. Parameter 'sid' is the identifier of the item to remove. Returns the item removed. As mentioned above, the caller owns the returned item. """ return _libsbml.ListOfUnitDefinitions_remove(self, *args) __swig_destroy__ = _libsbml.delete_ListOfUnitDefinitions __del__ = lambda self: None ListOfUnitDefinitions_swigregister = _libsbml.ListOfUnitDefinitions_swigregister ListOfUnitDefinitions_swigregister(ListOfUnitDefinitions) class CompartmentType(SBase): """ A compartment type in SBML Level 2. SBML Level 2 Versions 2-4 provide the compartment type as a grouping construct that can be used to establish a relationship between multiple Compartment objects. A CompartmentType object only has an identity, and this identity can only be used to indicate that particular Compartment objects in the model belong to this type. This may be useful for conveying a modeling intention, such as when a model contains many similar compartments, either by their biological function or the reactions they carry. Without a compartment type construct, it would be impossible within SBML itself to indicate that all of the compartments share an underlying conceptual relationship because each SBML compartment must be given a unique and separate identity. A CompartmentType has no mathematical meaning in SBML---it has no effect on a model's mathematical interpretation. Simulators and other numerical analysis software may ignore CompartmentType definitions and references to them in a model. There is no mechanism in SBML Level 2 for representing hierarchies of compartment types. One CompartmentType instance cannot be the subtype of another CompartmentType instance; SBML provides no means of defining such relationships. As with other major structures in SBML, CompartmentType has a mandatory attribute, 'id', used to give the compartment type an identifier. The identifier must be a text string conforming to the identifer syntax permitted in SBML. CompartmentType also has an optional 'name' attribute, of type 'string.' The 'id' and 'name' must be used according to the guidelines described in the SBML specification (e.g., Section 3.3 in the Level 2 Version 4 specification). CompartmentType was introduced in SBML Level 2 Version 2. It is not available in SBML Level 1 nor in Level 3. See also Compartment, ListOfCompartmentTypes, SpeciesType, ListOfSpeciesTypes. """ __swig_setmethods__ = {} for _s in [SBase]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, CompartmentType, name, value) __swig_getmethods__ = {} for _s in [SBase]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, CompartmentType, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_CompartmentType __del__ = lambda self: None def __init__(self, *args): """ __init__(CompartmentType self, unsigned int level, unsigned int version) -> CompartmentType __init__(CompartmentType self, SBMLNamespaces sbmlns) -> CompartmentType __init__(CompartmentType self, CompartmentType orig) -> CompartmentType This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: CompartmentType(SBMLNamespaces sbmlns) Creates a new CompartmentType object using the given SBMLNamespaces object 'sbmlns'. The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments. It is worth emphasizing that although this constructor does not take an identifier argument, in SBML Level 2 and beyond, the 'id' (identifier) attribute of a CompartmentType object is required to have a value. Thus, callers are cautioned to assign a value after calling this constructor. Setting the identifier can be accomplished using the method setId(). Parameter 'sbmlns' is an SBMLNamespaces object. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: CompartmentType(long level, long version) Creates a new CompartmentType object using the given SBML 'level' and 'version' values. Parameter 'level' is a long integer, the SBML Level to assign to this CompartmentType. Parameter 'version' is a long integer, the SBML Version to assign to this CompartmentType. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: CompartmentType(CompartmentType orig) Copy constructor; creates a copy of this CompartmentType object. Parameter 'orig' is the object to copy. """ this = _libsbml.new_CompartmentType(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(CompartmentType self) -> CompartmentType Creates and returns a deep copy of this CompartmentType object. Returns the (deep) copy of this CompartmentType object. """ return _libsbml.CompartmentType_clone(self) def getId(self): """ getId(CompartmentType self) -> string Returns the value of the 'id' attribute of this CompartmentType. Note: Because of the inconsistent behavior of this function with respect to assignments and rules, it is now recommended to use the getIdAttribute() function instead. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Returns the id of this CompartmentType. See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(). """ return _libsbml.CompartmentType_getId(self) def getName(self): """ getName(CompartmentType self) -> string Returns the value of the 'name' attribute of this CompartmentType object. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns the name of this SBML object, or the empty string if not set or unsettable. See also getIdAttribute(), isSetName(), setName(), unsetName(). """ return _libsbml.CompartmentType_getName(self) def isSetId(self): """ isSetId(CompartmentType self) -> bool Predicate returning 'True' if this CompartmentType object's 'id' attribute is set. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Returns 'True' if the 'id' attribute of this SBML object is set, 'False' otherwise. Note: Because of the inconsistent behavior of this function with respect to assignments and rules, it is recommended that callers use isSetIdAttribute() instead. See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(), isSetIdAttribute(). """ return _libsbml.CompartmentType_isSetId(self) def isSetName(self): """ isSetName(CompartmentType self) -> bool Predicate returning 'True' if this CompartmentType object's 'name' attribute is set. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns 'True' if the 'name' attribute of this SBML object is set, 'False' otherwise. See also getName(), setName(), unsetName(). """ return _libsbml.CompartmentType_isSetName(self) def setId(self, sid): """ setId(CompartmentType self, string sid) -> int Sets the value of the 'id' attribute of this CompartmentType. The string 'sid' is copied. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Parameter 'sid' is the string to use as the identifier of this object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE * LIBSBML_UNEXPECTED_ATTRIBUTE See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(). """ return _libsbml.CompartmentType_setId(self, sid) def setName(self, name): """ setName(CompartmentType self, string name) -> int Sets the value of the 'name' attribute of this CompartmentType. The string in 'name' is copied. Parameter 'name' is the new name for the SBML object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.CompartmentType_setName(self, name) def unsetName(self): """ unsetName(CompartmentType self) -> int Unsets the value of the 'name' attribute of this CompartmentType object. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also getName(), setName(), isSetName(). """ return _libsbml.CompartmentType_unsetName(self) def getTypeCode(self): """ getTypeCode(CompartmentType self) -> int Returns the libSBML type code for this SBML object. LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for this object: SBML_COMPARTMENT_TYPE (default). WARNING: The specific integer values of the possible type codes may be reused by different libSBML plug-ins for SBML Level 3. packages, To fully identify the correct code, it is necessary to invoke both getPackageName() and getTypeCode() (or ListOf.getItemTypeCode()). See also getElementName(), getPackageName(). """ return _libsbml.CompartmentType_getTypeCode(self) def getElementName(self): """ getElementName(CompartmentType self) -> string Returns the XML element name of this object For CompartmentType, the element name is always ''compartmentType'.' Returns the name of this element. See also getTypeCode(), getPackageName(). """ return _libsbml.CompartmentType_getElementName(self) def hasRequiredAttributes(self): """ hasRequiredAttributes(CompartmentType self) -> bool Predicate returning 'True' if all the required attributes for this CompartmentType object have been set. The required attributes for a CompartmentType object are: * 'id' Returns 'True' if the required attributes have been set, 'False' otherwise. """ return _libsbml.CompartmentType_hasRequiredAttributes(self) CompartmentType_swigregister = _libsbml.CompartmentType_swigregister CompartmentType_swigregister(CompartmentType) class ListOfCompartmentTypes(ListOf): """ A list of CompartmentType objects. The various ListOf___ classes in SBML are merely containers used for organizing the main components of an SBML model. In libSBML's implementation, ListOf___ classes are derived from the intermediate utility class ListOf, which is not defined by the SBML specifications but serves as a useful programmatic construct. ListOf is itself is in turn derived from SBase, which provides all of the various ListOf___ classes with common features defined by the SBML specification, such as 'metaid' attributes and annotations. The relationship between the lists and the rest of an SBML model is illustrated by the following (for SBML Level 2 Version 4): ... ... ... ... ... ... ... elements of subclasses of Rule ... ... ... ... SBML Level 3 Version 1 has essentially the same structure as Level 2 Version 4, depicted above, but SBML Level 3 Version 2 allows containers to contain zero or more of the relevant object, instead of requiring at least one. As such, libsbml will write out an otherwise-empty ListOf___ element that has any optional attribute set (such as 'id' or 'metaid'), that has an optional child (such as a 'notes' or 'annotation'), or that has attributes or children set from any SBML Level 3 package, whether or not the ListOf___ has any other children. Readers may wonder about the motivations for using the ListOf___ containers in SBML. A simpler approach in XML might be to place the components all directly at the top level of the model definition. The choice made in SBML is to group them within XML elements named after ListOfClassname, in part because it helps organize the components. More importantly, the fact that the container classes are derived from SBase means that software tools can add information about the lists themselves into each list container's 'annotation'. See also ListOfFunctionDefinitions, ListOfUnitDefinitions, ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments, ListOfSpecies, ListOfParameters, ListOfInitialAssignments, ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents. """ __swig_setmethods__ = {} for _s in [ListOf]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfCompartmentTypes, name, value) __swig_getmethods__ = {} for _s in [ListOf]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, ListOfCompartmentTypes, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(ListOfCompartmentTypes self, unsigned int level, unsigned int version) -> ListOfCompartmentTypes __init__(ListOfCompartmentTypes self, SBMLNamespaces sbmlns) -> ListOfCompartmentTypes This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: ListOfCompartmentTypes(SBMLNamespaces sbmlns) Creates a new ListOfCompartmentTypes object. The object is constructed such that it is valid for the SBML Level and Version combination determined by the SBMLNamespaces object in 'sbmlns'. Parameter 'sbmlns' is an SBMLNamespaces object that is used to determine the characteristics of the ListOfCompartmentTypes object to be created. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: ListOfCompartmentTypes(long level, long version) Creates a new ListOfCompartmentTypes object. The object is constructed such that it is valid for the given SBML Level and Version combination. Parameter 'level' is the SBML Level. Parameter 'version' is the Version within the SBML Level. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. """ this = _libsbml.new_ListOfCompartmentTypes(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(ListOfCompartmentTypes self) -> ListOfCompartmentTypes Creates and returns a deep copy of this ListOfCompartmentTypes object. Returns the (deep) copy of this ListOfCompartmentTypes object. """ return _libsbml.ListOfCompartmentTypes_clone(self) def getItemTypeCode(self): """ getItemTypeCode(ListOfCompartmentTypes self) -> int Returns the libSBML type code for the objects contained in this ListOf (i.e., CompartmentType objects, if the list is non-empty). LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for the objects contained in this ListOf instance: SBML_COMPARTMENT_TYPE (default). See also getElementName(), getPackageName(). """ return _libsbml.ListOfCompartmentTypes_getItemTypeCode(self) def getElementName(self): """ getElementName(ListOfCompartmentTypes self) -> string Returns the XML element name of this object. For ListOfCompartmentTypes, the XML element name is ''listOfCompartmentTypes'.' Returns the name of this element, i.e., ''listOfCompartmentTypes'.' """ return _libsbml.ListOfCompartmentTypes_getElementName(self) def get(self, *args): """ get(ListOfCompartmentTypes self, unsigned int n) -> CompartmentType get(ListOfCompartmentTypes self, unsigned int n) -> CompartmentType get(ListOfCompartmentTypes self, string sid) -> CompartmentType get(ListOfCompartmentTypes self, string sid) -> CompartmentType This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: get(long n) Get a CompartmentType object from the ListOfCompartmentTypes. Parameter 'n' is the index number of the CompartmentType object to get. Returns the nth CompartmentType object in this ListOfCompartmentTypes. If the index 'n' is invalid, 'None' is returned. See also size(). ______________________________________________________________________ Method variant with the following signature: get(string sid) Get a CompartmentType object from the ListOfCompartmentTypes based on its identifier. Parameter 'sid' is a string representing the identifier of the CompartmentType object to get. Returns CompartmentType object in this ListOfCompartmentTypes with the given 'sid' or 'None' if no such CompartmentType object exists. See also get(), size(). """ return _libsbml.ListOfCompartmentTypes_get(self, *args) def remove(self, *args): """ remove(ListOfCompartmentTypes self, unsigned int n) -> CompartmentType remove(ListOfCompartmentTypes self, string sid) -> CompartmentType This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: remove(long n) Removes the nth item from this ListOfCompartmentTypes items and returns a pointer to it. The caller owns the returned item and is responsible for deleting it. Parameter 'n' is the index of the item to remove. See also size(). ______________________________________________________________________ Method variant with the following signature: remove(string sid) Removes item in this ListOfCompartmentTypes items with the given identifier. The caller owns the returned item and is responsible for deleting it. If none of the items in this list have the identifier 'sid', then 'None' is returned. Parameter 'sid' is the identifier of the item to remove. Returns the item removed. As mentioned above, the caller owns the returned item. """ return _libsbml.ListOfCompartmentTypes_remove(self, *args) __swig_destroy__ = _libsbml.delete_ListOfCompartmentTypes __del__ = lambda self: None ListOfCompartmentTypes_swigregister = _libsbml.ListOfCompartmentTypes_swigregister ListOfCompartmentTypes_swigregister(ListOfCompartmentTypes) class SpeciesType(SBase): """ A species type in SBML Level 2. The term species type refers to reacting entities independent of location. These include simple ions (e.g., protons, calcium), simple molecules (e.g., glucose, ATP), large molecules (e.g., RNA, polysaccharides, and proteins), and others. SBML Level 2 Versions 2-4 provide an explicit SpeciesType class of object to enable Species objects of the same type to be related together. SpeciesType is a conceptual construct; the existence of SpeciesType objects in a model has no effect on the model's numerical interpretation. Except for the requirement for uniqueness of species/species type combinations located in compartments, simulators and other numerical analysis software may ignore SpeciesType definitions and references to them in a model. There is no mechanism in SBML Level 2 for representing hierarchies of species types. One SpeciesType object cannot be the subtype of another SpeciesType object; SBML provides no means of defining such relationships. As with other major structures in SBML, SpeciesType has a mandatory attribute, 'id', used to give the species type an identifier. The identifier must be a text string conforming to the identifer syntax permitted in SBML. SpeciesType also has an optional 'name' attribute, of type 'string.' The 'id' and 'name' must be used according to the guidelines described in the SBML specification (e.g., Section 3.3 in the Level 2 Version 4 specification). SpeciesType was introduced in SBML Level 2 Version 2. It is not available in SBML Level 1 nor in Level 3. See also Species, ListOfSpeciesTypes, CompartmentType, ListOfCompartmentTypes. """ __swig_setmethods__ = {} for _s in [SBase]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, SpeciesType, name, value) __swig_getmethods__ = {} for _s in [SBase]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, SpeciesType, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_SpeciesType __del__ = lambda self: None def __init__(self, *args): """ __init__(SpeciesType self, unsigned int level, unsigned int version) -> SpeciesType __init__(SpeciesType self, SBMLNamespaces sbmlns) -> SpeciesType __init__(SpeciesType self, SpeciesType orig) -> SpeciesType This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: SpeciesType(SBMLNamespaces sbmlns) Creates a new SpeciesType using the given SBMLNamespaces object 'sbmlns'. The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments. It is worth emphasizing that although this constructor does not take an identifier argument, in SBML Level 2 and beyond, the 'id' (identifier) attribute of a SpeciesType object is required to have a value. Thus, callers are cautioned to assign a value after calling this constructor. Setting the identifier can be accomplished using the method SBase.setId(). Parameter 'sbmlns' is an SBMLNamespaces object. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: SpeciesType(long level, long version) Creates a new SpeciesType using the given SBML 'level' and 'version' values. Parameter 'level' is a long integer, the SBML Level to assign to this SpeciesType. Parameter 'version' is a long integer, the SBML Version to assign to this SpeciesType. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: SpeciesType(SpeciesType orig) Copy constructor; creates a copy of this SpeciesType. Parameter 'orig' is the object to copy. """ this = _libsbml.new_SpeciesType(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(SpeciesType self) -> SpeciesType Creates and returns a deep copy of this SpeciesType object. Returns the (deep) copy of this SpeciesType object. """ return _libsbml.SpeciesType_clone(self) def getId(self): """ getId(SpeciesType self) -> string Returns the value of the 'id' attribute of this SpeciesType. Note: Because of the inconsistent behavior of this function with respect to assignments and rules, it is now recommended to use the getIdAttribute() function instead. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Returns the id of this SpeciesType. See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(). """ return _libsbml.SpeciesType_getId(self) def getName(self): """ getName(SpeciesType self) -> string Returns the value of the 'name' attribute of this SpeciesType object. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns the name of this SBML object, or the empty string if not set or unsettable. See also getIdAttribute(), isSetName(), setName(), unsetName(). """ return _libsbml.SpeciesType_getName(self) def isSetId(self): """ isSetId(SpeciesType self) -> bool Predicate returning 'True' if this SpeciesType's 'id' attribute is set. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Returns 'True' if the 'id' attribute of this SBML object is set, 'False' otherwise. Note: Because of the inconsistent behavior of this function with respect to assignments and rules, it is recommended that callers use isSetIdAttribute() instead. See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(), isSetIdAttribute(). """ return _libsbml.SpeciesType_isSetId(self) def isSetName(self): """ isSetName(SpeciesType self) -> bool Predicate returning 'True' if this SpeciesType's 'name' attribute is set. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns 'True' if the 'name' attribute of this SBML object is set, 'False' otherwise. See also getName(), setName(), unsetName(). """ return _libsbml.SpeciesType_isSetName(self) def setId(self, sid): """ setId(SpeciesType self, string sid) -> int Sets the value of the 'id' attribute of this SpeciesType. The string 'sid' is copied. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Parameter 'sid' is the string to use as the identifier of this object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE * LIBSBML_UNEXPECTED_ATTRIBUTE See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(). """ return _libsbml.SpeciesType_setId(self, sid) def setName(self, name): """ setName(SpeciesType self, string name) -> int Sets the value of the 'name' attribute of this SpeciesType. The string in 'name' is copied. Parameter 'name' is the new name for the SBML object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.SpeciesType_setName(self, name) def unsetName(self): """ unsetName(SpeciesType self) -> int Unsets the value of the 'name' attribute of this SpeciesType. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also getName(), setName(), isSetName(). """ return _libsbml.SpeciesType_unsetName(self) def getTypeCode(self): """ getTypeCode(SpeciesType self) -> int Returns the libSBML type code for this SBML object. LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for this object: SBML_SPECIES_TYPE (default). WARNING: The specific integer values of the possible type codes may be reused by different libSBML plug-ins for SBML Level 3. packages, To fully identify the correct code, it is necessary to invoke both getPackageName() and getTypeCode() (or ListOf.getItemTypeCode()). See also getElementName(), getPackageName(). """ return _libsbml.SpeciesType_getTypeCode(self) def getElementName(self): """ getElementName(SpeciesType self) -> string Returns the XML element name of this object, which for SpeciesType, is always ''compartmentType'.' Returns the name of this element, i.e., ''compartmentType'.' """ return _libsbml.SpeciesType_getElementName(self) def hasRequiredAttributes(self): """ hasRequiredAttributes(SpeciesType self) -> bool Predicate returning 'True' if all the required attributes for this SpeciesType object have been set. The required attributes for a SpeciesType object are: * 'id' Returns 'True' if the required attributes have been set, 'False' otherwise. """ return _libsbml.SpeciesType_hasRequiredAttributes(self) SpeciesType_swigregister = _libsbml.SpeciesType_swigregister SpeciesType_swigregister(SpeciesType) class ListOfSpeciesTypes(ListOf): """ A list of SpeciesType objects. The various ListOf___ classes in SBML are merely containers used for organizing the main components of an SBML model. In libSBML's implementation, ListOf___ classes are derived from the intermediate utility class ListOf, which is not defined by the SBML specifications but serves as a useful programmatic construct. ListOf is itself is in turn derived from SBase, which provides all of the various ListOf___ classes with common features defined by the SBML specification, such as 'metaid' attributes and annotations. The relationship between the lists and the rest of an SBML model is illustrated by the following (for SBML Level 2 Version 4): ... ... ... ... ... ... ... elements of subclasses of Rule ... ... ... ... SBML Level 3 Version 1 has essentially the same structure as Level 2 Version 4, depicted above, but SBML Level 3 Version 2 allows containers to contain zero or more of the relevant object, instead of requiring at least one. As such, libsbml will write out an otherwise-empty ListOf___ element that has any optional attribute set (such as 'id' or 'metaid'), that has an optional child (such as a 'notes' or 'annotation'), or that has attributes or children set from any SBML Level 3 package, whether or not the ListOf___ has any other children. Readers may wonder about the motivations for using the ListOf___ containers in SBML. A simpler approach in XML might be to place the components all directly at the top level of the model definition. The choice made in SBML is to group them within XML elements named after ListOfClassname, in part because it helps organize the components. More importantly, the fact that the container classes are derived from SBase means that software tools can add information about the lists themselves into each list container's 'annotation'. See also ListOfFunctionDefinitions, ListOfUnitDefinitions, ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments, ListOfSpecies, ListOfParameters, ListOfInitialAssignments, ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents. """ __swig_setmethods__ = {} for _s in [ListOf]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfSpeciesTypes, name, value) __swig_getmethods__ = {} for _s in [ListOf]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, ListOfSpeciesTypes, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(ListOfSpeciesTypes self, unsigned int level, unsigned int version) -> ListOfSpeciesTypes __init__(ListOfSpeciesTypes self, SBMLNamespaces sbmlns) -> ListOfSpeciesTypes This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: ListOfSpeciesTypes(SBMLNamespaces sbmlns) Creates a new ListOfSpeciesTypes object. The object is constructed such that it is valid for the SBML Level and Version combination determined by the SBMLNamespaces object in 'sbmlns'. Parameter 'sbmlns' is an SBMLNamespaces object that is used to determine the characteristics of the ListOfSpeciesTypes object to be created. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: ListOfSpeciesTypes(long level, long version) Creates a new ListOfSpeciesTypes object. The object is constructed such that it is valid for the given SBML Level and Version combination. Parameter 'level' is the SBML Level. Parameter 'version' is the Version within the SBML Level. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. """ this = _libsbml.new_ListOfSpeciesTypes(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(ListOfSpeciesTypes self) -> ListOfSpeciesTypes Creates and returns a deep copy of this ListOfSpeciesTypes object. Returns the (deep) copy of this ListOfSpeciesTypes object. """ return _libsbml.ListOfSpeciesTypes_clone(self) def getItemTypeCode(self): """ getItemTypeCode(ListOfSpeciesTypes self) -> int Returns the libSBML type code for the objects contained in this ListOf (i.e., SpeciesType objects, if the list is non-empty). LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for objects contained in this list: SBML_SPECIES_TYPE (default). See also getElementName(), getPackageName(). """ return _libsbml.ListOfSpeciesTypes_getItemTypeCode(self) def getElementName(self): """ getElementName(ListOfSpeciesTypes self) -> string Returns the XML element name of this object. For ListOfSpeciesTypes, the XML element name is ''listOfSpeciesTypes'.' Returns the name of this element, i.e., ''listOfSpeciesTypes'.' """ return _libsbml.ListOfSpeciesTypes_getElementName(self) def get(self, *args): """ get(ListOfSpeciesTypes self, unsigned int n) -> SpeciesType get(ListOfSpeciesTypes self, unsigned int n) -> SpeciesType get(ListOfSpeciesTypes self, string sid) -> SpeciesType get(ListOfSpeciesTypes self, string sid) -> SpeciesType This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: get(long n) Get a SpeciesType from the ListOfSpeciesTypes. Parameter 'n' is the index number of the SpeciesType to get. Returns the nth SpeciesType in this ListOfSpeciesTypes. If the index 'n' is invalid, 'None' is returned. See also size(). ______________________________________________________________________ Method variant with the following signature: get(string sid) Get a SpeciesType from the ListOfSpeciesTypes based on its identifier. Parameter 'sid' is a string representing the identifier of the SpeciesType to get. Returns SpeciesType in this ListOfSpeciesTypes with the given 'sid' or 'None' if no such SpeciesType exists. See also get(), size(). """ return _libsbml.ListOfSpeciesTypes_get(self, *args) def remove(self, *args): """ remove(ListOfSpeciesTypes self, unsigned int n) -> SpeciesType remove(ListOfSpeciesTypes self, string sid) -> SpeciesType This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: remove(long n) Removes the nth item from this ListOfSpeciesTypes items and returns a pointer to it. The caller owns the returned item and is responsible for deleting it. Parameter 'n' is the index of the item to remove. See also size(). ______________________________________________________________________ Method variant with the following signature: remove(string sid) Removes item in this ListOfSpeciesTypes items with the given identifier. The caller owns the returned item and is responsible for deleting it. If none of the items in this list have the identifier 'sid', then 'None' is returned. Parameter 'sid' is the identifier of the item to remove. Returns the item removed. As mentioned above, the caller owns the returned item. """ return _libsbml.ListOfSpeciesTypes_remove(self, *args) __swig_destroy__ = _libsbml.delete_ListOfSpeciesTypes __del__ = lambda self: None ListOfSpeciesTypes_swigregister = _libsbml.ListOfSpeciesTypes_swigregister ListOfSpeciesTypes_swigregister(ListOfSpeciesTypes) class Compartment(SBase): """ An SBML compartment, where species are located. A compartment in SBML represents a bounded space in which species are located. Compartments do not necessarily have to correspond to actual structures inside or outside of a biological cell. It is important to note that although compartments are optional in the overall definition of Model, every species in an SBML model must be located in a compartment. This in turn means that if a model defines any species, the model must also define at least one compartment. The reason is simply that species represent physical things, and therefore must exist somewhere. Compartments represent the somewhere. Compartment has one required attribute, 'id', to give the compartment a unique identifier by which other parts of an SBML model definition can refer to it. A compartment can also have an optional 'name' attribute of type 'string.' Identifiers and names must be used according to the guidelines described in the SBML specifications. Compartment also has an optional attribute 'spatialDimensions' that is used to indicate the number of spatial dimensions possessed by the compartment. Most modeling scenarios involve compartments with integer values of 'spatialDimensions' of '3' (i.e., a three- dimensional compartment, which is to say, a volume), or 2 (a two- dimensional compartment, a surface), or '1' (a one-dimensional compartment, a line). In SBML Level 3, the type of this attribute is 'float,' there are no restrictions on the permitted values of the 'spatialDimensions' attribute, and there are no default values. In SBML Level 2, the value must be a positive 'integer,' and the default value is '3;' the permissible values in SBML Level 2 are '3,' '2,' '1,' and '0' (for a point). Another optional attribute on Compartment is 'size', representing the initial total size of that compartment in the model. The 'size' attribute must be a floating-point value and may represent a volume (if the compartment is a three-dimensional one), or an area (if the compartment is two-dimensional), or a length (if the compartment is one-dimensional). There is no default value of compartment size in SBML Level 2 or Level 3. In particular, a missing 'size' value does not imply that the compartment size is 1. (This is unlike the definition of compartment 'volume' in SBML Level 1.) When the compartment's 'spatialDimensions' attribute does not have a value of '0,' a missing value of 'size' for a given compartment signifies that the value either is unknown, or to be obtained from an external source, or determined by an InitialAssignment, AssignmentRule, AlgebraicRule or RateRule object elsewhere in the model. In SBML Level 2, there are additional special requirements on the values of 'size'; we discuss them in a separate section below. The units associated with a compartment's 'size' attribute value may be set using the optional attribute 'units'. The rules for setting and using compartment size units differ between SBML Level 2 and Level 3, and are discussed separately below. Finally, the Compartment attribute named 'constant' is used to indicate whether the compartment's size stays constant after simulation begins. A value of 'True' indicates the compartment's 'size' cannot be changed by any other construct except InitialAssignment; a value of 'False' indicates the compartment's 'size' can be changed by other constructs in SBML. In SBML Level 2, there is an additional explicit restriction that if 'spatialDimensions'=''0',' the value cannot be changed by InitialAssignment either. Further, in Level 2, 'constant' is optional, and has a default value of 'True.' In SBML Level 3, there is no default value for the 'constant' attribute, and it is required. Additional considerations in SBML Level 2 ====================================================================== In SBML Level 2, the default units of compartment size, and the kinds of units allowed as values of the attribute 'units', interact with the number of spatial dimensions of the compartment. The value of the 'units' attribute of a Compartment object must be one of the base units (see Unit), or the predefined unit identifiers 'volume,' 'area,' 'length' or 'dimensionless,' or a new unit defined by a UnitDefinition object in the enclosing Model, subject to the restrictions detailed in the following table: +----------------------------+---------------+----------------+-----------------------------------+----------------------------------+ | Value of spatialDimensions | size allowed? | units allowed? | Allowable kinds of units | Default value of attribute units | +----------------------------+---------------+----------------+-----------------------------------+----------------------------------+ | 3 | yes | yes | units of volume, or dimensionless | volume | | 2 | yes | yes | units of area, or dimensionless | area | | 1 | yes | yes | units of length, or dimensionless | length | | 0 | no | no | (no units allowed) | | +----------------------------+---------------+----------------+-----------------------------------+----------------------------------+ In SBML Level 2, the units of the compartment size, as defined by the 'units' attribute or (if 'units' is not set) the default value listed in the table above, are used in the following ways when the compartment has a 'spatialDimensions' value greater than '0:' * The value of the 'units' attribute is used as the units of the compartment identifier when the identifier appears as a numerical quantity in a mathematical formula expressed in MathML. * The 'math' element of an AssignmentRule or InitialAssignment referring to this compartment must (in Level 2 Versions 1-3) or should (in Level 2 Version 4) have identical units. * In RateRule objects that set the rate of change of the compartment's size, the units of the rule's 'math' element must (in Level 2 Versions 1-3) or should (in Level 2 Version 4) be identical to the compartment's units (whether defined by the 'units' attribute or by taking the default value from the Model) divided by the default time units. (In other words, the units for the rate of change of compartment size are compartment size/time units. * When a Species is to be treated in terms of concentrations or density, the units of the spatial size portion of the concentration value (i.e., the denominator in the units formula substance/size) are those indicated by the value of the 'units' attribute on the compartment in which the species is located. Compartments with 'spatialDimensions'='0' require special treatment in this framework. As implied above, the 'size' attribute must not have a value on an SBML Level 2 Compartment object if the 'spatialDimensions' attribute has a value of '0.' An additional related restriction is that the 'constant' attribute must default to or be set to 'True' if the value of the 'spatialDimensions' attribute is '0,' because a zero- dimensional compartment cannot ever have a size. If a compartment has no size or dimensional units, how should such a compartment's identifier be interpreted when it appears in mathematical formulas? The answer is that such a compartment's identifier should not appear in mathematical formulas in the first place---it has no value, and its value cannot change. Note also that a zero-dimensional compartment is a point, and species located at points can only be described in terms of amounts, not spatially- dependent measures such as concentration. Since SBML KineticLaw formulas are already in terms of substance/time and not (say) concentration/time, volume or other factors in principle are not needed for species located in zero-dimensional compartments. Finally, in SBML Level 2 Versions 2-4, each compartment in a model may optionally be designated as belonging to a particular compartment type. The optional attribute 'compartmentType' is used identify the compartment type represented by the Compartment structure. The 'compartmentType' attribute's value must be the identifier of a CompartmentType instance defined in the model. If the 'compartmentType' attribute is not present on a particular compartment definition, a unique virtual compartment type is assumed for that compartment, and no other compartment can belong to that compartment type. The values of 'compartmentType' attributes on compartments have no effect on the numerical interpretation of a model. Simulators and other numerical analysis software may ignore 'compartmentType' attributes. The 'compartmentType' attribute and the CompartmentType class of objects are not present in SBML Level 3 Core nor in SBML Level 1. Additional considerations in SBML Level 3 ====================================================================== One difference between SBML Level 3 and lower Levels of SBML is that there are no restrictions on the permissible values of the 'spatialDimensions' attribute, and there is no default value defined for the attribute. The value of 'spatialDimensions' does not have to be an integer, either; this is to allow for the possibility of representing structures with fractal dimensions. The number of spatial dimensions possessed by a compartment cannot enter into mathematical formulas, and therefore cannot directly alter the numerical interpretation of a model. However, the value of 'spatialDimensions' does affect the interpretation of the units associated with a compartment's size. Specifically, the value of 'spatialDimensions' is used to select among the Model attributes 'volumeUnits', 'areaUnits' and 'lengthUnits' when a Compartment structure does not define a value for its 'units' attribute. The 'units' attribute may be left unspecified for a given compartment in a model; in that case, the compartment inherits the unit of measurement specified by one of the attributes on the enclosing Model object instance. The applicable attribute on Model depends on the value of the compartment's 'spatialDimensions' attribute; the relationship is shown in the table below. If the Model object does not define the relevant attribute ('volumeUnits', 'areaUnits' or 'lengthUnits') for a given 'spatialDimensions' value, the unit associated with that Compartment object's size is undefined. If a given Compartment's 'units' are left unset and the 'spatialDimensions' either has a value other than '1,' '2,' or '3' or is left unset itself (as it has no default value), then no unit can be chosen from among the Model's 'volumeUnits', 'areaUnits' or 'lengthUnits' attributes (even if the Model instance provides values for those attributes), because there is no basis to select between them. Leaving the units of compartments' sizes undefined in an SBML model does not render the model invalid; however, as a matter of best practice, we strongly recommend that all models specify the units of measurement for all compartment sizes. +----------------------------------------+-------------------------------------------------+-----------------------------------+ | Value of attribute 'spatialDimensions' | Attribute of Model used for inheriting the unit | Recommended candidate units | +----------------------------------------+-------------------------------------------------+-----------------------------------+ | 3 | "volumeUnits" | units of volume, or dimensionless | | 2 | "areaUnits" | units of area, or dimensionless | | 1 | "lengthUnits" | units of length, or dimensionless | | other | no units inherited | no specific recommendations | +----------------------------------------+-------------------------------------------------+-----------------------------------+ The unit of measurement associated with a compartment's size, as defined by the 'units' attribute or (if 'units' is not set) the inherited value from Model according to the table above, is used in the following ways: * When the identifier of the compartment appears as a numerical quantity in a mathematical formula expressed in MathML, it represents the size of the compartment, and the unit associated with the size is the value of the 'units' attribute. * When a Species is to be treated in terms of concentrations or density, the unit associated with the spatial size portion of the concentration value (i.e., the denominator in the formula amount/size) is specified by the value of the 'units' attribute on the compartment in which the species is located. * The 'math' elements of AssignmentRule, InitialAssignment and EventAssignment objects setting the value of the compartment size should all have the same units as the unit associated with the compartment's size. * In a RateRule object that defines a rate of change for a compartment's size, the unit of the rule's 'math' element should be identical to the compartment's 'units' attribute divided by the model- wide unit of time. (In other words, {unit of compartment size}/{unit of time}.) Other aspects of Compartment ====================================================================== In SBML Level 1 and Level 2, Compartment has an optional attribute named 'outside', whose value can be the identifier of another Compartment object defined in the enclosing Model object. Doing so means that the other compartment contains it or is outside of it. This enables the representation of simple topological relationships between compartments, for those simulation systems that can make use of the information (e.g., for drawing simple diagrams of compartments). It is worth noting that in SBML, there is no relationship between compartment sizes when compartment positioning is expressed using the 'outside' attribute. The size of a given compartment does not in any sense include the sizes of other compartments having it as the value of their 'outside' attributes. In other words, if a compartment B has the identifier of compartment A as its 'outside' attribute value, the size of A does not include the size of B. The compartment sizes are separate. In Level 2, there are two restrictions on the 'outside' attribute. First, because a compartment with 'spatialDimensions' of '0' has no size, such a compartment cannot act as the container of any other compartment except compartments that also have 'spatialDimensions' values of '0.' Second, the directed graph formed by representing Compartment structures as vertexes and the 'outside' attribute values as edges must be acyclic. The latter condition is imposed to prevent a compartment from being contained inside itself. In the absence of a value for 'outside', compartment definitions in SBML Level 2 do not have any implied spatial relationships between each other. """ __swig_setmethods__ = {} for _s in [SBase]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, Compartment, name, value) __swig_getmethods__ = {} for _s in [SBase]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, Compartment, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_Compartment __del__ = lambda self: None def __init__(self, *args): """ __init__(Compartment self, unsigned int level, unsigned int version) -> Compartment __init__(Compartment self, SBMLNamespaces sbmlns) -> Compartment __init__(Compartment self, Compartment orig) -> Compartment This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: Compartment(SBMLNamespaces sbmlns) Creates a new Compartment object using the given SBMLNamespaces object 'sbmlns'. The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments. It is worth emphasizing that although this constructor does not take an identifier argument, in SBML Level 2 and beyond, the 'id' (identifier) attribute of a Compartment object is required to have a value. Thus, callers are cautioned to assign a value after calling this constructor. Setting the identifier can be accomplished using the method setId(). Parameter 'sbmlns' is an SBMLNamespaces object. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: Compartment(long level, long version) Creates a new Compartment object using the given SBML 'level' and 'version' values. Parameter 'level' is a long integer, the SBML Level to assign to this Compartment. Parameter 'version' is a long integer, the SBML Version to assign to this Compartment. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: Compartment(Compartment orig) Copy constructor. This creates a copy of a Compartment object. Parameter 'orig' is the Compartment instance to copy. """ this = _libsbml.new_Compartment(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(Compartment self) -> Compartment Creates and returns a deep copy of this Compartment object. Returns the (deep) copy of this Compartment object. """ return _libsbml.Compartment_clone(self) def initDefaults(self): """ initDefaults(Compartment self) Initializes the fields of this Compartment object to 'typical' default values. The SBML Compartment component has slightly different aspects and default attribute values in different SBML Levels and Versions. This method sets the values to certain common defaults, based mostly on what they are in SBML Level 2. Specifically: * Sets attribute 'spatialDimensions' to '3' * Sets attribute 'constant' to 'True' * (Applies to Level 1 models only) Sets attribute 'volume' to '1.0' * (Applies to Level 3 models only) Sets attribute 'units' to 'litre' """ return _libsbml.Compartment_initDefaults(self) def getId(self): """ getId(Compartment self) -> string Returns the value of the 'id' attribute of this Compartment. Note: Because of the inconsistent behavior of this function with respect to assignments and rules, it is now recommended to use the getIdAttribute() function instead. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Returns the id of this Compartment. See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(). """ return _libsbml.Compartment_getId(self) def getName(self): """ getName(Compartment self) -> string Returns the value of the 'name' attribute of this Compartment object. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns the name of this SBML object, or the empty string if not set or unsettable. See also getIdAttribute(), isSetName(), setName(), unsetName(). """ return _libsbml.Compartment_getName(self) def getCompartmentType(self): """ getCompartmentType(Compartment self) -> string Get the value of the 'compartmentType' attribute of this Compartment object. Returns the value of the 'compartmentType' attribute of this Compartment object as a string. Note: The 'compartmentType' attribute is only available in SBML Level 2 Versions 2-4. See also isSetCompartmentType(), setCompartmentType(), unsetCompartmentType(). """ return _libsbml.Compartment_getCompartmentType(self) def getSpatialDimensions(self): """ getSpatialDimensions(Compartment self) -> unsigned int Get the number of spatial dimensions of this Compartment object. Returns the value of the 'spatialDimensions' attribute of this Compartment object as a long integereger. Note: In SBML Level 3, the data type of the 'spatialDimensions' attribute is 'float,' whereas in Level 2, it is 'integer.' To avoid backward compatibility issues, libSBML provides two separate methods for obtaining the value as either an integer or a type 'float,' for models where it is relevant. See also getSpatialDimensionsAsDouble(), setSpatialDimensions(), isSetSpatialDimensions(), unsetSpatialDimensions(). """ return _libsbml.Compartment_getSpatialDimensions(self) def getSpatialDimensionsAsDouble(self): """ getSpatialDimensionsAsDouble(Compartment self) -> double Get the number of spatial dimensions of this Compartment object, as a double. Returns the value of the 'spatialDimensions' attribute of this Compartment object as a double, or 'NaN' if this model is not in SBML Level 3 format. Note: In SBML Level 3, the data type of the 'spatialDimensions' attribute is 'float,' whereas in Level 2, it is 'integer.' To avoid backward compatibility issues, libSBML provides two separate methods for obtaining the value as either an integer or a type 'float,' for models where it is relevant. See also getSpatialDimensions(), setSpatialDimensions(), isSetSpatialDimensions(), unsetSpatialDimensions(). """ return _libsbml.Compartment_getSpatialDimensionsAsDouble(self) def getSize(self): """ getSize(Compartment self) -> double Get the size of this Compartment object. In SBML Level 1, compartments are always three-dimensional constructs and only have volumes, whereas in SBML Level 2 and higher, compartments may be other than three-dimensional, and therefore the 'volume' attribute is named 'size' in Level 2 and above. LibSBML provides both getSize() and getVolume() for easier support of different SBML Levels. Returns the value of the 'size' attribute ('volume' in Level 1) of this Compartment object as a floating-point number. Note: This method is identical to getVolume(). See also getVolume(), isSetSize(), setSize(), unsetSize(). """ return _libsbml.Compartment_getSize(self) def getVolume(self): """ getVolume(Compartment self) -> double Get the volume of this Compartment object. In SBML Level 1, compartments are always three-dimensional constructs and only have volumes, whereas in SBML Level 2 and higher, compartments may be other than three-dimensional, and therefore the 'volume' attribute is named 'size' in Level 2 and above. LibSBML provides both getSize() and getVolume() for easier support of different SBML Levels. Returns the value of the 'volume' attribute ('size' in Level 2) of this Compartment object, as a floating-point number. Note: The attribute 'volume' only exists by that name in SBML Level 1. In Level 2 and above, the equivalent attribute is named 'size'. In SBML Level 1, a compartment's volume has a default value ('1.0)' and therefore methods such as isSetVolume() will always return 'True' for a Level 1 model. In Level 2, a compartment's size (the equivalent of SBML Level 1's 'volume') is optional and has no default value, and therefore may or may not be set. Note: This method is identical to getSize(). See also getSize(), isSetVolume(), setVolume(), unsetVolume(). """ return _libsbml.Compartment_getVolume(self) def getUnits(self): """ getUnits(Compartment self) -> string Get the units of this Compartment object's size. The value of an SBML compartment's 'units' attribute establishes the unit of measurement associated with the compartment's size. Returns the value of the 'units' attribute of this Compartment object, as a string. An empty string indicates that no units have been assigned to the value of the size. Note: There is an important distinction to be made between no units assigned, and assuming a value without units has any specific unit such as dimensionless. In SBML, default units are never attributed to numbers, and numbers without units are not automatically assumed to have the unit dimensionless. Please consult the relevant SBML specification document for a more in-depth explanation of this topic and the SBML unit system. See also isSetUnits(), setUnits(), unsetUnits(). """ return _libsbml.Compartment_getUnits(self) def getOutside(self): """ getOutside(Compartment self) -> string Get the identifier, if any, of the Compartment object that is designated as being outside of this one. Returns the value of the 'outside' attribute of this Compartment object. Note: The 'outside' attribute is defined in SBML Level 1 and Level 2, but does not exist in SBML Level 3. See also isSetOutside(), setOutside(), unsetOutside(). """ return _libsbml.Compartment_getOutside(self) def getConstant(self): """ getConstant(Compartment self) -> bool Get the value of the 'constant' attribute of this Compartment object. Returns 'True' if this Compartment object's size is flagged as being constant, 'False' otherwise. See also isSetConstant(), setConstant(). """ return _libsbml.Compartment_getConstant(self) def isSetId(self): """ isSetId(Compartment self) -> bool Predicate returning 'True' if this Compartment object's 'id' attribute is set. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Returns 'True' if the 'id' attribute of this SBML object is set, 'False' otherwise. Note: Because of the inconsistent behavior of this function with respect to assignments and rules, it is recommended that callers use isSetIdAttribute() instead. See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(), isSetIdAttribute(). """ return _libsbml.Compartment_isSetId(self) def isSetName(self): """ isSetName(Compartment self) -> bool Predicate returning 'True' if this Compartment object's 'name' attribute is set. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns 'True' if the 'name' attribute of this SBML object is set, 'False' otherwise. See also getName(), setName(), unsetName(). """ return _libsbml.Compartment_isSetName(self) def isSetCompartmentType(self): """ isSetCompartmentType(Compartment self) -> bool Predicate returning 'True' if this Compartment object's 'compartmentType' attribute is set. Returns 'True' if the 'compartmentType' attribute of this Compartment is set, 'False' otherwise. Note: The 'compartmentType' attribute is only available in SBML Level 2 Versions 2-4. See also setCompartmentType(), getCompartmentType(), unsetCompartmentType(). """ return _libsbml.Compartment_isSetCompartmentType(self) def isSetSize(self): """ isSetSize(Compartment self) -> bool Predicate returning 'True' if this Compartment object's 'size' attribute is set. This method is similar but not identical to isSetVolume(). The latter should be used in the context of SBML Level 1 models instead of isSetSize() because isSetVolume() performs extra processing to take into account the difference in default values between SBML Levels 1 and 2. Returns 'True' if the 'size' attribute ('volume' in Level 2) of this Compartment object is set, 'False' otherwise. See also isSetVolume(), setSize(), getSize(), unsetSize(). """ return _libsbml.Compartment_isSetSize(self) def isSetVolume(self): """ isSetVolume(Compartment self) -> bool Predicate returning 'True' if this Compartment object's 'volume' attribute is set. This method is similar but not identical to isSetSize(). The latter should not be used in the context of SBML Level 1 models because the present method performs extra processing to take into account the difference in default values between SBML Levels 1 and 2. Returns 'True' if the 'volume' attribute ('size' in Level 2 and above) of this Compartment object is set, 'False' otherwise. Note: The attribute 'volume' only exists by that name in SBML Level 1. In Level 2 and above, the equivalent attribute is named 'size'. In SBML Level 1, a compartment's volume has a default value ('1.0)' and therefore methods such as isSetVolume() will always return 'True' for a Level 1 model. In Level 2, a compartment's size (the equivalent of SBML Level 1's 'volume') is optional and has no default value, and therefore may or may not be set. See also isSetSize(), getVolume(), setVolume(), unsetVolume(). """ return _libsbml.Compartment_isSetVolume(self) def isSetUnits(self): """ isSetUnits(Compartment self) -> bool Predicate returning 'True' if this Compartment object's 'units' attribute is set. Returns 'True' if the 'units' attribute of this Compartment object is set, 'False' otherwise. Note: There is an important distinction to be made between no units assigned, and assuming a value without units has any specific unit such as dimensionless. In SBML, default units are never attributed to numbers, and numbers without units are not automatically assumed to have the unit dimensionless. Please consult the relevant SBML specification document for a more in-depth explanation of this topic and the SBML unit system. See also setUnits(), getUnits(), unsetUnits(). """ return _libsbml.Compartment_isSetUnits(self) def isSetOutside(self): """ isSetOutside(Compartment self) -> bool Predicate returning 'True' if this Compartment object's 'outside' attribute is set. Returns 'True' if the 'outside' attribute of this Compartment object is set, 'False' otherwise. Note: The 'outside' attribute is defined in SBML Level 1 and Level 2, but does not exist in SBML Level 3. See also getOutside(), setOutside(), unsetOutside(). """ return _libsbml.Compartment_isSetOutside(self) def isSetSpatialDimensions(self): """ isSetSpatialDimensions(Compartment self) -> bool Predicate returning 'True' if this Compartment object's 'spatialDimensions' attribute is set. Returns 'True' if the 'spatialDimensions' attribute of this Compartment object is set, 'False' otherwise. See also getSpatialDimensions(), setSpatialDimensions(), unsetSpatialDimensions(). """ return _libsbml.Compartment_isSetSpatialDimensions(self) def isSetConstant(self): """ isSetConstant(Compartment self) -> bool Predicate returning 'True' if this Compartment object's 'constant' attribute is set. Returns 'True' if the 'constant' attribute of this Compartment object is set, 'False' otherwise. See also getConstant(), setConstant(). """ return _libsbml.Compartment_isSetConstant(self) def setId(self, sid): """ setId(Compartment self, string sid) -> int Sets the value of the 'id' attribute of this Compartment object. The string 'sid' is copied. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Parameter 'sid' is the string to use as the identifier of this Compartment object. If the string is 'None,' this method will return LIBSBML_INVALID_ATTRIBUTE_VALUE. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE See also getId(), unsetId(), isSetId(). """ return _libsbml.Compartment_setId(self, sid) def setName(self, name): """ setName(Compartment self, string name) -> int Sets the value of the 'name' attribute of this Compartment object. The string in 'name' is copied. Parameter 'name' is the new name for the SBML object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.Compartment_setName(self, name) def setCompartmentType(self, sid): """ setCompartmentType(Compartment self, string sid) -> int Sets the 'compartmentType' attribute of this Compartment object. Parameter 'sid' is the identifier of a CompartmentType object defined elsewhere in this Model. If the string is 'None,' this method will return LIBSBML_INVALID_ATTRIBUTE_VALUE. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE * LIBSBML_UNEXPECTED_ATTRIBUTE Note: The 'compartmentType' attribute is only available in SBML Level 2 Versions 2-4. See also isSetCompartmentType(), getCompartmentType(), unsetCompartmentType(). """ return _libsbml.Compartment_setCompartmentType(self, sid) def setSpatialDimensions(self, *args): """ setSpatialDimensions(Compartment self, unsigned int value) -> int setSpatialDimensions(Compartment self, double value) -> int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: setSpatialDimensions(double value) Sets the 'spatialDimensions' attribute of this Compartment object as a double. Parameter 'value' is a double indicating the number of dimensions of this compartment. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE * LIBSBML_UNEXPECTED_ATTRIBUTE See also getSpatialDimensions(), isSetSpatialDimensions(), unsetSpatialDimensions(). ______________________________________________________________________ Method variant with the following signature: setSpatialDimensions(long value) Sets the 'spatialDimensions' attribute of this Compartment object. Parameter 'value' is a long integereger indicating the number of dimensions of this compartment. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE * LIBSBML_UNEXPECTED_ATTRIBUTE See also getSpatialDimensions(), isSetSpatialDimensions(), unsetSpatialDimensions(). """ return _libsbml.Compartment_setSpatialDimensions(self, *args) def setSize(self, value): """ setSize(Compartment self, double value) -> int Sets the 'size' attribute (or 'volume' in SBML Level 1) of this Compartment object. Parameter 'value' is a 'float' representing the size of this compartment instance in whatever units are in effect for the compartment. Returns integer value indicating success/failure of the function. This particular function only does one thing irrespective of user input or object state, and thus will only return a single value: * LIBSBML_OPERATION_SUCCESS Note: This method is identical to setVolume(). See also setVolume(), getSize(), isSetSize(), unsetSize(). """ return _libsbml.Compartment_setSize(self, value) def setVolume(self, value): """ setVolume(Compartment self, double value) -> int Sets the 'volume' attribute (or 'size' in SBML Level 2) of this Compartment object. This method is identical to setSize() and is provided for compatibility between SBML Level 1 and higher Levels of SBML. Parameter 'value' is a 'float' representing the volume of this compartment instance in whatever units are in effect for the compartment. Returns integer value indicating success/failure of the function. This particular function only does one thing irrespective of user input or object state, and thus will only return a single value: * LIBSBML_OPERATION_SUCCESS Note: The attribute 'volume' only exists by that name in SBML Level 1. In Level 2 and above, the equivalent attribute is named 'size'. In SBML Level 1, a compartment's volume has a default value ('1.0)' and therefore methods such as isSetVolume() will always return 'True' for a Level 1 model. In Level 2, a compartment's size (the equivalent of SBML Level 1's 'volume') is optional and has no default value, and therefore may or may not be set. See also setSize(), getVolume(), isSetVolume(), unsetVolume(). """ return _libsbml.Compartment_setVolume(self, value) def setUnits(self, sid): """ setUnits(Compartment self, string sid) -> int Sets the 'units' attribute of this Compartment object. Parameter 'sid' is the identifier of the defined units to use. If 'sid' is 'None,' then this method will return LIBSBML_INVALID_ATTRIBUTE_VALUE. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE See also isSetUnits(), getUnits(), unsetUnits(). """ return _libsbml.Compartment_setUnits(self, sid) def setOutside(self, sid): """ setOutside(Compartment self, string sid) -> int Sets the 'outside' attribute of this Compartment object. Parameter 'sid' is the identifier of a compartment that encloses this one. If 'sid' is 'None,' then this method will return LIBSBML_INVALID_ATTRIBUTE_VALUE. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE Note: The 'outside' attribute is defined in SBML Level 1 and Level 2, but does not exist in SBML Level 3. See also isSetOutside(), getOutside(), unsetOutside(). """ return _libsbml.Compartment_setOutside(self, sid) def setConstant(self, value): """ setConstant(Compartment self, bool value) -> int Sets the value of the 'constant' attribute of this Compartment object. Parameter 'value' is a boolean indicating whether the size/volume of this compartment should be considered constant ('True)' or variable ('False).' Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE See also isSetConstant(), getConstant(). """ return _libsbml.Compartment_setConstant(self, value) def renameSIdRefs(self, oldid, newid): """ renameSIdRefs(Compartment self, string oldid, string newid) Replaces all uses of a given 'SIdRef' type attribute value with another value. In SBML, object identifiers are of a data type called SId. In SBML Level 3, an explicit data type called SIdRef was introduced for attribute values that refer to SId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to an identifier', but the effective data type was the same as SIdRef in Level 3. These and other methods of libSBML refer to the type SIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all attributes and (if appropriate) mathematical formulas in MathML content, comparing the referenced identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.Compartment_renameSIdRefs(self, oldid, newid) def renameUnitSIdRefs(self, oldid, newid): """ renameUnitSIdRefs(Compartment self, string oldid, string newid) Replaces all uses of a given 'UnitSIdRef' type attribute value with another value. In SBML, unit definitions have identifiers of type UnitSId. In SBML Level 3, an explicit data type called UnitSIdRef was introduced for attribute values that refer to UnitSId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to a unit identifier', but the effective data type was the same as UnitSIdRef in Level 3. These and other methods of libSBML refer to the type UnitSIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all unit identifier attribute values (including, if appropriate, inside mathematical formulas), comparing the referenced unit identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.Compartment_renameUnitSIdRefs(self, oldid, newid) def unsetName(self): """ unsetName(Compartment self) -> int Unsets the value of the 'name' attribute of this Compartment object. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also getName(), setName(), isSetName(). """ return _libsbml.Compartment_unsetName(self) def unsetCompartmentType(self): """ unsetCompartmentType(Compartment self) -> int Unsets the value of the 'compartmentType' attribute of this Compartment object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_UNEXPECTED_ATTRIBUTE Note: The 'compartmentType' attribute is only available in SBML Level 2 Versions 2-4. See also setCompartmentType(), isSetCompartmentType(), getCompartmentType(). """ return _libsbml.Compartment_unsetCompartmentType(self) def unsetConstant(self): """ unsetConstant(Compartment self) -> int Unsets the value of the 'constant' attribute of this Compartment object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also isSetConstant(), setConstant(), getConstant(). """ return _libsbml.Compartment_unsetConstant(self) def unsetSize(self): """ unsetSize(Compartment self) -> int Unsets the value of the 'size' attribute of this Compartment object. In SBML Level 1, a compartment's volume has a default value ('1.0)' and therefore should always be set. Calling this method on a Level 1 model resets the value to '1.0' rather than actually unsetting it. In Level 2, a compartment's 'size' is optional with no default value, and unsetting it will result in the compartment having no defined size. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED Note: This method is identical to unsetVolume(). See also unsetVolume(), getSize(), isSetSize(), setSize(). """ return _libsbml.Compartment_unsetSize(self) def unsetVolume(self): """ unsetVolume(Compartment self) -> int Unsets the value of the 'volume' attribute of this Compartment object. This method is identical to unsetSize(). Please refer to that method's documentation for more information about its behavior. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED Note: The attribute 'volume' only exists by that name in SBML Level 1. In Level 2 and above, the equivalent attribute is named 'size'. In SBML Level 1, a compartment's volume has a default value ('1.0)' and therefore methods such as isSetVolume() will always return 'True' for a Level 1 model. In Level 2, a compartment's size (the equivalent of SBML Level 1's 'volume') is optional and has no default value, and therefore may or may not be set. See also unsetSize(), getVolume(), setVolume(), isSetVolume(). """ return _libsbml.Compartment_unsetVolume(self) def unsetUnits(self): """ unsetUnits(Compartment self) -> int Unsets the value of the 'units' attribute of this Compartment object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also isSetUnits(), setUnits(), getUnits(). """ return _libsbml.Compartment_unsetUnits(self) def unsetOutside(self): """ unsetOutside(Compartment self) -> int Unsets the value of the 'outside' attribute of this Compartment object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED Note: The 'outside' attribute is defined in SBML Level 1 and Level 2, but does not exist in SBML Level 3. See also isSetOutside(), getOutside(), setOutside(). """ return _libsbml.Compartment_unsetOutside(self) def unsetSpatialDimensions(self): """ unsetSpatialDimensions(Compartment self) -> int Unsets the value of the 'spatialDimensions' attribute of this Compartment object. In SBML Levels prior to Level 3, compartments must always have a value for the number of dimensions. Consequently, calling this method on a model of SBML Level 1-2 will result in a return value of LIBSBML_UNEXPECTED_ATTRIBUTE Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_UNEXPECTED_ATTRIBUTE Note: This function is only valid for SBML Level 3. See also getSpatialDimensions(), isSetSpatialDimensions(), setSpatialDimensions(). """ return _libsbml.Compartment_unsetSpatialDimensions(self) def getDerivedUnitDefinition(self, *args): """ getDerivedUnitDefinition(Compartment self) -> UnitDefinition getDerivedUnitDefinition(Compartment self) -> UnitDefinition Constructs and returns a UnitDefinition that corresponds to the units of this Compartment object's designated size. Compartments in SBML have an attribute ('units') for declaring the units of measurement intended for the value of the compartment's size. In the absence of a value given for this attribute, the units are inherited from values either defined on the enclosing Model (in SBML Level 3) or in defaults (in SBML Level 2). This method returns a UnitDefinition object based on how this compartment's units are interpreted according to the relevant SBML guidelines, or it returns 'None' if no units have been declared and no defaults are defined by the relevant SBML specification. Note that unit declarations for Compartment objects are specified in terms of the identifier of a unit, but this method returns an object , not a unit identifier. It does this by constructing an appropriate UnitDefinition object. For SBML Level 2 models, it will do this even when the value of the 'units' attribute is one of the special SBML Level 2 unit identifiers ''substance',' ''volume',' ''area',' ''length'' or ''time'.' Callers may find this useful in conjunction with the helper methods provided by the UnitDefinition class for comparing different UnitDefinition objects. Returns a UnitDefinition that expresses the units of this Compartment object, or 'None' if one cannot be constructed. Note: The libSBML system for unit analysis depends on the model as a whole. In cases where the Compartment object has not yet been added to a model, or the model itself is incomplete, unit analysis is not possible, and consequently this method will return 'None.' See also isSetUnits(), getUnits(). """ return _libsbml.Compartment_getDerivedUnitDefinition(self, *args) def getTypeCode(self): """ getTypeCode(Compartment self) -> int Returns the libSBML type code for this SBML object. LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for this object: SBML_COMPARTMENT (default). WARNING: The specific integer values of the possible type codes may be reused by different libSBML plug-ins for SBML Level 3. packages, To fully identify the correct code, it is necessary to invoke both getPackageName() and getTypeCode() (or ListOf.getItemTypeCode()). See also getElementName(), getPackageName(). """ return _libsbml.Compartment_getTypeCode(self) def getElementName(self): """ getElementName(Compartment self) -> string Returns the XML element name of this object For Compartment, the XML element name is always ''compartment'.' Returns the name of this element. """ return _libsbml.Compartment_getElementName(self) def hasRequiredAttributes(self): """ hasRequiredAttributes(Compartment self) -> bool Predicate returning 'True' if all the required attributes for this Compartment object have been set. The required attributes for a Compartment object are: * 'id' (or 'name' in SBML Level 1) * 'constant' (in SBML Level 3 only) Returns 'True' if the required attributes have been set, 'False' otherwise. """ return _libsbml.Compartment_hasRequiredAttributes(self) Compartment_swigregister = _libsbml.Compartment_swigregister Compartment_swigregister(Compartment) class ListOfCompartments(ListOf): """ A list of Compartment objects. The various ListOf___ classes in SBML are merely containers used for organizing the main components of an SBML model. In libSBML's implementation, ListOf___ classes are derived from the intermediate utility class ListOf, which is not defined by the SBML specifications but serves as a useful programmatic construct. ListOf is itself is in turn derived from SBase, which provides all of the various ListOf___ classes with common features defined by the SBML specification, such as 'metaid' attributes and annotations. The relationship between the lists and the rest of an SBML model is illustrated by the following (for SBML Level 2 Version 4): ... ... ... ... ... ... ... elements of subclasses of Rule ... ... ... ... SBML Level 3 Version 1 has essentially the same structure as Level 2 Version 4, depicted above, but SBML Level 3 Version 2 allows containers to contain zero or more of the relevant object, instead of requiring at least one. As such, libsbml will write out an otherwise-empty ListOf___ element that has any optional attribute set (such as 'id' or 'metaid'), that has an optional child (such as a 'notes' or 'annotation'), or that has attributes or children set from any SBML Level 3 package, whether or not the ListOf___ has any other children. Readers may wonder about the motivations for using the ListOf___ containers in SBML. A simpler approach in XML might be to place the components all directly at the top level of the model definition. The choice made in SBML is to group them within XML elements named after ListOfClassname, in part because it helps organize the components. More importantly, the fact that the container classes are derived from SBase means that software tools can add information about the lists themselves into each list container's 'annotation'. See also ListOfFunctionDefinitions, ListOfUnitDefinitions, ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments, ListOfSpecies, ListOfParameters, ListOfInitialAssignments, ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents. """ __swig_setmethods__ = {} for _s in [ListOf]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfCompartments, name, value) __swig_getmethods__ = {} for _s in [ListOf]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, ListOfCompartments, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(ListOfCompartments self, unsigned int level, unsigned int version) -> ListOfCompartments __init__(ListOfCompartments self, SBMLNamespaces sbmlns) -> ListOfCompartments This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: ListOfCompartments(SBMLNamespaces sbmlns) Creates a new ListOfCompartments object. The object is constructed such that it is valid for the SBML Level and Version combination determined by the SBMLNamespaces object in 'sbmlns'. Parameter 'sbmlns' is an SBMLNamespaces object that is used to determine the characteristics of the ListOfCompartments object to be created. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: ListOfCompartments(long level, long version) Creates a new ListOfCompartments object. The object is constructed such that it is valid for the given SBML Level and Version combination. Parameter 'level' is the SBML Level. Parameter 'version' is the Version within the SBML Level. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. """ this = _libsbml.new_ListOfCompartments(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(ListOfCompartments self) -> ListOfCompartments Creates and returns a deep copy of this ListOfCompartments object. Returns the (deep) copy of this ListOfCompartments object. """ return _libsbml.ListOfCompartments_clone(self) def getItemTypeCode(self): """ getItemTypeCode(ListOfCompartments self) -> int Returns the libSBML type code for the objects contained in this ListOf (i.e., Compartment objects, if the list is non-empty). LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for the objects contained in this ListOf instance: SBML_COMPARTMENT (default). See also getElementName(), getPackageName(). """ return _libsbml.ListOfCompartments_getItemTypeCode(self) def getElementName(self): """ getElementName(ListOfCompartments self) -> string Returns the XML element name of this object. For ListOfCompartments, the XML element name is always ''listOfCompartments'.' Returns the name of this element. """ return _libsbml.ListOfCompartments_getElementName(self) def get(self, *args): """ get(ListOfCompartments self, unsigned int n) -> Compartment get(ListOfCompartments self, unsigned int n) -> Compartment get(ListOfCompartments self, string sid) -> Compartment get(ListOfCompartments self, string sid) -> Compartment This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: get(long n) Get a Compartment object from the ListOfCompartments. Parameter 'n' is the index number of the Compartment object to get. Returns the nth Compartment object in this ListOfCompartments. If the index 'n' is invalid, 'None' is returned. See also size(). ______________________________________________________________________ Method variant with the following signature: get(string sid) Get a Compartment object from the ListOfCompartments based on its identifier. Parameter 'sid' is a string representing the identifier of the Compartment object to get. Returns Compartment object in this ListOfCompartments with the given 'sid' or 'None' if no such Compartment object exists. See also get(), size(). """ return _libsbml.ListOfCompartments_get(self, *args) def remove(self, *args): """ remove(ListOfCompartments self, unsigned int n) -> Compartment remove(ListOfCompartments self, string sid) -> Compartment This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: remove(long n) Removes the nth item from this ListOfCompartments items and returns a pointer to it. The caller owns the returned item and is responsible for deleting it. Parameter 'n' is the index of the item to remove. See also size(). ______________________________________________________________________ Method variant with the following signature: remove(string sid) Removes item in this ListOfCompartments items with the given identifier. The caller owns the returned item and is responsible for deleting it. If none of the items in this list have the identifier 'sid', then 'None' is returned. Parameter 'sid' is the identifier of the item to remove. Returns the item removed. As mentioned above, the caller owns the returned item. """ return _libsbml.ListOfCompartments_remove(self, *args) __swig_destroy__ = _libsbml.delete_ListOfCompartments __del__ = lambda self: None ListOfCompartments_swigregister = _libsbml.ListOfCompartments_swigregister ListOfCompartments_swigregister(ListOfCompartments) class Species(SBase): """ An SBML species - a pool of entities. A species in SBML refers to a pool of entities that (a) are considered indistinguishable from each other for the purposes of the model, (b) participate in reactions, and (c) are located in a specific compartment. The SBML Species object class is intended to represent these pools. As with other major constructs in SBML, Species has a mandatory attribute, 'id', used to give the species type an identifier in the model. The identifier must be a text string conforming to the identifer syntax permitted in SBML. Species also has an optional 'name' attribute, of type 'string.' The 'id' and 'name' must be used according to the guidelines described in the SBML specifications. The required attribute 'compartment' is used to identify the compartment in which the species is located. The attribute's value must be the identifier of an existing Compartment object. It is important to note that there is no default value for the 'compartment' attribute on Species; every species in an SBML model must be assigned a compartment explicitly. (This also implies that every model with one or more Species objects must define at least one Compartment object.) The initial amount and concentration of a species ====================================================================== The optional attributes 'initialAmount' and 'initialConcentration', both having a data type of 'float,' can be used to set the initial quantity of the species in the compartment where the species is located. These attributes are mutually exclusive; i.e., only one can have a value on any given instance of a Species object. Missing 'initialAmount' and 'initialConcentration' values implies that their values either are unknown, or to be obtained from an external source, or determined by an InitialAssignment or other SBML construct elsewhere in the model. A species' initial quantity in SBML is set by the 'initialAmount' or 'initialConcentration' attribute exactly once. If the 'constant' attribute is 'True,' then the value of the species' quantity is fixed and cannot be changed except by an InitialAssignment. These methods differ in that the 'initialAmount' and 'initialConcentration' attributes can only be used to set the species quantity to a literal floating-point number, whereas the use of an InitialAssignment object allows the value to be set using an arbitrary mathematical expression (which, thanks to MathML's expressiveness, may evaluate to a rational number). If the species' 'constant' attribute is 'False,' the species' quantity value may be overridden by an InitialAssignment or changed by AssignmentRule or AlgebraicRule, and in addition, for t > 0, it may also be changed by a RateRule, Event objects, and as a result of being a reactant or product in one or more Reaction objects. (However, some constructs are mutually exclusive; see the SBML specifications for the precise details.) It is not an error to define 'initialAmount' or 'initialConcentration' on a species and also redefine the value using an InitialAssignment, but the 'initialAmount' or 'initialConcentration' setting in that case is ignored. The SBML specifications provide additional information about the semantics of assignments, rules and values for simulation time t <= 0. SBML Level 2 additionally stipulates that in cases where a species' compartment has a 'spatialDimensions' value of '0' (zero), the species cannot have a value for 'initialConcentration' because the concepts of concentration and density break down when a container has zero dimensions. The units of a species' amount or concentration ====================================================================== When the attribute 'initialAmount' is set, the unit of measurement associated with the value of 'initialAmount' is specified by the Species attribute 'substanceUnits'. When the 'initialConcentration' attribute is set, the unit of measurement associated with this concentration value is {unit of amount} divided by {unit of size}, where the {unit of amount} is specified by the Species 'substanceUnits' attribute, and the {unit of size} is specified by the 'units' attribute of the Compartment object in which the species is located. Note that in either case, a unit of amount is involved and determined by the 'substanceUnits' attribute. Note these two attributes alone do not determine the units of the species when the species identifier appears in a mathematical expression; that aspect is determined by the attribute 'hasOnlySubstanceUnits' discussed below. In SBML Level 3, if the 'substanceUnits' attribute is not set on a given Species object instance, then the unit of amount for that species is inherited from the 'substanceUnits' attribute on the enclosing Model object instance. If that attribute on Model is not set either, then the unit associated with the species' quantity is undefined. In SBML Level 2, if the 'substanceUnits' attribute is not set on a given Species object instance, then the unit of amount for that species is taken from the predefined SBML unit identifier ''substance'.' The value assigned to 'substanceUnits' must be chosen from one of the following possibilities: one of the base unit identifiers defined in SBML, the built-in unit identifier ''substance',' or the identifier of a new unit defined in the list of unit definitions in the enclosing Model object. The chosen units for 'substanceUnits' must be be ''dimensionless',' ''mole',' ''item',' ''kilogram',' ''gram',' or units derived from these. As noted at the beginning of this section, simply setting 'initialAmount' or 'initialConcentration' alone does not determine whether a species identifier represents an amount or a concentration when it appears elsewhere in an SBML model. The role of the attribute 'hasOnlySubstanceUnits' is to indicate whether the units of the species, when the species identifier appears in mathematical formulas, are intended to be concentration or amount. The attribute takes on a boolean value. In SBML Level 3, the attribute has no default value and must always be set in a model; in SBML Level 2, it has a default value of 'False.' The units of the species are used in the following ways: * When the species' identifier appears in a MathML formula, it represents the species' quantity, and the unit of measurement associated with the quantity is as described above. * The 'math' elements of AssignmentRule, InitialAssignment and EventAssignment objects referring to this species should all have the same units as the unit of measurement associated with the species quantity. * In a RateRule object that defines the rate of change of the species' quantity, the unit associated with the rule's 'math' element should be equal to the unit of the species' quantity divided by the model-wide unit of time; in other words, {unit of species quantity}/{unit of time}. The 'constant' and 'boundaryCondition' attributes ====================================================================== The Species object class has two boolean attributes named 'constant' and 'boundaryCondition', used to indicate whether and how the quantity of that species can vary during a simulation. In SBML Level 2 they are optional; in SBML Level 3 they are mandatory. The following table shows how to interpret the combined values of these attributes. +----------------+-------------------------+-----------------------------------+-----------------------------+----------------------------------------------------------------+ | constant value | boundaryCondition value | Can have assignment or rate rule? | Can be reactant or product? | Species' quantity can be changed by | +----------------+-------------------------+-----------------------------------+-----------------------------+----------------------------------------------------------------+ | true | true | no | yes | (never changes) | | false | true | yes | yes | rules and events | | true | false | no | no | (never changes) | | false | false | yes | yes | reactions or rules (but not both at the same time), and events | +----------------+-------------------------+-----------------------------------+-----------------------------+----------------------------------------------------------------+ By default, when a species is a product or reactant of one or more reactions, its quantity is determined by those reactions. In SBML, it is possible to indicate that a given species' quantity is not determined by the set of reactions even when that species occurs as a product or reactant; i.e., the species is on the boundary of the reaction system, and its quantity is not determined by the reactions. The boolean attribute 'boundaryCondition' can be used to indicate this. A value of 'False' indicates that the species is part of the reaction system. In SBML Level 2, the attribute has a default value of 'False,' while in SBML Level 3, it has no default. The 'constant' attribute indicates whether the species' quantity can be changed at all, regardless of whether by reactions, rules, or constructs other than InitialAssignment. A value of 'False' indicates that the species' quantity can be changed. (This is also a common value because the purpose of most simulations is precisely to calculate changes in species quantities.) In SBML Level 2, the attribute has a default value of 'False,' while in SBML Level 3, it has no default. Note that the initial quantity of a species can be set by an InitialAssignment irrespective of the value of the 'constant' attribute. In practice, a 'boundaryCondition' value of 'True' means a differential equation derived from the reaction definitions should not be generated for the species. However, the species' quantity may still be changed by AssignmentRule, RateRule, AlgebraicRule, Event, and InitialAssignment constructs if its 'constant' attribute is 'False.' Conversely, if the species' 'constant' attribute is 'True,' then its value cannot be changed by anything except InitialAssignment. A species having 'boundaryCondition'='False' and 'constant'='False' can appear as a product and/or reactant of one or more reactions in the model. If the species is a reactant or product of a reaction, it must not also appear as the target of any AssignmentRule or RateRule object in the model. If instead the species has 'boundaryCondition'= 'False' and 'constant'='True,' then it cannot appear as a reactant or product, or as the target of any AssignmentRule, RateRule or EventAssignment object in the model. Finally, it is worth clarifying that while the constant and boundaryCondition attributes restrict whether and how the species amount changes, the same is not true of a species' concentration. In SBML, the concentration of a species is a quantity that depends on the size of the compartment in which it is located. A compartment's size may change, and therefore, so can the concentration of a species even if the amount of the species remains unchanged. A species' concentration may therefore vary even if the Species object's constant attribute is set to 'True' in a model. The conversionFactor attribute in SBML Level 3 ====================================================================== In SBML Level 3, Species has an additional optional attribute, 'conversionFactor', that defines a conversion factor that applies to a particular species. The value must be the identifier of a Parameter object instance defined in the model. That Parameter object must be a constant, meaning its 'constant' attribute must be set to 'True.' If a given Species object definition defines a value for its 'conversionFactor' attribute, it takes precedence over any factor defined by the Model object's 'conversionFactor' attribute. The unit of measurement associated with a species' quantity can be different from the unit of extent of reactions in the model. SBML Level 3 avoids implicit unit conversions by providing an explicit way to indicate any unit conversion that might be required. The use of a conversion factor in computing the effects of reactions on a species' quantity is explained in detail in the SBML Level 3 specification document. Because the value of the 'conversionFactor' attribute is the identifier of a Parameter object, and because parameters can have units attached to them, the transformation from reaction extent units to species units can be completely specified using this approach. Note that the unit conversion factor is only applied when calculating the effect of a reaction on a species. It is not used in any rules or other SBML constructs that affect the species, and it is also not used when the value of the species is referenced in a mathematical expression. The speciesType attribute in SBML Level 2 Versions 2-4 ====================================================================== In SBML Level 2 Versions 2-4, each species in a model may optionally be designated as belonging to a particular species type. The optional attribute 'speciesType' is used to identify the species type of the chemical entities that make up the pool represented by the Species objects. The attribute's value must be the identifier of an existing SpeciesType object in the model. If the 'speciesType' attribute is not present on a particular species definition, it means the pool contains chemical entities of a type unique to that pool; in effect, a virtual species type is assumed for that species, and no other species can belong to that species type. The value of 'speciesType' attributes on species have no effect on the numerical interpretation of a model; simulators and other numerical analysis software may ignore 'speciesType' attributes. There can be only one species of a given species type in any given compartment of a model. More specifically, for all Species objects having a value for the 'speciesType' attribute, the pair
('speciesType' attribute value, 'compartment' attribute value)
must be unique across the set of all Species object in a model. The spatialSizeUnits attribute in SBML Level 2 Versions 1-2 ====================================================================== In versions of SBML Level 2 before Version 3, the class Species included an attribute called 'spatialSizeUnits', which allowed explicitly setting the units of size for initial concentration. LibSBML retains this attribute for compatibility with older definitions of Level 2, but its use is strongly discouraged because many software tools do no properly interpret this unit declaration and it is incompatible with all SBML specifications after Level 2 Version 3. Additional considerations for interpreting the numerical value of a species ====================================================================== Species are unique in SBML in that they have a kind of duality: a species identifier may stand for either substance amount (meaning, a count of the number of individual entities) or a concentration or density (meaning, amount divided by a compartment size). The previous sections explain the meaning of a species identifier when it is referenced in a mathematical formula or in rules or other SBML constructs; however, it remains to specify what happens to a species when the compartment in which it is located changes in size. When a species definition has a 'hasOnlySubstanceUnits' attribute value of 'False' and the size of the compartment in which the species is located changes, the default in SBML is to assume that it is the concentration that must be updated to account for the size change. This follows from the principle that, all other things held constant, if a compartment simply changes in size, the size change does not in itself cause an increase or decrease in the number of entities of any species in that compartment. In a sense, the default is that the amount of a species is preserved across compartment size changes. Upon such size changes, the value of the concentration or density must be recalculated from the simple relationship concentration = amount / size if the value of the concentration is needed (for example, if the species identifier appears in a mathematical formula or is otherwise referenced in an SBML construct). There is one exception: if the species' quantity is determined by an AssignmentRule, RateRule, AlgebraicRule, or an EventAssignment and the species has a 'hasOnlySubstanceUnits' attribute value of 'False,' it means that the concentration is assigned by the rule or event; in that case, the amount must be calculated when the compartment size changes. (Events also require additional care in this situation, because an event with multiple assignments could conceivably reassign both a species quantity and a compartment size simultaneously. Please refer to the SBML specifications for the details.) Note that the above only matters if a species has a 'hasOnlySubstanceUnits' attribute value of 'False,' meaning that the species identifier refers to a concentration wherever the identifier appears in a mathematical formula. If instead the attribute's value is 'True,' then the identifier of the species always stands for an amount wherever it appears in a mathematical formula or is referenced by an SBML construct. In that case, there is never a question about whether an assignment or event is meant to affect the amount or concentration: it is always the amount. A particularly confusing situation can occur when the species has 'constant' attribute value of 'True' in combination with a 'hasOnlySubstanceUnits' attribute value of 'False.' Suppose this species is given a value for 'initialConcentration'. Does a 'constant' value of 'True' mean that the concentration is held constant if the compartment size changes? No; it is still the amount that is kept constant across a compartment size change. The fact that the species was initialized using a concentration value is irrelevant. """ __swig_setmethods__ = {} for _s in [SBase]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, Species, name, value) __swig_getmethods__ = {} for _s in [SBase]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, Species, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_Species __del__ = lambda self: None def __init__(self, *args): """ __init__(Species self, unsigned int level, unsigned int version) -> Species __init__(Species self, SBMLNamespaces sbmlns) -> Species __init__(Species self, Species orig) -> Species This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: Species(SBMLNamespaces sbmlns) Creates a new Species using the given SBMLNamespaces object 'sbmlns'. The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments. It is worth emphasizing that although this constructor does not take an identifier argument, in SBML Level 2 and beyond, the 'id' (identifier) attribute of a Species is required to have a value. Thus, callers are cautioned to assign a value after calling this constructor. Setting the identifier can be accomplished using the method Species.setId(). Parameter 'sbmlns' is an SBMLNamespaces object. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: Species(long level, long version) Creates a new Species using the given SBML 'level' and 'version' values. Parameter 'level' is a long integer, the SBML Level to assign to this Species. Parameter 'version' is a long integer, the SBML Version to assign to this Species. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: Species(Species orig) Copy constructor; creates a copy of this Species object. Parameter 'orig' is the object to copy. """ this = _libsbml.new_Species(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(Species self) -> Species Creates and returns a deep copy of this Species object. Returns the (deep) copy of this Species object. """ return _libsbml.Species_clone(self) def initDefaults(self): """ initDefaults(Species self) Initializes the fields of this Species object to 'typical' defaults values. The SBML Species component has slightly different aspects and default attribute values in different SBML Levels and Versions. This method sets the values to certain common defaults, based mostly on what they are in SBML Level 2. Specifically: * Sets 'boundaryCondition' to 'False' * Sets 'constant' to 'False' * sets 'hasOnlySubstanceUnits' to 'False' * (Applies to Level 3 models only) Sets attribute 'substanceUnits' to 'mole' """ return _libsbml.Species_initDefaults(self) def getId(self): """ getId(Species self) -> string Returns the value of the 'id' attribute of this Species. Note: Because of the inconsistent behavior of this function with respect to assignments and rules, it is now recommended to use the getIdAttribute() function instead. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Returns the id of this Species. See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(). """ return _libsbml.Species_getId(self) def getName(self): """ getName(Species self) -> string Returns the value of the 'name' attribute of this Species object. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns the name of this SBML object, or the empty string if not set or unsettable. See also getIdAttribute(), isSetName(), setName(), unsetName(). """ return _libsbml.Species_getName(self) def getSpeciesType(self): """ getSpeciesType(Species self) -> string Get the type of this Species object object. Returns the value of the 'speciesType' attribute of this Species as a string. Note: The 'speciesType' attribute is only available in SBML Level 2 Versions 2-4. """ return _libsbml.Species_getSpeciesType(self) def getCompartment(self): """ getCompartment(Species self) -> string Get the compartment in which this species is located. The compartment is designated by its identifier. Returns the value of the 'compartment' attribute of this Species object, as a string. """ return _libsbml.Species_getCompartment(self) def getInitialAmount(self): """ getInitialAmount(Species self) -> double Get the value of the 'initialAmount' attribute. Returns the initialAmount of this Species, as a floating point number. """ return _libsbml.Species_getInitialAmount(self) def getInitialConcentration(self): """ getInitialConcentration(Species self) -> double Get the value of the 'initialConcentration' attribute. Returns the initialConcentration of this Species,, as a floating point number. Note: The attribute 'initialConcentration' is only available in SBML Level 2 and 3. It does not exist on Species in Level 1. """ return _libsbml.Species_getInitialConcentration(self) def getSubstanceUnits(self): """ getSubstanceUnits(Species self) -> string Get the value of the 'substanceUnits' attribute. Returns the value of the 'substanceUnits' attribute of this Species, as a string. An empty string indicates that no units have been assigned. Note: There is an important distinction to be made between no units assigned, and assuming a value without units has any specific unit such as dimensionless. In SBML, default units are never attributed to numbers, and numbers without units are not automatically assumed to have the unit dimensionless. Please consult the relevant SBML specification document for a more in-depth explanation of this topic and the SBML unit system. See also isSetSubstanceUnits(), setSubstanceUnits(). """ return _libsbml.Species_getSubstanceUnits(self) def getSpatialSizeUnits(self): """ getSpatialSizeUnits(Species self) -> string Get the value of the 'spatialSizeUnits' attribute. Returns the value of the 'spatialSizeUnits' attribute of this Species object, as a string. WARNING: In versions of SBML Level 2 before Version 3, the class Species included an attribute called 'spatialSizeUnits', which allowed explicitly setting the units of size for initial concentration. This attribute was removed in SBML Level 2 Version 3. LibSBML retains this attribute for compatibility with older definitions of Level 2, but its use is strongly discouraged because it is incompatible with levels and versions of SBML beyond Level 2 Version 2. """ return _libsbml.Species_getSpatialSizeUnits(self) def getUnits(self): """ getUnits(Species self) -> string Get the value of the 'units' attribute. Returns the units of this Species (L1 only). Note: The 'units' attribute is defined only in SBML Level 1. In SBML Level 2 and Level 3, it has been replaced by a combination of 'substanceUnits' and the units of the Compartment object in which a species is located. In SBML Level 2 Versions 1-2, an additional attribute 'spatialSizeUnits' helps determine the units of the species quantity, but this attribute was removed in later versions of SBML Level 2. """ return _libsbml.Species_getUnits(self) def getHasOnlySubstanceUnits(self): """ getHasOnlySubstanceUnits(Species self) -> bool Get the value of the 'hasOnlySubstanceUnits' attribute. Returns 'True' if this Species' 'hasOnlySubstanceUnits' attribute value is 'True,' 'False' otherwise. Note: The 'hasOnlySubstanceUnits' attribute does not exist in SBML Level 1. """ return _libsbml.Species_getHasOnlySubstanceUnits(self) def getBoundaryCondition(self): """ getBoundaryCondition(Species self) -> bool Get the value of the 'boundaryCondition' attribute. Returns 'True' if this Species' 'boundaryCondition' attribute value is 'True,' 'False' otherwise. """ return _libsbml.Species_getBoundaryCondition(self) def getCharge(self): """ getCharge(Species self) -> int Get the value of the 'charge' attribute. Returns the charge of this Species object. Note: Beginning in SBML Level 2 Version 2, the 'charge' attribute on Species is deprecated and in SBML Level 3 it does not exist at all. Its use strongly discouraged. Its presence is considered a misfeature in earlier definitions of SBML because its implications for the mathematics of a model were never defined, and in any case, no known modeling system ever used it. Instead, models take account of charge values directly in their definitions of species by (for example) having separate species identities for the charged and uncharged versions of the same species. This allows the condition to affect model mathematics directly. LibSBML retains this method for easier compatibility with SBML Level 1. """ return _libsbml.Species_getCharge(self) def getConstant(self): """ getConstant(Species self) -> bool Get the value of the 'constant' attribute. Returns 'True' if this Species's 'constant' attribute value is 'True,' 'False' otherwise. Note: The attribute 'constant' is only available in SBML Levels 2 and 3. It does not exist on Species in Level 1. """ return _libsbml.Species_getConstant(self) def getConversionFactor(self): """ getConversionFactor(Species self) -> string Get the value of the 'conversionFactor' attribute. Returns the conversionFactor of this Species, as a string. Note: The 'conversionFactor' attribute was introduced in SBML Level 3. It does not exist on Species in SBML Levels 1 and 2. """ return _libsbml.Species_getConversionFactor(self) def isSetId(self): """ isSetId(Species self) -> bool Predicate returning 'True' if this Species object's 'id' attribute is set. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Returns 'True' if the 'id' attribute of this SBML object is set, 'False' otherwise. Note: Because of the inconsistent behavior of this function with respect to assignments and rules, it is recommended that callers use isSetIdAttribute() instead. See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(), isSetIdAttribute(). """ return _libsbml.Species_isSetId(self) def isSetName(self): """ isSetName(Species self) -> bool Predicate returning 'True' if this Species object's 'name' attribute is set. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns 'True' if the 'name' attribute of this SBML object is set, 'False' otherwise. See also getName(), setName(), unsetName(). """ return _libsbml.Species_isSetName(self) def isSetSpeciesType(self): """ isSetSpeciesType(Species self) -> bool Predicate returning 'True' if this Species object's 'speciesType' attribute is set. Returns 'True' if the 'speciesType' attribute of this Species is set, 'False' otherwise. Note: The 'speciesType' attribute is only available in SBML Level 2 Versions 2-4. """ return _libsbml.Species_isSetSpeciesType(self) def isSetCompartment(self): """ isSetCompartment(Species self) -> bool Predicate returning 'True' if this Species object's 'compartment' attribute is set. Returns 'True' if the 'compartment' attribute of this Species is set, 'False' otherwise. """ return _libsbml.Species_isSetCompartment(self) def isSetInitialAmount(self): """ isSetInitialAmount(Species self) -> bool Predicate returning 'True' if this Species object's 'initialAmount' attribute is set. Returns 'True' if the 'initialAmount' attribute of this Species is set, 'False' otherwise. Note: In SBML Level 1, Species' 'initialAmount' is required and therefore should always be set. (However, in Level 1, the attribute has no default value either, so this method will not return 'True' until a value has been assigned.) In SBML Level 2, 'initialAmount' is optional and as such may or may not be set. """ return _libsbml.Species_isSetInitialAmount(self) def isSetInitialConcentration(self): """ isSetInitialConcentration(Species self) -> bool Predicate returning 'True' if this Species object's 'initialConcentration' attribute is set. Returns 'True' if the 'initialConcentration' attribute of this Species is set, 'False' otherwise. Note: The attribute 'initialConcentration' is only available in SBML Level 2 and 3. It does not exist on Species in Level 1. """ return _libsbml.Species_isSetInitialConcentration(self) def isSetSubstanceUnits(self): """ isSetSubstanceUnits(Species self) -> bool Predicate returning 'True' if this Species object's 'substanceUnits' attribute is set. Returns 'True' if the 'substanceUnits' attribute of this Species is set, 'False' otherwise. """ return _libsbml.Species_isSetSubstanceUnits(self) def isSetSpatialSizeUnits(self): """ isSetSpatialSizeUnits(Species self) -> bool Predicate returning 'True' if this Species object's 'spatialSizeUnits' attribute is set. Returns 'True' if the 'spatialSizeUnits' attribute of this Species is set, 'False' otherwise. WARNING: In versions of SBML Level 2 before Version 3, the class Species included an attribute called 'spatialSizeUnits', which allowed explicitly setting the units of size for initial concentration. This attribute was removed in SBML Level 2 Version 3. LibSBML retains this attribute for compatibility with older definitions of Level 2, but its use is strongly discouraged because it is incompatible with levels and versions of SBML beyond Level 2 Version 2. """ return _libsbml.Species_isSetSpatialSizeUnits(self) def isSetUnits(self): """ isSetUnits(Species self) -> bool Predicate returning 'True' if this Species object's 'units' attribute is set. Returns 'True' if the 'units' attribute of this Species is set, 'False' otherwise. """ return _libsbml.Species_isSetUnits(self) def isSetCharge(self): """ isSetCharge(Species self) -> bool Predicate returning 'True' if this Species object's 'charge' attribute is set. Returns 'True' if the 'charge' attribute of this Species is set, 'False' otherwise. Note: Beginning in SBML Level 2 Version 2, the 'charge' attribute on Species is deprecated and in SBML Level 3 it does not exist at all. Its use strongly discouraged. Its presence is considered a misfeature in earlier definitions of SBML because its implications for the mathematics of a model were never defined, and in any case, no known modeling system ever used it. Instead, models take account of charge values directly in their definitions of species by (for example) having separate species identities for the charged and uncharged versions of the same species. This allows the condition to affect model mathematics directly. LibSBML retains this method for easier compatibility with SBML Level 1. """ return _libsbml.Species_isSetCharge(self) def isSetConversionFactor(self): """ isSetConversionFactor(Species self) -> bool Predicate returning 'True' if this Species object's 'conversionFactor' attribute is set. Returns 'True' if the 'conversionFactor' attribute of this Species is set, 'False' otherwise. Note: The 'conversionFactor' attribute was introduced in SBML Level 3. It does not exist on Species in SBML Levels 1 and 2. """ return _libsbml.Species_isSetConversionFactor(self) def isSetBoundaryCondition(self): """ isSetBoundaryCondition(Species self) -> bool Predicate returning 'True' if this Species object's 'boundaryCondition' attribute is set. Returns 'True' if the 'boundaryCondition' attribute of this Species is set, 'False' otherwise. """ return _libsbml.Species_isSetBoundaryCondition(self) def isSetHasOnlySubstanceUnits(self): """ isSetHasOnlySubstanceUnits(Species self) -> bool Predicate returning 'True' if this Species object's 'hasOnlySubstanceUnits' attribute is set. Returns 'True' if the 'hasOnlySubstanceUnits' attribute of this Species is set, 'False' otherwise. Note: The 'hasOnlySubstanceUnits' attribute does not exist in SBML Level 1. """ return _libsbml.Species_isSetHasOnlySubstanceUnits(self) def isSetConstant(self): """ isSetConstant(Species self) -> bool Predicate returning 'True' if this Species object's 'constant' attribute is set. Returns 'True' if the 'constant' attribute of this Species is set, 'False' otherwise. Note: The attribute 'constant' is only available in SBML Levels 2 and 3. It does not exist on Species in Level 1. """ return _libsbml.Species_isSetConstant(self) def setId(self, sid): """ setId(Species self, string sid) -> int Sets the value of the 'id' attribute of this Species. The string 'sid' is copied. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Parameter 'sid' is the string to use as the identifier of this object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE * LIBSBML_UNEXPECTED_ATTRIBUTE See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(). """ return _libsbml.Species_setId(self, sid) def setName(self, name): """ setName(Species self, string name) -> int Sets the value of the 'name' attribute of this Species. The string in 'name' is copied. Parameter 'name' is the new name for the SBML object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.Species_setName(self, name) def setSpeciesType(self, sid): """ setSpeciesType(Species self, string sid) -> int Sets the 'speciesType' attribute of this Species object. Parameter 'sid' is the identifier of a SpeciesType object defined elsewhere in this Model. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE * LIBSBML_UNEXPECTED_ATTRIBUTE Note: The 'speciesType' attribute is only available in SBML Level 2 Versions 2-4. """ return _libsbml.Species_setSpeciesType(self, sid) def setCompartment(self, sid): """ setCompartment(Species self, string sid) -> int Sets the 'compartment' attribute of this Species object. Parameter 'sid' is the identifier of a Compartment object defined elsewhere in this Model. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.Species_setCompartment(self, sid) def setInitialAmount(self, value): """ setInitialAmount(Species self, double value) -> int Sets the 'initialAmount' attribute of this Species and marks the field as set. This method also unsets the 'initialConcentration' attribute. Parameter 'value' is the value to which the 'initialAmount' attribute should be set. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS """ return _libsbml.Species_setInitialAmount(self, value) def setInitialConcentration(self, value): """ setInitialConcentration(Species self, double value) -> int Sets the 'initialConcentration' attribute of this Species and marks the field as set. This method also unsets the 'initialAmount' attribute. Parameter 'value' is the value to which the 'initialConcentration' attribute should be set. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE Note: The attribute 'initialConcentration' is only available in SBML Level 2 and 3. It does not exist on Species in Level 1. """ return _libsbml.Species_setInitialConcentration(self, value) def setSubstanceUnits(self, sid): """ setSubstanceUnits(Species self, string sid) -> int Sets the 'substanceUnits' attribute of this Species object. Parameter 'sid' is the identifier of the unit to use. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.Species_setSubstanceUnits(self, sid) def setSpatialSizeUnits(self, sid): """ setSpatialSizeUnits(Species self, string sid) -> int (SBML Level 2 Versions 1-2) Sets the 'spatialSizeUnits' attribute of this Species object. Parameter 'sid' is the identifier of the unit to use. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE * LIBSBML_UNEXPECTED_ATTRIBUTE WARNING: In versions of SBML Level 2 before Version 3, the class Species included an attribute called 'spatialSizeUnits', which allowed explicitly setting the units of size for initial concentration. This attribute was removed in SBML Level 2 Version 3. LibSBML retains this attribute for compatibility with older definitions of Level 2, but its use is strongly discouraged because it is incompatible with levels and versions of SBML beyond Level 2 Version 2. """ return _libsbml.Species_setSpatialSizeUnits(self, sid) def setUnits(self, sname): """ setUnits(Species self, string sname) -> int (SBML Level 1 only) Sets the units of this Species object. Parameter 'sname' is the identifier of the unit to use. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.Species_setUnits(self, sname) def setHasOnlySubstanceUnits(self, value): """ setHasOnlySubstanceUnits(Species self, bool value) -> int Sets the 'hasOnlySubstanceUnits' attribute of this Species object. Parameter 'value' is boolean value for the 'hasOnlySubstanceUnits' attribute. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE Note: The 'hasOnlySubstanceUnits' attribute does not exist in SBML Level 1. """ return _libsbml.Species_setHasOnlySubstanceUnits(self, value) def setBoundaryCondition(self, value): """ setBoundaryCondition(Species self, bool value) -> int Sets the 'boundaryCondition' attribute of this Species object. Parameter 'value' is boolean value for the 'boundaryCondition' attribute. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS """ return _libsbml.Species_setBoundaryCondition(self, value) def setCharge(self, value): """ setCharge(Species self, int value) -> int Sets the 'charge' attribute of this Species object. Parameter 'value' is an integer to which to set the 'charge' to. Note: Beginning in SBML Level 2 Version 2, the 'charge' attribute on Species is deprecated and in SBML Level 3 it does not exist at all. Its use strongly discouraged. Its presence is considered a misfeature in earlier definitions of SBML because its implications for the mathematics of a model were never defined, and in any case, no known modeling system ever used it. Instead, models take account of charge values directly in their definitions of species by (for example) having separate species identities for the charged and uncharged versions of the same species. This allows the condition to affect model mathematics directly. LibSBML retains this method for easier compatibility with SBML Level 1. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE """ return _libsbml.Species_setCharge(self, value) def setConstant(self, value): """ setConstant(Species self, bool value) -> int Sets the 'constant' attribute of this Species object. Parameter 'value' is a boolean value for the 'constant' attribute. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE Note: The attribute 'constant' is only available in SBML Levels 2 and 3. It does not exist on Species in Level 1. """ return _libsbml.Species_setConstant(self, value) def setConversionFactor(self, sid): """ setConversionFactor(Species self, string sid) -> int Sets the value of the 'conversionFactor' attribute of this Species object. The string in 'sid' is copied. Parameter 'sid' is the new conversionFactor for the Species. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE * LIBSBML_INVALID_ATTRIBUTE_VALUE Note: The 'conversionFactor' attribute was introduced in SBML Level 3. It does not exist on Species in SBML Levels 1 and 2. """ return _libsbml.Species_setConversionFactor(self, sid) def unsetName(self): """ unsetName(Species self) -> int Unsets the value of the 'name' attribute of this Species object. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also getName(), setName(), isSetName(). """ return _libsbml.Species_unsetName(self) def unsetConstant(self): """ unsetConstant(Species self) -> int Unsets the value of the 'constant' attribute of this Species object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also isSetConstant(), setConstant(), getConstant(). """ return _libsbml.Species_unsetConstant(self) def unsetSpeciesType(self): """ unsetSpeciesType(Species self) -> int Unsets the 'speciesType' attribute value of this Species object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED Note: The attribute 'speciesType' is only available in SBML Level 2 Versions 2-4. """ return _libsbml.Species_unsetSpeciesType(self) def unsetInitialAmount(self): """ unsetInitialAmount(Species self) -> int Unsets the 'initialAmount' attribute value of this Species object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.Species_unsetInitialAmount(self) def unsetInitialConcentration(self): """ unsetInitialConcentration(Species self) -> int Unsets the 'initialConcentration' attribute value of this Species object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED Note: The attribute 'initialConcentration' is only available in SBML Level 2 and 3. It does not exist on Species in Level 1. """ return _libsbml.Species_unsetInitialConcentration(self) def unsetSubstanceUnits(self): """ unsetSubstanceUnits(Species self) -> int Unsets the 'substanceUnits' attribute value of this Species object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.Species_unsetSubstanceUnits(self) def unsetSpatialSizeUnits(self): """ unsetSpatialSizeUnits(Species self) -> int Unsets the 'spatialSizeUnits' attribute value of this Species object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED WARNING: In versions of SBML Level 2 before Version 3, the class Species included an attribute called 'spatialSizeUnits', which allowed explicitly setting the units of size for initial concentration. This attribute was removed in SBML Level 2 Version 3. LibSBML retains this attribute for compatibility with older definitions of Level 2, but its use is strongly discouraged because it is incompatible with levels and versions of SBML beyond Level 2 Version 2. """ return _libsbml.Species_unsetSpatialSizeUnits(self) def unsetUnits(self): """ unsetUnits(Species self) -> int Unsets the 'units' attribute value of this Species object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.Species_unsetUnits(self) def unsetCharge(self): """ unsetCharge(Species self) -> int Unsets the 'charge' attribute value of this Species object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE * LIBSBML_OPERATION_FAILED Note: Beginning in SBML Level 2 Version 2, the 'charge' attribute on Species is deprecated and in SBML Level 3 it does not exist at all. Its use strongly discouraged. Its presence is considered a misfeature in earlier definitions of SBML because its implications for the mathematics of a model were never defined, and in any case, no known modeling system ever used it. Instead, models take account of charge values directly in their definitions of species by (for example) having separate species identities for the charged and uncharged versions of the same species. This allows the condition to affect model mathematics directly. LibSBML retains this method for easier compatibility with SBML Level 1. """ return _libsbml.Species_unsetCharge(self) def unsetConversionFactor(self): """ unsetConversionFactor(Species self) -> int Unsets the 'conversionFactor' attribute value of this Species object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE * LIBSBML_OPERATION_FAILED Note: The 'conversionFactor' attribute was introduced in SBML Level 3. It does not exist on Species in SBML Levels 1 and 2. """ return _libsbml.Species_unsetConversionFactor(self) def unsetCompartment(self): """ unsetCompartment(Species self) -> int Unsets the 'compartment' attribute value of this Species object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.Species_unsetCompartment(self) def unsetBoundaryCondition(self): """ unsetBoundaryCondition(Species self) -> int Unsets the 'boundaryCondition' attribute value of this Species object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.Species_unsetBoundaryCondition(self) def unsetHasOnlySubstanceUnits(self): """ unsetHasOnlySubstanceUnits(Species self) -> int Unsets the 'hasOnlySubstanceUnits' attribute value of this Species object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.Species_unsetHasOnlySubstanceUnits(self) def getDerivedUnitDefinition(self, *args): """ getDerivedUnitDefinition(Species self) -> UnitDefinition getDerivedUnitDefinition(Species self) -> UnitDefinition Constructs and returns a UnitDefinition that corresponds to the units of this Species' amount or concentration. Species in SBML have an attribute ('substanceUnits') for declaring the units of measurement intended for the species' amount or concentration (depending on which one applies). In the absence of a value given for 'substanceUnits', the units are taken from the enclosing Model's definition of ''substance'' or ''substance'/(size' of the compartment) in which the species is located, or finally, if these are not redefined by the Model, the relevant SBML default units for those quantities. Following that procedure, the method getDerivedUnitDefinition() returns a UnitDefinition based on the interpreted units of this species's amount or concentration. Note that the functionality that facilitates unit analysis depends on the model as a whole. Thus, in cases where the object has not been added to a model or the model itself is incomplete, unit analysis is not possible and this method will return 'None.' Note also that unit declarations for Species are in terms of the identifier of a unit, but this method returns a UnitDefinition object, not a unit identifier. It does this by constructing an appropriate UnitDefinition. Callers may find this particularly useful when used in conjunction with the helper methods on UnitDefinition for comparing different UnitDefinition objects. In SBML Level 2 specifications prior to Version 3, Species includes an additional attribute named 'spatialSizeUnits', which allows explicitly setting the units of size for initial concentration. The getDerivedUnitDefinition() takes this into account for models expressed in SBML Level 2 Versions 1 and 2. Returns a UnitDefinition that expresses the units of this Species, or 'None' if one cannot be constructed. See also getSubstanceUnits(). """ return _libsbml.Species_getDerivedUnitDefinition(self, *args) def getTypeCode(self): """ getTypeCode(Species self) -> int Returns the libSBML type code for this SBML object. LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for this object: SBML_SPECIES (default). WARNING: The specific integer values of the possible type codes may be reused by different libSBML plug-ins for SBML Level 3. packages, To fully identify the correct code, it is necessary to invoke both getPackageName() and getTypeCode() (or ListOf.getItemTypeCode()). See also getElementName(), getPackageName(). """ return _libsbml.Species_getTypeCode(self) def getElementName(self): """ getElementName(Species self) -> string Returns the XML element name of this object, which for Species, is always ''species'.' Returns the name of this element, i.e., ''species'.' """ return _libsbml.Species_getElementName(self) def hasRequiredAttributes(self): """ hasRequiredAttributes(Species self) -> bool Predicate returning 'True' if all the required attributes for this Species object have been set. The required attributes for a Species object are: * 'id' (or 'name' in SBML Level 1) * 'compartment' * 'initialAmount' (required in SBML Level 1 only; optional otherwise) * 'hasOnlySubstanceUnits' (required in SBML Level 3; optional in SBML Level 2) * 'boundaryCondition' (required in SBML Level 3; optional in Levels 1 and 2) * 'constant' (required in SBML Level 3; optional in SBML Level 2) Returns 'True' if the required attributes have been set, 'False' otherwise. """ return _libsbml.Species_hasRequiredAttributes(self) def renameSIdRefs(self, oldid, newid): """ renameSIdRefs(Species self, string oldid, string newid) Replaces all uses of a given 'SIdRef' type attribute value with another value. In SBML, object identifiers are of a data type called SId. In SBML Level 3, an explicit data type called SIdRef was introduced for attribute values that refer to SId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to an identifier', but the effective data type was the same as SIdRef in Level 3. These and other methods of libSBML refer to the type SIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all attributes and (if appropriate) mathematical formulas in MathML content, comparing the referenced identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.Species_renameSIdRefs(self, oldid, newid) def renameUnitSIdRefs(self, oldid, newid): """ renameUnitSIdRefs(Species self, string oldid, string newid) Replaces all uses of a given 'UnitSIdRef' type attribute value with another value. In SBML, unit definitions have identifiers of type UnitSId. In SBML Level 3, an explicit data type called UnitSIdRef was introduced for attribute values that refer to UnitSId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to a unit identifier', but the effective data type was the same as UnitSIdRef in Level 3. These and other methods of libSBML refer to the type UnitSIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all unit identifier attribute values (including, if appropriate, inside mathematical formulas), comparing the referenced unit identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.Species_renameUnitSIdRefs(self, oldid, newid) Species_swigregister = _libsbml.Species_swigregister Species_swigregister(Species) class ListOfSpecies(ListOf): """ A list of Species objects. The various ListOf___ classes in SBML are merely containers used for organizing the main components of an SBML model. In libSBML's implementation, ListOf___ classes are derived from the intermediate utility class ListOf, which is not defined by the SBML specifications but serves as a useful programmatic construct. ListOf is itself is in turn derived from SBase, which provides all of the various ListOf___ classes with common features defined by the SBML specification, such as 'metaid' attributes and annotations. The relationship between the lists and the rest of an SBML model is illustrated by the following (for SBML Level 2 Version 4): ... ... ... ... ... ... ... elements of subclasses of Rule ... ... ... ... SBML Level 3 Version 1 has essentially the same structure as Level 2 Version 4, depicted above, but SBML Level 3 Version 2 allows containers to contain zero or more of the relevant object, instead of requiring at least one. As such, libsbml will write out an otherwise-empty ListOf___ element that has any optional attribute set (such as 'id' or 'metaid'), that has an optional child (such as a 'notes' or 'annotation'), or that has attributes or children set from any SBML Level 3 package, whether or not the ListOf___ has any other children. Readers may wonder about the motivations for using the ListOf___ containers in SBML. A simpler approach in XML might be to place the components all directly at the top level of the model definition. The choice made in SBML is to group them within XML elements named after ListOfClassname, in part because it helps organize the components. More importantly, the fact that the container classes are derived from SBase means that software tools can add information about the lists themselves into each list container's 'annotation'. See also ListOfFunctionDefinitions, ListOfUnitDefinitions, ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments, ListOfSpecies, ListOfParameters, ListOfInitialAssignments, ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents. """ __swig_setmethods__ = {} for _s in [ListOf]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfSpecies, name, value) __swig_getmethods__ = {} for _s in [ListOf]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, ListOfSpecies, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(ListOfSpecies self, unsigned int level, unsigned int version) -> ListOfSpecies __init__(ListOfSpecies self, SBMLNamespaces sbmlns) -> ListOfSpecies This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: ListOfSpecies(SBMLNamespaces sbmlns) Creates a new ListOfSpecies object. The object is constructed such that it is valid for the SBML Level and Version combination determined by the SBMLNamespaces object in 'sbmlns'. Parameter 'sbmlns' is an SBMLNamespaces object that is used to determine the characteristics of the ListOfSpecies object to be created. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: ListOfSpecies(long level, long version) Creates a new ListOfSpecies object. The object is constructed such that it is valid for the given SBML Level and Version combination. Parameter 'level' is the SBML Level. Parameter 'version' is the Version within the SBML Level. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. """ this = _libsbml.new_ListOfSpecies(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(ListOfSpecies self) -> ListOfSpecies Creates and returns a deep copy of this ListOfSpecies object. Returns the (deep) copy of this ListOfSpecies object. """ return _libsbml.ListOfSpecies_clone(self) def getItemTypeCode(self): """ getItemTypeCode(ListOfSpecies self) -> int Returns the libSBML type code for the objects contained in this ListOf (i.e., Species objects, if the list is non-empty). LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for objects contained in this list: SBML_SPECIES (default). See also getElementName(), getPackageName(). """ return _libsbml.ListOfSpecies_getItemTypeCode(self) def getElementName(self): """ getElementName(ListOfSpecies self) -> string Returns the XML element name of this object. For ListOfSpeciess, the XML element name is ''listOfSpeciess'.' Returns the name of this element, i.e., ''listOfSpeciess'.' """ return _libsbml.ListOfSpecies_getElementName(self) def get(self, *args): """ get(ListOfSpecies self, unsigned int n) -> Species get(ListOfSpecies self, unsigned int n) -> Species get(ListOfSpecies self, string sid) -> Species get(ListOfSpecies self, string sid) -> Species This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: get(long n) Get a Species from the ListOfSpecies. Parameter 'n' is the index number of the Species to get. Returns the nth Species in this ListOfSpecies. If the index 'n' is invalid, 'None' is returned. See also size(). ______________________________________________________________________ Method variant with the following signature: get(string sid) Get a Species from the ListOfSpecies based on its identifier. Parameter 'sid' is a string representing the identifier of the Species to get. Returns Species in this ListOfSpecies with the given 'sid' or 'None' if no such Species exists. See also get(), size(). """ return _libsbml.ListOfSpecies_get(self, *args) def remove(self, *args): """ remove(ListOfSpecies self, unsigned int n) -> Species remove(ListOfSpecies self, string sid) -> Species This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: remove(long n) Removes the nth item from this ListOfSpeciess items and returns a pointer to it. The caller owns the returned item and is responsible for deleting it. Parameter 'n' is the index of the item to remove. See also size(). ______________________________________________________________________ Method variant with the following signature: remove(string sid) Removes item in this ListOfSpeciess items with the given identifier. The caller owns the returned item and is responsible for deleting it. If none of the items in this list have the identifier 'sid', then 'None' is returned. Parameter 'sid' is the identifier of the item to remove. Returns the item removed. As mentioned above, the caller owns the returned item. """ return _libsbml.ListOfSpecies_remove(self, *args) __swig_destroy__ = _libsbml.delete_ListOfSpecies __del__ = lambda self: None ListOfSpecies_swigregister = _libsbml.ListOfSpecies_swigregister ListOfSpecies_swigregister(ListOfSpecies) class Parameter(SBase): """ An SBML parameter: a named symbol with a value. A Parameter is used in SBML to define a symbol associated with a value; this symbol can then be used in mathematical formulas in a model. By default, parameters have constant value for the duration of a simulation, and for this reason are called parameters instead of variables in SBML, although it is crucial to understand that SBML parameters represent both concepts. Whether a given SBML parameter is intended to be constant or variable is indicated by the value of its 'constant' attribute. SBML's Parameter has a required attribute, 'id', that gives the parameter a unique identifier by which other parts of an SBML model definition can refer to it. A parameter can also have an optional 'name' attribute of type 'string.' Identifiers and names must be used according to the guidelines described in the SBML specifications. The optional attribute 'value' determines the value (of type 'float)' assigned to the parameter. A missing value for 'value' implies that the value either is unknown, or to be obtained from an external source, or determined by an initial assignment. The unit of measurement associated with the value of the parameter can be specified using the optional attribute 'units'. Here we only mention briefly some notable points about the possible unit choices, but readers are urged to consult the SBML specification documents for more information: * In SBML Level 3, there are no constraints on the units that can be assigned to parameters in a model; there are also no units to inherit from the enclosing Model object (unlike the case for, e.g., Species and Compartment). * In SBML Level 2, the value assigned to the parameter's 'units' attribute must be chosen from one of the following possibilities: one of the base unit identifiers defined in SBML; one of the built-in unit identifiers ''substance',' ''time',' ''volume',' ''area'' or ''length';' or the identifier of a new unit defined in the list of unit definitions in the enclosing Model structure. There are no constraints on the units that can be chosen from these sets. There are no default units for parameters. The Parameter structure has another boolean attribute named 'constant' that is used to indicate whether the parameter's value can vary during a simulation. (In SBML Level 3, the attribute is mandatory and must be given a value; in SBML Levels below Level 3, the attribute is optional.) A value of 'True' indicates the parameter's value cannot be changed by any construct except InitialAssignment. Conversely, if the value of 'constant' is 'False,' other constructs in SBML, such as rules and events, can change the value of the parameter. SBML Level 3 uses a separate object class, LocalParameter, for parameters that are local to a Reaction's KineticLaw. In Levels prior to SBML Level 3, the Parameter class is used both for definitions of global parameters, as well as reaction-local parameters stored in a list within KineticLaw objects. Parameter objects that are local to a reaction (that is, those defined within the KineticLaw structure of a Reaction) cannot be changed by rules and therefore are implicitly always constant; consequently, in SBML Level 2, parameter definitions within Reaction structures should not have their 'constant' attribute set to 'False.' What if a global parameter has its 'constant' attribute set to 'False,' but the model does not contain any rules, events or other constructs that ever change its value over time? Although the model may be suspect, this situation is not strictly an error. A value of 'False' for 'constant' only indicates that a parameter can change value, not that it must. As with all other major SBML components, Parameter is derived from SBase, and the methods defined on SBase are available on Parameter. Note: The use of the term parameter in SBML sometimes leads to confusion among readers who have a particular notion of what something called 'parameter' should be. It has been the source of heated debate, but despite this, no one has yet found an adequate replacement term that does not have different connotations to different people and hence leads to confusion among some subset of users. Perhaps it would have been better to have two constructs, one called constants and the other called variables. The current approach in SBML is simply more parsimonious, using a single Parameter construct with the boolean flag 'constant' indicating which flavor it is. In any case, readers are implored to look past their particular definition of a parameter and simply view SBML's Parameter as a single mechanism for defining both constants and (additional) variables in a model. (We write additional because the species in a model are usually considered to be the central variables.) After all, software tools are not required to expose to users the actual names of particular SBML constructs, and thus tools can present to their users whatever terms their designers feel best matches their target audience. In SBML Level 3 Version 2, many restrictions were lifted requiring only Boolean values in Boolean contexts, and numeric values in numeric contexts. This means that a Parameter may now be used as a Boolean, despite canonically having a numeric value. To be consistent, one should always assign it a value of 'True' or 'False,' and use it in Boolean contexts exclusively. It would be appropriate to give it an SBO value of 602 ('Logical parameter') if one chooses to do this. See also ListOfParameters. """ __swig_setmethods__ = {} for _s in [SBase]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, Parameter, name, value) __swig_getmethods__ = {} for _s in [SBase]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, Parameter, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_Parameter __del__ = lambda self: None def __init__(self, *args): """ __init__(Parameter self, unsigned int level, unsigned int version) -> Parameter __init__(Parameter self, SBMLNamespaces sbmlns) -> Parameter __init__(Parameter self, Parameter orig) -> Parameter This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: Parameter(SBMLNamespaces sbmlns) Creates a new Parameter using the given SBMLNamespaces object 'sbmlns'. The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments. It is worth emphasizing that although this constructor does not take an identifier argument, in SBML Level 2 and beyond, the 'id' (identifier) attribute of a Parameter is required to have a value. Thus, callers are cautioned to assign a value after calling this constructor if no identifier is provided as an argument. Setting the identifier can be accomplished using the method setId(). Parameter 'sbmlns' is an SBMLNamespaces object. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: Parameter(long level, long version) Creates a new Parameter using the given SBML 'level' and 'version' values. Parameter 'level' is a long integer, the SBML Level to assign to this Parameter. Parameter 'version' is a long integer, the SBML Version to assign to this Parameter. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: Parameter(Parameter orig) Copy constructor; creates a copy of a Parameter. Parameter 'orig' is the Parameter instance to copy. """ this = _libsbml.new_Parameter(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(Parameter self) -> Parameter Creates and returns a deep copy of this Parameter object. Returns the (deep) copy of this Parameter object. """ return _libsbml.Parameter_clone(self) def initDefaults(self): """ initDefaults(Parameter self) Initializes the fields of this Parameter object to 'typical' defaults values. The SBML Parameter component has slightly different aspects and default attribute values in different SBML Levels and Versions. Many SBML object classes defined by libSBML have an initDefaults() method to set the values to certain common defaults, based mostly on what they are in SBML Level 2. In the case of Parameter, this method only sets the value of the 'constant' attribute to 'True.' See also getConstant(), isSetConstant(), setConstant(). """ return _libsbml.Parameter_initDefaults(self) def getId(self): """ getId(Parameter self) -> string Returns the value of the 'id' attribute of this Parameter. Note: Because of the inconsistent behavior of this function with respect to assignments and rules, it is now recommended to use the getIdAttribute() function instead. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Returns the id of this Parameter. See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(). """ return _libsbml.Parameter_getId(self) def getName(self): """ getName(Parameter self) -> string Returns the value of the 'name' attribute of this Parameter object. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns the name of this SBML object, or the empty string if not set or unsettable. See also getIdAttribute(), isSetName(), setName(), unsetName(). """ return _libsbml.Parameter_getName(self) def getValue(self): """ getValue(Parameter self) -> double Gets the numerical value of this Parameter. Returns the value of the 'value' attribute of this Parameter, as a number of type 'float.' Note: It is crucial that callers not blindly call Parameter.getValue() without first using Parameter.isSetValue() to determine whether a value has ever been set. Otherwise, the value return by Parameter.getValue() may not actually represent a value assigned to the parameter. The reason is simply that the data type 'float' in a program always has some value. A separate test is needed to determine whether the value is a true model value, or uninitialized data in a computer's memory location. See also isSetValue(), setValue(), getUnits(). """ return _libsbml.Parameter_getValue(self) def getUnits(self): """ getUnits(Parameter self) -> string Gets the units defined for this Parameter. The value of an SBML parameter's 'units' attribute establishes the unit of measurement associated with the parameter's value. Returns the value of the 'units' attribute of this Parameter, as a string. An empty string indicates that no units have been assigned. Note: There is an important distinction to be made between no units assigned, and assuming a value without units has any specific unit such as dimensionless. In SBML, default units are never attributed to numbers, and numbers without units are not automatically assumed to have the unit dimensionless. Please consult the relevant SBML specification document for a more in-depth explanation of this topic and the SBML unit system. See also isSetUnits(), setUnits(), getValue(). """ return _libsbml.Parameter_getUnits(self) def getConstant(self): """ getConstant(Parameter self) -> bool Gets the value of the 'constant' attribute of this Parameter instance. Returns 'True' if this Parameter is declared as being constant, 'False' otherwise. Note: Readers who view the documentation for LocalParameter may be confused about the presence of this method. LibSBML derives LocalParameter from Parameter; however, this does not precisely match the object hierarchy defined by SBML Level 3, where LocalParameter is derived directly from SBase and not Parameter. We believe this arrangement makes it easier for libSBML users to program applications that work with both SBML Level 2 and SBML Level 3, but programmers should also keep in mind this difference exists. A side-effect of libSBML's scheme is that certain methods on LocalParameter that are inherited from Parameter do not actually have relevance to LocalParameter objects. An example of this is the methods pertaining to Parameter's attribute 'constant' (i.e., isSetConstant(), setConstant(), and getConstant()). See also isSetConstant(), setConstant(). """ return _libsbml.Parameter_getConstant(self) def isSetId(self): """ isSetId(Parameter self) -> bool Predicate returning 'True' if this Parameter's 'id' attribute is set. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Returns 'True' if the 'id' attribute of this SBML object is set, 'False' otherwise. Note: Because of the inconsistent behavior of this function with respect to assignments and rules, it is recommended that callers use isSetIdAttribute() instead. See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(), isSetIdAttribute(). """ return _libsbml.Parameter_isSetId(self) def isSetName(self): """ isSetName(Parameter self) -> bool Predicate returning 'True' if this Parameter's 'name' attribute is set. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns 'True' if the 'name' attribute of this SBML object is set, 'False' otherwise. See also getName(), setName(), unsetName(). """ return _libsbml.Parameter_isSetName(self) def isSetValue(self): """ isSetValue(Parameter self) -> bool Predicate returning 'True' if the 'value' attribute of this Parameter is set. In SBML definitions after SBML Level 1 Version 1, parameter values are optional and have no defaults. If a model read from a file does not contain a setting for the 'value' attribute of a parameter, its value is considered unset; it does not default to any particular value. Similarly, when a Parameter object is created in libSBML, it has no value until given a value. The Parameter.isSetValue() method allows calling applications to determine whether a given parameter's value has ever been set. In SBML Level 1 Version 1, parameters are required to have values and therefore, the value of a Parameter should always be set. In Level 1 Version 2 and beyond, the value is optional and as such, the 'value' attribute may or may not be set. Returns 'True' if the value of this Parameter is set, 'False' otherwise. See also getValue(), setValue(). """ return _libsbml.Parameter_isSetValue(self) def isSetUnits(self): """ isSetUnits(Parameter self) -> bool Predicate returning 'True' if the 'units' attribute of this Parameter is set. Returns 'True' if the 'units' attribute of this Parameter is set, 'False' otherwise. Note: There is an important distinction to be made between no units assigned, and assuming a value without units has any specific unit such as dimensionless. In SBML, default units are never attributed to numbers, and numbers without units are not automatically assumed to have the unit dimensionless. Please consult the relevant SBML specification document for a more in-depth explanation of this topic and the SBML unit system. """ return _libsbml.Parameter_isSetUnits(self) def isSetConstant(self): """ isSetConstant(Parameter self) -> bool Predicate returning 'True' if the 'constant' attribute of this Parameter is set. Returns 'True' if the 'constant' attribute of this Parameter is set, 'False' otherwise. Note: Readers who view the documentation for LocalParameter may be confused about the presence of this method. LibSBML derives LocalParameter from Parameter; however, this does not precisely match the object hierarchy defined by SBML Level 3, where LocalParameter is derived directly from SBase and not Parameter. We believe this arrangement makes it easier for libSBML users to program applications that work with both SBML Level 2 and SBML Level 3, but programmers should also keep in mind this difference exists. A side-effect of libSBML's scheme is that certain methods on LocalParameter that are inherited from Parameter do not actually have relevance to LocalParameter objects. An example of this is the methods pertaining to Parameter's attribute 'constant' (i.e., isSetConstant(), setConstant(), and getConstant()). See also getConstant(), setConstant(). """ return _libsbml.Parameter_isSetConstant(self) def setId(self, sid): """ setId(Parameter self, string sid) -> int Sets the value of the 'id' attribute of this Parameter. The string 'sid' is copied. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Parameter 'sid' is the string to use as the identifier of this object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE * LIBSBML_UNEXPECTED_ATTRIBUTE See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(). """ return _libsbml.Parameter_setId(self, sid) def setName(self, name): """ setName(Parameter self, string name) -> int Sets the value of the 'name' attribute of this Parameter. The string in 'name' is copied. Parameter 'name' is the new name for the Parameter. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.Parameter_setName(self, name) def setValue(self, value): """ setValue(Parameter self, double value) -> int Sets the 'value' attribute of this Parameter to the given 'float' value and marks the attribute as set. Parameter 'value' is a 'float,' the value to assign. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS """ return _libsbml.Parameter_setValue(self, value) def setUnits(self, units): """ setUnits(Parameter self, string units) -> int Sets the 'units' attribute of this Parameter to a copy of the given units identifier 'units'. Parameter 'units' is a string, the identifier of the units to assign to this Parameter instance. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.Parameter_setUnits(self, units) def setConstant(self, flag): """ setConstant(Parameter self, bool flag) -> int Sets the 'constant' attribute of this Parameter to the given boolean 'flag'. Parameter 'flag' is a boolean, the value for the 'constant' attribute of this Parameter instance. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE Note: Readers who view the documentation for LocalParameter may be confused about the presence of this method. LibSBML derives LocalParameter from Parameter; however, this does not precisely match the object hierarchy defined by SBML Level 3, where LocalParameter is derived directly from SBase and not Parameter. We believe this arrangement makes it easier for libSBML users to program applications that work with both SBML Level 2 and SBML Level 3, but programmers should also keep in mind this difference exists. A side-effect of libSBML's scheme is that certain methods on LocalParameter that are inherited from Parameter do not actually have relevance to LocalParameter objects. An example of this is the methods pertaining to Parameter's attribute 'constant' (i.e., isSetConstant(), setConstant(), and getConstant()). See also getConstant(), isSetConstant(). """ return _libsbml.Parameter_setConstant(self, flag) def unsetName(self): """ unsetName(Parameter self) -> int Unsets the value of the 'name' attribute of this Parameter. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also getName(), setName(), isSetName(). """ return _libsbml.Parameter_unsetName(self) def unsetConstant(self): """ unsetConstant(Parameter self) -> int Unsets the value of the 'constant' attribute of this Parameter object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also isSetConstant(), setConstant(), getConstant(). """ return _libsbml.Parameter_unsetConstant(self) def unsetValue(self): """ unsetValue(Parameter self) -> int Unsets the 'value' attribute of this Parameter instance. Returns integer value indicating success/failure of the function. This particular function only does one thing irrespective of user input or object state, and thus will only return a single value: * LIBSBML_OPERATION_SUCCESS In SBML Level 1 Version 1, parameters are required to have values and therefore, the value of a Parameter should always be set. In SBML Level 1 Version 2 and beyond, the value is optional and as such, the 'value' attribute may or may not be set. """ return _libsbml.Parameter_unsetValue(self) def unsetUnits(self): """ unsetUnits(Parameter self) -> int Unsets the 'units' attribute of this Parameter instance. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.Parameter_unsetUnits(self) def getDerivedUnitDefinition(self, *args): """ getDerivedUnitDefinition(Parameter self) -> UnitDefinition getDerivedUnitDefinition(Parameter self) -> UnitDefinition Constructs and returns a UnitDefinition that corresponds to the units of this Parameter's value. Parameters in SBML have an attribute ('units') for declaring the units of measurement intended for the parameter's value. No defaults are defined by SBML in the absence of a definition for 'units'. This method returns a UnitDefinition object based on the units declared for this Parameter using its 'units' attribute, or it returns 'None' if no units have been declared. Note that unit declarations for Parameter objects are specified in terms of the identifier of a unit (e.g., using setUnits()), but this method returns a UnitDefinition object, not a unit identifier. It does this by constructing an appropriate UnitDefinition.For SBML Level 2 models, it will do this even when the value of the 'units' attribute is one of the special SBML Level 2 unit identifiers ''substance',' ''volume',' ''area',' ''length'' or ''time'.' Callers may find this useful in conjunction with the helper methods provided by the UnitDefinition class for comparing different UnitDefinition objects. Returns a UnitDefinition that expresses the units of this Parameter, or 'None' if one cannot be constructed. Note: The libSBML system for unit analysis depends on the model as a whole. In cases where the Parameter object has not yet been added to a model, or the model itself is incomplete, unit analysis is not possible, and consequently this method will return 'None.' See also isSetUnits(). """ return _libsbml.Parameter_getDerivedUnitDefinition(self, *args) def getTypeCode(self): """ getTypeCode(Parameter self) -> int Returns the libSBML type code for this SBML object. LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for this object: SBML_PARAMETER (default). WARNING: The specific integer values of the possible type codes may be reused by different libSBML plug-ins for SBML Level 3. packages, To fully identify the correct code, it is necessary to invoke both getPackageName() and getTypeCode() (or ListOf.getItemTypeCode()). See also getElementName(), getPackageName(). """ return _libsbml.Parameter_getTypeCode(self) def getElementName(self): """ getElementName(Parameter self) -> string Returns the XML element name of this object, which for Parameter, is always ''parameter'.' Returns the name of this element, i.e., ''parameter'.' """ return _libsbml.Parameter_getElementName(self) def hasRequiredAttributes(self): """ hasRequiredAttributes(Parameter self) -> bool Predicate returning 'True' if all the required attributes for this Parameter object have been set. The required attributes for a Parameter object are: * 'id' (or 'name' in SBML Level 1) * 'value' (required in Level 1, optional otherwise) Returns 'True' if the required attributes have been set, 'False' otherwise. """ return _libsbml.Parameter_hasRequiredAttributes(self) def renameUnitSIdRefs(self, oldid, newid): """ renameUnitSIdRefs(Parameter self, string oldid, string newid) Renames all the 'UnitSIdRef' attributes on this element. In SBML, unit definitions have identifiers of type UnitSId. In SBML Level 3, an explicit data type called UnitSIdRef was introduced for attribute values that refer to UnitSId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to a unit identifier', but the effective data type was the same as UnitSIdRef in Level 3. These and other methods of libSBML refer to the type UnitSIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all unit identifier attribute values (including, if appropriate, inside mathematical formulas), comparing the unit identifiers to the value of 'oldid'. If any matches are found, the matching identifiers are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.Parameter_renameUnitSIdRefs(self, oldid, newid) def setCalculatingUnits(self, calculatingUnits): """ setCalculatingUnits(Parameter self, bool calculatingUnits) Internal implementation method. """ return _libsbml.Parameter_setCalculatingUnits(self, calculatingUnits) Parameter_swigregister = _libsbml.Parameter_swigregister Parameter_swigregister(Parameter) class ListOfParameters(ListOf): """ A list of Parameter objects. The various ListOf___ classes in SBML are merely containers used for organizing the main components of an SBML model. In libSBML's implementation, ListOf___ classes are derived from the intermediate utility class ListOf, which is not defined by the SBML specifications but serves as a useful programmatic construct. ListOf is itself is in turn derived from SBase, which provides all of the various ListOf___ classes with common features defined by the SBML specification, such as 'metaid' attributes and annotations. The relationship between the lists and the rest of an SBML model is illustrated by the following (for SBML Level 2 Version 4): ... ... ... ... ... ... ... elements of subclasses of Rule ... ... ... ... SBML Level 3 Version 1 has essentially the same structure as Level 2 Version 4, depicted above, but SBML Level 3 Version 2 allows containers to contain zero or more of the relevant object, instead of requiring at least one. As such, libsbml will write out an otherwise-empty ListOf___ element that has any optional attribute set (such as 'id' or 'metaid'), that has an optional child (such as a 'notes' or 'annotation'), or that has attributes or children set from any SBML Level 3 package, whether or not the ListOf___ has any other children. Readers may wonder about the motivations for using the ListOf___ containers in SBML. A simpler approach in XML might be to place the components all directly at the top level of the model definition. The choice made in SBML is to group them within XML elements named after ListOfClassname, in part because it helps organize the components. More importantly, the fact that the container classes are derived from SBase means that software tools can add information about the lists themselves into each list container's 'annotation'. See also ListOfFunctionDefinitions, ListOfUnitDefinitions, ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments, ListOfSpecies, ListOfParameters, ListOfInitialAssignments, ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents. """ __swig_setmethods__ = {} for _s in [ListOf]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfParameters, name, value) __swig_getmethods__ = {} for _s in [ListOf]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, ListOfParameters, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(ListOfParameters self, unsigned int level, unsigned int version) -> ListOfParameters __init__(ListOfParameters self, SBMLNamespaces sbmlns) -> ListOfParameters This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: ListOfParameters(SBMLNamespaces sbmlns) Creates a new ListOfParameters object. The object is constructed such that it is valid for the SBML Level and Version combination determined by the SBMLNamespaces object in 'sbmlns'. Parameter 'sbmlns' is an SBMLNamespaces object that is used to determine the characteristics of the ListOfParameters object to be created. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: ListOfParameters(long level, long version) Creates a new ListOfParameters object. The object is constructed such that it is valid for the given SBML Level and Version combination. Parameter 'level' is the SBML Level. Parameter 'version' is the Version within the SBML Level. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. """ this = _libsbml.new_ListOfParameters(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(ListOfParameters self) -> ListOfParameters Creates and returns a deep copy of this ListOfParameters object. Returns the (deep) copy of this ListOfParameters object. """ return _libsbml.ListOfParameters_clone(self) def getItemTypeCode(self): """ getItemTypeCode(ListOfParameters self) -> int Returns the libSBML type code for the objects contained in this ListOf (i.e., Parameter objects, if the list is non-empty). LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for this objects contained in this list: SBML_PARAMETER (default). See also getElementName(), getPackageName(). """ return _libsbml.ListOfParameters_getItemTypeCode(self) def getElementName(self): """ getElementName(ListOfParameters self) -> string Returns the XML element name of this object. For ListOfParameters, the XML element name is ''listOfParameters'.' Returns the name of this element, i.e., ''listOfParameters'.' """ return _libsbml.ListOfParameters_getElementName(self) def get(self, *args): """ get(ListOfParameters self, unsigned int n) -> Parameter get(ListOfParameters self, unsigned int n) -> Parameter get(ListOfParameters self, string sid) -> Parameter get(ListOfParameters self, string sid) -> Parameter This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: get(long n) Returns the Parameter object located at position 'n' within this ListOfParameters instance. Parameter 'n' is the index number of the Parameter to get. Returns the nth Parameter in this ListOfParameters. If the index 'n' is out of bounds for the length of the list, then 'None' is returned. See also size(), get(). ______________________________________________________________________ Method variant with the following signature: get(string sid) Returns the first Parameter object matching the given identifier. Parameter 'sid' is a string representing the identifier of the Parameter to get. Returns the Parameter object found. The caller owns the returned object and is responsible for deleting it. If none of the items have an identifier matching 'sid', then 'None' is returned. See also get(), size(). """ return _libsbml.ListOfParameters_get(self, *args) def remove(self, *args): """ remove(ListOfParameters self, unsigned int n) -> Parameter remove(ListOfParameters self, string sid) -> Parameter This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: remove(long n) Removes the nth item from this ListOfParameters, and returns a pointer to it. Parameter 'n' is the index of the item to remove. Returns the item removed. The caller owns the returned object and is responsible for deleting it. If the index number 'n' is out of bounds for the length of the list, then 'None' is returned. See also size(). ______________________________________________________________________ Method variant with the following signature: remove(string sid) Removes the first Parameter object in this ListOfParameters matching the given identifier, and returns a pointer to it. Parameter 'sid' is the identifier of the item to remove. Returns the item removed. The caller owns the returned object and is responsible for deleting it. If none of the items have an identifier matching 'sid', then 'None' is returned. """ return _libsbml.ListOfParameters_remove(self, *args) __swig_destroy__ = _libsbml.delete_ListOfParameters __del__ = lambda self: None ListOfParameters_swigregister = _libsbml.ListOfParameters_swigregister ListOfParameters_swigregister(ListOfParameters) class LocalParameter(Parameter): """ A parameter inside an SBML reaction definition. LocalParameter has been introduced in SBML Level 3 to serve as the object class for parameter definitions that are intended to be local to a Reaction. Objects of class LocalParameter never appear at the Model level; they are always contained within ListOfLocalParameters lists which are in turn contained within KineticLaw objects. Like its global Parameter counterpart, the LocalParameter object class is used to define a symbol associated with a value; this symbol can then be used in a model's mathematical formulas (and specifically, for LocalParameter, reaction rate formulas). Unlike Parameter, the LocalParameter class does not have a 'constant' attribute: local parameters within reactions are always constant. LocalParameter has one required attribute, 'id', to give the parameter a unique identifier by which other parts of an SBML model definition can refer to it. A parameter can also have an optional 'name' attribute of type 'string.' Identifiers and names must be used according to the guidelines described in the SBML specifications. The optional attribute 'value' determines the value (of type 'float)' assigned to the parameter. A missing value for 'value' implies that the value either is unknown, or to be obtained from an external source, or determined by an initial assignment. The unit of measurement associated with the value of the parameter can be specified using the optional attribute 'units'. Here we only mention briefly some notable points about the possible unit choices, but readers are urged to consult the SBML specification documents for more information: * In SBML Level 3, there are no constraints on the units that can be assigned to parameters in a model; there are also no units to inherit from the enclosing Model object. * In SBML Level 2, the value assigned to the parameter's 'units' attribute must be chosen from one of the following possibilities: one of the base unit identifiers defined in SBML; one of the built-in unit identifiers ''substance',' ''time',' ''volume',' ''area'' or ''length';' or the identifier of a new unit defined in the list of unit definitions in the enclosing Model structure. There are no constraints on the units that can be chosen from these sets. There are no default units for local parameters. As with all other major SBML components, LocalParameter is derived from SBase, and the methods defined on SBase are available on LocalParameter. In SBML Level 3 Version 2, the scope of the LocalParameter was expanded slightly to officially encompass the entire Reaction instead of just the KineticLaw in which it appears. This has no effect on models using only SBML Level 3 Core constructs, but has the potential to allow SBML Level 3 Packages to include elements in a Reaction that could reference a LocalParameter from that Reaction's KineticLaw. It also means that no LocalParameter may have the same ''id'' as a referenced Species in any SimpleSpeciesReference in that Reaction. WARNING: LibSBML derives LocalParameter from Parameter; however, this does not precisely match the object hierarchy defined by SBML Level 3, where LocalParameter is derived directly from SBase and not Parameter. We believe this arrangement makes it easier for libSBML users to program applications that work with both SBML Level 2 and SBML Level 3, but programmers should also keep in mind this difference exists. A side- effect of libSBML's scheme is that certain methods on LocalParameter that are inherited from Parameter do not actually have relevance to LocalParameter objects. An example of this is the methods pertaining to Parameter's attribute 'constant' (i.e., isSetConstant(), setConstant(), and getConstant()). See also ListOfLocalParameters, KineticLaw. """ __swig_setmethods__ = {} for _s in [Parameter]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, LocalParameter, name, value) __swig_getmethods__ = {} for _s in [Parameter]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, LocalParameter, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_LocalParameter __del__ = lambda self: None def __init__(self, *args): """ __init__(LocalParameter self, unsigned int level, unsigned int version) -> LocalParameter __init__(LocalParameter self, SBMLNamespaces sbmlns) -> LocalParameter __init__(LocalParameter self, LocalParameter orig) -> LocalParameter __init__(LocalParameter self, Parameter orig) -> LocalParameter This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: LocalParameter(SBMLNamespaces sbmlns) Creates a new LocalParameter object with the given SBMLNamespaces object 'sbmlns'. The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments. It is worth emphasizing that although this constructor does not take an identifier argument, in SBML Level 2 and beyond, the 'id' (identifier) attribute of a LocalParameter is required to have a value. Thus, callers are cautioned to assign a value after calling this constructor if no identifier is provided as an argument. Setting the identifier can be accomplished using the method setId(). Parameter 'sbmlns' is an SBMLNamespaces object. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: LocalParameter(long level, long version) Creates a new LocalParameter object with the given SBML 'level' and 'version' values. Parameter 'level' is a long integer, the SBML Level to assign to this LocalParameter. Parameter 'version' is a long integer, the SBML Version to assign to this LocalParameter. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: LocalParameter(LocalParameter orig) Copy constructor; creates a copy of a given LocalParameter object. Parameter 'orig' is the LocalParameter instance to copy. ______________________________________________________________________ Method variant with the following signature: LocalParameter(Parameter orig) Copy constructor; creates a LocalParameter object by copying the attributes of a given Parameter object. Parameter 'orig' is the Parameter instance to copy. """ this = _libsbml.new_LocalParameter(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(LocalParameter self) -> LocalParameter Creates and returns a deep copy of this LocalParameter object. Returns the (deep) copy of this LocalParameter object. """ return _libsbml.LocalParameter_clone(self) def getDerivedUnitDefinition(self, *args): """ getDerivedUnitDefinition(LocalParameter self) -> UnitDefinition getDerivedUnitDefinition(LocalParameter self) -> UnitDefinition Constructs and returns a UnitDefinition that corresponds to the units of this LocalParameter's value. LocalParameters in SBML have an attribute ('units') for declaring the units of measurement intended for the parameter's value. No defaults are defined by SBML in the absence of a definition for 'units'. This method returns a UnitDefinition object based on the units declared for this LocalParameter using its 'units' attribute, or it returns 'None' if no units have been declared. Note that unit declarations for LocalParameter objects are specified in terms of the identifier of a unit (e.g., using setUnits()), but this method returns a UnitDefinition object, not a unit identifier. It does this by constructing an appropriate UnitDefinition. For SBML Level 2 models, it will do this even when the value of the 'units' attribute is one of the predefined SBML units ''substance',' ''volume',' ''area',' ''length'' or ''time'.' Callers may find this useful in conjunction with the helper methods provided by the UnitDefinition class for comparing different UnitDefinition objects. Returns a UnitDefinition that expresses the units of this LocalParameter, or 'None' if one cannot be constructed. Note: The libSBML system for unit analysis depends on the model as a whole. In cases where the LocalParameter object has not yet been added to a model, or the model itself is incomplete, unit analysis is not possible, and consequently this method will return 'None.' See also isSetUnits(). """ return _libsbml.LocalParameter_getDerivedUnitDefinition(self, *args) def getTypeCode(self): """ getTypeCode(LocalParameter self) -> int Returns the libSBML type code for this SBML object. LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for this object: SBML_LOCAL_PARAMETER (default). WARNING: The specific integer values of the possible type codes may be reused by different libSBML plug-ins for SBML Level 3. packages, To fully identify the correct code, it is necessary to invoke both getPackageName() and getTypeCode() (or ListOf.getItemTypeCode()). See also getElementName(), getPackageName(). """ return _libsbml.LocalParameter_getTypeCode(self) def getElementName(self): """ getElementName(LocalParameter self) -> string Returns the XML element name of this object, which for LocalParameter, is always ''localParameter'.' Returns the name of this element, i.e., ''localParameter'.' """ return _libsbml.LocalParameter_getElementName(self) def hasRequiredAttributes(self): """ hasRequiredAttributes(LocalParameter self) -> bool Predicate returning 'True' if all the required attributes for this LocalParameter object have been set. The required attributes for a LocalParameter object are: * 'id' * 'value' Returns 'True' if the required attributes have been set, 'False' otherwise. """ return _libsbml.LocalParameter_hasRequiredAttributes(self) def getConstant(self): """ getConstant(LocalParameter self) -> bool Internal implementation method. """ return _libsbml.LocalParameter_getConstant(self) def isSetConstant(self): """ isSetConstant(LocalParameter self) -> bool Internal implementation method. """ return _libsbml.LocalParameter_isSetConstant(self) def setConstant(self, flag): """ setConstant(LocalParameter self, bool flag) -> int Internal implementation method. """ return _libsbml.LocalParameter_setConstant(self, flag) def unsetConstant(self): """ unsetConstant(LocalParameter self) -> int Internal implementation method. """ return _libsbml.LocalParameter_unsetConstant(self) LocalParameter_swigregister = _libsbml.LocalParameter_swigregister LocalParameter_swigregister(LocalParameter) class ListOfLocalParameters(ListOfParameters): """ A list of LocalParameter objects. The various ListOf___ classes in SBML are merely containers used for organizing the main components of an SBML model. In libSBML's implementation, ListOf___ classes are derived from the intermediate utility class ListOf, which is not defined by the SBML specifications but serves as a useful programmatic construct. ListOf is itself is in turn derived from SBase, which provides all of the various ListOf___ classes with common features defined by the SBML specification, such as 'metaid' attributes and annotations. The relationship between the lists and the rest of an SBML model is illustrated by the following (for SBML Level 2 Version 4): ... ... ... ... ... ... ... elements of subclasses of Rule ... ... ... ... SBML Level 3 Version 1 has essentially the same structure as Level 2 Version 4, depicted above, but SBML Level 3 Version 2 allows containers to contain zero or more of the relevant object, instead of requiring at least one. As such, libsbml will write out an otherwise-empty ListOf___ element that has any optional attribute set (such as 'id' or 'metaid'), that has an optional child (such as a 'notes' or 'annotation'), or that has attributes or children set from any SBML Level 3 package, whether or not the ListOf___ has any other children. Readers may wonder about the motivations for using the ListOf___ containers in SBML. A simpler approach in XML might be to place the components all directly at the top level of the model definition. The choice made in SBML is to group them within XML elements named after ListOfClassname, in part because it helps organize the components. More importantly, the fact that the container classes are derived from SBase means that software tools can add information about the lists themselves into each list container's 'annotation'. See also ListOfFunctionDefinitions, ListOfUnitDefinitions, ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments, ListOfSpecies, ListOfParameters, ListOfInitialAssignments, ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents. """ __swig_setmethods__ = {} for _s in [ListOfParameters]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfLocalParameters, name, value) __swig_getmethods__ = {} for _s in [ListOfParameters]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, ListOfLocalParameters, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(ListOfLocalParameters self, unsigned int level, unsigned int version) -> ListOfLocalParameters __init__(ListOfLocalParameters self, SBMLNamespaces sbmlns) -> ListOfLocalParameters This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: ListOfLocalParameters(SBMLNamespaces sbmlns) Creates a new ListOfLocalParameters object. The object is constructed such that it is valid for the SBML Level and Version combination determined by the SBMLNamespaces object in 'sbmlns'. Parameter 'sbmlns' is an SBMLNamespaces object that is used to determine the characteristics of the ListOfLocalParameters object to be created. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: ListOfLocalParameters(long level, long version) Creates a new ListOfLocalParameters object. The object is constructed such that it is valid for the given SBML Level and Version combination. Parameter 'level' is the SBML Level. Parameter 'version' is the Version within the SBML Level. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. """ this = _libsbml.new_ListOfLocalParameters(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(ListOfLocalParameters self) -> ListOfLocalParameters Creates and returns a deep copy of this ListOfLocalParameters object. Returns the (deep) copy of this ListOfLocalParameters object. """ return _libsbml.ListOfLocalParameters_clone(self) def getItemTypeCode(self): """ getItemTypeCode(ListOfLocalParameters self) -> int Returns the libSBML type code for the objects contained in this ListOf (i.e., LocalParameter objects, if the list is non-empty). LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for the objects contained in this ListOf: SBML_LOCAL_PARAMETER (default). See also getElementName(), getPackageName(). """ return _libsbml.ListOfLocalParameters_getItemTypeCode(self) def getElementName(self): """ getElementName(ListOfLocalParameters self) -> string Returns the XML element name of this object. For ListOfLocalParameters, the XML element name is ''listOfLocalParameters'.' Returns the name of this element, i.e., ''listOfLocalParameters'.' """ return _libsbml.ListOfLocalParameters_getElementName(self) def get(self, *args): """ get(ListOfLocalParameters self, unsigned int n) -> LocalParameter get(ListOfLocalParameters self, unsigned int n) -> LocalParameter get(ListOfLocalParameters self, string sid) -> LocalParameter get(ListOfLocalParameters self, string sid) -> LocalParameter This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: get(long n) Returns the LocalParameter object located at position 'n' within this ListOfLocalParameters instance. Parameter 'n' is the index number of the LocalParameter to get. Returns the item at position 'n'. The caller owns the returned object and is responsible for deleting it. If the index number 'n' is out of bounds for the length of the list, then 'None' is returned. See also size(), get(). ______________________________________________________________________ Method variant with the following signature: get(string sid) Returns the first LocalParameter object matching the given identifier. Parameter 'sid' is a string representing the identifier of the LocalParameter to get. Returns the LocalParameter object found. The caller owns the returned object and is responsible for deleting it. If none of the items have an identifier matching 'sid', then 'None' is returned. See also get(), size(). """ return _libsbml.ListOfLocalParameters_get(self, *args) def getElementBySId(self, id): """ getElementBySId(ListOfLocalParameters self, string id) -> SBase Returns the first child element found that has the given 'id' in the model-wide SId namespace, or 'None' if no such object is found. Note that LocalParameters, while they use the SId namespace, are not in the model-wide SId namespace, so no LocalParameter object will be returned from this function (and is the reason we override the base ListOf::getElementBySId function here). Parameter 'id' is string representing the id of the object to find. Returns pointer to the first element found with the given 'id'. """ return _libsbml.ListOfLocalParameters_getElementBySId(self, id) def remove(self, *args): """ remove(ListOfLocalParameters self, unsigned int n) -> LocalParameter remove(ListOfLocalParameters self, string sid) -> LocalParameter This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: remove(long n) Removes the nth item from this ListOfLocalParameters, and returns a pointer to it. Parameter 'n' is the index of the item to remove. Returns the item removed. The caller owns the returned object and is responsible for deleting it. If the index number 'n' is out of bounds for the length of the list, then 'None' is returned. See also size(), remove(). ______________________________________________________________________ Method variant with the following signature: remove(string sid) Removes the first LocalParameter object in this ListOfLocalParameters matching the given identifier, and returns a pointer to it. Parameter 'sid' is the identifier of the item to remove. Returns the item removed. The caller owns the returned object and is responsible for deleting it. If none of the items have an identifier matching 'sid', then 'None' is returned. """ return _libsbml.ListOfLocalParameters_remove(self, *args) __swig_destroy__ = _libsbml.delete_ListOfLocalParameters __del__ = lambda self: None ListOfLocalParameters_swigregister = _libsbml.ListOfLocalParameters_swigregister ListOfLocalParameters_swigregister(ListOfLocalParameters) class InitialAssignment(SBase): """ An SBML initial assignment, evaluated once only. SBML Level 2 Versions 2-4 and SBML Level 3 provide two ways of assigning initial values to entities in a model. The simplest and most basic is to set the values of the appropriate attributes in the relevant components; for example, the initial value of a model parameter (whether it is a constant or a variable) can be assigned by setting its 'value' attribute directly in the model definition. However, this approach is not suitable when the value must be calculated, because the initial value attributes on different components such as species, compartments, and parameters are single values and not mathematical expressions. In those situations, the InitialAssignment construct can be used; it permits the calculation of the value of a constant or the initial value of a variable from the values of other quantities in a model. As explained below, the provision of InitialAssignment does not mean that models necessarily must use this construct when defining initial values of quantities in a model. If a value can be set directly using the relevant attribute of a component in a model, then that approach may be more efficient and more portable to other software tools. InitialAssignment should be used when the other mechanism is insufficient for the needs of a particular model. The InitialAssignment construct has some similarities to AssignmentRule. The main differences are: (a) an InitialAssignment can set the value of a constant whereas an AssignmentRule cannot, and (b) unlike AssignmentRule, an InitialAssignment definition only applies up to and including the beginning of simulation time, i.e., t <= 0, while an AssignmentRule applies at all times. InitialAssignment has a required attribute, 'symbol', whose value must follow the guidelines for identifiers described in the SBML specification (e.g., Section 3.3 in the Level 2 Version 4 specification). The value of this attribute in an InitialAssignment object can be the identifier of a Compartment, Species, SpeciesReference (in SBML Level 3), global Parameter, or (as of SBML Level 3 Version 2) the identifier of a SBML Level 3 package element with mathematical meaning. The InitialAssignment defines the initial value of the constant or variable referred to by the 'symbol' attribute. (The attribute's name is 'symbol' rather than 'variable' because it may assign values to constants as well as variables in a model.) Note that an initial assignment cannot be made to reaction identifiers, that is, the 'symbol' attribute value of an InitialAssignment cannot be an identifier that is the 'id' attribute value of a Reaction object in the model. This is identical to a restriction placed on rules. InitialAssignment also has a 'math' subelement that contains a MathML expression used to calculate the value of the constant or the initial value of the variable. This subelement is required in SBML Level 2 and SBML Level 3 Version 1, but the requirement was relaxed in SBML Level 3 Version 2, making it optional. The units of the value computed by the formula in the 'math' subelement should (in SBML Level 2 Version 4 and in SBML Level 3) or must (in previous Versions) be identical to be the units associated with the identifier given in the 'symbol' attribute. (That is, the units are the units of the species, compartment, or parameter, as appropriate for the kind of object identified by the value of 'symbol'.) InitialAssignment was introduced in SBML Level 2 Version 2. It is not available in SBML Level 2 Version 1 nor in any version of Level 1. Semantics of Initial Assignments ====================================================================== The value calculated by an InitialAssignment object overrides the value assigned to the given symbol by the object defining that symbol. For example, if a compartment's 'size' attribute is set in its definition, and the model also contains an InitialAssignment having that compartment's identifier as its 'symbol' attribute value, then the interpretation is that the 'size' assigned in the Compartment object should be ignored and the value assigned based on the computation defined in the InitialAssignment. Initial assignments can take place for Compartment, Species, global Parameter, SpeciesReference (in Level 3), and SBML Level 3 package elements (in Level 3 Version 2), regardless of the value of their 'constant' attribute. The actions of all InitialAssignment objects are in general terms the same, but differ in the precise details depending on the type of variable being set: * In the case of a species, an InitialAssignment sets the referenced species' initial quantity (concentration or amount of substance) to the value determined by the formula in the 'math' subelement. The overall units of the formula should (in SBML Level 2 Version 4 and in SBML Level 3) or must (in previous Versions) be the same as the units specified for the species. * In the case of a compartment, an InitialAssignment sets the referenced compartment's initial size to the size determined by the formula in 'math'. The overall units of the formula should (in SBML Level 2 Version 4 and in SBML Level 3) or must (in previous Versions) be the same as the units specified for the size of the compartment. * In the case of a parameter, an InitialAssignment sets the referenced parameter's initial value to that determined by the formula in 'math'. The overall units of the formula should (in SBML Level 2 Version 4 and SBML Level 3) or must (in previous Versions) be the same as the units defined for the parameter. * (For SBML Level 3 only) In the case of a species reference, an initial assignment sets the initial value of the stoichiometry of the referenced reactant or product to the value determined by the formula in 'math'. The unit associated with the value produced by the 'math' formula should be consistent with the unit 'dimensionless', because reactant and product stoichiometries in reactions are dimensionless quantities. * (For SBML Level 3 Version 2 only) In the case of an object from an SBML Level 3 package, an InitialAssignment sets the referenced object's initial value (however such values are defined by the package) to the value of the formula in math. The unit of measurement associated with the value produced by the formula should be the same as that object's units attribute value (if it has such an attribute), or be equal to the units of model components of that type (if objects of that class are defined by the package as having the same units). If the symbol attribute of an InitialAssignment object references an object in an SBML namespace that is not understood by the interpreter reading a given SBML document (that is, if the object is defined by an SBML Level 3 package that the software does not support), the assignment must be ignored--the object's initial value will not need to be set, as the interpreter could not understand that package. If an interpreter cannot establish whether a referenced object is missing from the model or instead is defined in an SBML namespace not understood by the interpreter, it may produce a warning to the user. (The latter situation may only arise if an SBML package is present in the SBML document with a package:required attribute of 'true'.) In the context of a simulation, initial assignments establish values that are in effect prior to and including the start of simulation time, i.e., t <= 0. Section 3.4.8 in the SBML Level 2 Version 4 and SBML Level 3 specifications provides information about the interpretation of assignments, rules, and entity values for simulation time up to and including the start time t = 0; this is important for establishing the initial conditions of a simulation if the model involves expressions containing the delay 'csymbol'. There cannot be two initial assignments for the same symbol in a model; that is, a model must not contain two or more InitialAssignment objects that both have the same identifier as their 'symbol' attribute value. A model must also not define initial assignments and assignment rules for the same entity. That is, there cannot be both an InitialAssignment and an AssignmentRule for the same symbol in a model, because both kinds of constructs apply prior to and at the start of simulated time---allowing both to exist for a given symbol would result in indeterminism). The ordering of InitialAssignment objects is not significant. The combined set of InitialAssignment, AssignmentRule and KineticLaw objects form a set of assignment statements that must be considered as a whole. The combined set of assignment statements should not contain algebraic loops: a chain of dependency between these statements should terminate. (More formally, consider the directed graph of assignment statements where nodes are a model's assignment statements and directed arcs exist for each occurrence of a symbol in an assignment statement 'math' attribute. The directed arcs in this graph start from the statement assigning the symbol and end at the statement that contains the symbol in their math elements. Such a graph must be acyclic.) Finally, it is worth being explicit about the expected behavior in the following situation. Suppose (1) a given symbol has a value x assigned to it in its definition, and (2) there is an initial assignment having the identifier as its 'symbol' value and reassigning the value to y, and (3) the identifier is also used in the mathematical formula of a second initial assignment. What value should the second initial assignment use? It is y, the value assigned to the symbol by the first initial assignment, not whatever value was given in the symbol's definition. This follows directly from the behavior described above: if an InitialAssignment object exists for a given symbol, then the symbol's value is overridden by that initial assignment. """ __swig_setmethods__ = {} for _s in [SBase]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, InitialAssignment, name, value) __swig_getmethods__ = {} for _s in [SBase]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, InitialAssignment, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_InitialAssignment __del__ = lambda self: None def __init__(self, *args): """ __init__(InitialAssignment self, unsigned int level, unsigned int version) -> InitialAssignment __init__(InitialAssignment self, SBMLNamespaces sbmlns) -> InitialAssignment __init__(InitialAssignment self, InitialAssignment orig) -> InitialAssignment This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: InitialAssignment(SBMLNamespaces sbmlns) Creates a new InitialAssignment using the given SBMLNamespaces object 'sbmlns'. The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments. Parameter 'sbmlns' is an SBMLNamespaces object. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: InitialAssignment(long level, long version) Creates a new InitialAssignment using the given SBML 'level' and 'version' values. Parameter 'level' is a long integer, the SBML Level to assign to this InitialAssignment. Parameter 'version' is a long integer, the SBML Version to assign to this InitialAssignment. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: InitialAssignment(InitialAssignment orig) Copy constructor; creates a copy of this InitialAssignment. Parameter 'orig' is the object to copy. """ this = _libsbml.new_InitialAssignment(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(InitialAssignment self) -> InitialAssignment Creates and returns a deep copy of this InitialAssignment object. Returns the (deep) copy of this InitialAssignment object. """ return _libsbml.InitialAssignment_clone(self) def getSymbol(self): """ getSymbol(InitialAssignment self) -> string Get the value of the 'symbol' attribute of this InitialAssignment. Returns the identifier string stored as the 'symbol' attribute value in this InitialAssignment. """ return _libsbml.InitialAssignment_getSymbol(self) def getMath(self): """ getMath(InitialAssignment self) -> ASTNode Get the mathematical formula of this InitialAssignment. Returns an ASTNode, the value of the 'math' subelement of this InitialAssignment, or 'None' if the math is not set. """ return _libsbml.InitialAssignment_getMath(self) def isSetSymbol(self): """ isSetSymbol(InitialAssignment self) -> bool Predicate returning 'True' if this InitialAssignment's 'symbol' attribute is set. Returns 'True' if the 'symbol' attribute of this InitialAssignment is set, 'False' otherwise. """ return _libsbml.InitialAssignment_isSetSymbol(self) def isSetMath(self): """ isSetMath(InitialAssignment self) -> bool Predicate returning 'True' if this InitialAssignment's 'math' subelement contains a value. Returns 'True' if the 'math' for this InitialAssignment is set, 'False' otherwise. """ return _libsbml.InitialAssignment_isSetMath(self) def setSymbol(self, sid): """ setSymbol(InitialAssignment self, string sid) -> int Sets the 'symbol' attribute value of this InitialAssignment. Parameter 'sid' is the identifier of an element defined in this model whose value can be set. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.InitialAssignment_setSymbol(self, sid) def unsetSymbol(self): """ unsetSymbol(InitialAssignment self) -> int Unsets the 'symbol' attribute value of this InitialAssignment. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.InitialAssignment_unsetSymbol(self) def setMath(self, math): """ setMath(InitialAssignment self, ASTNode math) -> int Sets the 'math' subelement of this InitialAssignment. The AST passed in 'math' is copied. Parameter 'math' is an AST containing the mathematical expression to be used as the formula for this InitialAssignment. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT """ return _libsbml.InitialAssignment_setMath(self, math) def getDerivedUnitDefinition(self, *args): """ getDerivedUnitDefinition(InitialAssignment self) -> UnitDefinition getDerivedUnitDefinition(InitialAssignment self) -> UnitDefinition Calculates and returns a UnitDefinition that expresses the units of measurement assumed for the 'math' expression of this InitialAssignment. The units are calculated based on the mathematical expression in the InitialAssignment and the model quantities referenced by elements used within that expression. The method InitialAssignment.getDerivedUnitDefinition() returns the calculated units, to the extent that libSBML can compute them. Note: The functionality that facilitates unit analysis depends on the model as a whole. Thus, in cases where the object has not been added to a model or the model itself is incomplete, unit analysis is not possible and this method will return 'None.' WARNING: Note that it is possible the 'math' expression in the InitialAssignment contains literal numbers or parameters with undeclared units. In those cases, it is not possible to calculate the units of the overall expression without making assumptions. LibSBML does not make assumptions about the units, and InitialAssignment.getDerivedUnitDefinition() only returns the units as far as it is able to determine them. For example, in an expression X + Y, if X has unambiguously-defined units and Y does not, it will return the units of X. When using this method, it is critical that callers also invoke the method InitialAssignment.containsUndeclaredUnits() to determine whether this situation holds. Callers should take suitable action in those situations. Returns a UnitDefinition that expresses the units of the math expression of this InitialAssignment, or 'None' if one cannot be constructed. See also containsUndeclaredUnits(). """ return _libsbml.InitialAssignment_getDerivedUnitDefinition(self, *args) def containsUndeclaredUnits(self, *args): """ containsUndeclaredUnits(InitialAssignment self) -> bool containsUndeclaredUnits(InitialAssignment self) -> bool Predicate returning 'True' if the math expression of this InitialAssignment contains parameters/numbers with undeclared units. Returns 'True' if the math expression of this InitialAssignment includes parameters/numbers with undeclared units, 'False' otherwise. Note: A return value of 'True' indicates that the UnitDefinition returned by InitialAssignment::getDerivedUnitDefinition may not accurately represent the units of the expression. See also getDerivedUnitDefinition(). """ return _libsbml.InitialAssignment_containsUndeclaredUnits(self, *args) def getTypeCode(self): """ getTypeCode(InitialAssignment self) -> int Returns the libSBML type code for this SBML object. LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for this object: SBML_INITIAL_ASSIGNMENT (default). WARNING: The specific integer values of the possible type codes may be reused by different libSBML plug-ins for SBML Level 3. packages, To fully identify the correct code, it is necessary to invoke both getPackageName() and getTypeCode() (or ListOf.getItemTypeCode()). See also getElementName(), getPackageName(). """ return _libsbml.InitialAssignment_getTypeCode(self) def getElementName(self): """ getElementName(InitialAssignment self) -> string Returns the XML element name of this object, which for InitialAssignment, is always ''initialAssignment'.' Returns the name of this element, i.e., ''initialAssignment'.' """ return _libsbml.InitialAssignment_getElementName(self) def hasRequiredAttributes(self): """ hasRequiredAttributes(InitialAssignment self) -> bool Predicate returning 'True' if all the required attributes for this InitialAssignment object have been set. The required attributes for an InitialAssignment object are: * 'symbol' Returns 'True' if the required attributes have been set, 'False' otherwise. """ return _libsbml.InitialAssignment_hasRequiredAttributes(self) def hasRequiredElements(self): """ hasRequiredElements(InitialAssignment self) -> bool Predicate returning 'True' if all the required elements for this InitialAssignment object have been set. Note: The required elements for a InitialAssignment object are: * 'math' inSBML Level 2 and Level 3 Version 1. (In SBML Level 3 Version 2+, it is no longer required.) Returns a boolean value indicating whether all the required elements for this object have been defined. """ return _libsbml.InitialAssignment_hasRequiredElements(self) def getId(self): """ getId(InitialAssignment self) -> string Returns the value of the 'symbol' attribute of this InitialAssignment (NOT the 'id'). Note: Because of the inconsistent behavior of this function with respect to assignments and rules, it is now recommended to use the getIdAttribute() or InitialAssignment.getSymbol() functions instead. The 'symbol' attribute of an InitialAssignment indicates the element which the results of the 'math' are to be applied. Returns the symbol of this InitialAssignment. See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(), getSymbol(). """ return _libsbml.InitialAssignment_getId(self) def renameSIdRefs(self, oldid, newid): """ renameSIdRefs(InitialAssignment self, string oldid, string newid) Replaces all uses of a given 'SIdRef' type attribute value with another value. In SBML, object identifiers are of a data type called SId. In SBML Level 3, an explicit data type called SIdRef was introduced for attribute values that refer to SId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to an identifier', but the effective data type was the same as SIdRef in Level 3. These and other methods of libSBML refer to the type SIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all attributes and (if appropriate) mathematical formulas in MathML content, comparing the referenced identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.InitialAssignment_renameSIdRefs(self, oldid, newid) def renameUnitSIdRefs(self, oldid, newid): """ renameUnitSIdRefs(InitialAssignment self, string oldid, string newid) Replaces all uses of a given 'UnitSIdRef' type attribute value with another value. In SBML, unit definitions have identifiers of type UnitSId. In SBML Level 3, an explicit data type called UnitSIdRef was introduced for attribute values that refer to UnitSId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to a unit identifier', but the effective data type was the same as UnitSIdRef in Level 3. These and other methods of libSBML refer to the type UnitSIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all unit identifier attribute values (including, if appropriate, inside mathematical formulas), comparing the referenced unit identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.InitialAssignment_renameUnitSIdRefs(self, oldid, newid) def replaceSIDWithFunction(self, id, function): """ replaceSIDWithFunction(InitialAssignment self, string id, ASTNode function) Internal implementation method. """ return _libsbml.InitialAssignment_replaceSIDWithFunction(self, id, function) def divideAssignmentsToSIdByFunction(self, id, function): """ divideAssignmentsToSIdByFunction(InitialAssignment self, string id, ASTNode function) Internal implementation method. """ return _libsbml.InitialAssignment_divideAssignmentsToSIdByFunction(self, id, function) def multiplyAssignmentsToSIdByFunction(self, id, function): """ multiplyAssignmentsToSIdByFunction(InitialAssignment self, string id, ASTNode function) Internal implementation method. """ return _libsbml.InitialAssignment_multiplyAssignmentsToSIdByFunction(self, id, function) InitialAssignment_swigregister = _libsbml.InitialAssignment_swigregister InitialAssignment_swigregister(InitialAssignment) class ListOfInitialAssignments(ListOf): """ A list of InitialAssignment objects. The various ListOf___ classes in SBML are merely containers used for organizing the main components of an SBML model. In libSBML's implementation, ListOf___ classes are derived from the intermediate utility class ListOf, which is not defined by the SBML specifications but serves as a useful programmatic construct. ListOf is itself is in turn derived from SBase, which provides all of the various ListOf___ classes with common features defined by the SBML specification, such as 'metaid' attributes and annotations. The relationship between the lists and the rest of an SBML model is illustrated by the following (for SBML Level 2 Version 4): ... ... ... ... ... ... ... elements of subclasses of Rule ... ... ... ... SBML Level 3 Version 1 has essentially the same structure as Level 2 Version 4, depicted above, but SBML Level 3 Version 2 allows containers to contain zero or more of the relevant object, instead of requiring at least one. As such, libsbml will write out an otherwise-empty ListOf___ element that has any optional attribute set (such as 'id' or 'metaid'), that has an optional child (such as a 'notes' or 'annotation'), or that has attributes or children set from any SBML Level 3 package, whether or not the ListOf___ has any other children. Readers may wonder about the motivations for using the ListOf___ containers in SBML. A simpler approach in XML might be to place the components all directly at the top level of the model definition. The choice made in SBML is to group them within XML elements named after ListOfClassname, in part because it helps organize the components. More importantly, the fact that the container classes are derived from SBase means that software tools can add information about the lists themselves into each list container's 'annotation'. See also ListOfFunctionDefinitions, ListOfUnitDefinitions, ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments, ListOfSpecies, ListOfParameters, ListOfInitialAssignments, ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents. """ __swig_setmethods__ = {} for _s in [ListOf]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfInitialAssignments, name, value) __swig_getmethods__ = {} for _s in [ListOf]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, ListOfInitialAssignments, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(ListOfInitialAssignments self, unsigned int level, unsigned int version) -> ListOfInitialAssignments __init__(ListOfInitialAssignments self, SBMLNamespaces sbmlns) -> ListOfInitialAssignments This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: ListOfInitialAssignments(SBMLNamespaces sbmlns) Creates a new ListOfInitialAssignments object. The object is constructed such that it is valid for the SBML Level and Version combination determined by the SBMLNamespaces object in 'sbmlns'. Parameter 'sbmlns' is an SBMLNamespaces object that is used to determine the characteristics of the ListOfInitialAssignments object to be created. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: ListOfInitialAssignments(long level, long version) Creates a new ListOfInitialAssignments object. The object is constructed such that it is valid for the given SBML Level and Version combination. Parameter 'level' is the SBML Level. Parameter 'version' is the Version within the SBML Level. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. """ this = _libsbml.new_ListOfInitialAssignments(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(ListOfInitialAssignments self) -> ListOfInitialAssignments Creates and returns a deep copy of this ListOfInitialAssignments object. Returns the (deep) copy of this ListOfInitialAssignments object. """ return _libsbml.ListOfInitialAssignments_clone(self) def getItemTypeCode(self): """ getItemTypeCode(ListOfInitialAssignments self) -> int Returns the libSBML type code for the objects contained in this ListOf (i.e., InitialAssignment objects, if the list is non-empty). LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for the objects contained in this ListOf: SBML_INITIAL_ASSIGNMENT (default). See also getElementName(), getPackageName(). """ return _libsbml.ListOfInitialAssignments_getItemTypeCode(self) def getElementName(self): """ getElementName(ListOfInitialAssignments self) -> string Returns the XML element name of this object. For ListOfInitialAssignments, the XML element name is ''listOfInitialAssignments'.' Returns the name of this element, i.e., ''listOfInitialAssignments'.' """ return _libsbml.ListOfInitialAssignments_getElementName(self) def get(self, *args): """ get(ListOfInitialAssignments self, unsigned int n) -> InitialAssignment get(ListOfInitialAssignments self, unsigned int n) -> InitialAssignment get(ListOfInitialAssignments self, string sid) -> InitialAssignment get(ListOfInitialAssignments self, string sid) -> InitialAssignment This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: get(long n) Get a InitialAssignment from the ListOfInitialAssignments. Parameter 'n' is the index number of the InitialAssignment to get. Returns the nth InitialAssignment in this ListOfInitialAssignments. If the index 'n' is invalid, 'None' is returned. See also size(). ______________________________________________________________________ Method variant with the following signature: get(string sid) Get a InitialAssignment from the ListOfInitialAssignments based on its identifier. Parameter 'sid' is a string representing the identifier of the InitialAssignment to get. Returns InitialAssignment in this ListOfInitialAssignments with the given 'sid' or 'None' if no such InitialAssignment exists. See also get(), size(). """ return _libsbml.ListOfInitialAssignments_get(self, *args) def remove(self, *args): """ remove(ListOfInitialAssignments self, unsigned int n) -> InitialAssignment remove(ListOfInitialAssignments self, string sid) -> InitialAssignment This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: remove(long n) Removes the nth item from this ListOfInitialAssignments items and returns a pointer to it. The caller owns the returned item and is responsible for deleting it. Parameter 'n' is the index of the item to remove. See also size(). ______________________________________________________________________ Method variant with the following signature: remove(string sid) Removes item in this ListOfInitialAssignments items with the given identifier. The caller owns the returned item and is responsible for deleting it. If none of the items in this list have the identifier 'sid', then 'None' is returned. Parameter 'sid' is the identifier of the item to remove. Returns the item removed. As mentioned above, the caller owns the returned item. """ return _libsbml.ListOfInitialAssignments_remove(self, *args) def getElementBySId(self, id): """ getElementBySId(ListOfInitialAssignments self, string id) -> SBase Returns the first child element found that has the given 'id' in the model-wide SId namespace, or 'None' if no such object is found. Note that InitialAssignments do not actually have IDs, though the libsbml interface pretends that they do: no initial assignment is returned by this function. Parameter 'id' is string representing the id of the object to find. Returns pointer to the first element found with the given 'id'. """ return _libsbml.ListOfInitialAssignments_getElementBySId(self, id) __swig_destroy__ = _libsbml.delete_ListOfInitialAssignments __del__ = lambda self: None ListOfInitialAssignments_swigregister = _libsbml.ListOfInitialAssignments_swigregister ListOfInitialAssignments_swigregister(ListOfInitialAssignments) RULE_TYPE_RATE = _libsbml.RULE_TYPE_RATE RULE_TYPE_SCALAR = _libsbml.RULE_TYPE_SCALAR RULE_TYPE_INVALID = _libsbml.RULE_TYPE_INVALID class Rule(SBase): """ Parent class for SBML rules in libSBML. In SBML, rules provide additional ways to define the values of variables in a model, their relationships, and the dynamical behaviors of those variables. They enable encoding relationships that cannot be expressed using Reaction nor InitialAssignment objects alone. The libSBML implementation of rules mirrors the SBML Level 3 definition (which is in turn is very similar to the Level 2 Version 4 definition), with Rule being the parent class of three subclasses as explained below. The Rule class itself cannot be instantiated by user programs and has no constructor; only the subclasses AssignmentRule, AlgebraicRule and RateRule can be instantiated directly. General summary of SBML rules ====================================================================== In SBML Level 3 as well as Level 2, rules are separated into three subclasses for the benefit of model analysis software. The three subclasses are based on the following three different possible functional forms (where x is a variable, f is some arbitrary function returning a numerical result, V is a vector of variables that does not include x, and W is a vector of variables that may include x): Algebraic: left-hand side is zero 0 = f(W) Assignment: left-hand side is a scalar: x = f(V) Rate: left-hand side is a rate-of-change: dx/dt = f(W) In their general form given above, there is little to distinguish between assignment and algebraic rules. They are treated as separate cases for the following reasons: * Assignment rules can simply be evaluated to calculate intermediate values for use in numerical methods. They are statements of equality that hold at all times. (For assignments that are only performed once, see InitialAssignment.) * SBML needs to place restrictions on assignment rules, for example the restriction that assignment rules cannot contain algebraic loops. * Some simulators do not contain numerical solvers capable of solving unconstrained algebraic equations, and providing more direct forms such as assignment rules may enable those simulators to process models they could not process if the same assignments were put in the form of general algebraic equations; * Those simulators that can solve these algebraic equations make a distinction between the different categories listed above; and * Some specialized numerical analyses of models may only be applicable to models that do not contain algebraic rules. The approach taken to covering these cases in SBML is to define an abstract Rule structure containing a subelement, 'math', to hold the right-hand side expression, then to derive subtypes of Rule that add attributes to distinguish the cases of algebraic, assignment and rate rules. The 'math' subelement must contain a MathML expression defining the mathematical formula of the rule. This MathML formula must return a numerical value. The formula can be an arbitrary expression referencing the variables and other entities in an SBML model. Each of the three subclasses of Rule (AssignmentRule, AlgebraicRule, RateRule) inherit the the 'math' subelement and other fields from SBase. The AssignmentRule and RateRule classes add an additional attribute, 'variable'. See the definitions of AssignmentRule, AlgebraicRule and RateRule for details about the structure and interpretation of each one. Additional restrictions on SBML rules ====================================================================== An important design goal of SBML rule semantics is to ensure that a model's simulation and analysis results will not be dependent on when or how often rules are evaluated. To achieve this, SBML needs to place two restrictions on rule use. The first concerns algebraic loops in the system of assignments in a model, and the second concerns overdetermined systems. A model must not contain algebraic loops ...................................................................... The combined set of InitialAssignment, AssignmentRule and KineticLaw objects in a model constitute a set of assignment statements that should be considered as a whole. (A KineticLaw object is counted as an assignment because it assigns a value to the symbol contained in the 'id' attribute of the Reaction object in which it is defined.) This combined set of assignment statements must not contain algebraic loops---dependency chains between these statements must terminate. To put this more formally, consider a directed graph in which nodes are assignment statements and directed arcs exist for each occurrence of an SBML species, compartment or parameter symbol in an assignment statement's 'math' subelement. Let the directed arcs point from the statement assigning the symbol to the statements that contain the symbol in their 'math' subelement expressions. This graph must be acyclic. Similarly, the combined set of RateRule and Reaction objects constitute a set of definitions for the rates of change of various model entities (namely, the objects identified by the values of the 'variable' attributes of the RateRule objects, and the 'species' attributes of the SpeciesReference objects in each Reaction). In SBML Level 3 Version 2, these rates of change may be referenced directly using the rateOf csymbol, but may not thereby contain algebraic loops---dependency chains between these statements must terminate. More formally, consider a directed graph in which the nodes are the definitions of different variables' rates of change, and directed arcs exist for each occurrence of a variable referenced by a rateOf csymbol from any RateRule or KineticLaw object in the model. Let the directed arcs point from the variable referenced by the rateOf csymbol (call it x) to the variable(s) determined by the 'math' expression in which x appears. This graph must be acyclic. SBML does not specify when or how often rules should be evaluated. Eliminating algebraic loops ensures that assignment statements can be evaluated any number of times without the result of those evaluations changing. As an example, consider the set of equations x = x + 1, y = z + 200 and z = y + 100. If this set of equations were interpreted as a set of assignment statements, it would be invalid because the rule for x refers to x (exhibiting one type of loop), and the rule for y refers to z while the rule for z refers back to y (exhibiting another type of loop). Conversely, the following set of equations would constitute a valid set of assignment statements: x = 10, y = z + 200, and z = x + 100. A model must not be overdetermined ...................................................................... An SBML model must not be overdetermined; that is, a model must not define more equations than there are unknowns in a model. A valid SBML model that does not contain AlgebraicRule structures cannot be overdetermined. LibSBML implements the static analysis procedure described in Appendix B of the SBML Level 3 specification for assessing whether a model is overdetermined. (In summary, assessing whether a given continuous, deterministic, mathematical model is overdetermined does not require dynamic analysis; it can be done by analyzing the system of equations created from the model. One approach is to construct a bipartite graph in which one set of vertices represents the variables and the other the set of vertices represents the equations. Place edges between vertices such that variables in the system are linked to the equations that determine them. For algebraic equations, there will be edges between the equation and each variable occurring in the equation. For ordinary differential equations (such as those defined by rate rules or implied by the reaction rate definitions), there will be a single edge between the equation and the variable determined by that differential equation. A mathematical model is overdetermined if the maximal matchings of the bipartite graph contain disconnected vertexes representing equations. If one maximal matching has this property, then all the maximal matchings will have this property; i.e., it is only necessary to find one maximal matching.) Rule types for SBML Level 1 ====================================================================== SBML Level 1 uses a different scheme than SBML Level 2 and Level 3 for distinguishing rules; specifically, it uses an attribute whose value is drawn from an enumeration of 3 values. LibSBML supports this using methods that work with the enumeration values listed below. * RULE_TYPE_RATE: Indicates the rule is a 'rate' rule. * RULE_TYPE_SCALAR: Indicates the rule is a 'scalar' rule. * RULE_TYPE_INVALID: Indicates the rule type is unknown or not yet set. """ __swig_setmethods__ = {} for _s in [SBase]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, Rule, name, value) __swig_getmethods__ = {} for _s in [SBase]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, Rule, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_Rule __del__ = lambda self: None def __init__(self, orig): """ __init__(Rule self, Rule orig) -> Rule @internal """ this = _libsbml.new_Rule(orig) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(Rule self) -> Rule Creates and returns a deep copy of this Rule object. Returns the (deep) copy of this Rule object. """ return _libsbml.Rule_clone(self) def getFormula(self): """ getFormula(Rule self) -> string Returns the mathematical expression of this Rule in text-string form. The text string is produced by SBML_formulaToString(); please consult the documentation for that function to find out more about the format of the text-string formula. Returns the formula text string for this Rule. Note: The attribute 'formula' is specific to SBML Level 1; in higher Levels of SBML, it has been replaced with a subelement named 'math'. However, libSBML provides a unified interface to the underlying math expression and this method can be used for models of all Levels of SBML. See also getMath(). """ return _libsbml.Rule_getFormula(self) def getMath(self): """ getMath(Rule self) -> ASTNode Get the mathematical formula of this Rule as an ASTNode tree. Returns an ASTNode, the value of the 'math' subelement of this Rule, or 'None' if the math is not set. Note: The subelement 'math' is present in SBML Levels 2 and 3. In SBML Level 1, the equivalent construct is the attribute named 'formula'. LibSBML provides a unified interface to the underlying math expression and this method can be used for models of all Levels of SBML. See also getFormula(). """ return _libsbml.Rule_getMath(self) def getVariable(self): """ getVariable(Rule self) -> string Get the value of the 'variable' attribute of this Rule object. In SBML Level 1, the different rule types each have a different name for the attribute holding the reference to the object constituting the left-hand side of the rule. (E.g., for SBML Level 1's SpeciesConcentrationRule the attribute is 'species', for CompartmentVolumeRule it is 'compartment', etc.) In SBML Levels 2 and 3, the only two types of Rule objects with a left-hand side object reference are AssignmentRule and RateRule, and both of them use the same name for attribute: 'variable'. In order to make it easier for application developers to work with all Levels of SBML, libSBML uses a uniform name for all such attributes, and it is 'variable', regardless of whether Level 1 rules or Level 2-3 rules are being used. The 'variable' attribute of a Rule indicates the element which the results of the 'math' are to be applied. An AlgebraicRule has no 'variable', and will always return an empty string. Returns the identifier string stored as the 'variable' attribute value in this Rule, or 'None' if this object is an AlgebraicRule object, or if the attribute is unset. """ return _libsbml.Rule_getVariable(self) def getUnits(self): """ getUnits(Rule self) -> string Returns the units for the mathematical formula of this Rule. Returns the identifier of the units for the expression of this Rule. Note: The attribute 'units' exists on SBML Level 1 ParameterRule objects only. It is not present in SBML Levels 2 and 3. """ return _libsbml.Rule_getUnits(self) def isSetFormula(self): """ isSetFormula(Rule self) -> bool Predicate returning 'True' if this Rule's mathematical expression is set. This method is equivalent to isSetMath(). This version is present for easier compatibility with SBML Level 1, in which mathematical formulas were written in text-string form. Returns 'True' if the mathematical formula for this Rule is set, 'False' otherwise. Note: The attribute 'formula' is specific to SBML Level 1; in higher Levels of SBML, it has been replaced with a subelement named 'math'. However, libSBML provides a unified interface to the underlying math expression and this method can be used for models of all Levels of SBML. See also isSetMath(). """ return _libsbml.Rule_isSetFormula(self) def isSetMath(self): """ isSetMath(Rule self) -> bool Predicate returning 'True' if this Rule's mathematical expression is set. This method is equivalent to isSetFormula(). Returns 'True' if the formula (or equivalently the math) for this Rule is set, 'False' otherwise. Note: The subelement 'math' is present in SBML Levels 2 and 3. In SBML Level 1, the equivalent construct is the attribute named 'formula'. LibSBML provides a unified interface to the underlying math expression and this method can be used for models of all Levels of SBML. See also isSetFormula(). """ return _libsbml.Rule_isSetMath(self) def isSetVariable(self): """ isSetVariable(Rule self) -> bool Predicate returning 'True' if this Rule's 'variable' attribute is set. In SBML Level 1, the different rule types each have a different name for the attribute holding the reference to the object constituting the left-hand side of the rule. (E.g., for SBML Level 1's SpeciesConcentrationRule the attribute is 'species', for CompartmentVolumeRule it is 'compartment', etc.) In SBML Levels 2 and 3, the only two types of Rule objects with a left-hand side object reference are AssignmentRule and RateRule, and both of them use the same name for attribute: 'variable'. In order to make it easier for application developers to work with all Levels of SBML, libSBML uses a uniform name for all such attributes, and it is 'variable', regardless of whether Level 1 rules or Level 2-3 rules are being used. Returns 'True' if the 'variable' attribute value of this Rule is set, 'False' otherwise. """ return _libsbml.Rule_isSetVariable(self) def isSetUnits(self): """ isSetUnits(Rule self) -> bool Predicate returning 'True' if this Rule's 'units' attribute is set. Returns 'True' if the units for this Rule is set, 'False' otherwise. Note: The attribute 'units' exists on SBML Level 1 ParameterRule objects only. It is not present in SBML Levels 2 and 3. """ return _libsbml.Rule_isSetUnits(self) def setFormula(self, formula): """ setFormula(Rule self, string formula) -> int Sets the 'math' subelement of this Rule to an expression in text- string form. This is equivalent to setMath(ASTNode math). The provision of using text-string formulas is retained for easier SBML Level 1 compatibility. The formula is converted to an ASTNode internally. Parameter 'formula' is a mathematical formula in text-string form. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT Note: The attribute 'formula' is specific to SBML Level 1; in higher Levels of SBML, it has been replaced with a subelement named 'math'. However, libSBML provides a unified interface to the underlying math expression and this method can be used for models of all Levels of SBML. See also setMath(). """ return _libsbml.Rule_setFormula(self, formula) def setMath(self, math): """ setMath(Rule self, ASTNode math) -> int Sets the 'math' subelement of this Rule to a copy of the given ASTNode. Parameter 'math' is the AST structure of the mathematical formula. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT Note: The subelement 'math' is present in SBML Levels 2 and 3. In SBML Level 1, the equivalent construct is the attribute named 'formula'. LibSBML provides a unified interface to the underlying math expression and this method can be used for models of all Levels of SBML. See also setFormula(). """ return _libsbml.Rule_setMath(self, math) def setVariable(self, sid): """ setVariable(Rule self, string sid) -> int Sets the 'variable' attribute value of this Rule object. In SBML Level 1, the different rule types each have a different name for the attribute holding the reference to the object constituting the left-hand side of the rule. (E.g., for SBML Level 1's SpeciesConcentrationRule the attribute is 'species', for CompartmentVolumeRule it is 'compartment', etc.) In SBML Levels 2 and 3, the only two types of Rule objects with a left-hand side object reference are AssignmentRule and RateRule, and both of them use the same name for attribute: 'variable'. In order to make it easier for application developers to work with all Levels of SBML, libSBML uses a uniform name for all such attributes, and it is 'variable', regardless of whether Level 1 rules or Level 2-3 rules are being used. Parameter 'sid' is the identifier of a Compartment, Species or Parameter elsewhere in the enclosing Model object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE * LIBSBML_UNEXPECTED_ATTRIBUTE """ return _libsbml.Rule_setVariable(self, sid) def setUnits(self, sname): """ setUnits(Rule self, string sname) -> int Sets the units for this Rule. Parameter 'sname' is the identifier of the units. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE * LIBSBML_UNEXPECTED_ATTRIBUTE Note: The attribute 'units' exists on SBML Level 1 ParameterRule objects only. It is not present in SBML Levels 2 and 3. """ return _libsbml.Rule_setUnits(self, sname) def unsetVariable(self): """ unsetVariable(Rule self) -> int Unsets the value of the 'variable' attribute of this Rule object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_UNEXPECTED_ATTRIBUTE See also setVariable(), isSetVariable(), getVariable(). """ return _libsbml.Rule_unsetVariable(self) def unsetUnits(self): """ unsetUnits(Rule self) -> int Unsets the 'units' for this Rule. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_UNEXPECTED_ATTRIBUTE Note: The attribute 'units' exists on SBML Level 1 ParameterRule objects only. It is not present in SBML Levels 2 and 3. """ return _libsbml.Rule_unsetUnits(self) def getDerivedUnitDefinition(self, *args): """ getDerivedUnitDefinition(Rule self) -> UnitDefinition getDerivedUnitDefinition(Rule self) -> UnitDefinition Calculates and returns a UnitDefinition that expresses the units of measurement assumed for the 'math' expression of this Rule. The units are calculated based on the mathematical expression in the Rule and the model quantities referenced by elements used within that expression. The method Rule.getDerivedUnitDefinition() returns the calculated units, to the extent that libSBML can compute them. Note: The functionality that facilitates unit analysis depends on the model as a whole. Thus, in cases where the object has not been added to a model or the model itself is incomplete, unit analysis is not possible and this method will return 'None.' WARNING: Note that it is possible the 'math' expression in the Rule contains pure numbers or parameters with undeclared units. In those cases, it is not possible to calculate the units of the overall expression without making assumptions. LibSBML does not make assumptions about the units, and Rule.getDerivedUnitDefinition() only returns the units as far as it is able to determine them. For example, in an expression X + Y, if X has unambiguously-defined units and Y does not, it will return the units of X. It is important that callers also invoke the method Rule.containsUndeclaredUnits() to determine whether this situation holds. Callers may wish to take suitable actions in those scenarios. Returns a UnitDefinition that expresses the units of the math expression of this Rule, or 'None' if one cannot be constructed. See also containsUndeclaredUnits(). """ return _libsbml.Rule_getDerivedUnitDefinition(self, *args) def containsUndeclaredUnits(self, *args): """ containsUndeclaredUnits(Rule self) -> bool containsUndeclaredUnits(Rule self) -> bool Predicate returning 'True' if the math expression of this Rule contains parameters/numbers with undeclared units. Returns 'True' if the math expression of this Rule includes parameters/numbers with undeclared units, 'False' otherwise. Note: A return value of 'True' indicates that the UnitDefinition returned by getDerivedUnitDefinition() may not accurately represent the units of the expression. See also getDerivedUnitDefinition(). """ return _libsbml.Rule_containsUndeclaredUnits(self, *args) def getType(self): """ getType(Rule self) -> RuleType_t Returns a code representing the type of rule this is. Returns the rule type, which will be one of the following three possible values: * RULE_TYPE_RATE * RULE_TYPE_SCALAR * RULE_TYPE_INVALID Note: The attribute 'type' on Rule objects is present only in SBML Level 1. In SBML Level 2 and later, the type has been replaced by subclassing the Rule object. """ return _libsbml.Rule_getType(self) def isAlgebraic(self): """ isAlgebraic(Rule self) -> bool Predicate returning 'True' if this Rule is an AlgebraicRule. Returns 'True' if this Rule is an AlgebraicRule, 'False' otherwise. """ return _libsbml.Rule_isAlgebraic(self) def isAssignment(self): """ isAssignment(Rule self) -> bool Predicate returning 'True' if this Rule is an AssignmentRule. Returns 'True' if this Rule is an AssignmentRule, 'False' otherwise. """ return _libsbml.Rule_isAssignment(self) def isCompartmentVolume(self): """ isCompartmentVolume(Rule self) -> bool Predicate returning 'True' if this Rule is an CompartmentVolumeRule or equivalent. This libSBML method works for SBML Level 1 models (where there is such a thing as an explicit CompartmentVolumeRule), as well as other Levels of SBML. For Levels above Level 1, this method checks the symbol being affected by the rule, and returns 'True' if the symbol is the identifier of a Compartment object defined in the model. Returns 'True' if this Rule is a CompartmentVolumeRule, 'False' otherwise. """ return _libsbml.Rule_isCompartmentVolume(self) def isParameter(self): """ isParameter(Rule self) -> bool Predicate returning 'True' if this Rule is an ParameterRule or equivalent. This libSBML method works for SBML Level 1 models (where there is such a thing as an explicit ParameterRule), as well as other Levels of SBML. For Levels above Level 1, this method checks the symbol being affected by the rule, and returns 'True' if the symbol is the identifier of a Parameter object defined in the model. Returns 'True' if this Rule is a ParameterRule, 'False' otherwise. """ return _libsbml.Rule_isParameter(self) def isRate(self): """ isRate(Rule self) -> bool Predicate returning 'True' if this Rule is a RateRule (SBML Levels 2-3) or has a 'type' attribute value of ''rate'' (SBML Level 1). Returns 'True' if this Rule is a RateRule (Level 2) or has type 'rate' (Level 1), 'False' otherwise. """ return _libsbml.Rule_isRate(self) def isScalar(self): """ isScalar(Rule self) -> bool Predicate returning 'True' if this Rule is an AssignmentRule (SBML Levels 2-3) or has a 'type' attribute value of ''scalar'' (SBML Level 1). Returns 'True' if this Rule is an AssignmentRule (Level 2) or has type 'scalar' (Level 1), 'False' otherwise. """ return _libsbml.Rule_isScalar(self) def isSpeciesConcentration(self): """ isSpeciesConcentration(Rule self) -> bool Predicate returning 'True' if this Rule is a SpeciesConcentrationRule or equivalent. This libSBML method works for SBML Level 1 models (where there is such a thing as an explicit SpeciesConcentrationRule), as well as other Levels of SBML. For Levels above Level 1, this method checks the symbol being affected by the rule, and returns 'True' if the symbol is the identifier of a Species object defined in the model. Returns 'True' if this Rule is a SpeciesConcentrationRule, 'False' otherwise. """ return _libsbml.Rule_isSpeciesConcentration(self) def getTypeCode(self): """ getTypeCode(Rule self) -> int Returns the libSBML type code for this SBML object. LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for this object, either SBML_ASSIGNMENT_RULE, SBML_RATE_RULE, or SBML_ALGEBRAIC_RULE for SBML Core. WARNING: The specific integer values of the possible type codes may be reused by different libSBML plug-ins for SBML Level 3. packages, To fully identify the correct code, it is necessary to invoke both getPackageName() and getTypeCode() (or ListOf.getItemTypeCode()). See also getElementName(), getPackageName(). """ return _libsbml.Rule_getTypeCode(self) def getL1TypeCode(self): """ getL1TypeCode(Rule self) -> int Returns the SBML Level 1 type code for this Rule object. This method only applies to SBML Level 1 model objects. If this is not an SBML Level 1 rule object, this method will return SBML_UNKNOWN. Returns the SBML Level 1 type code for this Rule (namely, SBML_COMPARTMENT_VOLUME_RULE, SBML_PARAMETER_RULE, SBML_SPECIES_CONCENTRATION_RULE, or SBML_UNKNOWN). """ return _libsbml.Rule_getL1TypeCode(self) def getElementName(self): """ getElementName(Rule self) -> string Returns the XML element name of this object. The returned value can be any of a number of different strings, depending on the SBML Level in use and the kind of Rule object this is. The rules as of libSBML version 5.17.2 are the following: * (Level 2 and 3) RateRule: returns ''rateRule'' * (Level 2 and 3) AssignmentRule: returns ''assignmentRule'' * (Level 2 and 3) AlgebraicRule: returns ''algebraicRule'' * (Level 1 Version 1) SpecieConcentrationRule: returns ''specieConcentrationRule'' * (Level 1 Version 2) SpeciesConcentrationRule: returns ''speciesConcentrationRule'' * (Level 1) CompartmentVolumeRule: returns ''compartmentVolumeRule'' * (Level 1) ParameterRule: returns ''parameterRule'' * Unknown rule type: returns ''unknownRule'' Beware that the last (''unknownRule')' is not a valid SBML element name. Returns the name of this element. """ return _libsbml.Rule_getElementName(self) def setL1TypeCode(self, type): """ setL1TypeCode(Rule self, int type) -> int Sets the SBML Level 1 type code for this Rule. Parameter 'type' is the SBML Level 1 type code for this Rule. The allowable values are SBML_COMPARTMENT_VOLUME_RULE, SBML_PARAMETER_RULE, and SBML_SPECIES_CONCENTRATION_RULE. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE if given 'type' value is not one of the above. """ return _libsbml.Rule_setL1TypeCode(self, type) def hasRequiredElements(self): """ hasRequiredElements(Rule self) -> bool Predicate returning 'True' if all the required elements for this Rule object have been set. The only required element for a Rule object is the 'math' subelement in SBML Level 2 and Level 3 Version 1. In SBML Level 3 Version 2+, it is no longer required. Returns a boolean value indicating whether all the required elements for this object have been defined. """ return _libsbml.Rule_hasRequiredElements(self) def hasRequiredAttributes(self): """ hasRequiredAttributes(Rule self) -> bool Predicate returning 'True' if all the required attributes for this Rule object have been set. The required attributes for a Rule object depend on the type of Rule it is. For AssignmentRule and RateRule objects (and SBML Level 1's SpeciesConcentrationRule, CompartmentVolumeRule, and ParameterRule objects), the required attribute is 'variable'; for AlgebraicRule objects, there is no required attribute. Returns 'True' if the required attributes have been set, 'False' otherwise. """ return _libsbml.Rule_hasRequiredAttributes(self) def renameSIdRefs(self, oldid, newid): """ renameSIdRefs(Rule self, string oldid, string newid) Replaces all uses of a given 'SIdRef' type attribute value with another value. In SBML, object identifiers are of a data type called SId. In SBML Level 3, an explicit data type called SIdRef was introduced for attribute values that refer to SId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to an identifier', but the effective data type was the same as SIdRef in Level 3. These and other methods of libSBML refer to the type SIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all attributes and (if appropriate) mathematical formulas in MathML content, comparing the referenced identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.Rule_renameSIdRefs(self, oldid, newid) def renameUnitSIdRefs(self, oldid, newid): """ renameUnitSIdRefs(Rule self, string oldid, string newid) Replaces all uses of a given 'UnitSIdRef' type attribute value with another value. In SBML, unit definitions have identifiers of type UnitSId. In SBML Level 3, an explicit data type called UnitSIdRef was introduced for attribute values that refer to UnitSId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to a unit identifier', but the effective data type was the same as UnitSIdRef in Level 3. These and other methods of libSBML refer to the type UnitSIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all unit identifier attribute values (including, if appropriate, inside mathematical formulas), comparing the referenced unit identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.Rule_renameUnitSIdRefs(self, oldid, newid) def getId(self): """ getId(Rule self) -> string Returns the value of the 'variable' attribute of this Rule (NOT the 'id'). Note: Because of the inconsistent behavior of this function with respect to assignments and rules, it is now recommended to use the getIdAttribute() or the getVariable() function instead. The 'variable' attribute of a Rule indicates the element which the results of the 'math' are to be applied. An AlgebraicRule has no 'variable', and will always return an empty string. Returns the variable of this Rule. See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(), getVariable(). """ return _libsbml.Rule_getId(self) def replaceSIDWithFunction(self, id, function): """ replaceSIDWithFunction(Rule self, string id, ASTNode function) Internal implementation method. """ return _libsbml.Rule_replaceSIDWithFunction(self, id, function) def divideAssignmentsToSIdByFunction(self, id, function): """ divideAssignmentsToSIdByFunction(Rule self, string id, ASTNode function) Internal implementation method. """ return _libsbml.Rule_divideAssignmentsToSIdByFunction(self, id, function) def multiplyAssignmentsToSIdByFunction(self, id, function): """ multiplyAssignmentsToSIdByFunction(Rule self, string id, ASTNode function) Internal implementation method. """ return _libsbml.Rule_multiplyAssignmentsToSIdByFunction(self, id, function) Rule_swigregister = _libsbml.Rule_swigregister Rule_swigregister(Rule) class ListOfRules(ListOf): """ A list of Rule objects. The various ListOf___ classes in SBML are merely containers used for organizing the main components of an SBML model. In libSBML's implementation, ListOf___ classes are derived from the intermediate utility class ListOf, which is not defined by the SBML specifications but serves as a useful programmatic construct. ListOf is itself is in turn derived from SBase, which provides all of the various ListOf___ classes with common features defined by the SBML specification, such as 'metaid' attributes and annotations. The relationship between the lists and the rest of an SBML model is illustrated by the following (for SBML Level 2 Version 4): ... ... ... ... ... ... ... elements of subclasses of Rule ... ... ... ... SBML Level 3 Version 1 has essentially the same structure as Level 2 Version 4, depicted above, but SBML Level 3 Version 2 allows containers to contain zero or more of the relevant object, instead of requiring at least one. As such, libsbml will write out an otherwise-empty ListOf___ element that has any optional attribute set (such as 'id' or 'metaid'), that has an optional child (such as a 'notes' or 'annotation'), or that has attributes or children set from any SBML Level 3 package, whether or not the ListOf___ has any other children. Readers may wonder about the motivations for using the ListOf___ containers in SBML. A simpler approach in XML might be to place the components all directly at the top level of the model definition. The choice made in SBML is to group them within XML elements named after ListOfClassname, in part because it helps organize the components. More importantly, the fact that the container classes are derived from SBase means that software tools can add information about the lists themselves into each list container's 'annotation'. See also ListOfFunctionDefinitions, ListOfUnitDefinitions, ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments, ListOfSpecies, ListOfParameters, ListOfInitialAssignments, ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents. """ __swig_setmethods__ = {} for _s in [ListOf]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfRules, name, value) __swig_getmethods__ = {} for _s in [ListOf]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, ListOfRules, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(ListOfRules self, unsigned int level, unsigned int version) -> ListOfRules __init__(ListOfRules self, SBMLNamespaces sbmlns) -> ListOfRules This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: ListOfRules(SBMLNamespaces sbmlns) Creates a new ListOfRules object. The object is constructed such that it is valid for the SBML Level and Version combination determined by the SBMLNamespaces object in 'sbmlns'. Parameter 'sbmlns' is an SBMLNamespaces object that is used to determine the characteristics of the ListOfRules object to be created. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: ListOfRules(long level, long version) Creates a new ListOfRules object. The object is constructed such that it is valid for the given SBML Level and Version combination. Parameter 'level' is the SBML Level. Parameter 'version' is the Version within the SBML Level. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. """ this = _libsbml.new_ListOfRules(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(ListOfRules self) -> ListOfRules Creates and returns a deep copy of this ListOfRules object. Returns the (deep) copy of this ListOfRules object. """ return _libsbml.ListOfRules_clone(self) def getItemTypeCode(self): """ getItemTypeCode(ListOfRules self) -> int Returns the libSBML type code for the objects contained in this ListOf (i.e., Rule objects, if the list is non-empty). LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for objects contained in this list: SBML_RULE (default). See also getElementName(), getPackageName(). """ return _libsbml.ListOfRules_getItemTypeCode(self) def getElementName(self): """ getElementName(ListOfRules self) -> string Returns the XML element name of this object. For ListOfRules, the XML element name is ''listOfRules'.' Returns the name of this element, i.e., ''listOfRules'.' """ return _libsbml.ListOfRules_getElementName(self) def get(self, *args): """ get(ListOfRules self, unsigned int n) -> Rule get(ListOfRules self, unsigned int n) -> Rule get(ListOfRules self, string sid) -> Rule get(ListOfRules self, string sid) -> Rule This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: get(long n) Get a Rule from the ListOfRules. Parameter 'n' is the index number of the Rule to get. Returns the nth Rule in this ListOfRules. If the index 'n' is invalid, 'None' is returned. See also size(). ______________________________________________________________________ Method variant with the following signature: get(string sid) Get a Rule from the ListOfRules based on its identifier. Parameter 'sid' is a string representing the identifier of the Rule to get. Returns Rule in this ListOfRules with the given 'sid' or 'None' if no such Rule exists. See also get(), size(). """ return _libsbml.ListOfRules_get(self, *args) def getElementBySId(self, id): """ getElementBySId(ListOfRules self, string id) -> SBase Returns the first child element found that has the given 'id' in the model-wide SId namespace, or 'None' if no such object is found. Note that AssignmentRules and RateRules do not actually have IDs, but the libsbml interface pretends that they do: no assignment rule or rate rule is returned by this function. Parameter 'id' is string representing the id of the object to find. Returns pointer to the first element found with the given 'id'. """ return _libsbml.ListOfRules_getElementBySId(self, id) def remove(self, *args): """ remove(ListOfRules self, unsigned int n) -> Rule remove(ListOfRules self, string sid) -> Rule This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: remove(long n) Removes the nth item from this ListOfRules items and returns a pointer to it. The caller owns the returned item and is responsible for deleting it. Parameter 'n' is the index of the item to remove. See also size(). ______________________________________________________________________ Method variant with the following signature: remove(string sid) Removes item in this ListOfRules items with the given identifier. The caller owns the returned item and is responsible for deleting it. If none of the items in this list have the identifier 'sid', then 'None' is returned. Parameter 'sid' is the identifier of the item to remove. Returns the item removed. As mentioned above, the caller owns the returned item. """ return _libsbml.ListOfRules_remove(self, *args) __swig_destroy__ = _libsbml.delete_ListOfRules __del__ = lambda self: None ListOfRules_swigregister = _libsbml.ListOfRules_swigregister ListOfRules_swigregister(ListOfRules) class AlgebraicRule(Rule): """ An SBML algebraic rule representing 0 = f(W). The rule type AlgebraicRule is derived from the parent class Rule. It is used to express equations that are neither assignments of model variables nor rates of change. AlgebraicRule does not add any attributes to the basic Rule; its role is simply to distinguish this case from the other cases. In the context of a simulation, algebraic rules are in effect at all times, t >= 0. For purposes of evaluating expressions that involve the delay 'csymbol' (see the SBML specification), algebraic rules are considered to apply also at t <= 0. Please consult the relevant SBML specification for additional information about the semantics of assignments, rules, and entity values for simulation time t <= 0. An SBML model must not be overdetermined. The ability to define arbitrary algebraic expressions in an SBML model introduces the possibility that a model is mathematically overdetermined by the overall system of equations constructed from its rules, reactions and events. Therefore, if an algebraic rule is introduced in a model, for at least one of the entities referenced in the rule's 'math' element the value of that entity must not be completely determined by other constructs in the model. This means that at least this entity must not have the attribute 'constant'='True' and there must also not be a rate rule or assignment rule for it. Furthermore, if the entity is a Species object, its value must not be determined by reactions, which means that it must either have the attribute 'boundaryCondition'='True' or else not be involved in any reaction at all. These restrictions are explained in more detail in the SBML specification documents. In SBML Levels 2 and 3, Reaction object identifiers can be referenced in the 'math' expression of an algebraic rule, but reaction rates can never be determined by algebraic rules. This is true even when a reaction does not contain a KineticLaw object. (In such cases of missing kinetic law definitions, the model is valid but incomplete; the rates of reactions lacking kinetic laws are simply undefined, and not determined by the algebraic rule.) In SBML Level 2 and Level 3 Version 1, the 'math' subelement of the AlgebraicRule is required. In SBML Level 3 Version 2, this rule is relaxed, and the subelement is optional. If an AlgebraicRule with no 'math' child is present in the model, no additional mathematical constraints on the model are added by the rule. This may represent a situation where the model itself is unfinished, or the missing information may be provided by an SBML Level 3 package. Finally, any symbol that appears as the target of a rateOf csymbol (AST_FUNCTION_RATE_OF, introduced in SBML Level 3 Version 2) may not be determined by an AlgebraicRule. This is because the rateOf csymbol is defined as applying only to symbols whose rates of change are easily determinable. Users should note that these rules about what symbols may not be determined by an AlgebraicRule may be used to discover what symbol is being determined by an AlgebraicRule. If three symbols appear in the math element of an AlgebraicRule, the first of which is flagged constant='True,' and the second of which appears as the target of a rateOf csymbol, one may conclude that the AlgebraicRule must be used to determine the value of the third symbol. This is, in fact, a principle use (outside of validation) of the constant attribute: its use in allowing software to properly identify the dependent variable in an AlgebraicRule. General summary of SBML rules ====================================================================== In SBML Level 3 as well as Level 2, rules are separated into three subclasses for the benefit of model analysis software. The three subclasses are based on the following three different possible functional forms (where x is a variable, f is some arbitrary function returning a numerical result, V is a vector of variables that does not include x, and W is a vector of variables that may include x): Algebraic: left-hand side is zero 0 = f(W) Assignment: left-hand side is a scalar: x = f(V) Rate: left-hand side is a rate-of-change: dx/dt = f(W) In their general form given above, there is little to distinguish between assignment and algebraic rules. They are treated as separate cases for the following reasons: * Assignment rules can simply be evaluated to calculate intermediate values for use in numerical methods. They are statements of equality that hold at all times. (For assignments that are only performed once, see InitialAssignment.) * SBML needs to place restrictions on assignment rules, for example the restriction that assignment rules cannot contain algebraic loops. * Some simulators do not contain numerical solvers capable of solving unconstrained algebraic equations, and providing more direct forms such as assignment rules may enable those simulators to process models they could not process if the same assignments were put in the form of general algebraic equations; * Those simulators that can solve these algebraic equations make a distinction between the different categories listed above; and * Some specialized numerical analyses of models may only be applicable to models that do not contain algebraic rules. The approach taken to covering these cases in SBML is to define an abstract Rule structure containing a subelement, 'math', to hold the right-hand side expression, then to derive subtypes of Rule that add attributes to distinguish the cases of algebraic, assignment and rate rules. The 'math' subelement must contain a MathML expression defining the mathematical formula of the rule. This MathML formula must return a numerical value. The formula can be an arbitrary expression referencing the variables and other entities in an SBML model. Each of the three subclasses of Rule (AssignmentRule, AlgebraicRule, RateRule) inherit the the 'math' subelement and other fields from SBase. The AssignmentRule and RateRule classes add an additional attribute, 'variable'. See the definitions of AssignmentRule, AlgebraicRule and RateRule for details about the structure and interpretation of each one. Additional restrictions on SBML rules ====================================================================== An important design goal of SBML rule semantics is to ensure that a model's simulation and analysis results will not be dependent on when or how often rules are evaluated. To achieve this, SBML needs to place two restrictions on rule use. The first concerns algebraic loops in the system of assignments in a model, and the second concerns overdetermined systems. A model must not contain algebraic loops ...................................................................... The combined set of InitialAssignment, AssignmentRule and KineticLaw objects in a model constitute a set of assignment statements that should be considered as a whole. (A KineticLaw object is counted as an assignment because it assigns a value to the symbol contained in the 'id' attribute of the Reaction object in which it is defined.) This combined set of assignment statements must not contain algebraic loops---dependency chains between these statements must terminate. To put this more formally, consider a directed graph in which nodes are assignment statements and directed arcs exist for each occurrence of an SBML species, compartment or parameter symbol in an assignment statement's 'math' subelement. Let the directed arcs point from the statement assigning the symbol to the statements that contain the symbol in their 'math' subelement expressions. This graph must be acyclic. Similarly, the combined set of RateRule and Reaction objects constitute a set of definitions for the rates of change of various model entities (namely, the objects identified by the values of the 'variable' attributes of the RateRule objects, and the 'species' attributes of the SpeciesReference objects in each Reaction). In SBML Level 3 Version 2, these rates of change may be referenced directly using the rateOf csymbol, but may not thereby contain algebraic loops---dependency chains between these statements must terminate. More formally, consider a directed graph in which the nodes are the definitions of different variables' rates of change, and directed arcs exist for each occurrence of a variable referenced by a rateOf csymbol from any RateRule or KineticLaw object in the model. Let the directed arcs point from the variable referenced by the rateOf csymbol (call it x) to the variable(s) determined by the 'math' expression in which x appears. This graph must be acyclic. SBML does not specify when or how often rules should be evaluated. Eliminating algebraic loops ensures that assignment statements can be evaluated any number of times without the result of those evaluations changing. As an example, consider the set of equations x = x + 1, y = z + 200 and z = y + 100. If this set of equations were interpreted as a set of assignment statements, it would be invalid because the rule for x refers to x (exhibiting one type of loop), and the rule for y refers to z while the rule for z refers back to y (exhibiting another type of loop). Conversely, the following set of equations would constitute a valid set of assignment statements: x = 10, y = z + 200, and z = x + 100. A model must not be overdetermined ...................................................................... An SBML model must not be overdetermined; that is, a model must not define more equations than there are unknowns in a model. A valid SBML model that does not contain AlgebraicRule structures cannot be overdetermined. LibSBML implements the static analysis procedure described in Appendix B of the SBML Level 3 specification for assessing whether a model is overdetermined. (In summary, assessing whether a given continuous, deterministic, mathematical model is overdetermined does not require dynamic analysis; it can be done by analyzing the system of equations created from the model. One approach is to construct a bipartite graph in which one set of vertices represents the variables and the other the set of vertices represents the equations. Place edges between vertices such that variables in the system are linked to the equations that determine them. For algebraic equations, there will be edges between the equation and each variable occurring in the equation. For ordinary differential equations (such as those defined by rate rules or implied by the reaction rate definitions), there will be a single edge between the equation and the variable determined by that differential equation. A mathematical model is overdetermined if the maximal matchings of the bipartite graph contain disconnected vertexes representing equations. If one maximal matching has this property, then all the maximal matchings will have this property; i.e., it is only necessary to find one maximal matching.) Rule types for SBML Level 1 ====================================================================== SBML Level 1 uses a different scheme than SBML Level 2 and Level 3 for distinguishing rules; specifically, it uses an attribute whose value is drawn from an enumeration of 3 values. LibSBML supports this using methods that work with the enumeration values listed below. * RULE_TYPE_RATE: Indicates the rule is a 'rate' rule. * RULE_TYPE_SCALAR: Indicates the rule is a 'scalar' rule. * RULE_TYPE_INVALID: Indicates the rule type is unknown or not yet set. """ __swig_setmethods__ = {} for _s in [Rule]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, AlgebraicRule, name, value) __swig_getmethods__ = {} for _s in [Rule]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, AlgebraicRule, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(AlgebraicRule self, unsigned int level, unsigned int version) -> AlgebraicRule __init__(AlgebraicRule self, SBMLNamespaces sbmlns) -> AlgebraicRule This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: AlgebraicRule(SBMLNamespaces sbmlns) Creates a new AlgebraicRule object using the given SBMLNamespaces object 'sbmlns'. The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments. Parameter 'sbmlns' is an SBMLNamespaces object. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: AlgebraicRule(long level, long version) Creates a new AlgebraicRule object using the given SBML 'level' and 'version' values. Parameter 'level' is the SBML Level to assign to this AlgebraicRule object. Parameter 'version' is the SBML Version to assign to this AlgebraicRule object. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. """ this = _libsbml.new_AlgebraicRule(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_AlgebraicRule __del__ = lambda self: None def clone(self): """ clone(AlgebraicRule self) -> AlgebraicRule Creates and returns a deep copy of this AlgebraicRule object. Returns the (deep) copy of this Rule object. """ return _libsbml.AlgebraicRule_clone(self) def hasRequiredAttributes(self): """ hasRequiredAttributes(AlgebraicRule self) -> bool Predicate returning 'True' if all the required attributes for this AlgebraicRule object have been set. In SBML Levels 2-3, there is no required attribute for an AlgebraicRule object. For Level 1, the only required attribute is 'formula'. Returns 'True' if the required attributes have been set, 'False' otherwise. """ return _libsbml.AlgebraicRule_hasRequiredAttributes(self) AlgebraicRule_swigregister = _libsbml.AlgebraicRule_swigregister AlgebraicRule_swigregister(AlgebraicRule) class AssignmentRule(Rule): """ An SBML assignment rule representing x = f(Y). The rule type AssignmentRule is derived from the parent class Rule. It is used to express equations that set the values of variables. The left-hand side (the attribute named 'variable') of an assignment rule must refer to the identifier of a Species, SpeciesReference (in SBML Level 3), Compartment, or global Parameter object in the model (but not a Reaction). In SBML Level 3 Version 2, it may also refer to the SId of an element defined in an SBML Level 3 package with mathematical meaning and the ability to be assigned. The entity identified must have its 'constant' attribute set to 'False.' The effects of an assignment rule construct are in general terms the same, but differ in the precise details depending on the type of SBML component being set: * In the case of a species, an SBML assignment rule sets the referenced species' quantity (whether a 'concentration' or 'amount') to the value determined by the formula in the MathML subelement 'math'. The unit associated with the value produced by the 'math' formula should (in SBML Level 2 Version 4 and in SBML Level 3) or must (in SBML releases prior to Level 2 version 4) be equal to the unit associated with the species' quantity. Restrictions: There must not be both an AssignmentRule 'variable' attribute and a SpeciesReference 'species' attribute having the same value in a model, unless the referenced Species object has its 'boundaryCondition' attribute set to 'True.' In other words, an assignment rule cannot be defined for a species that is created or destroyed in a reaction unless that species is defined as a boundary condition in the model. * (For SBML Level 3 only) In the case of a species reference, an assignment rule sets the stoichiometry of the referenced reactant or product to the value determined by the formula in 'math'. The unit associated with the value produced by the 'math' formula should be consistent with the unit 'dimensionless', because reactant and product stoichiometries in reactions are dimensionless quantities. * In the case of a compartment, an SBML assignment rule sets the referenced compartment's size to the value determined by the formula in the 'math' subelement of the AssignmentRule object. The overall units of the formula in 'math' should (in SBML Level 2 Version 4 and in SBML Level 3) or must (in SBML releases prior to Level 2 version 4) be the same as the units of the size of the compartment. * In the case of a parameter, an assignment rule sets the referenced parameter's value to that determined by the formula in the 'math' subelement of the AssignmentRule object. The overall units of the formula in the 'math' subelement should (in SBML Level 2 Version 4 and in SBML Level 3) or must (in SBML releases prior to Level 2 version 4) be the same as the units defined for the parameter. * (For SBML Level 3 Version 2 only) In the case of an object from an SBML Level 3 package, an AssignmentRule sets the referenced object's value (as defined by that package) to the value of the formula in math. The unit of measurement associated with the value produced by the formula should be the same as that object's units attribute value (if it has such an attribute), or be equal to the units of model components of that type (if objects of that class are defined by the package as having the same units). In SBML Level 2 and Level 3 Version 1, the 'math' subelement of the AssignmentRule is required. In SBML Level 3 Version 2, this rule is relaxed, and the subelement is optional. If an AssignmentRule with no 'math' child is present in the model, the value of its referenced 'variable' is undefined. This may represent a situation where the model itself is unfinished, or the missing information may be provided by an SBML Level 3 package. If the variable attribute of an AssignmentRule object references an object in an SBML namespace not understood by the interpreter reading a given SBML document (that is, if the object is defined by an SBML Level 3 package that the software does not support), the assignment rule must be ignored--the object's value will not need to be set, as the interpreter could not understand that package. If an interpreter cannot establish whether a referenced object is missing from the model or instead is defined in an SBML namespace not understood by the interpreter, it may produce a warning to the user. (The latter situation may only arise if an SBML package is present in the SBML document with a package:required attribute of 'true'.) In the context of a simulation, assignment rules are in effect at all times, t >= 0. For purposes of evaluating expressions that involve the delay 'csymbol' (see the SBML Level 2 specification), assignment rules are considered to apply also at t <= 0. Please consult the relevant SBML specification for additional information about the semantics of assignments, rules, and entity values for simulation time t <= 0. A model must not contain more than one AssignmentRule or RateRule object having the same value of 'variable'; in other words, in the set of all assignment rules and rate rules in an SBML model, each variable appearing in the left-hand sides can only appear once. This simply follows from the fact that an indeterminate system would result if a model contained more than one assignment rule for the same variable or both an assignment rule and a rate rule for the same variable. Similarly, a model must also not contain both an AssignmentRule and an InitialAssignment definition for the same variable, because both kinds of constructs apply prior to and at the start of simulation time, i.e., t <= 0. If a model contained both an initial assignment and an assignment rule for the same variable, an indeterminate system would result. The value calculated by an AssignmentRule object overrides the value assigned to the given symbol by the model component defining that symbol. For example, if a Compartment object's 'size' attribute value is set in its definition, and the model also contains an AssignmentRule object having that compartment's 'id' as its 'variable' value, then the 'size' assigned in the Compartment object definition is ignored and the value assigned based on the computation defined in the AssignmentRule. This does not mean that a definition for a given symbol can be omitted if there is an AssignmentRule object involving it. For example, there must be a Parameter object definition for a given parameter if there is an AssignmentRule definition for that parameter. It is only a question of which value definition takes precedence. General summary of SBML rules ====================================================================== In SBML Level 3 as well as Level 2, rules are separated into three subclasses for the benefit of model analysis software. The three subclasses are based on the following three different possible functional forms (where x is a variable, f is some arbitrary function returning a numerical result, V is a vector of variables that does not include x, and W is a vector of variables that may include x): Algebraic: left-hand side is zero 0 = f(W) Assignment: left-hand side is a scalar: x = f(V) Rate: left-hand side is a rate-of-change: dx/dt = f(W) In their general form given above, there is little to distinguish between assignment and algebraic rules. They are treated as separate cases for the following reasons: * Assignment rules can simply be evaluated to calculate intermediate values for use in numerical methods. They are statements of equality that hold at all times. (For assignments that are only performed once, see InitialAssignment.) * SBML needs to place restrictions on assignment rules, for example the restriction that assignment rules cannot contain algebraic loops. * Some simulators do not contain numerical solvers capable of solving unconstrained algebraic equations, and providing more direct forms such as assignment rules may enable those simulators to process models they could not process if the same assignments were put in the form of general algebraic equations; * Those simulators that can solve these algebraic equations make a distinction between the different categories listed above; and * Some specialized numerical analyses of models may only be applicable to models that do not contain algebraic rules. The approach taken to covering these cases in SBML is to define an abstract Rule structure containing a subelement, 'math', to hold the right-hand side expression, then to derive subtypes of Rule that add attributes to distinguish the cases of algebraic, assignment and rate rules. The 'math' subelement must contain a MathML expression defining the mathematical formula of the rule. This MathML formula must return a numerical value. The formula can be an arbitrary expression referencing the variables and other entities in an SBML model. Each of the three subclasses of Rule (AssignmentRule, AlgebraicRule, RateRule) inherit the the 'math' subelement and other fields from SBase. The AssignmentRule and RateRule classes add an additional attribute, 'variable'. See the definitions of AssignmentRule, AlgebraicRule and RateRule for details about the structure and interpretation of each one. Additional restrictions on SBML rules ====================================================================== An important design goal of SBML rule semantics is to ensure that a model's simulation and analysis results will not be dependent on when or how often rules are evaluated. To achieve this, SBML needs to place two restrictions on rule use. The first concerns algebraic loops in the system of assignments in a model, and the second concerns overdetermined systems. A model must not contain algebraic loops ...................................................................... The combined set of InitialAssignment, AssignmentRule and KineticLaw objects in a model constitute a set of assignment statements that should be considered as a whole. (A KineticLaw object is counted as an assignment because it assigns a value to the symbol contained in the 'id' attribute of the Reaction object in which it is defined.) This combined set of assignment statements must not contain algebraic loops---dependency chains between these statements must terminate. To put this more formally, consider a directed graph in which nodes are assignment statements and directed arcs exist for each occurrence of an SBML species, compartment or parameter symbol in an assignment statement's 'math' subelement. Let the directed arcs point from the statement assigning the symbol to the statements that contain the symbol in their 'math' subelement expressions. This graph must be acyclic. Similarly, the combined set of RateRule and Reaction objects constitute a set of definitions for the rates of change of various model entities (namely, the objects identified by the values of the 'variable' attributes of the RateRule objects, and the 'species' attributes of the SpeciesReference objects in each Reaction). In SBML Level 3 Version 2, these rates of change may be referenced directly using the rateOf csymbol, but may not thereby contain algebraic loops---dependency chains between these statements must terminate. More formally, consider a directed graph in which the nodes are the definitions of different variables' rates of change, and directed arcs exist for each occurrence of a variable referenced by a rateOf csymbol from any RateRule or KineticLaw object in the model. Let the directed arcs point from the variable referenced by the rateOf csymbol (call it x) to the variable(s) determined by the 'math' expression in which x appears. This graph must be acyclic. SBML does not specify when or how often rules should be evaluated. Eliminating algebraic loops ensures that assignment statements can be evaluated any number of times without the result of those evaluations changing. As an example, consider the set of equations x = x + 1, y = z + 200 and z = y + 100. If this set of equations were interpreted as a set of assignment statements, it would be invalid because the rule for x refers to x (exhibiting one type of loop), and the rule for y refers to z while the rule for z refers back to y (exhibiting another type of loop). Conversely, the following set of equations would constitute a valid set of assignment statements: x = 10, y = z + 200, and z = x + 100. A model must not be overdetermined ...................................................................... An SBML model must not be overdetermined; that is, a model must not define more equations than there are unknowns in a model. A valid SBML model that does not contain AlgebraicRule structures cannot be overdetermined. LibSBML implements the static analysis procedure described in Appendix B of the SBML Level 3 specification for assessing whether a model is overdetermined. (In summary, assessing whether a given continuous, deterministic, mathematical model is overdetermined does not require dynamic analysis; it can be done by analyzing the system of equations created from the model. One approach is to construct a bipartite graph in which one set of vertices represents the variables and the other the set of vertices represents the equations. Place edges between vertices such that variables in the system are linked to the equations that determine them. For algebraic equations, there will be edges between the equation and each variable occurring in the equation. For ordinary differential equations (such as those defined by rate rules or implied by the reaction rate definitions), there will be a single edge between the equation and the variable determined by that differential equation. A mathematical model is overdetermined if the maximal matchings of the bipartite graph contain disconnected vertexes representing equations. If one maximal matching has this property, then all the maximal matchings will have this property; i.e., it is only necessary to find one maximal matching.) Rule types for SBML Level 1 ====================================================================== SBML Level 1 uses a different scheme than SBML Level 2 and Level 3 for distinguishing rules; specifically, it uses an attribute whose value is drawn from an enumeration of 3 values. LibSBML supports this using methods that work with the enumeration values listed below. * RULE_TYPE_RATE: Indicates the rule is a 'rate' rule. * RULE_TYPE_SCALAR: Indicates the rule is a 'scalar' rule. * RULE_TYPE_INVALID: Indicates the rule type is unknown or not yet set. """ __swig_setmethods__ = {} for _s in [Rule]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, AssignmentRule, name, value) __swig_getmethods__ = {} for _s in [Rule]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, AssignmentRule, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(AssignmentRule self, unsigned int level, unsigned int version) -> AssignmentRule __init__(AssignmentRule self, SBMLNamespaces sbmlns) -> AssignmentRule This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: AssignmentRule(SBMLNamespaces sbmlns) Creates a new AssignmentRule using the given SBMLNamespaces object 'sbmlns'. The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments. Parameter 'sbmlns' is an SBMLNamespaces object. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: AssignmentRule(long level, long version) Creates a new AssignmentRule using the given SBML 'level' and 'version' values. Parameter 'level' is a long integer, the SBML Level to assign to this AssignmentRule. Parameter 'version' is a long integer, the SBML Version to assign to this AssignmentRule. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. """ this = _libsbml.new_AssignmentRule(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_AssignmentRule __del__ = lambda self: None def clone(self): """ clone(AssignmentRule self) -> AssignmentRule Creates and returns a deep copy of this AssignmentRule object. Returns the (deep) copy of this Rule object. """ return _libsbml.AssignmentRule_clone(self) def hasRequiredAttributes(self): """ hasRequiredAttributes(AssignmentRule self) -> bool Predicate returning 'True' if all the required attributes for this AssignmentRule object have been set. In SBML Levels 2-3, the only required attribute for an AssignmentRule object is 'variable'. For Level 1, where the equivalent attribute is known by different names ('compartment', 'species', or 'name', depending on the type of object), there is an additional required attribute called 'formula'. Returns 'True' if the required attributes have been set, 'False' otherwise. """ return _libsbml.AssignmentRule_hasRequiredAttributes(self) def renameSIdRefs(self, oldid, newid): """ renameSIdRefs(AssignmentRule self, string oldid, string newid) Replaces all uses of a given 'SIdRef' type attribute value with another value. In SBML, object identifiers are of a data type called SId. In SBML Level 3, an explicit data type called SIdRef was introduced for attribute values that refer to SId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to an identifier', but the effective data type was the same as SIdRef in Level 3. These and other methods of libSBML refer to the type SIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all attributes and (if appropriate) mathematical formulas in MathML content, comparing the referenced identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.AssignmentRule_renameSIdRefs(self, oldid, newid) AssignmentRule_swigregister = _libsbml.AssignmentRule_swigregister AssignmentRule_swigregister(AssignmentRule) class RateRule(Rule): """ An SBML rate rule representing dx/dt = f(Y). The rule type RateRule is derived from the parent class Rule. It is used to express equations that determine the rates of change of variables. The left-hand side (the 'variable' attribute) can refer to the identifier of a species, compartment, or parameter (but not a reaction). The entity identified must have its 'constant' attribute set to 'False.' The effects of a RateRule are in general terms the same, but differ in the precise details depending on which variable is being set: * In the case of a species, a RateRule sets the rate of change of the species' quantity (concentration or amount of substance) to the value determined by the formula in the 'math' subelement of the RateRule object. The overall units of the formula in 'math' should (in SBML Level 2 Version 4 and in SBML Level 3) or must (in SBML releases prior to Level 2 version 4) be equal to the unit of species quantity divided by the model-wide unit of time. Restrictions: There must not be both a RateRule 'variable' attribute and a SpeciesReference 'species' attribute having the same value, unless that species has its 'boundaryCondition' attribute is set to 'True.' This means a rate rule cannot be defined for a species that is created or destroyed in a reaction, unless that species is defined as a boundary condition in the model. * (For SBML Level 3 only) In the case of a species reference, a RateRule sets the rate of change of the stoichiometry of the referenced reactant or product to the value determined by the formula in 'math'. The unit associated with the value produced by the 'math' formula should be consistent with the unit 'dimensionless' divided by the model-wide unit of time. * In the case of a compartment, a RateRule sets the rate of change of the compartment's size to the value determined by the formula in the 'math' subelement of the RateRule object. The overall units of the formula should (in SBML Level 2 Version 4 and in SBML Level 3) or must (in SBML releases prior to Level 2 version 4) be the units of the compartment's size divided by the model-wide unit of time. * In the case of a parameter, a RateRule sets the rate of change of the parameter's value to that determined by the formula in the 'math' subelement of the RateRule object. The overall units of the formula should (in SBML Level 2 Version 4 and in SBML Level 3) or must (in SBML releases prior to Level 2 version 4) be the Parameter object's 'unit' attribute value divided by the model-wide unit of time. * (For SBML Level 3 Version 2 only) In the case of an object from an SBML Level 3 package, a RateRule sets the rate of change of the referenced object's value (as defined by that package) to the value of the formula in 'math'. The unit of measurement associated with the value produced by the formula should be the same as that object's units attribute value (if it has such an attribute) divided by the model-wide unit of time, or be equal to the units of model components of that type (if objects of that class are defined by the package as having the same units) divided by the model-wide unit of time. In SBML Level 2 and Level 3 Version 1, the 'math' subelement of the RateRule is required. In SBML Level 3 Version 2, this rule is relaxed, and the subelement is optional. If a RateRule with no 'math' child is present in the model, the rate at which its referenced 'variable' changes over time is undefined. This may represent a situation where the model itself is unfinished, or the missing information may be provided by an SBML Level 3 package. If the variable attribute of a RateRule object references an object in an SBML namespace that is not understood by the interpreter reading a given SBML document (that is, if the object is defined by an SBML Level 3 package that the software does not support), the rate rule must be ignored--the object's value will not need to be set, as the interpreter could not understand that package. If an interpreter cannot establish whether a referenced object is missing from the model or instead is defined in an SBML namespace not understood by the interpreter, it may produce a warning to the user. (The latter situation may only arise if an SBML package is present in the SBML document with a package:required attribute of 'true'.) In the context of a simulation, rate rules are in effect for simulation time t > 0. Please consult the relevant SBML specification for additional information about the semantics of assignments, rules, and entity values for simulation time t <= 0. As mentioned in the description of AssignmentRule, a model must not contain more than one RateRule or AssignmentRule object having the same value of 'variable'; in other words, in the set of all assignment rules and rate rules in an SBML model, each variable appearing in the left-hand sides can only appear once. This simply follows from the fact that an indeterminate system would result if a model contained more than one assignment rule for the same variable or both an assignment rule and a rate rule for the same variable. General summary of SBML rules ====================================================================== In SBML Level 3 as well as Level 2, rules are separated into three subclasses for the benefit of model analysis software. The three subclasses are based on the following three different possible functional forms (where x is a variable, f is some arbitrary function returning a numerical result, V is a vector of variables that does not include x, and W is a vector of variables that may include x): Algebraic: left-hand side is zero 0 = f(W) Assignment: left-hand side is a scalar: x = f(V) Rate: left-hand side is a rate-of-change: dx/dt = f(W) In their general form given above, there is little to distinguish between assignment and algebraic rules. They are treated as separate cases for the following reasons: * Assignment rules can simply be evaluated to calculate intermediate values for use in numerical methods. They are statements of equality that hold at all times. (For assignments that are only performed once, see InitialAssignment.) * SBML needs to place restrictions on assignment rules, for example the restriction that assignment rules cannot contain algebraic loops. * Some simulators do not contain numerical solvers capable of solving unconstrained algebraic equations, and providing more direct forms such as assignment rules may enable those simulators to process models they could not process if the same assignments were put in the form of general algebraic equations; * Those simulators that can solve these algebraic equations make a distinction between the different categories listed above; and * Some specialized numerical analyses of models may only be applicable to models that do not contain algebraic rules. The approach taken to covering these cases in SBML is to define an abstract Rule structure containing a subelement, 'math', to hold the right-hand side expression, then to derive subtypes of Rule that add attributes to distinguish the cases of algebraic, assignment and rate rules. The 'math' subelement must contain a MathML expression defining the mathematical formula of the rule. This MathML formula must return a numerical value. The formula can be an arbitrary expression referencing the variables and other entities in an SBML model. Each of the three subclasses of Rule (AssignmentRule, AlgebraicRule, RateRule) inherit the the 'math' subelement and other fields from SBase. The AssignmentRule and RateRule classes add an additional attribute, 'variable'. See the definitions of AssignmentRule, AlgebraicRule and RateRule for details about the structure and interpretation of each one. Additional restrictions on SBML rules ====================================================================== An important design goal of SBML rule semantics is to ensure that a model's simulation and analysis results will not be dependent on when or how often rules are evaluated. To achieve this, SBML needs to place two restrictions on rule use. The first concerns algebraic loops in the system of assignments in a model, and the second concerns overdetermined systems. A model must not contain algebraic loops ...................................................................... The combined set of InitialAssignment, AssignmentRule and KineticLaw objects in a model constitute a set of assignment statements that should be considered as a whole. (A KineticLaw object is counted as an assignment because it assigns a value to the symbol contained in the 'id' attribute of the Reaction object in which it is defined.) This combined set of assignment statements must not contain algebraic loops---dependency chains between these statements must terminate. To put this more formally, consider a directed graph in which nodes are assignment statements and directed arcs exist for each occurrence of an SBML species, compartment or parameter symbol in an assignment statement's 'math' subelement. Let the directed arcs point from the statement assigning the symbol to the statements that contain the symbol in their 'math' subelement expressions. This graph must be acyclic. Similarly, the combined set of RateRule and Reaction objects constitute a set of definitions for the rates of change of various model entities (namely, the objects identified by the values of the 'variable' attributes of the RateRule objects, and the 'species' attributes of the SpeciesReference objects in each Reaction). In SBML Level 3 Version 2, these rates of change may be referenced directly using the rateOf csymbol, but may not thereby contain algebraic loops---dependency chains between these statements must terminate. More formally, consider a directed graph in which the nodes are the definitions of different variables' rates of change, and directed arcs exist for each occurrence of a variable referenced by a rateOf csymbol from any RateRule or KineticLaw object in the model. Let the directed arcs point from the variable referenced by the rateOf csymbol (call it x) to the variable(s) determined by the 'math' expression in which x appears. This graph must be acyclic. SBML does not specify when or how often rules should be evaluated. Eliminating algebraic loops ensures that assignment statements can be evaluated any number of times without the result of those evaluations changing. As an example, consider the set of equations x = x + 1, y = z + 200 and z = y + 100. If this set of equations were interpreted as a set of assignment statements, it would be invalid because the rule for x refers to x (exhibiting one type of loop), and the rule for y refers to z while the rule for z refers back to y (exhibiting another type of loop). Conversely, the following set of equations would constitute a valid set of assignment statements: x = 10, y = z + 200, and z = x + 100. A model must not be overdetermined ...................................................................... An SBML model must not be overdetermined; that is, a model must not define more equations than there are unknowns in a model. A valid SBML model that does not contain AlgebraicRule structures cannot be overdetermined. LibSBML implements the static analysis procedure described in Appendix B of the SBML Level 3 specification for assessing whether a model is overdetermined. (In summary, assessing whether a given continuous, deterministic, mathematical model is overdetermined does not require dynamic analysis; it can be done by analyzing the system of equations created from the model. One approach is to construct a bipartite graph in which one set of vertices represents the variables and the other the set of vertices represents the equations. Place edges between vertices such that variables in the system are linked to the equations that determine them. For algebraic equations, there will be edges between the equation and each variable occurring in the equation. For ordinary differential equations (such as those defined by rate rules or implied by the reaction rate definitions), there will be a single edge between the equation and the variable determined by that differential equation. A mathematical model is overdetermined if the maximal matchings of the bipartite graph contain disconnected vertexes representing equations. If one maximal matching has this property, then all the maximal matchings will have this property; i.e., it is only necessary to find one maximal matching.) Rule types for SBML Level 1 ====================================================================== SBML Level 1 uses a different scheme than SBML Level 2 and Level 3 for distinguishing rules; specifically, it uses an attribute whose value is drawn from an enumeration of 3 values. LibSBML supports this using methods that work with the enumeration values listed below. * RULE_TYPE_RATE: Indicates the rule is a 'rate' rule. * RULE_TYPE_SCALAR: Indicates the rule is a 'scalar' rule. * RULE_TYPE_INVALID: Indicates the rule type is unknown or not yet set. """ __swig_setmethods__ = {} for _s in [Rule]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, RateRule, name, value) __swig_getmethods__ = {} for _s in [Rule]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, RateRule, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(RateRule self, unsigned int level, unsigned int version) -> RateRule __init__(RateRule self, SBMLNamespaces sbmlns) -> RateRule This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: RateRule(SBMLNamespaces sbmlns) Creates a new RateRule using the given SBMLNamespaces object 'sbmlns'. The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments. Parameter 'sbmlns' is an SBMLNamespaces object. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: RateRule(long level, long version) Creates a new RateRule using the given SBML 'level' and 'version' values. Parameter 'level' is a long integer, the SBML Level to assign to this RateRule. Parameter 'version' is a long integer, the SBML Version to assign to this RateRule. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. """ this = _libsbml.new_RateRule(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_RateRule __del__ = lambda self: None def clone(self): """ clone(RateRule self) -> RateRule Creates and returns a deep copy of this RateRule object. Returns the (deep) copy of this RateRule object. """ return _libsbml.RateRule_clone(self) def hasRequiredAttributes(self): """ hasRequiredAttributes(RateRule self) -> bool Predicate returning 'True' if all the required attributes for this RateRule object have been set. In SBML Levels 2-3, the only required attribute for a RateRule object is 'variable'. For Level 1, where the equivalent attribute is known by different names ('compartment', 'species', or 'name', depending on the type of object), there is an additional required attribute called 'formula'. Returns 'True' if the required attributes have been set, 'False' otherwise. """ return _libsbml.RateRule_hasRequiredAttributes(self) def renameSIdRefs(self, oldid, newid): """ renameSIdRefs(RateRule self, string oldid, string newid) Replaces all uses of a given 'SIdRef' type attribute value with another value. In SBML, object identifiers are of a data type called SId. In SBML Level 3, an explicit data type called SIdRef was introduced for attribute values that refer to SId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to an identifier', but the effective data type was the same as SIdRef in Level 3. These and other methods of libSBML refer to the type SIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all attributes and (if appropriate) mathematical formulas in MathML content, comparing the referenced identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.RateRule_renameSIdRefs(self, oldid, newid) RateRule_swigregister = _libsbml.RateRule_swigregister RateRule_swigregister(RateRule) class Constraint(SBase): """ An SBML constraint, for stating validity assumptions. The Constraint object class was introduced in SBML Level 2 Version 2 as 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. Constraints are not used to compute dynamical values for simulation or analysis, but rather, they serve an advisory role for simulation/analysis tools. SBML's Constraint object class has one required attribute, 'id', to give the parameter a unique identifier by which other parts of an SBML model definition can refer to it. A Constraint object can also have an optional 'name' attribute of type 'string.' Identifiers and names must be used according to the guidelines described in the SBML specification (e.g., Section 3.3 in the Level 2 Version 4 specification). Constraint has one subelement, 'math', containing a MathML formula defining the condition of the constraint. This formula will return a Boolean value of 'True' when the model is a valid state. The formula can be an arbitrary expression referencing the variables and other entities in an SBML model. The evaluation of 'math' and behavior of constraints are described in more detail below. In SBML Level 2 and SBML Level 3 Version 1, the 'math' subelement is required, and its formula must be a Boolean value. In SBML Level 3 Version 2, these restrictions were relaxed: the 'math' subelement is optional, and numeric values are allowed in Boolean contexts (a '0' is interpreted as 'False,' and all other values are interpreted as 'True).' If a Constraint with no 'math' is present in a Model, no restriction on the Model's behavior is implied or enforced. A Constraint structure also has an optional subelement called 'message'. This can contain a message in XHTML format that may be displayed to the user when the condition of the formula in the 'math' subelement evaluates to a value of 'False.' Software tools are not required to display the message, but it is recommended that they do so as a matter of best practice. The XHTML content within a 'message' subelement must follow the same restrictions as for the 'notes' element on SBase described in in the SBML Level 2 specification; please consult the SBML specification document corresponding to the SBML Level and Version of your model for more information about the requirements for 'notes' content. Constraint was introduced in SBML Level 2 Version 2. It is not available in earlier versions of Level 2 nor in any version of Level 1. Semantics of Constraints ====================================================================== In the context of a simulation, a Constraint has effect at all times t >= 0. Each Constraint's 'math' subelement is first evaluated after any InitialAssignment definitions in a model at t = 0 and can conceivably trigger at that point. (In other words, a simulation could fail a constraint immediately.) Constraint structures cannot and should not be used to compute the dynamical behavior of a model as part of, for example, simulation. Constraints may be used as input to non-dynamical analysis, for instance by expressing flux constraints for flux balance analysis. The results of a simulation of a model containing a constraint are invalid from any simulation time at and after a point when the function given by the 'math' subelement returns a value of 'False.' Invalid simulation results do not make a prediction of the behavior of the biochemical reaction network represented by the model. The precise behavior of simulation tools is left undefined with respect to constraints. If invalid results are detected with respect to a given constraint, the 'message' subelement may optionally be displayed to the user. The simulation tool may also halt the simulation or clearly delimit in output data the simulation time point at which the simulation results become invalid. SBML does not impose restrictions on duplicate Constraint definitions or the order of evaluation of Constraint objects in a model. It is possible for a model to define multiple constraints all with the same mathematical expression. Since the failure of any constraint indicates that the model simulation has entered an invalid state, a system is not required to attempt to detect whether other constraints in the model have failed once any one constraint has failed. """ __swig_setmethods__ = {} for _s in [SBase]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, Constraint, name, value) __swig_getmethods__ = {} for _s in [SBase]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, Constraint, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_Constraint __del__ = lambda self: None def __init__(self, *args): """ __init__(Constraint self, unsigned int level, unsigned int version) -> Constraint __init__(Constraint self, SBMLNamespaces sbmlns) -> Constraint __init__(Constraint self, Constraint orig) -> Constraint This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: Constraint(SBMLNamespaces sbmlns) Creates a new Constraint using the given SBMLNamespaces object 'sbmlns'. The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments. Parameter 'sbmlns' is an SBMLNamespaces object. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: Constraint(long level, long version) Creates a new Constraint using the given SBML 'level' and 'version' values. Parameter 'level' is a long integer, the SBML Level to assign to this Constraint. Parameter 'version' is a long integer, the SBML Version to assign to this Constraint. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: Constraint( Constraint orig) Copy constructor; creates a copy of this Constraint. Parameter 'orig' is the object to copy. """ this = _libsbml.new_Constraint(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(Constraint self) -> Constraint Creates and returns a deep copy of this Constraint object. Returns the (deep) copy of this Constraint object. """ return _libsbml.Constraint_clone(self) def getMessage(self): """ getMessage(Constraint self) -> XMLNode Get the message, if any, associated with this Constraint Returns the message for this Constraint, as an XMLNode. """ return _libsbml.Constraint_getMessage(self) def getMessageString(self): """ getMessageString(Constraint self) -> string Get the message string, if any, associated with this Constraint Returns the message for this Constraint, as a string. """ return _libsbml.Constraint_getMessageString(self) def getMath(self): """ getMath(Constraint self) -> ASTNode Get the mathematical expression of this Constraint Returns the math for this Constraint, as an ASTNode, or 'None' if the math is not set. """ return _libsbml.Constraint_getMath(self) def isSetMessage(self): """ isSetMessage(Constraint self) -> bool Predicate returning 'True' if a message is defined for this Constraint. Returns 'True' if the message of this Constraint is set, 'False' otherwise. """ return _libsbml.Constraint_isSetMessage(self) def isSetMath(self): """ isSetMath(Constraint self) -> bool Predicate returning 'True' if a mathematical formula is defined for this Constraint. Returns 'True' if the 'math' subelement for this Constraint is set, 'False' otherwise. """ return _libsbml.Constraint_isSetMath(self) def setMessage(self, *args): """ setMessage(Constraint self, XMLNode xhtml) -> int setMessage(Constraint self, string message, bool addXHTMLMarkup=False) -> int setMessage(Constraint self, string message) -> int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: setMessage(string message, bool addXHTMLMarkup = false) Sets the message of this Constraint. Parameter 'message' is an XML string that is to be used as the content of the 'message' subelement of this object. Parameter 'addXHTMLMarkup' is a boolean indicating whether to wrap the contents of the 'message' argument with XHTML paragraph (

) tags. This is appropriate when the string in 'message' does not already containg the appropriate XHTML markup. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. ______________________________________________________________________ Method variant with the following signature: setMessage(XMLNode xhtml) Sets the message of this Constraint. The XMLNode tree passed in 'xhtml' is copied. Parameter 'xhtml' is an XML tree containing XHTML content. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT """ return _libsbml.Constraint_setMessage(self, *args) def setMath(self, math): """ setMath(Constraint self, ASTNode math) -> int Sets the mathematical expression of this Constraint to a copy of the AST given as 'math'. Parameter 'math' is an ASTNode expression to be assigned as the 'math' subelement of this Constraint. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT """ return _libsbml.Constraint_setMath(self, math) def unsetMessage(self): """ unsetMessage(Constraint self) -> int Unsets the 'message' subelement of this Constraint. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.Constraint_unsetMessage(self) def renameSIdRefs(self, oldid, newid): """ renameSIdRefs(Constraint self, string oldid, string newid) Replaces all uses of a given 'SIdRef' type attribute value with another value. In SBML, object identifiers are of a data type called SId. In SBML Level 3, an explicit data type called SIdRef was introduced for attribute values that refer to SId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to an identifier', but the effective data type was the same as SIdRef in Level 3. These and other methods of libSBML refer to the type SIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all attributes and (if appropriate) mathematical formulas in MathML content, comparing the referenced identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.Constraint_renameSIdRefs(self, oldid, newid) def renameUnitSIdRefs(self, oldid, newid): """ renameUnitSIdRefs(Constraint self, string oldid, string newid) Replaces all uses of a given 'UnitSIdRef' type attribute value with another value. In SBML, unit definitions have identifiers of type UnitSId. In SBML Level 3, an explicit data type called UnitSIdRef was introduced for attribute values that refer to UnitSId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to a unit identifier', but the effective data type was the same as UnitSIdRef in Level 3. These and other methods of libSBML refer to the type UnitSIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all unit identifier attribute values (including, if appropriate, inside mathematical formulas), comparing the referenced unit identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.Constraint_renameUnitSIdRefs(self, oldid, newid) def replaceSIDWithFunction(self, id, function): """ replaceSIDWithFunction(Constraint self, string id, ASTNode function) Internal implementation method. """ return _libsbml.Constraint_replaceSIDWithFunction(self, id, function) def getTypeCode(self): """ getTypeCode(Constraint self) -> int Returns the libSBML type code for this SBML object. LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for this object: SBML_CONSTRAINT (default). WARNING: The specific integer values of the possible type codes may be reused by different libSBML plug-ins for SBML Level 3. packages, To fully identify the correct code, it is necessary to invoke both getPackageName() and getTypeCode() (or ListOf.getItemTypeCode()). See also getElementName(), getPackageName(). """ return _libsbml.Constraint_getTypeCode(self) def getElementName(self): """ getElementName(Constraint self) -> string Returns the XML element name of this object, which for Constraint, is always ''constraint'.' Returns the name of this element, i.e., ''constraint'.' """ return _libsbml.Constraint_getElementName(self) def hasRequiredElements(self): """ hasRequiredElements(Constraint self) -> bool Predicate returning 'True' if all the required elements for this Constraint object have been set. Note: The required elements for a Constraint object are: * 'math' (through SBML Level 3 Version 1 only; not required in Level 3 Version 2+.) Returns a boolean value indicating whether all the required elements for this object have been defined. """ return _libsbml.Constraint_hasRequiredElements(self) Constraint_swigregister = _libsbml.Constraint_swigregister Constraint_swigregister(Constraint) class ListOfConstraints(ListOf): """ A list of Constraint objects. The various ListOf___ classes in SBML are merely containers used for organizing the main components of an SBML model. In libSBML's implementation, ListOf___ classes are derived from the intermediate utility class ListOf, which is not defined by the SBML specifications but serves as a useful programmatic construct. ListOf is itself is in turn derived from SBase, which provides all of the various ListOf___ classes with common features defined by the SBML specification, such as 'metaid' attributes and annotations. The relationship between the lists and the rest of an SBML model is illustrated by the following (for SBML Level 2 Version 4): ... ... ... ... ... ... ... elements of subclasses of Rule ... ... ... ... SBML Level 3 Version 1 has essentially the same structure as Level 2 Version 4, depicted above, but SBML Level 3 Version 2 allows containers to contain zero or more of the relevant object, instead of requiring at least one. As such, libsbml will write out an otherwise-empty ListOf___ element that has any optional attribute set (such as 'id' or 'metaid'), that has an optional child (such as a 'notes' or 'annotation'), or that has attributes or children set from any SBML Level 3 package, whether or not the ListOf___ has any other children. Readers may wonder about the motivations for using the ListOf___ containers in SBML. A simpler approach in XML might be to place the components all directly at the top level of the model definition. The choice made in SBML is to group them within XML elements named after ListOfClassname, in part because it helps organize the components. More importantly, the fact that the container classes are derived from SBase means that software tools can add information about the lists themselves into each list container's 'annotation'. See also ListOfFunctionDefinitions, ListOfUnitDefinitions, ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments, ListOfSpecies, ListOfParameters, ListOfInitialAssignments, ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents. """ __swig_setmethods__ = {} for _s in [ListOf]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfConstraints, name, value) __swig_getmethods__ = {} for _s in [ListOf]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, ListOfConstraints, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(ListOfConstraints self, unsigned int level, unsigned int version) -> ListOfConstraints __init__(ListOfConstraints self, SBMLNamespaces sbmlns) -> ListOfConstraints This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: ListOfConstraints(SBMLNamespaces sbmlns) Creates a new ListOfConstraints object. The object is constructed such that it is valid for the SBML Level and Version combination determined by the SBMLNamespaces object in 'sbmlns'. Parameter 'sbmlns' is an SBMLNamespaces object that is used to determine the characteristics of the ListOfConstraints object to be created. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: ListOfConstraints(long level, long version) Creates a new ListOfConstraints object. The object is constructed such that it is valid for the given SBML Level and Version combination. Parameter 'level' is the SBML Level. Parameter 'version' is the Version within the SBML Level. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. """ this = _libsbml.new_ListOfConstraints(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(ListOfConstraints self) -> ListOfConstraints Creates and returns a deep copy of this ListOfConstraints object. Returns the (deep) copy of this ListOfConstraints object. """ return _libsbml.ListOfConstraints_clone(self) def getItemTypeCode(self): """ getItemTypeCode(ListOfConstraints self) -> int Returns the libSBML type code for the objects contained in this ListOf (i.e., Constraint objects, if the list is non-empty). LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for the objects contained in this ListOf instance: SBML_CONSTRAINT (default). See also getElementName(), getPackageName(). """ return _libsbml.ListOfConstraints_getItemTypeCode(self) def getElementName(self): """ getElementName(ListOfConstraints self) -> string Returns the XML element name of this object. For ListOfConstraints, the XML element name is ''listOfConstraints'.' Returns the name of this element. """ return _libsbml.ListOfConstraints_getElementName(self) def get(self, *args): """ get(ListOfConstraints self, unsigned int n) -> Constraint get(ListOfConstraints self, unsigned int n) -> Constraint Get a Constraint from the ListOfConstraints. Parameter 'n' is the index number of the Constraint to get. Returns the nth Constraint in this ListOfConstraints. If the index 'n' is invalid, 'None' is returned. See also size(). """ return _libsbml.ListOfConstraints_get(self, *args) def remove(self, n): """ remove(ListOfConstraints self, unsigned int n) -> Constraint Removes the nth item from this ListOfConstraints items and returns a pointer to it. The caller owns the returned item and is responsible for deleting it. Parameter 'n' is the index of the item to remove. See also size(). """ return _libsbml.ListOfConstraints_remove(self, n) __swig_destroy__ = _libsbml.delete_ListOfConstraints __del__ = lambda self: None ListOfConstraints_swigregister = _libsbml.ListOfConstraints_swigregister ListOfConstraints_swigregister(ListOfConstraints) class Reaction(SBase): """ An SBML reaction between species in an SBML model. A reaction represents any transformation, transport or binding process, typically a chemical reaction, that can change the quantity of one or more species. In SBML, a reaction is defined primarily in terms of the participating reactants and products (and their corresponding stoichiometries), along with optional modifier species, an optional rate at which the reaction takes place, and optional parameters. As with other major objects in SBML, Reaction has a mandatory attribute, 'id', used to give the reaction an identifier. The identifier must be a text string conforming to the identifer syntax permitted in SBML. In SBML Level 2 and Level 3, the reaction 'id' identifier can be used in mathematical formulas elsewhere in an SBML model to represent the rate of that reaction; this usage is explained below. Reaction also has an optional 'name' attribute, of type 'string.' The 'id' and 'name' must be used according to the guidelines described in the SBML specification. The species participating as reactants, products, and/or modifiers in a reaction are declared using lists of SpeciesReference and/or ModifierSpeciesReference instances stored in subelements 'listOfReactants', 'listOfProducts' and 'listOfModifiers'. Certain restrictions are placed on the appearance of species in reaction definitions: * The ability of a species to appear as a reactant or product of any reaction in a model is governed by certain flags in that species' definition; see the definition of Species for more information. * Any species appearing in the mathematical formula of the subelement 'kineticLaw' (described below) of a Reaction must be declared in at least one of that Reaction's lists of reactants, products, and/or modifiers. Put another way, it is an error for a reaction's kinetic law formula to refer to species that have not been declared for that reaction. * For SBML Levels 1, 2, and SBML Level 3 Version 1, a reaction definition can contain an empty list of reactants or an empty list of products, but it must have at least one reactant or product; in other words, a reaction without any reactant or product species is not permitted. (This restriction does not apply to modifier species, which remain optional in all cases.) In SBML Level 3 Version 2, this requirement was dropped, allowing the creation of reactions with neither reactants nor products. A reaction can contain up to one KineticLaw object in a subelement named 'kineticLaw'. It defines the speed at which the process defined by the reaction takes place. The description of KineticLaw provides more details about its use. Note that although the inclusion of a KineticLaw object in an instance of a Reaction component is optional, there is no useful default that can be substituted in place of a missing rate expression in a reaction. Moreover, a reaction's rate cannot be defined in any other way in SBML ---InitialAssignment, AssignmentRule, RateRule, AlgebraicRule, Event, and other constructs in SBML cannot be used to set the reaction rate separately. Nevertheless, for some modeling applications, reactions without any defined rate can be perfectly acceptable. Reaction also has a boolean attribute named 'reversible' for indicating whether the reaction is reversible. This attribute is optional in SBML Level 2, with a default of 'True;' it is mandatory in SBML Level 3 (with no default value). To say that a reaction is reversible is to say it can proceed in either the forward or the reverse direction. Although the reversibility of a reaction can sometimes be deduced by inspecting its rate expression, this is not always the case, especially for complicated expressions. Moreover, the need in SBML to allow rate expressions (i.e., KineticLaw) to be optional leads to the need for a separate flag indicating reversibility. Note that labeling a reaction as irreversible is an assertion that the reaction always proceeds in the given forward direction. (Why else would it be flagged as irreversible?) This implies the rate expression in the KineticLaw always has a non- negative value during simulations. Software tools could provide a means of optionally testing that this condition holds. The presence of reversibility information in two places (i.e., the rate expression and the 'reversible' attribute on Reaction) leaves open the possibility that a model could contain contradictory information, but the creation of such a model would be an error on the part of the software generating it. The Reaction object class has another boolean attribute called 'fast'. This attribute is optional in SBML Level 2, with a default of 'False;' it is mandatory in SBML Level 3 (with no default value). In SBML Level 3 Version 2, a value of 'True' for the 'fast' attribute is deprecated in favor of all reactions having a 'fast' value of 'False.' It is used to indicate that a reaction occurs on a vastly faster time scale than others in a system. Readers are directed to the SBML Level 2 Version 4 specification, which provides more detail about the conditions under which a reaction can be considered to be fast in this sense. SBML Level 1 and Level 2 Version 1 incorrectly claimed that software tools could ignore this attribute if they did not implement support for the corresponding concept; however, further research in SBML has revealed that this is not true, and 'fast' cannot be ignored if it is set to 'True.' SBML Level 2 Versions 2-4 therefore stipulate that if a model has any reactions with 'fast' set to 'True,' a software tool must be able to respect the attribute or else indicate to the user that it does not have the capacity to do so. Analysis software cannot ignore the value of the 'fast' attribute because doing so may lead to different results as compared to a software system that does make use of 'fast'. In SBML Level 3 Version 2, the 'fast' attribute was removed. All reactions are assumed to be equivalent to reactions in previous levels/versions that have a 'fast' attribute value of 'False.' Users should be aware that even for previous levels/versions of the specification, 'fast' attribute values of 'True' never achieved widespread support, and many software packages may ignore it. To achieve the same or similar effects as setting the fast attribute to 'True' for a given reaction, the KineticLaw attribute should be constructed to produce a value in the desired time scale, or else the reaction could be replaced with an AssignmentRule or AlgebraicRule. In SBML Level 3, the Reaction object has an additional optional attribute named 'compartment', whose value must be the identifier of a compartment defined in the enclosing Model object. The 'compartment' attribute can be used to indicate the compartment in which the reaction is assumed to take place. If the attribute is present, its value must be the identifier of a Compartment object defined in the enclosing Model object. Similar to the 'reversible' attribute, the value of the 'compartment' attribute has no direct impact on the construction of mathematical equations for the SBML model. When a kinetic law is given for a reaction, the compartment location may already be implicit in the kinetic law (although this cannot always be guaranteed). Nevertheless, software tools may find the 'compartment' attribute value useful for such purposes as analyzing the structure of the model, guiding the modeler in constructing correct rate formulas, and visualization purposes. Readers are urged to read the SBML specification for more details about the proper use of Reaction. """ __swig_setmethods__ = {} for _s in [SBase]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, Reaction, name, value) __swig_getmethods__ = {} for _s in [SBase]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, Reaction, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_Reaction __del__ = lambda self: None def __init__(self, *args): """ __init__(Reaction self, unsigned int level, unsigned int version) -> Reaction __init__(Reaction self, SBMLNamespaces sbmlns) -> Reaction __init__(Reaction self, Reaction orig) -> Reaction This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: Reaction(SBMLNamespaces sbmlns) Creates a new Reaction using the given SBMLNamespaces object 'sbmlns'. The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments. Parameter 'sbmlns' is an SBMLNamespaces object. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: Reaction(long level, long version) Creates a new Reaction using the given SBML 'level' and 'version' values. Parameter 'level' is a long integer, the SBML Level to assign to this Reaction. Parameter 'version' is a long integer, the SBML Version to assign to this Reaction. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: Reaction(Reaction orig) Copy constructor; creates a copy of this Reaction. Parameter 'orig' is the object to copy. """ this = _libsbml.new_Reaction(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(Reaction self) -> Reaction Creates and returns a deep copy of this Reaction object. Returns the (deep) copy of this Reaction object. """ return _libsbml.Reaction_clone(self) def getElementBySId(self, id): """ getElementBySId(Reaction self, string id) -> SBase Returns the first child element found that has the given 'id' in the model-wide SId namespace, or 'None' if no such object is found. Parameter 'id' is string representing the id of the object to find. Returns pointer to the first element found with the given 'id'. """ return _libsbml.Reaction_getElementBySId(self, id) def getElementByMetaId(self, metaid): """ getElementByMetaId(Reaction self, string metaid) -> SBase Returns the first child element it can find with the given 'metaid', or 'None' if no such object is found. Parameter 'metaid' is string representing the metaid of the object to find. Returns pointer to the first element found with the given 'metaid'. """ return _libsbml.Reaction_getElementByMetaId(self, metaid) def renameSIdRefs(self, oldid, newid): """ renameSIdRefs(Reaction self, string oldid, string newid) Replaces all uses of a given 'SIdRef' type attribute value with another value. In SBML, object identifiers are of a data type called SId. In SBML Level 3, an explicit data type called SIdRef was introduced for attribute values that refer to SId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to an identifier', but the effective data type was the same as SIdRef in Level 3. These and other methods of libSBML refer to the type SIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all attributes and (if appropriate) mathematical formulas in MathML content, comparing the referenced identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.Reaction_renameSIdRefs(self, oldid, newid) def initDefaults(self): """ initDefaults(Reaction self) Initializes the fields of this Reaction object to 'typical' default values. The SBML Reaction component has slightly different aspects and default attribute values in different SBML Levels and Versions. This method sets the values to certain common defaults, based mostly on what they are in SBML Level 2. Specifically: * Sets the 'reversible' attribute to 'True' * Sets the 'fast' attribute to 'False' * Marks the 'fast' attribute as not having been set for SBML Level 2, but as having been set for SBML Level 1 and SBML Level 3. WARNING: SBML definitions before SBML Level 2 Version 2 incorrectly indicated that software tools could ignore the 'fast' attribute if they did not implement support for the corresponding concept; however, further research in SBML has revealed that this is not true, and 'fast' cannot be ignored if it is set to 'True.' Beginning with SBML Level 2 Versions 2, the SBML specifications therefore stipulate that if a model has any reactions with 'fast' set to 'True,' a software tool must be able to respect the attribute or else indicate to the user that it does not have the capacity to do so. Readers are directed to the SBML specifications, which provides more detail about the conditions under which a reaction can be considered to be fast in this sense. """ return _libsbml.Reaction_initDefaults(self) def getId(self): """ getId(Reaction self) -> string Returns the value of the 'id' attribute of this Reaction. Note: Because of the inconsistent behavior of this function with respect to assignments and rules, it is now recommended to use the getIdAttribute() function instead. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Returns the id of this Reaction. See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(). """ return _libsbml.Reaction_getId(self) def getName(self): """ getName(Reaction self) -> string Returns the value of the 'name' attribute of this Reaction object. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns the name of this SBML object, or the empty string if not set or unsettable. See also getIdAttribute(), isSetName(), setName(), unsetName(). """ return _libsbml.Reaction_getName(self) def getKineticLaw(self, *args): """ getKineticLaw(Reaction self) -> KineticLaw getKineticLaw(Reaction self) -> KineticLaw Returns the KineticLaw object contained in this Reaction. Returns the KineticLaw instance. """ return _libsbml.Reaction_getKineticLaw(self, *args) def getReversible(self): """ getReversible(Reaction self) -> bool Returns the value of the 'reversible' attribute on the Reaction as a boolean value. Returns the reversibility status of this Reaction. """ return _libsbml.Reaction_getReversible(self) def getFast(self): """ getFast(Reaction self) -> bool Returns the value of the 'fast' attribute of this Reaction. In SBML Level 3 Version 2, the 'fast' attribute was removed. All reactions are assumed to be equivalent to reactions in previous levels/versions that have a 'fast' attribute value of 'False.' Users should be aware that even for previous levels/versions of the specification, 'fast' attribute values of 'True' never achieved widespread support, and many software packages may ignore it. To achieve the same or similar effects as setting the fast attribute to 'True' for a given reaction, the KineticLaw attribute should be constructed to produce a value in the desired time scale, or else the reaction could be replaced with an AssignmentRule or AlgebraicRule. Returns the 'fast' status of this Reaction. WARNING: SBML definitions before SBML Level 2 Version 2 incorrectly indicated that software tools could ignore the 'fast' attribute if they did not implement support for the corresponding concept; however, further research in SBML has revealed that this is not true, and 'fast' cannot be ignored if it is set to 'True.' Beginning with SBML Level 2 Versions 2, the SBML specifications therefore stipulate that if a model has any reactions with 'fast' set to 'True,' a software tool must be able to respect the attribute or else indicate to the user that it does not have the capacity to do so. Readers are directed to the SBML specifications, which provides more detail about the conditions under which a reaction can be considered to be fast in this sense. """ return _libsbml.Reaction_getFast(self) def getCompartment(self): """ getCompartment(Reaction self) -> string (SBML Level 3 only) Returns the value of the 'compartment' attribute on the Reaction. Returns the compartment of this Reaction. Note: The 'compartment' attribute is available in SBML Level 3, but is not present on Reaction in lower Levels of SBML. """ return _libsbml.Reaction_getCompartment(self) def isSetId(self): """ isSetId(Reaction self) -> bool Predicate returning 'True' if this Reaction's 'id' attribute is set. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Returns 'True' if the 'id' attribute of this SBML object is set, 'False' otherwise. Note: Because of the inconsistent behavior of this function with respect to assignments and rules, it is recommended that callers use isSetIdAttribute() instead. See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(), isSetIdAttribute(). """ return _libsbml.Reaction_isSetId(self) def isSetName(self): """ isSetName(Reaction self) -> bool Predicate returning 'True' if this Reaction's 'name' attribute is set. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns 'True' if the 'name' attribute of this SBML object is set, 'False' otherwise. See also getName(), setName(), unsetName(). """ return _libsbml.Reaction_isSetName(self) def isSetKineticLaw(self): """ isSetKineticLaw(Reaction self) -> bool Predicate returning 'True' if this Reaction contains a kinetic law object. Returns 'True' if a KineticLaw is present in this Reaction,, 'False' otherwise. """ return _libsbml.Reaction_isSetKineticLaw(self) def isSetFast(self): """ isSetFast(Reaction self) -> bool Predicate returning 'True' if the value of the 'fast' attribute on this Reaction is set. In SBML Level 3 Version 2, the 'fast' attribute was removed. All reactions are assumed to be equivalent to reactions in previous levels/versions that have a 'fast' attribute value of 'False.' Users should be aware that even for previous levels/versions of the specification, 'fast' attribute values of 'True' never achieved widespread support, and many software packages may ignore it. To achieve the same or similar effects as setting the fast attribute to 'True' for a given reaction, the KineticLaw attribute should be constructed to produce a value in the desired time scale, or else the reaction could be replaced with an AssignmentRule or AlgebraicRule. Returns 'True' if the 'fast' attribute is set, 'False' otherwise. WARNING: SBML definitions before SBML Level 2 Version 2 incorrectly indicated that software tools could ignore the 'fast' attribute if they did not implement support for the corresponding concept; however, further research in SBML has revealed that this is not true, and 'fast' cannot be ignored if it is set to 'True.' Beginning with SBML Level 2 Versions 2, the SBML specifications therefore stipulate that if a model has any reactions with 'fast' set to 'True,' a software tool must be able to respect the attribute or else indicate to the user that it does not have the capacity to do so. Readers are directed to the SBML specifications, which provides more detail about the conditions under which a reaction can be considered to be fast in this sense. """ return _libsbml.Reaction_isSetFast(self) def isSetCompartment(self): """ isSetCompartment(Reaction self) -> bool Predicate returning 'True' if this Reaction's 'compartment' attribute is set. Returns 'True' if the 'compartment' attribute of this Reaction is set, 'False' otherwise. Note: The 'compartment' attribute is available in SBML Level 3, but is not present on Reaction in lower Levels of SBML. """ return _libsbml.Reaction_isSetCompartment(self) def isSetReversible(self): """ isSetReversible(Reaction self) -> bool Predicate returning 'True' if this Reaction's 'reversible' attribute is set. Returns 'True' if the 'reversible' attribute of this Reaction is set, 'False' otherwise. """ return _libsbml.Reaction_isSetReversible(self) def setId(self, sid): """ setId(Reaction self, string sid) -> int Sets the value of the 'id' attribute of this Reaction. The string 'sid' is copied. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Parameter 'sid' is the string to use as the identifier of this object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE * LIBSBML_UNEXPECTED_ATTRIBUTE See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(). """ return _libsbml.Reaction_setId(self, sid) def setName(self, name): """ setName(Reaction self, string name) -> int Sets the value of the 'name' attribute of this Reaction. The string in 'name' is copied. Parameter 'name' is the new name for the SBML object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.Reaction_setName(self, name) def setKineticLaw(self, kl): """ setKineticLaw(Reaction self, KineticLaw kl) -> int Sets the 'kineticLaw' subelement of this Reaction to a copy of the given KineticLaw object. Parameter 'kl' is the KineticLaw object to use. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_LEVEL_MISMATCH * LIBSBML_VERSION_MISMATCH """ return _libsbml.Reaction_setKineticLaw(self, kl) def setReversible(self, value): """ setReversible(Reaction self, bool value) -> int Sets the value of the 'reversible' attribute of this Reaction. Parameter 'value' is the value of the 'reversible' attribute. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS """ return _libsbml.Reaction_setReversible(self, value) def setFast(self, value): """ setFast(Reaction self, bool value) -> int Sets the value of the 'fast' attribute of this Reaction. In SBML Level 3 Version 2, the 'fast' attribute was removed. All reactions are assumed to be equivalent to reactions in previous levels/versions that have a 'fast' attribute value of 'False.' Users should be aware that even for previous levels/versions of the specification, 'fast' attribute values of 'True' never achieved widespread support, and many software packages may ignore it. To achieve the same or similar effects as setting the fast attribute to 'True' for a given reaction, the KineticLaw attribute should be constructed to produce a value in the desired time scale, or else the reaction could be replaced with an AssignmentRule or AlgebraicRule. Calling this function with an argument of 'True' for an SBML Level 3 Version 2 Reaction will not set the value, as the attribute does not exist for that level/version. * LIBSBML_UNEXPECTED_ATTRIBUTE Parameter 'value' is the value of the 'fast' attribute. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE WARNING: SBML definitions before SBML Level 2 Version 2 incorrectly indicated that software tools could ignore the 'fast' attribute if they did not implement support for the corresponding concept; however, further research in SBML has revealed that this is not true, and 'fast' cannot be ignored if it is set to 'True.' Beginning with SBML Level 2 Versions 2, the SBML specifications therefore stipulate that if a model has any reactions with 'fast' set to 'True,' a software tool must be able to respect the attribute or else indicate to the user that it does not have the capacity to do so. Readers are directed to the SBML specifications, which provides more detail about the conditions under which a reaction can be considered to be fast in this sense. """ return _libsbml.Reaction_setFast(self, value) def setCompartment(self, sid): """ setCompartment(Reaction self, string sid) -> int Sets the value of the 'compartment' attribute of this Reaction. The string 'sid' is copied. Parameter 'sid' is the string to use as the compartment of this Reaction. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE * LIBSBML_INVALID_ATTRIBUTE_VALUE Note: The 'compartment' attribute is available in SBML Level 3, but is not present on Reaction in lower Levels of SBML. """ return _libsbml.Reaction_setCompartment(self, sid) def unsetName(self): """ unsetName(Reaction self) -> int Unsets the value of the 'name' attribute of this Reaction. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also getName(), setName(), isSetName(). """ return _libsbml.Reaction_unsetName(self) def unsetKineticLaw(self): """ unsetKineticLaw(Reaction self) -> int Unsets the 'kineticLaw' subelement of this Reaction. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.Reaction_unsetKineticLaw(self) def unsetFast(self): """ unsetFast(Reaction self) -> int Unsets the value of the 'fast' attribute of this Reaction. In SBML Level 3 Version 2, the 'fast' attribute was removed. All reactions are assumed to be equivalent to reactions in previous levels/versions that have a 'fast' attribute value of 'False.' Users should be aware that even for previous levels/versions of the specification, 'fast' attribute values of 'True' never achieved widespread support, and many software packages may ignore it. To achieve the same or similar effects as setting the fast attribute to 'True' for a given reaction, the KineticLaw attribute should be constructed to produce a value in the desired time scale, or else the reaction could be replaced with an AssignmentRule or AlgebraicRule. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_UNEXPECTED_ATTRIBUTE WARNING: SBML definitions before SBML Level 2 Version 2 incorrectly indicated that software tools could ignore the 'fast' attribute if they did not implement support for the corresponding concept; however, further research in SBML has revealed that this is not true, and 'fast' cannot be ignored if it is set to 'True.' Beginning with SBML Level 2 Versions 2, the SBML specifications therefore stipulate that if a model has any reactions with 'fast' set to 'True,' a software tool must be able to respect the attribute or else indicate to the user that it does not have the capacity to do so. Readers are directed to the SBML specifications, which provides more detail about the conditions under which a reaction can be considered to be fast in this sense. """ return _libsbml.Reaction_unsetFast(self) def unsetCompartment(self): """ unsetCompartment(Reaction self) -> int Unsets the value of the 'compartment' attribute of this Reaction. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE * LIBSBML_OPERATION_FAILED Note: The 'compartment' attribute is available in SBML Level 3, but is not present on Reaction in lower Levels of SBML. """ return _libsbml.Reaction_unsetCompartment(self) def unsetReversible(self): """ unsetReversible(Reaction self) -> int Unsets the value of the 'reversible' attribute of this Reaction. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE * LIBSBML_OPERATION_FAILED """ return _libsbml.Reaction_unsetReversible(self) def addReactant(self, *args): """ addReactant(Reaction self, SpeciesReference sr) -> int addReactant(Reaction self, Species species, double stoichiometry=1.0, string id, bool constant=True) -> int addReactant(Reaction self, Species species, double stoichiometry=1.0, string id) -> int addReactant(Reaction self, Species species, double stoichiometry=1.0) -> int addReactant(Reaction self, Species species) -> int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: addReactant(Species species, double stoichiometry = 1.0, string id = '', bool constant = true) Adds the given species as a reactant with the given stoichiometry Parameter 'species' is the species to be added as reactant. Parameter 'stoichiometry' is an optional parameter specifying the stoichiometry of the added reactant (defaulting to 1). Parameter 'id' is an optional id to be given to the species reference that will be created. (defaulting to empty string, i.e. not set). Parameter 'constant' is an attribute specifying whether the species reference is constant or not (defaulting to true). Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT * LIBSBML_INVALID_ATTRIBUTE_VALUE * LIBSBML_DUPLICATE_OBJECT_ID Note: This method should be used with some caution. The fact that this method copies the object passed to it means that the caller will be left holding a physically different object instance than the one contained inside this object. Changes made to the original object instance (such as resetting attribute values) will not affect the instance in this object. In addition, the caller should make sure to free the original object if it is no longer being used, or else a memory leak will result. Please see other methods on this class (particularly a corresponding method whose name begins with the word create) for alternatives that do not lead to these issues. Note: the Species object itself is NOT added to the model See also createProduct(). Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. ______________________________________________________________________ Method variant with the following signature: addReactant(SpeciesReference sr) Adds a given SpeciesReference object as a reactant in this Reaction. The SpeciesReference instance in 'sr' is copied. Parameter 'sr' is a SpeciesReference object referring to a Species in the enclosing Model. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_LEVEL_MISMATCH * LIBSBML_VERSION_MISMATCH * LIBSBML_DUPLICATE_OBJECT_ID * LIBSBML_INVALID_OBJECT * LIBSBML_OPERATION_FAILED Note: This method should be used with some caution. The fact that this method copies the object passed to it means that the caller will be left holding a physically different object instance than the one contained inside this object. Changes made to the original object instance (such as resetting attribute values) will not affect the instance in this object. In addition, the caller should make sure to free the original object if it is no longer being used, or else a memory leak will result. Please see other methods on this class (particularly a corresponding method whose name begins with the word create) for alternatives that do not lead to these issues. See also createReactant(). """ return _libsbml.Reaction_addReactant(self, *args) def addProduct(self, *args): """ addProduct(Reaction self, SpeciesReference sr) -> int addProduct(Reaction self, Species species, double stoichiometry=1.0, string id, bool constant=True) -> int addProduct(Reaction self, Species species, double stoichiometry=1.0, string id) -> int addProduct(Reaction self, Species species, double stoichiometry=1.0) -> int addProduct(Reaction self, Species species) -> int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: addProduct(Species species, double stoichiometry = 1.0, string id = '', bool constant = true) Adds the given species as a product with the given stoichiometry Parameter 'species' is the species to be added as product. Parameter 'stoichiometry' is an optional parameter specifying the stoichiometry of the added product (defaulting to 1). Parameter 'id' is an optional id to be given to the species reference that will be created. (defaulting to empty string, i.e. not set). Parameter 'constant' is an attribute specifying whether the species reference is constant or not (defaulting to true). Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT * LIBSBML_INVALID_ATTRIBUTE_VALUE * LIBSBML_DUPLICATE_OBJECT_ID Note: This method should be used with some caution. The fact that this method copies the object passed to it means that the caller will be left holding a physically different object instance than the one contained inside this object. Changes made to the original object instance (such as resetting attribute values) will not affect the instance in this object. In addition, the caller should make sure to free the original object if it is no longer being used, or else a memory leak will result. Please see other methods on this class (particularly a corresponding method whose name begins with the word create) for alternatives that do not lead to these issues. Note: the Species object itself is NOT added to the model See also createProduct(). Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. ______________________________________________________________________ Method variant with the following signature: addProduct(SpeciesReference sr) Adds a given SpeciesReference object as a product in this Reaction. The SpeciesReference instance in 'sr' is copied. Parameter 'sr' is a SpeciesReference object referring to a Species in the enclosing Model. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_LEVEL_MISMATCH * LIBSBML_VERSION_MISMATCH * LIBSBML_OPERATION_FAILED Note: This method should be used with some caution. The fact that this method copies the object passed to it means that the caller will be left holding a physically different object instance than the one contained inside this object. Changes made to the original object instance (such as resetting attribute values) will not affect the instance in this object. In addition, the caller should make sure to free the original object if it is no longer being used, or else a memory leak will result. Please see other methods on this class (particularly a corresponding method whose name begins with the word create) for alternatives that do not lead to these issues. See also createProduct(). """ return _libsbml.Reaction_addProduct(self, *args) def addModifier(self, *args): """ addModifier(Reaction self, ModifierSpeciesReference msr) -> int addModifier(Reaction self, Species species, string id) -> int addModifier(Reaction self, Species species) -> int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: addModifier(Species species, string &id = '') Adds the given species as a modifier to this reaction Parameter 'species' is the species to be added as modifier. Parameter 'id' is an optional id to be given to the species reference that will be created. (defaulting to empty string, i.e. not set). Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT * LIBSBML_INVALID_ATTRIBUTE_VALUE * LIBSBML_DUPLICATE_OBJECT_ID Note: This method should be used with some caution. The fact that this method copies the object passed to it means that the caller will be left holding a physically different object instance than the one contained inside this object. Changes made to the original object instance (such as resetting attribute values) will not affect the instance in this object. In addition, the caller should make sure to free the original object if it is no longer being used, or else a memory leak will result. Please see other methods on this class (particularly a corresponding method whose name begins with the word create) for alternatives that do not lead to these issues. Note: the Species object itself is NOT added to the model See also createModifier(). Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. ______________________________________________________________________ Method variant with the following signature: addModifier(ModifierSpeciesReference msr) Adds a given ModifierSpeciesReference object as a product in this Reaction. The ModifierSpeciesReference instance in 'msr' is copied. Parameter 'msr' is a ModifierSpeciesReference object referring to a Species in the enclosing Model. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE * LIBSBML_LEVEL_MISMATCH * LIBSBML_DUPLICATE_OBJECT_ID * LIBSBML_VERSION_MISMATCH * LIBSBML_OPERATION_FAILED Note: This method should be used with some caution. The fact that this method copies the object passed to it means that the caller will be left holding a physically different object instance than the one contained inside this object. Changes made to the original object instance (such as resetting attribute values) will not affect the instance in this object. In addition, the caller should make sure to free the original object if it is no longer being used, or else a memory leak will result. Please see other methods on this class (particularly a corresponding method whose name begins with the word create) for alternatives that do not lead to these issues. See also createModifier(). """ return _libsbml.Reaction_addModifier(self, *args) def createReactant(self): """ createReactant(Reaction self) -> SpeciesReference Creates a new SpeciesReference, adds it to this Reaction's list of reactants, and returns it. Returns a new SpeciesReference object. """ return _libsbml.Reaction_createReactant(self) def createProduct(self): """ createProduct(Reaction self) -> SpeciesReference Creates a new SpeciesReference, adds it to this Reaction's list of products, and returns it. Returns a new SpeciesReference object. """ return _libsbml.Reaction_createProduct(self) def createModifier(self): """ createModifier(Reaction self) -> ModifierSpeciesReference Creates a new ModifierSpeciesReference, adds it to this Reaction's list of modifiers and returns it. Returns a new ModifierSpeciesReference object. """ return _libsbml.Reaction_createModifier(self) def createKineticLaw(self): """ createKineticLaw(Reaction self) -> KineticLaw Creates a new KineticLaw object, installs it as this Reaction's 'kineticLaw' subelement, and returns it. If this Reaction had a previous KineticLaw, it will be destroyed. Returns the new KineticLaw object. """ return _libsbml.Reaction_createKineticLaw(self) def getListOfReactants(self, *args): """ getListOfReactants(Reaction self) -> ListOfSpeciesReferences getListOfReactants(Reaction self) -> ListOfSpeciesReferences Returns the list of reactants in this Reaction object. Returns the ListOfSpeciesReferences containing the references to the species acting as reactants in this reaction. """ return _libsbml.Reaction_getListOfReactants(self, *args) def getListOfProducts(self, *args): """ getListOfProducts(Reaction self) -> ListOfSpeciesReferences getListOfProducts(Reaction self) -> ListOfSpeciesReferences Returns the list of products in this Reaction object. Returns the ListOfSpeciesReferences containing the references to the species acting as products in this reaction. """ return _libsbml.Reaction_getListOfProducts(self, *args) def getListOfModifiers(self, *args): """ getListOfModifiers(Reaction self) -> ListOfSpeciesReferences getListOfModifiers(Reaction self) -> ListOfSpeciesReferences Returns the list of modifiers in this Reaction object. Returns the ListOfSpeciesReferences containing the references to the species acting as modifiers in this reaction. """ return _libsbml.Reaction_getListOfModifiers(self, *args) def getReactant(self, *args): """ getReactant(Reaction self, unsigned int n) -> SpeciesReference getReactant(Reaction self, unsigned int n) -> SpeciesReference getReactant(Reaction self, string species) -> SpeciesReference getReactant(Reaction self, string species) -> SpeciesReference This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getReactant(string species) Returns the reactant species (as a SpeciesReference object) having a specific identifier in this Reaction. Parameter 'species' is the identifier of the reactant Species ('species' attribute of the reactant SpeciesReference object). Returns a SpeciesReference object, or 'None' if no species with the given identifier 'species' appears as a reactant in this Reaction. ______________________________________________________________________ Method variant with the following signature: getReactant(long n) Returns the nth reactant species (as a SpeciesReference object) in the list of reactants in this Reaction. Callers should first call getNumReactants() to find out how many reactants there are, to avoid using an invalid index number. Parameter 'n' is the index of the reactant sought. Returns the nth reactant (as a SpeciesReference object) of this Reaction. If the index 'n' is invalid, 'None' is returned. """ return _libsbml.Reaction_getReactant(self, *args) def getProduct(self, *args): """ getProduct(Reaction self, unsigned int n) -> SpeciesReference getProduct(Reaction self, unsigned int n) -> SpeciesReference getProduct(Reaction self, string species) -> SpeciesReference getProduct(Reaction self, string species) -> SpeciesReference This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getProduct(string species) Returns the product species (as a SpeciesReference object) having a specific identifier in this Reaction. Parameter 'species' is the identifier of the product Species ('species' attribute of the product SpeciesReference object). Returns a SpeciesReference object, or 'None' if no species with the given identifier 'species' appears as a product in this Reaction. ______________________________________________________________________ Method variant with the following signature: getProduct(long n) Returns the nth product species (as a SpeciesReference object) in the list of products in this Reaction. Callers should first call getNumProducts() to find out how many products there are, to avoid using an invalid index number. Parameter 'n' is the index of the product sought. Returns the nth product (as a SpeciesReference object) of this Reaction. If the index 'n' is invalid, 'None' is returned. """ return _libsbml.Reaction_getProduct(self, *args) def getModifier(self, *args): """ getModifier(Reaction self, unsigned int n) -> ModifierSpeciesReference getModifier(Reaction self, unsigned int n) -> ModifierSpeciesReference getModifier(Reaction self, string species) -> ModifierSpeciesReference getModifier(Reaction self, string species) -> ModifierSpeciesReference This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getModifier(string species) Returns the modifier species (as a ModifierSpeciesReference object) having a specific identifier in this Reaction. Parameter 'species' is the identifier of the modifier Species ('species' attribute of the ModifierSpeciesReference object). Returns a ModifierSpeciesReference object, or 'None' if no species with the given identifier 'species' appears as a modifier in this Reaction. ______________________________________________________________________ Method variant with the following signature: getModifier(long n) Returns the nth modifier species (as a ModifierSpeciesReference object) in the list of modifiers of this Reaction. Callers should first call getNumModifiers() to find out how many modifiers there are, to avoid using an invalid index number. Parameter 'n' is the index of the modifier species sought. Returns the nth modifier (as a ModifierSpeciesReference object) of this Reaction. If the index 'n' is invalid, 'None' is returned. """ return _libsbml.Reaction_getModifier(self, *args) def getNumReactants(self): """ getNumReactants(Reaction self) -> unsigned int Returns the number of reactant species in this Reaction. Returns the number of reactants in this Reaction. """ return _libsbml.Reaction_getNumReactants(self) def getNumProducts(self): """ getNumProducts(Reaction self) -> unsigned int Returns the number of product species in this Reaction. Returns the number of products in this Reaction. """ return _libsbml.Reaction_getNumProducts(self) def getNumModifiers(self): """ getNumModifiers(Reaction self) -> unsigned int Returns the number of modifier species in this Reaction. Returns the number of modifiers in this Reaction. """ return _libsbml.Reaction_getNumModifiers(self) def removeReactant(self, *args): """ removeReactant(Reaction self, unsigned int n) -> SpeciesReference removeReactant(Reaction self, string species) -> SpeciesReference This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: removeReactant(string species) Removes the reactant species (SpeciesReference object) having the given 'species' attribute in this Reaction and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. Parameter 'species' is the 'species' attribute of the reactant SpeciesReference object. Returns the removed reactant SpeciesReference object, or 'None' if no reactant SpeciesReference object with the given 'species' attribute 'species' exists in this Reaction. ______________________________________________________________________ Method variant with the following signature: removeReactant(long n) Removes the nth reactant species (SpeciesReference object) in the list of reactants in this Reaction and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. The caller should first call getNumReactants() to find out how many reactants there are, to avoid using an invalid index number. Parameter 'n' is the index of the reactant SpeciesReference object to remove. Returns the removed reactant SpeciesReference object, or 'None' if the given index is out of range. """ return _libsbml.Reaction_removeReactant(self, *args) def removeProduct(self, *args): """ removeProduct(Reaction self, unsigned int n) -> SpeciesReference removeProduct(Reaction self, string species) -> SpeciesReference This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: removeProduct(string species) Removes the product species (SpeciesReference object) having the given 'species' attribute in this Reaction and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. Parameter 'species' is the 'species' attribute of the product SpeciesReference object. Returns the removed product SpeciesReference object, or 'None' if no product SpeciesReference object with the given 'species' attribute 'species' exists in this Reaction. ______________________________________________________________________ Method variant with the following signature: removeProduct(long n) Removes the nth product species (SpeciesReference object) in the list of products in this Reaction and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. The caller should first call getNumProducts() to find out how many products there are, to avoid using an invalid index number. Parameter 'n' is the index of the product SpeciesReference object to remove. Returns the removed product SpeciesReference object, or 'None' if the given index is out of range. """ return _libsbml.Reaction_removeProduct(self, *args) def removeModifier(self, *args): """ removeModifier(Reaction self, unsigned int n) -> ModifierSpeciesReference removeModifier(Reaction self, string species) -> ModifierSpeciesReference This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: removeModifier(string species) Removes the modifier species (ModifierSpeciesReference object) having the given 'species' attribute in this Reaction and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. Parameter 'species' is the 'species' attribute of the ModifierSpeciesReference object. Returns the removed ModifierSpeciesReference object, or 'None' if no ModifierSpeciesReference object with the given 'species' attribute 'species' exists in this Reaction. ______________________________________________________________________ Method variant with the following signature: removeModifier(long n) Removes the nth modifier species (ModifierSpeciesReference object) in the list of modifiers in this Reaction and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. The caller should first call getNumModifiers() to find out how many modifiers there are, to avoid using an invalid index number. Parameter 'n' is the index of the ModifierSpeciesReference object to remove. Returns the removed ModifierSpeciesReference object, or 'None' if the given index is out of range. """ return _libsbml.Reaction_removeModifier(self, *args) def connectToChild(self): """connectToChild(Reaction self)""" return _libsbml.Reaction_connectToChild(self) def enablePackageInternal(self, pkgURI, pkgPrefix, flag): """ enablePackageInternal(Reaction self, string pkgURI, string pkgPrefix, bool flag) Internal implementation method. """ return _libsbml.Reaction_enablePackageInternal(self, pkgURI, pkgPrefix, flag) def updateSBMLNamespace(self, package, level, version): """ updateSBMLNamespace(Reaction self, string package, unsigned int level, unsigned int version) Internal implementation method. """ return _libsbml.Reaction_updateSBMLNamespace(self, package, level, version) def getTypeCode(self): """ getTypeCode(Reaction self) -> int Returns the libSBML type code for this SBML object. LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for this object: SBML_REACTION (default). WARNING: The specific integer values of the possible type codes may be reused by different libSBML plug-ins for SBML Level 3. packages, To fully identify the correct code, it is necessary to invoke both getPackageName() and getTypeCode() (or ListOf.getItemTypeCode()). See also getElementName(), getPackageName(). """ return _libsbml.Reaction_getTypeCode(self) def getElementName(self): """ getElementName(Reaction self) -> string Returns the XML element name of this object, which for Reaction, is always ''reaction'.' Returns the name of this element, i.e., ''reaction'.' """ return _libsbml.Reaction_getElementName(self) def hasRequiredAttributes(self): """ hasRequiredAttributes(Reaction self) -> bool Predicate returning 'True' if all the required attributes for this Reaction object have been set. The required attributes for a Reaction object are: * 'id' (or 'name' in SBML Level 1) * 'fast' (in Level 3 Version 1 only, where it is defined as a required attribute) * 'reversible' (in Level 3 only, where it is defined as a required attribute) Returns 'True' if the required attributes have been set, 'False' otherwise. """ return _libsbml.Reaction_hasRequiredAttributes(self) Reaction_swigregister = _libsbml.Reaction_swigregister Reaction_swigregister(Reaction) class ListOfReactions(ListOf): """ A list of Reaction objects. The various ListOf___ classes in SBML are merely containers used for organizing the main components of an SBML model. In libSBML's implementation, ListOf___ classes are derived from the intermediate utility class ListOf, which is not defined by the SBML specifications but serves as a useful programmatic construct. ListOf is itself is in turn derived from SBase, which provides all of the various ListOf___ classes with common features defined by the SBML specification, such as 'metaid' attributes and annotations. The relationship between the lists and the rest of an SBML model is illustrated by the following (for SBML Level 2 Version 4): ... ... ... ... ... ... ... elements of subclasses of Rule ... ... ... ... SBML Level 3 Version 1 has essentially the same structure as Level 2 Version 4, depicted above, but SBML Level 3 Version 2 allows containers to contain zero or more of the relevant object, instead of requiring at least one. As such, libsbml will write out an otherwise-empty ListOf___ element that has any optional attribute set (such as 'id' or 'metaid'), that has an optional child (such as a 'notes' or 'annotation'), or that has attributes or children set from any SBML Level 3 package, whether or not the ListOf___ has any other children. Readers may wonder about the motivations for using the ListOf___ containers in SBML. A simpler approach in XML might be to place the components all directly at the top level of the model definition. The choice made in SBML is to group them within XML elements named after ListOfClassname, in part because it helps organize the components. More importantly, the fact that the container classes are derived from SBase means that software tools can add information about the lists themselves into each list container's 'annotation'. See also ListOfFunctionDefinitions, ListOfUnitDefinitions, ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments, ListOfSpecies, ListOfParameters, ListOfInitialAssignments, ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents. """ __swig_setmethods__ = {} for _s in [ListOf]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfReactions, name, value) __swig_getmethods__ = {} for _s in [ListOf]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, ListOfReactions, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(ListOfReactions self, unsigned int level, unsigned int version) -> ListOfReactions __init__(ListOfReactions self, SBMLNamespaces sbmlns) -> ListOfReactions This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: ListOfReactions(SBMLNamespaces sbmlns) Creates a new ListOfReactions object. The object is constructed such that it is valid for the SBML Level and Version combination determined by the SBMLNamespaces object in 'sbmlns'. Parameter 'sbmlns' is an SBMLNamespaces object that is used to determine the characteristics of the ListOfReactions object to be created. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: ListOfReactions(long level, long version) Creates a new ListOfReactions object. The object is constructed such that it is valid for the given SBML Level and Version combination. Parameter 'level' is the SBML Level. Parameter 'version' is the Version within the SBML Level. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. """ this = _libsbml.new_ListOfReactions(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(ListOfReactions self) -> ListOfReactions Creates and returns a deep copy of this ListOfReactions object. Returns the (deep) copy of this ListOfReactions object. """ return _libsbml.ListOfReactions_clone(self) def getItemTypeCode(self): """ getItemTypeCode(ListOfReactions self) -> int Returns the libSBML type code for the objects contained in this ListOf (i.e., Reaction objects, if the list is non-empty). LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for objects contained in this list: SBML_REACTION (default). See also getElementName(), getPackageName(). """ return _libsbml.ListOfReactions_getItemTypeCode(self) def getElementName(self): """ getElementName(ListOfReactions self) -> string Returns the XML element name of this object For ListOfReactions, the XML element name is ''listOfReactions'.' Returns the name of this element, i.e., ''listOfReactions'.' """ return _libsbml.ListOfReactions_getElementName(self) def get(self, *args): """ get(ListOfReactions self, unsigned int n) -> Reaction get(ListOfReactions self, unsigned int n) -> Reaction get(ListOfReactions self, string sid) -> Reaction get(ListOfReactions self, string sid) -> Reaction This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: get(long n) Get a Reaction from the ListOfReactions. Parameter 'n' is the index number of the Reaction to get. Returns the nth Reaction in this ListOfReactions. If the index 'n' is invalid, 'None' is returned. See also size(). ______________________________________________________________________ Method variant with the following signature: get(string sid) Get a Reaction from the ListOfReactions based on its identifier. Parameter 'sid' is a string representing the identifier of the Reaction to get. Returns Reaction in this ListOfReactions with the given 'sid' or 'None' if no such Reaction exists. See also get(), size(). """ return _libsbml.ListOfReactions_get(self, *args) def remove(self, *args): """ remove(ListOfReactions self, unsigned int n) -> Reaction remove(ListOfReactions self, string sid) -> Reaction This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: remove(long n) Removes the nth item from this ListOfReactions items and returns a pointer to it. The caller owns the returned item and is responsible for deleting it. Parameter 'n' is the index of the item to remove. See also size(). ______________________________________________________________________ Method variant with the following signature: remove(string sid) Removes item in this ListOfReactions items with the given identifier. The caller owns the returned item and is responsible for deleting it. If none of the items in this list have the identifier 'sid', then None is returned. Parameter 'sid' is the identifier of the item to remove. Returns the item removed. As mentioned above, the caller owns the returned item. """ return _libsbml.ListOfReactions_remove(self, *args) __swig_destroy__ = _libsbml.delete_ListOfReactions __del__ = lambda self: None ListOfReactions_swigregister = _libsbml.ListOfReactions_swigregister ListOfReactions_swigregister(ListOfReactions) class KineticLaw(SBase): """ The rate expression for an SBML reaction. An object of class KineticLaw is used to describe the rate at which the process defined by a given Reaction takes place. KineticLaw has subelements called 'math' (for MathML content) and 'listOfParameters' (of class ListOfParameters), in addition to the attributes and subelements it inherits from SBase. KineticLaw's 'math' subelement for holding a MathML formula (required through SBML Level 3 Version 1, but optional as of SBML Level 3 Version 2) defines the rate of the reaction. The formula may refer to other entities in a model as well as local parameter definitions within the scope of the Reaction (see below). It is important to keep in mind, however, that the only Species identifiers that can be used in this formula are those declared in the lists of reactants, products and modifiers in the Reaction structure. (In other words, before a species can be referenced in the KineticLaw, it must be declared in one of those lists.) KineticLaw provides a way to define local parameters whose identifiers can be used in the 'math' formula of that KineticLaw instance. Prior to SBML Level 3, these parameter definitions are stored inside a 'listOfParameters' subelement containing Parameter objects; in SBML Level 3, this is achieved using a specialized object class called LocalParameter and the containing subelement is called 'listOfLocalParameters'. In both cases, the parameters so defined are only visible within the KineticLaw (or, as of SBML Level 3 Version 2, only visible within the parent Reaction); they cannot be accessed outside. A local parameter within one reaction is not visible from within another reaction, nor is it visible to any other construct outside of the KineticLaw in which it is defined. In addition, another important feature is that if such a Parameter (or in Level 3, LocalParameter) object has the same identifier as another object in the scope of the enclosing Model, the definition inside the KineticLaw takes precedence. In other words, within the KineticLaw's 'math' formula, references to local parameter identifiers shadow any identical global identifiers. The values of local parameters defined within KineticLaw objects cannot change. In SBML Level 3, this quality is built into the LocalParameter construct. In Level 2, where the same kind of Parameter object class is used as for global parameters, the Parameter objects' 'constant' attribute must always have a value of 'True' (either explicitly or left to its default value). A warning about identifier shadowing ====================================================================== A common misconception is that different classes of objects (e.g., species, compartments, parameters) in SBML have different identifier scopes. They do not. The implication is that if a KineticLaw's local parameter definition uses an identifier identical to any other identifier defined in the model outside the KineticLaw, even if the other identifier does not belong to a parameter type of object, the local parameter's identifier takes precedence within that KineticLaw's 'math' formula. It is not an error in SBML for identifiers to shadow each other this way, but can lead to confusing and subtle errors. SBML Level/Version differences ====================================================================== In SBML Level 2 Version 1, the SBML specification included two additional attributes on KineticLaw called 'substanceUnits' and 'timeUnits'. They were removed beginning with SBML Level 2 Version 2 because further research determined they introduced many problems. The most significant problem was that their use could easily lead to the creation of valid models whose reactions nevertheless could not be integrated into a system of equations without outside knowledge for converting the quantities used. Examination of real-life models revealed that a common reason for using 'substanceUnits' on KineticLaw was to set the units of all reactions to the same set of substance units, something that is better achieved by using UnitDefinition to redefine ''substance'' for the whole Model. As mentioned above, in SBML Level 2 Versions 2-4, local parameters are of class Parameter. In SBML Level 3, the class of object is LocalParameter. In SBML Level 3 Version 2, the scope of the LocalParameter was expanded to the entire Reaction, instead of just the KineticLaw. This introduced a single new restriction: an L3v2 LocalParameter may not now shadow the 'id' of any Species referenced by a SpeciesReference in the same Reaction. Other than that, there is no difference in any core construct. However, packages may take advantage of this new scope by adding elements to the Reaction that may now reference a LocalParameter defined in the same Reaction. """ __swig_setmethods__ = {} for _s in [SBase]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, KineticLaw, name, value) __swig_getmethods__ = {} for _s in [SBase]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, KineticLaw, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_KineticLaw __del__ = lambda self: None def __init__(self, *args): """ __init__(KineticLaw self, unsigned int level, unsigned int version) -> KineticLaw __init__(KineticLaw self, SBMLNamespaces sbmlns) -> KineticLaw __init__(KineticLaw self, KineticLaw orig) -> KineticLaw This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: KineticLaw(SBMLNamespaces sbmlns) Creates a new KineticLaw using the given SBMLNamespaces object 'sbmlns'. The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments. Parameter 'sbmlns' is an SBMLNamespaces object. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: KineticLaw(long level, long version) Creates a new KineticLaw using the given SBML 'level' and 'version' values. Parameter 'level' is a long integer, the SBML Level to assign to this KineticLaw. Parameter 'version' is a long integer, the SBML Version to assign to this KineticLaw. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: KineticLaw(KineticLaw orig) Copy constructor; creates a copy of this KineticLaw. Parameter 'orig' is the object to copy. """ this = _libsbml.new_KineticLaw(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(KineticLaw self) -> KineticLaw Creates and returns a deep copy of this KineticLaw object. Returns the (deep) copy of this KineticLaw object. """ return _libsbml.KineticLaw_clone(self) def getElementBySId(self, id): """ getElementBySId(KineticLaw self, string id) -> SBase Returns the first child element found that has the given 'id' in the model-wide SId namespace, or 'None' if no such object is found. Parameter 'id' is string representing the id of the object to find. Returns pointer to the first element found with the given 'id'. """ return _libsbml.KineticLaw_getElementBySId(self, id) def getElementByMetaId(self, metaid): """ getElementByMetaId(KineticLaw self, string metaid) -> SBase Returns the first child element it can find with the given 'metaid', or 'None' if no such object is found. Parameter 'metaid' is string representing the metaid of the object to find. Returns pointer to the first element found with the given 'metaid'. """ return _libsbml.KineticLaw_getElementByMetaId(self, metaid) def getFormula(self): """ getFormula(KineticLaw self) -> string Returns the mathematical formula for this KineticLaw object and return it as as a text string. This is fundamentally equivalent to getMath(). This variant is provided principally for compatibility compatibility with SBML Level 1. Returns a string representing the formula of this KineticLaw. Note: SBML Level 1 uses a text-string format for mathematical formulas. SBML Level 2 uses MathML, an XML format for representing mathematical expressions. LibSBML provides an Abstract Syntax Tree API for working with mathematical expressions; this API is more powerful than working with formulas directly in text form, and ASTs can be translated into either MathML or the text-string syntax. The libSBML methods that accept text-string formulas directly (such as this constructor) are provided for SBML Level 1 compatibility, but developers are encouraged to use the AST mechanisms. See also getMath(). """ return _libsbml.KineticLaw_getFormula(self) def getMath(self): """ getMath(KineticLaw self) -> ASTNode Returns the mathematical formula for this KineticLaw object and return it as as an AST. This is fundamentally equivalent to getFormula(). The latter is provided principally for compatibility compatibility with SBML Level 1, which represented mathematical formulas in text-string form. Returns the ASTNode representation of the mathematical formula, or 'None' if the math is not set. See also getFormula(). """ return _libsbml.KineticLaw_getMath(self) def getTimeUnits(self): """ getTimeUnits(KineticLaw self) -> string (SBML Level 2 Version 1 only) Returns the value of the 'timeUnits' attribute of this KineticLaw object. Returns the 'timeUnits' attribute value. Note: The attributes 'timeUnits' and 'substanceUnits' are present only in SBML Level 2 Version 1. In SBML Level 2 Version 2, the 'timeUnits' and 'substanceUnits' attributes were removed. For compatibility with new versions of SBML, users are cautioned to avoid these attributes. """ return _libsbml.KineticLaw_getTimeUnits(self) def getSubstanceUnits(self): """ getSubstanceUnits(KineticLaw self) -> string (SBML Level 2 Version 1 only) Returns the value of the 'substanceUnits' attribute of this KineticLaw object. Returns the 'substanceUnits' attribute value. Note: The attributes 'timeUnits' and 'substanceUnits' are present only in SBML Level 2 Version 1. In SBML Level 2 Version 2, the 'timeUnits' and 'substanceUnits' attributes were removed. For compatibility with new versions of SBML, users are cautioned to avoid these attributes. """ return _libsbml.KineticLaw_getSubstanceUnits(self) def isSetFormula(self): """ isSetFormula(KineticLaw self) -> bool Predicate returning 'True' if this KineticLaw's 'formula' attribute is set. This is functionally identical to the method isSetMath(). It is provided in order to mirror the parallel between getFormula() and getMath(). Returns 'True' if the formula (meaning the 'math' subelement) of this KineticLaw is set, 'False' otherwise. Note: SBML Level 1 uses a text-string format for mathematical formulas. SBML Level 2 uses MathML, an XML format for representing mathematical expressions. LibSBML provides an Abstract Syntax Tree API for working with mathematical expressions; this API is more powerful than working with formulas directly in text form, and ASTs can be translated into either MathML or the text-string syntax. The libSBML methods that accept text-string formulas directly (such as this constructor) are provided for SBML Level 1 compatibility, but developers are encouraged to use the AST mechanisms. See also isSetMath(). """ return _libsbml.KineticLaw_isSetFormula(self) def isSetMath(self): """ isSetMath(KineticLaw self) -> bool Predicate returning 'True' if this Kinetic's 'math' subelement is set. This is identical to the method isSetFormula(). It is provided in order to mirror the parallel between getFormula() and getMath(). Returns 'True' if the formula (meaning the 'math' subelement) of this KineticLaw is set, 'False' otherwise. See also isSetFormula(). """ return _libsbml.KineticLaw_isSetMath(self) def isSetTimeUnits(self): """ isSetTimeUnits(KineticLaw self) -> bool (SBML Level 2 Version 1 only) Predicate returning 'True' if this SpeciesReference's 'timeUnits' attribute is set. Returns 'True' if the 'timeUnits' attribute of this KineticLaw object is set, 'False' otherwise. Note: The attributes 'timeUnits' and 'substanceUnits' are present only in SBML Level 2 Version 1. In SBML Level 2 Version 2, the 'timeUnits' and 'substanceUnits' attributes were removed. For compatibility with new versions of SBML, users are cautioned to avoid these attributes. """ return _libsbml.KineticLaw_isSetTimeUnits(self) def isSetSubstanceUnits(self): """ isSetSubstanceUnits(KineticLaw self) -> bool (SBML Level 2 Version 1 only) Predicate returning 'True' if this SpeciesReference's 'substanceUnits' attribute is set. Returns 'True' if the 'substanceUnits' attribute of this KineticLaw object is set, 'False' otherwise. Note: The attributes 'timeUnits' and 'substanceUnits' are present only in SBML Level 2 Version 1. In SBML Level 2 Version 2, the 'timeUnits' and 'substanceUnits' attributes were removed. For compatibility with new versions of SBML, users are cautioned to avoid these attributes. """ return _libsbml.KineticLaw_isSetSubstanceUnits(self) def setFormula(self, formula): """ setFormula(KineticLaw self, string formula) -> int Sets the mathematical expression of this KineticLaw instance to the given 'formula'. The given 'formula' string is copied. Internally, libSBML stores the mathematical expression as an ASTNode. Parameter 'formula' is the mathematical expression to use, represented in text-string form. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT Note: SBML Level 1 uses a text-string format for mathematical formulas. SBML Level 2 uses MathML, an XML format for representing mathematical expressions. LibSBML provides an Abstract Syntax Tree API for working with mathematical expressions; this API is more powerful than working with formulas directly in text form, and ASTs can be translated into either MathML or the text-string syntax. The libSBML methods that accept text-string formulas directly (such as this constructor) are provided for SBML Level 1 compatibility, but developers are encouraged to use the AST mechanisms. See also setMath(). """ return _libsbml.KineticLaw_setFormula(self, formula) def setMath(self, math): """ setMath(KineticLaw self, ASTNode math) -> int Sets the mathematical expression of this KineticLaw instance to a copy of the given ASTNode. This is fundamentally identical to getFormula(). The latter is provided principally for compatibility compatibility with SBML Level 1, which represented mathematical formulas in text-string form. Parameter 'math' is an ASTNode representing a formula tree. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT See also setFormula(). """ return _libsbml.KineticLaw_setMath(self, math) def setTimeUnits(self, sid): """ setTimeUnits(KineticLaw self, string sid) -> int (SBML Level 2 Version 1 only) Sets the 'timeUnits' attribute of this KineticLaw object to a copy of the identifier in 'sid'. Parameter 'sid' is the identifier of the units to use. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE * LIBSBML_UNEXPECTED_ATTRIBUTE Note: The attributes 'timeUnits' and 'substanceUnits' are present only in SBML Level 2 Version 1. In SBML Level 2 Version 2, the 'timeUnits' and 'substanceUnits' attributes were removed. For compatibility with new versions of SBML, users are cautioned to avoid these attributes. """ return _libsbml.KineticLaw_setTimeUnits(self, sid) def setSubstanceUnits(self, sid): """ setSubstanceUnits(KineticLaw self, string sid) -> int (SBML Level 2 Version 1 only) Sets the 'substanceUnits' attribute of this KineticLaw object to a copy of the identifier given in 'sid'. Parameter 'sid' is the identifier of the units to use. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE * LIBSBML_UNEXPECTED_ATTRIBUTE Note: The attributes 'timeUnits' and 'substanceUnits' are present only in SBML Level 2 Version 1. In SBML Level 2 Version 2, the 'timeUnits' and 'substanceUnits' attributes were removed. For compatibility with new versions of SBML, users are cautioned to avoid these attributes. """ return _libsbml.KineticLaw_setSubstanceUnits(self, sid) def unsetTimeUnits(self): """ unsetTimeUnits(KineticLaw self) -> int (SBML Level 2 Version 1 only) Unsets the 'timeUnits' attribugte of this KineticLaw object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_UNEXPECTED_ATTRIBUTE Note: The attributes 'timeUnits' and 'substanceUnits' are present only in SBML Level 2 Version 1. In SBML Level 2 Version 2, the 'timeUnits' and 'substanceUnits' attributes were removed. For compatibility with new versions of SBML, users are cautioned to avoid these attributes. """ return _libsbml.KineticLaw_unsetTimeUnits(self) def unsetSubstanceUnits(self): """ unsetSubstanceUnits(KineticLaw self) -> int (SBML Level 2 Version 1 only) Unsets the 'substanceUnits' attribute of this KineticLaw object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_UNEXPECTED_ATTRIBUTE Note: The attributes 'timeUnits' and 'substanceUnits' are present only in SBML Level 2 Version 1. In SBML Level 2 Version 2, the 'timeUnits' and 'substanceUnits' attributes were removed. For compatibility with new versions of SBML, users are cautioned to avoid these attributes. """ return _libsbml.KineticLaw_unsetSubstanceUnits(self) def addParameter(self, p): """ addParameter(KineticLaw self, Parameter p) -> int Adds a copy of the given Parameter object to the list of local parameters in this KineticLaw. This function should be used for SBML Level 1 and Level 2 documents, as the equivalent constructs in Level 3 are LocalParameter objects instead. Parameter 'p' is the Parameter to add. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_LEVEL_MISMATCH * LIBSBML_VERSION_MISMATCH * LIBSBML_DUPLICATE_OBJECT_ID * LIBSBML_INVALID_OBJECT * LIBSBML_OPERATION_FAILED Note: This method should be used with some caution. The fact that this method copies the object passed to it means that the caller will be left holding a physically different object instance than the one contained inside this object. Changes made to the original object instance (such as resetting attribute values) will not affect the instance in this object. In addition, the caller should make sure to free the original object if it is no longer being used, or else a memory leak will result. Please see other methods on this class (particularly a corresponding method whose name begins with the word create) for alternatives that do not lead to these issues. See also createParameter(). """ return _libsbml.KineticLaw_addParameter(self, p) def addLocalParameter(self, p): """ addLocalParameter(KineticLaw self, LocalParameter p) -> int Adds a copy of the given LocalParameter object to the list of local parameters in this KineticLaw. This function should be used for SBML Level 3 documents, as the equivalent constructs in Level 2 and Level 1 are Parameter objects instead. Parameter 'p' is the LocalParameter to add. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_LEVEL_MISMATCH * LIBSBML_VERSION_MISMATCH * LIBSBML_DUPLICATE_OBJECT_ID * LIBSBML_INVALID_OBJECT * LIBSBML_OPERATION_FAILED Note: This method should be used with some caution. The fact that this method copies the object passed to it means that the caller will be left holding a physically different object instance than the one contained inside this object. Changes made to the original object instance (such as resetting attribute values) will not affect the instance in this object. In addition, the caller should make sure to free the original object if it is no longer being used, or else a memory leak will result. Please see other methods on this class (particularly a corresponding method whose name begins with the word create) for alternatives that do not lead to these issues. See also createLocalParameter(). """ return _libsbml.KineticLaw_addLocalParameter(self, p) def createParameter(self): """ createParameter(KineticLaw self) -> Parameter Creates a new Parameter object, adds it to this KineticLaw's list of parameters, and returns the Parameter object created. This function should be used for SBML Level 1 and Level 2 documents, as the equivalent constructs in Level 3 are LocalParameter objects instead. Returns a new Parameter object instance. See also addParameter(). """ return _libsbml.KineticLaw_createParameter(self) def createLocalParameter(self): """ createLocalParameter(KineticLaw self) -> LocalParameter Creates a new LocalParameter object, adds it to this KineticLaw's list of local parameters, and returns the LocalParameter object created. This function should be used for SBML Level 3 documents, as the equivalent constructs in Level 2 and Level 1 are Parameter objects instead. Returns a new LocalParameter object instance. See also addLocalParameter(). """ return _libsbml.KineticLaw_createLocalParameter(self) def getListOfParameters(self, *args): """ getListOfParameters(KineticLaw self) -> ListOfParameters getListOfParameters(KineticLaw self) -> ListOfParameters Returns the list of parameters in this KineticLaw object. This function should be used for SBML Level 1 and Level 2 documents, as the equivalent constructs in Level 3 are LocalParameter objects instead. Returns the list of Parameters for this KineticLaw. """ return _libsbml.KineticLaw_getListOfParameters(self, *args) def getListOfLocalParameters(self, *args): """ getListOfLocalParameters(KineticLaw self) -> ListOfLocalParameters getListOfLocalParameters(KineticLaw self) -> ListOfLocalParameters Returns the list of local parameters in this KineticLaw object. This function should be used for SBML Level 3 documents, as the equivalent constructs in Level 2 and Level 1 are Parameter objects instead. Returns the list of LocalParameters for this KineticLaw. """ return _libsbml.KineticLaw_getListOfLocalParameters(self, *args) def getParameter(self, *args): """ getParameter(KineticLaw self, unsigned int n) -> Parameter getParameter(KineticLaw self, unsigned int n) -> Parameter getParameter(KineticLaw self, string sid) -> Parameter getParameter(KineticLaw self, string sid) -> Parameter This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getParameter(long n) Returns the nth Parameter object in the list of parameters in this KineticLaw instance. This function should be used for SBML Level 1 and Level 2 documents, as the equivalent constructs in Level 3 are LocalParameter objects instead. Parameter 'n' is the index of the Parameter object sought. Returns the nth Parameter of this KineticLaw. If the index 'n' is invalid, 'None' is returned. ______________________________________________________________________ Method variant with the following signature: getParameter(string sid) Returns a parameter based on its identifier. This function should be used for SBML Level 1 and Level 2 documents, as the equivalent constructs in Level 3 are LocalParameter objects instead. Parameter 'sid' is the identifier of the Parameter being sought. Returns the Parameter object in this KineticLaw instace having the given 'id', or 'None' if no such Parameter exists. """ return _libsbml.KineticLaw_getParameter(self, *args) def getLocalParameter(self, *args): """ getLocalParameter(KineticLaw self, unsigned int n) -> LocalParameter getLocalParameter(KineticLaw self, unsigned int n) -> LocalParameter getLocalParameter(KineticLaw self, string sid) -> LocalParameter getLocalParameter(KineticLaw self, string sid) -> LocalParameter This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getLocalParameter(long n) Returns the nth LocalParameter object in the list of local parameters in this KineticLaw instance. This function should be used for SBML Level 3 documents, as the equivalent constructs in Level 2 and Level 1 are Parameter objects instead. Parameter 'n' is the index of the LocalParameter object sought. Returns the nth LocalParameter of this KineticLaw. If the index 'n' is invalid, 'None' is returned. ______________________________________________________________________ Method variant with the following signature: getLocalParameter(string sid) Returns a local parameter based on its identifier. This function should be used for SBML Level 3 documents, as the equivalent constructs in Level 2 and Level 1 are Parameter objects instead. Parameter 'sid' is the identifier of the LocalParameter being sought. Returns the LocalParameter object in this KineticLaw instace having the given 'id', or 'None' if no such LocalParameter exists. """ return _libsbml.KineticLaw_getLocalParameter(self, *args) def getNumParameters(self): """ getNumParameters(KineticLaw self) -> unsigned int Returns the number of parameters in this KineticLaw instance. This function should be used for SBML Level 1 and Level 2 documents, as the equivalent constructs in Level 3 are LocalParameter objects instead. Returns the number of Parameters in this KineticLaw. """ return _libsbml.KineticLaw_getNumParameters(self) def getNumLocalParameters(self): """ getNumLocalParameters(KineticLaw self) -> unsigned int Returns the number of local parameters in this KineticLaw instance. This function should be used for SBML Level 3 documents, as the equivalent constructs in Level 2 and Level 1 are Parameter objects instead. Returns the number of LocalParameters in this KineticLaw. """ return _libsbml.KineticLaw_getNumLocalParameters(self) def getDerivedUnitDefinition(self, *args): """ getDerivedUnitDefinition(KineticLaw self) -> UnitDefinition getDerivedUnitDefinition(KineticLaw self) -> UnitDefinition Calculates and returns a UnitDefinition that expresses the units of measurement assumed for the 'math' expression of this KineticLaw. The units are calculated based on the mathematical expression in the KineticLaw and the model quantities referenced by elements used within that expression. The getDerivedUnitDefinition() method returns the calculated units. Note: The functionality that facilitates unit analysis depends on the model as a whole. Thus, in cases where the object has not been added to a model or the model itself is incomplete, unit analysis is not possible and this method will return 'None.' WARNING: Note that it is possible the 'math' expression in the KineticLaw contains pure numbers or parameters with undeclared units. In those cases, it is not possible to calculate the units of the overall expression without making assumptions. LibSBML does not make assumptions about the units, and KineticLaw.getDerivedUnitDefinition() returns the units as far as it is able to determine them. For example, in an expression X + Y, if X has unambiguously-defined units and Y does not, it will return the units of X. It is important that callers also invoke the method KineticLaw.containsUndeclaredUnits()to determine whether this situation holds. Callers may wish to take suitable actions in those scenarios. Returns a UnitDefinition that expresses the units of the math expression of this KineticLaw, or 'None' if one cannot be constructed. See also containsUndeclaredUnits(). """ return _libsbml.KineticLaw_getDerivedUnitDefinition(self, *args) def containsUndeclaredUnits(self, *args): """ containsUndeclaredUnits(KineticLaw self) -> bool containsUndeclaredUnits(KineticLaw self) -> bool Predicate returning 'True' if the math expression of this KineticLaw contains parameters/numbers with undeclared units. Returns 'True' if the math expression of this KineticLaw includes parameters/numbers with undeclared units, 'False' otherwise. Note: A return value of 'True' indicates that the UnitDefinition returned by getDerivedUnitDefinition() may not accurately represent the units of the expression. See also getDerivedUnitDefinition(). """ return _libsbml.KineticLaw_containsUndeclaredUnits(self, *args) def removeParameter(self, *args): """ removeParameter(KineticLaw self, unsigned int n) -> Parameter removeParameter(KineticLaw self, string sid) -> Parameter This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: removeParameter(long n) Removes the nth Parameter object in the list of parameters in this KineticLaw instance and returns a pointer to it. This function should be used for SBML Level 1 and Level 2 documents, as the equivalent constructs in Level 3 are LocalParameter objects instead. The caller owns the returned object and is responsible for deleting it. Parameter 'n' is the index of the Parameter object to remove. Returns the Parameter object removed. As mentioned above, the caller owns the returned item. 'None' is returned if the given index is out of range. ______________________________________________________________________ Method variant with the following signature: removeParameter(string sid) Removes a Parameter object with the given identifier in the list of parameters in this KineticLaw instance and returns a pointer to it. This function should be used for SBML Level 1 and Level 2 documents, as the equivalent constructs in Level 3 are LocalParameter objects instead. The caller owns the returned object and is responsible for deleting it. Parameter 'sid' is the identifier of the Parameter to remove. Returns the Parameter object removed. As mentioned above, the caller owns the returned object. 'None' is returned if no Parameter object with the identifier exists in this KineticLaw instance. """ return _libsbml.KineticLaw_removeParameter(self, *args) def removeLocalParameter(self, *args): """ removeLocalParameter(KineticLaw self, unsigned int n) -> LocalParameter removeLocalParameter(KineticLaw self, string sid) -> LocalParameter This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: removeLocalParameter(long n) Removes the nth LocalParameter object in the list of local parameters in this KineticLaw instance and returns a pointer to it. This function should be used for SBML Level 3 documents, as the equivalent constructs in Level 2 and Level 1 are Parameter objects instead. The caller owns the returned object and is responsible for deleting it. Parameter 'n' is the index of the LocalParameter object to remove. Returns the LocalParameter object removed. As mentioned above, the caller owns the returned item. 'None' is returned if the given index is out of range. ______________________________________________________________________ Method variant with the following signature: removeLocalParameter(string sid) Removes a LocalParameter object with the given identifier in the list of local parameters in this KineticLaw instance and returns a pointer to it. This function should be used for SBML Level 3 documents, as the equivalent constructs in Level 2 and Level 1 are Parameter objects instead. The caller owns the returned object and is responsible for deleting it. Parameter 'sid' is the identifier of the LocalParameter to remove. Returns the LocalParameter object removed. As mentioned above, the caller owns the returned object. 'None' is returned if no LocalParameter object with the identifier exists in this KineticLaw instance. """ return _libsbml.KineticLaw_removeLocalParameter(self, *args) def connectToChild(self): """connectToChild(KineticLaw self)""" return _libsbml.KineticLaw_connectToChild(self) def enablePackageInternal(self, pkgURI, pkgPrefix, flag): """ enablePackageInternal(KineticLaw self, string pkgURI, string pkgPrefix, bool flag) Internal implementation method. """ return _libsbml.KineticLaw_enablePackageInternal(self, pkgURI, pkgPrefix, flag) def updateSBMLNamespace(self, package, level, version): """ updateSBMLNamespace(KineticLaw self, string package, unsigned int level, unsigned int version) Internal implementation method. """ return _libsbml.KineticLaw_updateSBMLNamespace(self, package, level, version) def getTypeCode(self): """ getTypeCode(KineticLaw self) -> int Returns the libSBML type code for this SBML object. LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for this object: SBML_KINETIC_LAW (default). WARNING: The specific integer values of the possible type codes may be reused by different libSBML plug-ins for SBML Level 3. packages, To fully identify the correct code, it is necessary to invoke both getPackageName() and getTypeCode() (or ListOf.getItemTypeCode()). See also getElementName(), getPackageName(). """ return _libsbml.KineticLaw_getTypeCode(self) def getElementName(self): """ getElementName(KineticLaw self) -> string Returns the XML element name of this object, which for Species, is always ''kineticLaw'.' Returns the name of this element, i.e., ''kineticLaw'.' """ return _libsbml.KineticLaw_getElementName(self) def hasRequiredAttributes(self): """ hasRequiredAttributes(KineticLaw self) -> bool Predicate returning 'True' if all the required attributes for this KineticLaw object have been set. The required attributes for a KineticLaw object are: * 'formula' (SBML Level 1 only) Returns 'True' if the required attributes have been set, 'False' otherwise. """ return _libsbml.KineticLaw_hasRequiredAttributes(self) def hasRequiredElements(self): """ hasRequiredElements(KineticLaw self) -> bool Predicate returning 'True' if all the required elements for this KineticLaw object have been set. Note: The required elements for a KineticLaw object are: * 'math' inSBML Level 2 and Level 3 Version 1. (In SBML Level 3 Version 2+, it is no longer required.) Returns a boolean value indicating whether all the required elements for this object have been defined. """ return _libsbml.KineticLaw_hasRequiredElements(self) def removeFromParentAndDelete(self): """ removeFromParentAndDelete(KineticLaw self) -> int Finds this KineticLaw's Reaction parent and calls unsetKineticLaw() on it, indirectly deleting itself. Overridden from the SBase function since the parent is not a ListOf. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.KineticLaw_removeFromParentAndDelete(self) def renameSIdRefs(self, oldid, newid): """ renameSIdRefs(KineticLaw self, string oldid, string newid) Replaces all uses of a given 'SIdRef' type attribute value with another value. In SBML, object identifiers are of a data type called SId. In SBML Level 3, an explicit data type called SIdRef was introduced for attribute values that refer to SId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to an identifier', but the effective data type was the same as SIdRef in Level 3. These and other methods of libSBML refer to the type SIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all attributes and (if appropriate) mathematical formulas in MathML content, comparing the referenced identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.KineticLaw_renameSIdRefs(self, oldid, newid) def renameUnitSIdRefs(self, oldid, newid): """ renameUnitSIdRefs(KineticLaw self, string oldid, string newid) Replaces all uses of a given 'UnitSIdRef' type attribute value with another value. In SBML, unit definitions have identifiers of type UnitSId. In SBML Level 3, an explicit data type called UnitSIdRef was introduced for attribute values that refer to UnitSId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to a unit identifier', but the effective data type was the same as UnitSIdRef in Level 3. These and other methods of libSBML refer to the type UnitSIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all unit identifier attribute values (including, if appropriate, inside mathematical formulas), comparing the referenced unit identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.KineticLaw_renameUnitSIdRefs(self, oldid, newid) def replaceSIDWithFunction(self, id, function): """ replaceSIDWithFunction(KineticLaw self, string id, ASTNode function) Internal implementation method. """ return _libsbml.KineticLaw_replaceSIDWithFunction(self, id, function) def divideAssignmentsToSIdByFunction(self, id, function): """ divideAssignmentsToSIdByFunction(KineticLaw self, string id, ASTNode function) Internal implementation method. """ return _libsbml.KineticLaw_divideAssignmentsToSIdByFunction(self, id, function) def multiplyAssignmentsToSIdByFunction(self, id, function): """ multiplyAssignmentsToSIdByFunction(KineticLaw self, string id, ASTNode function) Internal implementation method. """ return _libsbml.KineticLaw_multiplyAssignmentsToSIdByFunction(self, id, function) KineticLaw_swigregister = _libsbml.KineticLaw_swigregister KineticLaw_swigregister(KineticLaw) class SimpleSpeciesReference(SBase): """ Abstract class for references to species in reactions. As mentioned in the description of Reaction, every species that enters into a given reaction must appear in that reaction's lists of reactants, products and/or modifiers. In an SBML model, all species that may participate in any reaction are listed in the 'listOfSpecies' element of the top-level Model object. Lists of products, reactants and modifiers in Reaction objects do not introduce new species, but rather, they refer back to those listed in the model's top-level 'listOfSpecies'. For reactants and products, the connection is made using SpeciesReference objects; for modifiers, it is made using ModifierSpeciesReference objects. SimpleSpeciesReference is an abstract type that serves as the parent class of both SpeciesReference and ModifierSpeciesReference. It is used simply to hold the attributes and elements that are common to the latter two structures. The SimpleSpeciesReference structure has a mandatory attribute, 'species', which must be a text string conforming to the identifer syntax permitted in SBML. This attribute is inherited by the SpeciesReference and ModifierSpeciesReference subclasses derived from SimpleSpeciesReference. The value of the 'species' attribute must be the identifier of a species defined in the enclosing Model. The species is thereby declared as participating in the reaction being defined. The precise role of that species as a reactant, product, or modifier in the reaction is determined by the subclass of SimpleSpeciesReference (i.e., either SpeciesReference or ModifierSpeciesReference) in which the identifier appears. SimpleSpeciesReference also contains an optional attribute, 'id', allowing instances to be referenced from other structures. No SBML structures currently do this; however, such structures are anticipated in future SBML Levels. """ __swig_setmethods__ = {} for _s in [SBase]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, SimpleSpeciesReference, name, value) __swig_getmethods__ = {} for _s in [SBase]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, SimpleSpeciesReference, name) def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_SimpleSpeciesReference __del__ = lambda self: None def getId(self): """ getId(SimpleSpeciesReference self) -> string Returns the value of the 'id' attribute of this SimpleSpeciesReference. Note: Because of the inconsistent behavior of this function with respect to assignments and rules, it is now recommended to use the getIdAttribute() function instead. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Returns the id of this SimpleSpeciesReference. See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(). """ return _libsbml.SimpleSpeciesReference_getId(self) def getName(self): """ getName(SimpleSpeciesReference self) -> string Returns the value of the 'name' attribute of this SimpleSpeciesReference object. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns the name of this SBML object, or the empty string if not set or unsettable. See also getIdAttribute(), isSetName(), setName(), unsetName(). """ return _libsbml.SimpleSpeciesReference_getName(self) def getSpecies(self): """ getSpecies(SimpleSpeciesReference self) -> string Get the value of the 'species' attribute. Returns the value of the attribute 'species' for this SimpleSpeciesReference. """ return _libsbml.SimpleSpeciesReference_getSpecies(self) def isSetId(self): """ isSetId(SimpleSpeciesReference self) -> bool Predicate returning 'True' if this SimpleSpeciesReference's 'id' attribute is set. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Returns 'True' if the 'id' attribute of this SBML object is set, 'False' otherwise. Note: Because of the inconsistent behavior of this function with respect to assignments and rules, it is recommended that callers use isSetIdAttribute() instead. See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(), isSetIdAttribute(). """ return _libsbml.SimpleSpeciesReference_isSetId(self) def isSetName(self): """ isSetName(SimpleSpeciesReference self) -> bool Predicate returning 'True' if this SimpleSpeciesReference's 'name' attribute is set. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns 'True' if the 'name' attribute of this SBML object is set, 'False' otherwise. See also getName(), setName(), unsetName(). """ return _libsbml.SimpleSpeciesReference_isSetName(self) def isSetSpecies(self): """ isSetSpecies(SimpleSpeciesReference self) -> bool Predicate returning 'True' if this SimpleSpeciesReference's 'species' attribute is set. Returns 'True' if the 'species' attribute of this SimpleSpeciesReference is set, 'False' otherwise. """ return _libsbml.SimpleSpeciesReference_isSetSpecies(self) def setSpecies(self, sid): """ setSpecies(SimpleSpeciesReference self, string sid) -> int Sets the 'species' attribute of this SimpleSpeciesReference. The identifier string passed in 'sid' is copied. Parameter 'sid' is the identifier of a species defined in the enclosing Model's ListOfSpecies. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.SimpleSpeciesReference_setSpecies(self, sid) def setId(self, sid): """ setId(SimpleSpeciesReference self, string sid) -> int Sets the value of the 'id' attribute of this SimpleSpeciesReference. The string 'sid' is copied. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Parameter 'sid' is the string to use as the identifier of this object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE * LIBSBML_UNEXPECTED_ATTRIBUTE See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(). """ return _libsbml.SimpleSpeciesReference_setId(self, sid) def setName(self, name): """ setName(SimpleSpeciesReference self, string name) -> int Sets the value of the 'name' attribute of this SimpleSpeciesReference. The string in 'name' is copied. Parameter 'name' is the new name for the SBML object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.SimpleSpeciesReference_setName(self, name) def unsetId(self): """ unsetId(SimpleSpeciesReference self) -> int Unsets the value of the 'id' attribute of this SimpleSpeciesReference. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(). """ return _libsbml.SimpleSpeciesReference_unsetId(self) def unsetName(self): """ unsetName(SimpleSpeciesReference self) -> int Unsets the value of the 'name' attribute of this SimpleSpeciesReference. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also getName(), setName(), isSetName(). """ return _libsbml.SimpleSpeciesReference_unsetName(self) def unsetSpecies(self): """ unsetSpecies(SimpleSpeciesReference self) -> int Unsets the value of the 'species' attribute of this SimpleSpeciesReference. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.SimpleSpeciesReference_unsetSpecies(self) def isModifier(self): """ isModifier(SimpleSpeciesReference self) -> bool Predicate returning 'True' if this is a ModifierSpeciesReference. Returns 'True' if this SimpleSpeciesReference's subclass is ModiferSpeciesReference, 'False' if it is a plain SpeciesReference. """ return _libsbml.SimpleSpeciesReference_isModifier(self) def renameSIdRefs(self, oldid, newid): """ renameSIdRefs(SimpleSpeciesReference self, string oldid, string newid) Replaces all uses of a given 'SIdRef' type attribute value with another value. In SBML, object identifiers are of a data type called SId. In SBML Level 3, an explicit data type called SIdRef was introduced for attribute values that refer to SId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to an identifier', but the effective data type was the same as SIdRef in Level 3. These and other methods of libSBML refer to the type SIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all attributes and (if appropriate) mathematical formulas in MathML content, comparing the referenced identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.SimpleSpeciesReference_renameSIdRefs(self, oldid, newid) SimpleSpeciesReference_swigregister = _libsbml.SimpleSpeciesReference_swigregister SimpleSpeciesReference_swigregister(SimpleSpeciesReference) class SpeciesReference(SimpleSpeciesReference): """ A reference to an SBML species in a reaction. The Reaction structure provides a way to express which species act as reactants and which species act as products in a reaction. In a given reaction, references to those species acting as reactants and/or products are made using instances of SpeciesReference structures in a Reaction object's lists of reactants and products. A species can occur more than once in the lists of reactants and products of a given Reaction instance. The effective stoichiometry for a species in a reaction is the sum of the stoichiometry values given on the SpeciesReference object in the list of products minus the sum of stoichiometry values given on the SpeciesReference objects in the list of reactants. A positive value indicates the species is effectively a product and a negative value indicates the species is effectively a reactant. SBML places no restrictions on the effective stoichiometry of a species in a reaction; for example, it can be zero. In the following SBML fragment, the two reactions have the same effective stoichiometry for all their species: The precise structure of SpeciesReference differs between SBML Level 2 and Level 3. We discuss the two variants in separate sections below. SpeciesReference in SBML Level 2 ====================================================================== The mandatory 'species' attribute of SpeciesReference must have as its value the identifier of an existing species defined in the enclosing Model. The species is thereby designated as a reactant or product in the reaction. Which one it is (i.e., reactant or product) is indicated by whether the SpeciesReference appears in the Reaction's 'reactant' or 'product' lists. Product and reactant stoichiometries can be specified using either 'stoichiometry' or 'stoichiometryMath' in a SpeciesReference object. The 'stoichiometry' attribute is of type double and should contain values greater than '0' (false). The 'stoichiometryMath' element is implemented as an element containing a MathML expression. These two are mutually exclusive; only one of 'stoichiometry' or 'stoichiometryMath' should be defined in a given SpeciesReference instance. When neither the attribute nor the element is present, the value of 'stoichiometry' in the SpeciesReference instance defaults to '1.' For maximum interoperability, the 'stoichiometry' attribute should be used in preference to 'stoichiometryMath' when a species' stoichiometry is a simple scalar number (integer or decimal). When the stoichiometry is a rational number, or when it is a more complicated formula, 'stoichiometryMath' must be used. The MathML expression in 'stoichiometryMath' may also refer to identifiers of entities in a model (except reaction identifiers). However, the only species identifiers that can be used in 'stoichiometryMath' are those referenced in the Reaction list of reactants, products and modifiers. The following is a simple example of a species reference for species 'X0,' with stoichiometry '2,' in a list of reactants within a reaction having the identifier 'J1:' ... ... ... ... The following is a more complex example of a species reference for species X0, with a stoichiometry formula consisting of the parameter 'x:' ... x ... ... ... SpeciesReference in SBML Level 3 ====================================================================== In Level 2's definition of a reaction, the stoichiometry attribute of a SpeciesReference is actually a combination of two factors, the standard biochemical stoichiometry and a conversion factor that may be needed to translate the units of the species quantity to the units of the reaction rate. Unfortunately, Level 2 offers no direct way of decoupling these two factors, or for explicitly indicating the units. The only way to do it in Level 2 is to use the StoichiometryMath object associated with SpeciesReferences, and to reference SBML Parameter objects from within the StoichiometryMath formula. This works because Parameter offers a way to attach units to a numerical value, but the solution is indirect and awkward for something that should be a simple matter. Moreover, the question of how to properly encode stoichiometries in SBML reactions has caused much confusion among implementors of SBML software. SBML Level 3 approaches this problem differently. It (1) extends the the use of the SpeciesReference identifier to represent the value of the 'stoichiometry' attribute, (2) makes the 'stoichiometry' attribute optional, (3) removes StoichiometryMath, and (4) adds a new 'constant' boolean attribute on SpeciesReference. As in Level 2, the 'stoichiometry' attribute is of type 'float' and should contain values greater than zero ('0).' A missing 'stoichiometry' implies that the stoichiometry is either unknown, or to be obtained from an external source, or determined by an InitialAssignment object or other SBML construct elsewhere in the model. A species reference's stoichiometry is set by its 'stoichiometry' attribute exactly once. If the SpeciesReference object's 'constant' attribute has the value 'True,' then the stoichiometry is fixed and cannot be changed except by an InitialAssignment object. These two methods of setting the stoichiometry (i.e., using 'stoichiometry' directly, or using InitialAssignment) differ in that the 'stoichiometry' attribute can only be set to a literal floating-point number, whereas InitialAssignment allows the value to be set using an arbitrary mathematical expression. (As an example, the approach could be used to set the stoichiometry to a rational number of the form p/q, where p and q are integers, something that is occasionally useful in the context of biochemical reaction networks.) If the species reference's 'constant' attribute has the value 'False,' the species reference's value may be overridden by an InitialAssignment or changed by AssignmentRule or AlgebraicRule, and in addition, for simulation time t > 0, it may also be changed by a RateRule or Event objects. (However, some of these constructs are mutually exclusive; see the SBML Level 3 Core specifiation for more details.) It is not an error to define 'stoichiometry' on a species reference and also redefine the stoichiometry using an InitialAssignment, but the 'stoichiometry' attribute in that case is ignored. The value of the 'id' attribute of a SpeciesReference can be used as the content of a element in MathML formulas elsewhere in the model. When the identifier appears in a MathML element, it represents the stoichiometry of the corresponding species in the reaction where the SpeciesReference object instance appears. More specifically, it represents the value of the 'stoichiometry' attribute on the SpeciesReference object. In SBML Level 3, the unit of measurement associated with the value of a species' stoichiometry is always considered to be 'dimensionless.' This has the following implications: * When a species reference's identifier appears in mathematical formulas elsewhere in the model, the unit associated with that value is 'dimensionless.' * The units of the 'math' elements of AssignmentRule, InitialAssignment and EventAssignment objects setting the stoichiometry of the species reference should be 'dimensionless.' * If a species reference's identifier is the subject of a RateRule, the unit associated with the RateRule object's value should be dimensionless/time, where time is the model-wide unit of time set on the Model object. """ __swig_setmethods__ = {} for _s in [SimpleSpeciesReference]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, SpeciesReference, name, value) __swig_getmethods__ = {} for _s in [SimpleSpeciesReference]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, SpeciesReference, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_SpeciesReference __del__ = lambda self: None def __init__(self, *args): """ __init__(SpeciesReference self, unsigned int level, unsigned int version) -> SpeciesReference __init__(SpeciesReference self, SBMLNamespaces sbmlns) -> SpeciesReference __init__(SpeciesReference self, SpeciesReference orig) -> SpeciesReference This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: SpeciesReference(SBMLNamespaces sbmlns) Creates a new SpeciesReference using the given SBMLNamespaces object 'sbmlns'. Parameter 'sbmlns' is an SBMLNamespaces object. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: SpeciesReference(long level, long version) Creates a new SpeciesReference using the given SBML 'level' and 'version' values. Parameter 'level' is a long integer, the SBML Level to assign to this SpeciesReference. Parameter 'version' is a long integer, the SBML Version to assign to this SpeciesReference. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: SpeciesReference(SpeciesReference orig) Copy constructor; creates a copy of this SpeciesReference. Parameter 'orig' is the SpeciesReference instance to copy. """ this = _libsbml.new_SpeciesReference(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(SpeciesReference self) -> SpeciesReference Creates and returns a deep copy of this SpeciesReference object. Returns the (deep) copy of this SpeciesReference object. """ return _libsbml.SpeciesReference_clone(self) def initDefaults(self): """ initDefaults(SpeciesReference self) Initializes the fields of this SpeciesReference object to 'typical' default values. The SBML SpeciesReference component has slightly different aspects and default attribute values in different SBML Levels and Versions. This method sets the values to certain common defaults, based mostly on what they are in SBML Level 2. Specifically: * Sets attribute 'stoichiometry' to '1.0' * (Applies to Level 1 models only) Sets attribute 'denominator' to '1' See also getDenominator(), setDenominator(), getStoichiometry(), setStoichiometry(), getStoichiometryMath(), setStoichiometryMath(). """ return _libsbml.SpeciesReference_initDefaults(self) def getStoichiometry(self): """ getStoichiometry(SpeciesReference self) -> double Get the value of the 'stoichiometry' attribute. In SBML Level 2, product and reactant stoichiometries can be specified using either 'stoichiometry' or 'stoichiometryMath' in a SpeciesReference object. The former is to be used when a stoichiometry is simply a scalar number, while the latter is for occasions when it needs to be a rational number or it needs to reference other mathematical expressions. The 'stoichiometry' attribute is of type 'float' and should contain values greater than zero ('0).' The 'stoichiometryMath' element is implemented as an element containing a MathML expression. These two are mutually exclusive; only one of 'stoichiometry' or 'stoichiometryMath' should be defined in a given SpeciesReference instance. When neither the attribute nor the element is present, the value of 'stoichiometry' in the SpeciesReference instance defaults to '1.' For maximum interoperability between different software tools, the 'stoichiometry' attribute should be used in preference to 'stoichiometryMath' when a species' stoichiometry is a simple scalar number (integer or decimal). In SBML Level 3, there is no StoichiometryMath, and SpeciesReference objects have only the 'stoichiometry' attribute. Returns the value of the (scalar) 'stoichiometry' attribute of this SpeciesReference. See also getStoichiometryMath(). """ return _libsbml.SpeciesReference_getStoichiometry(self) def getStoichiometryMath(self, *args): """ getStoichiometryMath(SpeciesReference self) -> StoichiometryMath getStoichiometryMath(SpeciesReference self) -> StoichiometryMath Get the content of the 'stoichiometryMath' subelement as an ASTNode tree. The 'stoichiometryMath' element exists only in SBML Level 2. There, product and reactant stoichiometries can be specified using either 'stoichiometry' or 'stoichiometryMath' in a SpeciesReference object. The former is to be used when a stoichiometry is simply a scalar number, while the latter is for occasions when it needs to be a rational number or it needs to reference other mathematical expressions. The 'stoichiometry' attribute is of type 'float' and should contain values greater than zero ('0).' The 'stoichiometryMath' element is implemented as an element containing a MathML expression. These two are mutually exclusive; only one of 'stoichiometry' or 'stoichiometryMath' should be defined in a given SpeciesReference instance. When neither the attribute nor the element is present, the value of 'stoichiometry' in the SpeciesReference instance defaults to '1.' For maximum interoperability between different software tools, the 'stoichiometry' attribute should be used in preference to 'stoichiometryMath' when a species' stoichiometry is a simple scalar number (integer or decimal). Returns the content of the 'stoichiometryMath' subelement of this SpeciesReference. """ return _libsbml.SpeciesReference_getStoichiometryMath(self, *args) def getDenominator(self): """ getDenominator(SpeciesReference self) -> int Get the value of the 'denominator' attribute, for the case of a rational-numbered stoichiometry or a model in SBML Level 1. The 'denominator' attribute is only actually written out in the case of an SBML Level 1 model. In SBML Level 2, rational-number stoichiometries are written as MathML elements in the 'stoichiometryMath' subelement. However, as a convenience to users, libSBML allows the creation and manipulation of rational-number stoichiometries by supplying the numerator and denominator directly rather than having to manually create an ASTNode object. LibSBML will write out the appropriate constructs (either a combination of 'stoichiometry' and 'denominator' in the case of SBML Level 1, or a 'stoichiometryMath' subelement in the case of SBML Level 2). However, as the 'stoichiometryMath' subelement was removed in SBML Level 3, automatic translation of the 'denominator' attribute is no longer supported for that level. Returns the value of the 'denominator' attribute of this SpeciesReference. """ return _libsbml.SpeciesReference_getDenominator(self) def getConstant(self): """ getConstant(SpeciesReference self) -> bool Get the value of the 'constant' attribute. Returns the value of the 'constant' attribute of this SpeciesReference. """ return _libsbml.SpeciesReference_getConstant(self) def isSetStoichiometryMath(self): """ isSetStoichiometryMath(SpeciesReference self) -> bool Predicate returning 'True' if this SpeciesReference's 'stoichiometryMath' subelement is set Returns 'True' if the 'stoichiometryMath' subelement of this SpeciesReference is set, 'False' otherwise. """ return _libsbml.SpeciesReference_isSetStoichiometryMath(self) def isSetConstant(self): """ isSetConstant(SpeciesReference self) -> bool Predicate returning 'True' if this SpeciesReference's 'constant' attribute is set Returns 'True' if the 'constant' attribute of this SpeciesReference is set, 'False' otherwise. """ return _libsbml.SpeciesReference_isSetConstant(self) def isSetStoichiometry(self): """ isSetStoichiometry(SpeciesReference self) -> bool Predicate returning 'True' if this SpeciesReference's 'stoichiometry' attribute is set. Returns 'True' if the 'stoichiometry' attribute of this SpeciesReference is set, 'False' otherwise. """ return _libsbml.SpeciesReference_isSetStoichiometry(self) def setStoichiometry(self, value): """ setStoichiometry(SpeciesReference self, double value) -> int Sets the value of the 'stoichiometry' attribute of this SpeciesReference. In SBML Level 2, product and reactant stoichiometries can be specified using either 'stoichiometry' or 'stoichiometryMath' in a SpeciesReference object. The former is to be used when a stoichiometry is simply a scalar number, while the latter is for occasions when it needs to be a rational number or it needs to reference other mathematical expressions. The 'stoichiometry' attribute is of type 'float' and should contain values greater than zero ('0).' The 'stoichiometryMath' element is implemented as an element containing a MathML expression. These two are mutually exclusive; only one of 'stoichiometry' or 'stoichiometryMath' should be defined in a given SpeciesReference instance. When neither the attribute nor the element is present, the value of 'stoichiometry' in the SpeciesReference instance defaults to '1.' For maximum interoperability between different software tools, the 'stoichiometry' attribute should be used in preference to 'stoichiometryMath' when a species' stoichiometry is a simple scalar number (integer or decimal). In SBML Level 3, there is no StoichiometryMath, and SpeciesReference objects have only the 'stoichiometry' attribute. Parameter 'value' is the new value of the 'stoichiometry' attribute. Note: In SBML Level 2, the 'stoichiometryMath' subelement of this SpeciesReference object will be unset because the 'stoichiometry' attribute and the stoichiometryMath' subelement are mutually exclusive. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS """ return _libsbml.SpeciesReference_setStoichiometry(self, value) def setStoichiometryMath(self, math): """ setStoichiometryMath(SpeciesReference self, StoichiometryMath math) -> int Sets the 'stoichiometryMath' subelement of this SpeciesReference. The Abstract Syntax Tree in 'math' is copied. In SBML Level 2, product and reactant stoichiometries can be specified using either 'stoichiometry' or 'stoichiometryMath' in a SpeciesReference object. The former is to be used when a stoichiometry is simply a scalar number, while the latter is for occasions when it needs to be a rational number or it needs to reference other mathematical expressions. The 'stoichiometry' attribute is of type 'float' and should contain values greater than zero ('0).' The 'stoichiometryMath' element is implemented as an element containing a MathML expression. These two are mutually exclusive; only one of 'stoichiometry' or 'stoichiometryMath' should be defined in a given SpeciesReference instance. When neither the attribute nor the element is present, the value of 'stoichiometry' in the SpeciesReference instance defaults to '1.' For maximum interoperability between different software tools, the 'stoichiometry' attribute should be used in preference to 'stoichiometryMath' when a species' stoichiometry is a simple scalar number (integer or decimal). In SBML Level 3, there is no StoichiometryMath, and SpeciesReference objects have only the 'stoichiometry' attribute. Parameter 'math' is the StoichiometryMath expression that is to be copied as the content of the 'stoichiometryMath' subelement. Note: In SBML Level 2, the 'stoichiometry' attribute of this SpeciesReference object will be unset (isSetStoichiometry() will return 'False' although getStoichiometry() will return '1.0)' if the given math is not null because the 'stoichiometry' attribute and the stoichiometryMath' subelement are mutually exclusive. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE * LIBSBML_LEVEL_MISMATCH * LIBSBML_VERSION_MISMATCH """ return _libsbml.SpeciesReference_setStoichiometryMath(self, math) def setDenominator(self, value): """ setDenominator(SpeciesReference self, int value) -> int Set the value of the 'denominator' attribute, for the case of a rational-numbered stoichiometry or a model in SBML Level 1. The 'denominator' attribute is only actually written out in the case of an SBML Level 1 model. In SBML Level 2, rational-number stoichiometries are written as MathML elements in the 'stoichiometryMath' subelement. However, as a convenience to users, libSBML allows the creation and manipulation of rational-number stoichiometries by supplying the numerator and denominator directly rather than having to manually create an ASTNode object. LibSBML will write out the appropriate constructs (either a combination of 'stoichiometry' and 'denominator' in the case of SBML Level 1, or a 'stoichiometryMath' subelement in the case of SBML Level 2). However, as the 'stoichiometryMath' subelement was removed in SBML Level 3, automatic translation of the 'denominator' attribute is no longer supported for that level. Parameter 'value' is the scalar value. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE """ return _libsbml.SpeciesReference_setDenominator(self, value) def setConstant(self, flag): """ setConstant(SpeciesReference self, bool flag) -> int Sets the 'constant' attribute of this SpeciesReference to the given boolean 'flag'. Parameter 'flag' is a boolean, the value for the 'constant' attribute of this SpeciesReference instance. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE """ return _libsbml.SpeciesReference_setConstant(self, flag) def unsetStoichiometryMath(self): """ unsetStoichiometryMath(SpeciesReference self) -> int Unsets the 'stoichiometryMath' subelement of this SpeciesReference. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE * LIBSBML_OPERATION_FAILED In SBML Level 2, product and reactant stoichiometries can be specified using either 'stoichiometry' or 'stoichiometryMath' in a SpeciesReference object. The former is to be used when a stoichiometry is simply a scalar number, while the latter is for occasions when it needs to be a rational number or it needs to reference other mathematical expressions. The 'stoichiometry' attribute is of type 'float' and should contain values greater than zero ('0).' The 'stoichiometryMath' element is implemented as an element containing a MathML expression. These two are mutually exclusive; only one of 'stoichiometry' or 'stoichiometryMath' should be defined in a given SpeciesReference instance. When neither the attribute nor the element is present, the value of 'stoichiometry' in the SpeciesReference instance defaults to '1.' For maximum interoperability between different software tools, the 'stoichiometry' attribute should be used in preference to 'stoichiometryMath' when a species' stoichiometry is a simple scalar number (integer or decimal). In SBML Level 3, there is no StoichiometryMath, and SpeciesReference objects have only the 'stoichiometry' attribute. Note: In SBML Level 2, the 'stoichiometry' attribute of this SpeciesReference object will be reset to a default value ('1.0)' if the 'stoichiometry' attribute has not been set. """ return _libsbml.SpeciesReference_unsetStoichiometryMath(self) def unsetStoichiometry(self): """ unsetStoichiometry(SpeciesReference self) -> int Unsets the 'stoichiometry' attribute of this SpeciesReference. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED Note: In SBML Level 1, the 'stoichiometry' attribute of this SpeciesReference object will be just reset to a default value ('1.0)' and isSetStoichiometry() will still return 'True.' In SBML Level 2, the 'stoichiometry' attribute of this object will be unset (which will result in isSetStoichiometry() returning 'False,' although getStoichiometry() will return '1.0)' if the 'stoichiometryMath' subelement is set, otherwise the attribute will be just reset to the default value ('1.0)' (and isSetStoichiometry() will still return 'True).' In SBML Level 3, the 'stoichiometry' attribute of this object will be set to 'NaN' and isSetStoichiometry() will return 'False.' """ return _libsbml.SpeciesReference_unsetStoichiometry(self) def unsetConstant(self): """ unsetConstant(SpeciesReference self) -> int Unsets the 'constant' attribute of this SpeciesReference. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE """ return _libsbml.SpeciesReference_unsetConstant(self) def createStoichiometryMath(self): """ createStoichiometryMath(SpeciesReference self) -> StoichiometryMath Creates a new, empty StoichiometryMath object, adds it to this SpeciesReference, and returns it. Returns the newly created StoichiometryMath object instance. Note: This function has no effect on SBML Level 1 or Level 3 SpeciesReference objects, neither of which have StoichiometryMath children. See also Reaction.addReactant(), Reaction.addProduct(). """ return _libsbml.SpeciesReference_createStoichiometryMath(self) def setAnnotation(self, *args): """ setAnnotation(SpeciesReference self, XMLNode annotation) -> int setAnnotation(SpeciesReference self, string annotation) -> int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: setAnnotation(XMLNode annotation) Sets the value of the 'annotation' subelement of this SBML object to a copy of 'annotation'. Any existing content of the 'annotation' subelement is discarded. Unless you have taken steps to first copy and reconstitute any existing annotations into the 'annotation' that is about to be assigned, it is likely that performing such wholesale replacement is unfriendly towards other software applications whose annotations are discarded. An alternative may be to use appendAnnotation(). Parameter 'annotation' is an XML structure that is to be used as the content of the 'annotation' subelement of this object. Returns integer value indicating success/failure of the function. This particular function only does one thing irrespective of user input or object state, and thus will only return a single value: * LIBSBML_OPERATION_SUCCESS See also appendAnnotation(), appendAnnotation(). ______________________________________________________________________ Method variant with the following signature: setAnnotation(string annotation) Sets the value of the 'annotation' subelement of this SBML object to a copy of 'annotation'. Any existing content of the 'annotation' subelement is discarded. Unless you have taken steps to first copy and reconstitute any existing annotations into the 'annotation' that is about to be assigned, it is likely that performing such wholesale replacement is unfriendly towards other software applications whose annotations are discarded. An alternative may be to use appendAnnotation(). Parameter 'annotation' is an XML string that is to be used as the content of the 'annotation' subelement of this object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also appendAnnotation(), appendAnnotation(). """ return _libsbml.SpeciesReference_setAnnotation(self, *args) def appendAnnotation(self, *args): """ appendAnnotation(SpeciesReference self, XMLNode annotation) -> int appendAnnotation(SpeciesReference self, string annotation) -> int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: appendAnnotation(XMLNode annotation) Appends annotation content to any existing content in the 'annotation' subelement of this object. The content in 'annotation' is copied. Unlike SpeciesReference.setAnnotation(), this method allows other annotations to be preserved when an application adds its own data. Parameter 'annotation' is an XML structure that is to be copied and appended to the content of the 'annotation' subelement of this object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also setAnnotation(), setAnnotation(). ______________________________________________________________________ Method variant with the following signature: appendAnnotation(string annotation) Appends annotation content to any existing content in the 'annotation' subelement of this object. The content in 'annotation' is copied. Unlike SpeciesReference.setAnnotation(), this method allows other annotations to be preserved when an application adds its own data. Parameter 'annotation' is an XML string that is to be copied and appended to the content of the 'annotation' subelement of this object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also setAnnotation(), setAnnotation(). """ return _libsbml.SpeciesReference_appendAnnotation(self, *args) def getTypeCode(self): """ getTypeCode(SpeciesReference self) -> int Returns the libSBML type code for this SBML object. LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for this object: SBML_SPECIES_REFERENCE (default). See also getElementName(), getPackageName(). """ return _libsbml.SpeciesReference_getTypeCode(self) def getElementName(self): """ getElementName(SpeciesReference self) -> string Returns the XML element name of this object, which for SpeciesReference, is always ''speciesReference'.' Returns the name of this element, i.e., ''speciesReference'.' """ return _libsbml.SpeciesReference_getElementName(self) def hasRequiredAttributes(self): """ hasRequiredAttributes(SpeciesReference self) -> bool Predicate returning 'True' if all the required attributes for this SpeciesReference object have been set. The required attributes for a SpeciesReference object are: * 'species' * 'constant' (only available SBML Level 3) Returns 'True' if the required attributes have been set, 'False' otherwise. """ return _libsbml.SpeciesReference_hasRequiredAttributes(self) SpeciesReference_swigregister = _libsbml.SpeciesReference_swigregister SpeciesReference_swigregister(SpeciesReference) class ListOfSpeciesReferences(ListOf): """ A list of SpeciesReference objects. The various ListOf___ classes in SBML are merely containers used for organizing the main components of an SBML model. In libSBML's implementation, ListOf___ classes are derived from the intermediate utility class ListOf, which is not defined by the SBML specifications but serves as a useful programmatic construct. ListOf is itself is in turn derived from SBase, which provides all of the various ListOf___ classes with common features defined by the SBML specification, such as 'metaid' attributes and annotations. The relationship between the lists and the rest of an SBML model is illustrated by the following (for SBML Level 2 Version 4): ... ... ... ... ... ... ... elements of subclasses of Rule ... ... ... ... SBML Level 3 Version 1 has essentially the same structure as Level 2 Version 4, depicted above, but SBML Level 3 Version 2 allows containers to contain zero or more of the relevant object, instead of requiring at least one. As such, libsbml will write out an otherwise-empty ListOf___ element that has any optional attribute set (such as 'id' or 'metaid'), that has an optional child (such as a 'notes' or 'annotation'), or that has attributes or children set from any SBML Level 3 package, whether or not the ListOf___ has any other children. Readers may wonder about the motivations for using the ListOf___ containers in SBML. A simpler approach in XML might be to place the components all directly at the top level of the model definition. The choice made in SBML is to group them within XML elements named after ListOfClassname, in part because it helps organize the components. More importantly, the fact that the container classes are derived from SBase means that software tools can add information about the lists themselves into each list container's 'annotation'. See also ListOfFunctionDefinitions, ListOfUnitDefinitions, ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments, ListOfSpecies, ListOfParameters, ListOfInitialAssignments, ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents. """ __swig_setmethods__ = {} for _s in [ListOf]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfSpeciesReferences, name, value) __swig_getmethods__ = {} for _s in [ListOf]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, ListOfSpeciesReferences, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(ListOfSpeciesReferences self, unsigned int level, unsigned int version) -> ListOfSpeciesReferences __init__(ListOfSpeciesReferences self, SBMLNamespaces sbmlns) -> ListOfSpeciesReferences This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: ListOfSpeciesReferences(SBMLNamespaces sbmlns) Creates a new ListOfSpeciesReferences object. The object is constructed such that it is valid for the SBML Level and Version combination determined by the SBMLNamespaces object in 'sbmlns'. Parameter 'sbmlns' is an SBMLNamespaces object that is used to determine the characteristics of the ListOfSpeciesReferences object to be created. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: ListOfSpeciesReferences(long level, long version) Creates a new, empty ListOfSpeciesReferences object. The object is constructed such that it is valid for the given SBML Level and Version combination. Parameter 'level' is the SBML Level. Parameter 'version' is the Version within the SBML Level. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. """ this = _libsbml.new_ListOfSpeciesReferences(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(ListOfSpeciesReferences self) -> ListOfSpeciesReferences Creates and returns a deep copy of this ListOfSpeciesReferences object. Returns the (deep) copy of this ListOfSpeciesReferences object. """ return _libsbml.ListOfSpeciesReferences_clone(self) def getItemTypeCode(self): """ getItemTypeCode(ListOfSpeciesReferences self) -> int Returns the libSBML type code for the objects contained in this ListOf (i.e., SpeciesReference objects, if the list is non-empty). LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for objects contained in this list: SBML_SPECIES_REFERENCE (default). See also getElementName(), getPackageName(). """ return _libsbml.ListOfSpeciesReferences_getItemTypeCode(self) def getElementName(self): """ getElementName(ListOfSpeciesReferences self) -> string Returns the XML element name of this object. For ListOfSpeciesReferences, the XML element name is ''listOfSpeciesReferences'.' Returns the name of this element, i.e., ''listOfSpeciesReferences'.' """ return _libsbml.ListOfSpeciesReferences_getElementName(self) def get(self, *args): """ get(ListOfSpeciesReferences self, unsigned int n) -> SimpleSpeciesReference get(ListOfSpeciesReferences self, unsigned int n) -> SimpleSpeciesReference get(ListOfSpeciesReferences self, string sid) -> SimpleSpeciesReference get(ListOfSpeciesReferences self, string sid) -> SimpleSpeciesReference This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: get(long n) Get a SpeciesReference from the ListOfSpeciesReferences. Parameter 'n' is the index number of the SpeciesReference to get. Returns the nth SpeciesReference in this ListOfSpeciesReferences. If the index 'n' is invalid, 'None' is returned. See also size(). ______________________________________________________________________ Method variant with the following signature: get(string sid) Get a SpeciesReference from the ListOfSpeciesReferences based on its identifier. Parameter 'sid' is a string representing the identifier of the SpeciesReference to get. Returns SpeciesReference in this ListOfSpeciesReferences with the given 'sid' or 'None' if no such SpeciesReference exists. See also get(), size(). """ return _libsbml.ListOfSpeciesReferences_get(self, *args) def remove(self, *args): """ remove(ListOfSpeciesReferences self, unsigned int n) -> SimpleSpeciesReference remove(ListOfSpeciesReferences self, string sid) -> SimpleSpeciesReference This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: remove(long n) Removes the nth item from this ListOfSpeciesReferences items and returns a pointer to it. The caller owns the returned item and is responsible for deleting it. Parameter 'n' is the index of the item to remove. See also size(). ______________________________________________________________________ Method variant with the following signature: remove(string sid) Removes item in this ListOfSpeciesReferences items with the given identifier. The caller owns the returned item and is responsible for deleting it. If none of the items in this list have the identifier 'sid', then 'None' is returned. Parameter 'sid' is the identifier of the item to remove. Returns the item removed. As mentioned above, the caller owns the returned item. """ return _libsbml.ListOfSpeciesReferences_remove(self, *args) def getType(self): """ getType(ListOfSpeciesReferences self) -> unsigned int Internal implementation method. """ return _libsbml.ListOfSpeciesReferences_getType(self) __swig_destroy__ = _libsbml.delete_ListOfSpeciesReferences __del__ = lambda self: None ListOfSpeciesReferences_swigregister = _libsbml.ListOfSpeciesReferences_swigregister ListOfSpeciesReferences_swigregister(ListOfSpeciesReferences) class ModifierSpeciesReference(SimpleSpeciesReference): """ A reference to an SBML modifier species. Sometimes a species appears in the kinetic rate formula of a reaction but is itself neither created nor destroyed in that reaction (for example, because it acts as a catalyst or inhibitor). In SBML, all such species are simply called modifiers without regard to the detailed role of those species in the model. The Reaction structure provides a way to express which species act as modifiers in a given reaction. This is the purpose of the list of modifiers available in Reaction. The list contains instances of ModifierSpeciesReference structures. The ModifierSpeciesReference structure inherits the mandatory attribute 'species' and optional attributes 'id' and 'name' from the parent class SimpleSpeciesReference. See the description of SimpleSpeciesReference for more information about these. The value of the 'species' attribute must be the identifier of a species defined in the enclosing Model; this species is designated as a modifier for the current reaction. A reaction may have any number of modifiers. It is permissible for a modifier species to appear simultaneously in the list of reactants and products of the same reaction where it is designated as a modifier, as well as to appear in the list of reactants, products and modifiers of other reactions in the model. """ __swig_setmethods__ = {} for _s in [SimpleSpeciesReference]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, ModifierSpeciesReference, name, value) __swig_getmethods__ = {} for _s in [SimpleSpeciesReference]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, ModifierSpeciesReference, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(ModifierSpeciesReference self, unsigned int level, unsigned int version) -> ModifierSpeciesReference __init__(ModifierSpeciesReference self, SBMLNamespaces sbmlns) -> ModifierSpeciesReference This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: ModifierSpeciesReference(SBMLNamespaces sbmlns) Creates a new ModifierSpeciesReference using the given SBMLNamespaces object 'sbmlns'. Parameter 'sbmlns' is an SBMLNamespaces object. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: ModifierSpeciesReference(long level, long version) Creates a new ModifierSpeciesReference using the given SBML 'level' and 'version' values. Parameter 'level' is a long integer, the SBML Level to assign to this ModifierSpeciesReference. Parameter 'version' is a long integer, the SBML Version to assign to this ModifierSpeciesReference. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. """ this = _libsbml.new_ModifierSpeciesReference(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_ModifierSpeciesReference __del__ = lambda self: None def clone(self): """ clone(ModifierSpeciesReference self) -> ModifierSpeciesReference Creates and returns a deep copy of this ModifierSpeciesReference object. Returns the (deep) copy of this ModifierSpeciesReference object. """ return _libsbml.ModifierSpeciesReference_clone(self) def getTypeCode(self): """ getTypeCode(ModifierSpeciesReference self) -> int Returns the libSBML type code for this SBML object. LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for this object: SBML_MODIFIER_SPECIES_REFERENCE (default). WARNING: The specific integer values of the possible type codes may be reused by different libSBML plug-ins for SBML Level 3. packages, To fully identify the correct code, it is necessary to invoke both getPackageName() and getTypeCode() (or ListOf.getItemTypeCode()). See also getElementName(), getPackageName(). """ return _libsbml.ModifierSpeciesReference_getTypeCode(self) def getElementName(self): """ getElementName(ModifierSpeciesReference self) -> string Returns the XML element name of this object, which for Species, is always ''modifierSpeciesReference'.' Returns the name of this element, i.e., ''modifierSpeciesReference'.' """ return _libsbml.ModifierSpeciesReference_getElementName(self) def hasRequiredAttributes(self): """ hasRequiredAttributes(ModifierSpeciesReference self) -> bool Predicate returning 'True' if all the required attributes for this ModifierSpeciesReference object have been set. The required attributes for a ModifierSpeciesReference object are: species Returns 'True' if the required attributes have been set, 'False' otherwise. """ return _libsbml.ModifierSpeciesReference_hasRequiredAttributes(self) ModifierSpeciesReference_swigregister = _libsbml.ModifierSpeciesReference_swigregister ModifierSpeciesReference_swigregister(ModifierSpeciesReference) class Event(SBase): """ A discontinuous SBML event. An SBML Event object defines when the event can occur, the variables that are affected by it, how the variables are affected, and the event's relationship to other events. The effect of the event can optionally be delayed after the occurrence of the condition which invokes it. The operation of Event is divided into two phases (even when the event is not delayed): one when the event is triggered, and the other when the event is executed. Trigger objects define the conditions for triggering an event, Delay objects define when the event is actually executed, EventAssignment objects define the effects of executing the event, and (in SBML Level 3) Priority objects influence the order of EventAssignment performance in cases of simultaneous events. Please consult the descriptions of Trigger, Delay, EventAssignment and Priority for more information. SBML Level/Version differences ====================================================================== SBML Level 2 ...................................................................... In SBML Level 2 versions before Version 4, the semantics of Event time delays were defined such that the expressions in the event's assignments were always evaluated at the time the event was triggered. This definition made it difficult to define an event whose assignment formulas were meant to be evaluated at the time the event was executed (i.e., after the time period defined by the value of the Delay element, or after any other simultaneous event may have been executed and changed the model state). In SBML Level 2 Version 4 and in Level 3, the attribute 'useValuesFromTriggerTime' on Event was added to allow a model to indicate the time at which the event's assignments are to be calculated, whether at the moment the event is triggered (if the value of the attribute is 'True),' or at the moment of execution (if 'useValuesFromTriggerTime'='False).' If the event has a delay, the 'useValuesFromTriggerTime' is likely to make a significant difference in the values used in the assignment, but the possibility of simultaneous events mean that even zero-delay events can have different results depending on the value of this attribute. The definition of Event in SBML Level 2 Versions 1 and 2 includes an additional attribute called 'timeUnits', which allowed the time units of the Delay to be set explicitly. Later Versions of SBML Level 2 as well as SBML Level 3 do not define this attribute. LibSBML supports this attribute for compatibility with previous versions of SBML Level 2; however, if a model in SBML Level 3 or Level 2 Versions 3-4 format sets the attribute, the consistency-checking method SBMLDocument.checkConsistency() will report an error. The attribute 'useValuesFromTriggerTime' was introduced in SBML Level 2 Version 4. Models defined in prior Versions of SBML Level 2 cannot use this attribute, and SBMLDocument.checkConsistency() will report an error if they do. SBML Level 3 ...................................................................... SBML Level 3 introduces several changes to the structure and components of Events compared to SBML Level 2. These changes fall into two main categories: changes to what is optional or required, and additions of new attributes and elements. * The attribute 'useValuesFromTriggerTime' on Event is mandatory (it was optional in Level 2 and had a default value of 'True);' * Event's 'listOfEventAssignments' element (of class ListOfEventAssignments) is optional (it was mandatory in Level 2); * Event's 'priority' element (of class Priority) is new in Level 3; and * The Trigger object gains new mandatory attributes (described as part of the definition of Trigger). * In SBML Level 3 Version 2, the Trigger object became optional. An Event with no Trigger will simply not fire. The changes to the attributes of Event are described below; the changes to Trigger and Priority are described in their respective sections. Semantics of events in SBML Level 3 Version 1 ====================================================================== The detailed semantics of events are described in the specification documents for each SBML Level/Version. Here we include the description from the SBML Level 1 Version 1. Any transition of a Trigger object's 'math' formula from the value 'False' to 'True' will cause the enclosing Event object to trigger. Such a transition is not possible at the very start of a simulation (i.e., at time t = 0) unless the Trigger object's 'initialValue' attribute has a value of 'False;' this defines the value of the trigger formula to be 'False' immediately prior to the start of simulation, thereby giving it the potential to change in value from 'False' to 'True' when the formula is evaluated at t = 0. If 'initialValue'='True,' then the trigger expression cannot transition from 'False' to 'True' at t = 0 but may do so at some time t > 0. Consider an Event object definition E with delay d in which the Trigger object's 'math' formula makes a transition in value from 'False' to 'True' at times t_1 and t_2. The EventAssignment within the Event object will have effect at t_1 + d and t_2 + d irrespective of the relative times of t_1 and t_2. For example, events can 'overlap' so that t_1 < t_2 < t_1 + d still causes an event assignments to occur at t_1 + d and t_2 + d. It is entirely possible for two events to be executed simultaneously, and it is possible for events to trigger other events (i.e., an event assignment can cause an event to trigger). This leads to several points: * A software package should retest all event triggers after executing an event assignment in order to account for the possibility that the assignment causes another event trigger to transition from 'False' to 'True.' This check should be made after each individual Event object's execution, even when several events are to be executed simultaneously. * Any Event object whose Trigger 'persistent' attribute has the value 'False' must have its trigger expression reevaluated continuously between when the event is triggered and when it is executed. If its trigger expression ever evaluates to 'False,' it must be removed from the queue of events pending execution and treated as any other event whose trigger expression evaluates to 'False.' * Although the precise time at which events are executed is not resolved beyond the given execution point in simulated time, it is assumed that the order in which the events occur is resolved. This order can be significant in determining the overall outcome of a given simulation. When an event X triggers another event Y and event Y has zero delay, then event Y is added to the existing set of simultaneous events that are pending execution. Events X and Y form a cascade of events at the same point in simulation time. An event such as Y may have a special priority if it contains a Priority subobject. * All events in a model are open to being in a cascade. The position of an event in the event queue does not affect whether it can be in the cascade: event Y can be triggered whether it is before or after X in the queue of events pending execution. A cascade of events can be potentially infinite (never terminate); when this occurs a simulator should indicate this has occurred---it is incorrect for a simulator to break a cascade arbitrarily and continue the simulation without at least indicating that the infinite cascade occurred. * Simultaneous events having no defined priorities are executed in an undefined order. This does not mean that the behavior of the simulation is completely undefined; merely that the order of execution of these particular events is undefined. A given simulator may use any algorithm to choose an order as long as every event is executed exactly once. * Events with defined priorities are executed in the order implied by their Priority 'math' formula values, with events having higher priorities being executed ahead of events with lower priorities, and events with identical priorities being executed in a random order with respect to one another (as determined at run-time by some random algorithm equivalent to coin-flipping). Newly-triggered events that are to be executed immediately (i.e., if they define no delays) should be inserted into the queue of events pending execution according to their priorities: events with higher priority values value must be inserted ahead of events with lower priority values and after any pending events with even higher priorities, and inserted randomly among pending events with the same priority values. Events without Priority objects must be inserted into the queue in some fashion, but the algorithm used to place it in the queue is undefined. Similarly, there is no restriction on the order of a newly-inserted event with a defined Priority with respect to any other pending Event without a defined Priority. * A model variable that is the target of one or more event assignments can change more than once when simultaneous events are processed at some time point t. The model's behavior (output) for such a variable is the value of the variable at the end of processing all the simultaneous events at time t. Restrictions relaxed in SBML Level 3 Version 2 ====================================================================== In SBML Level 3 Version 2, several restrictions were lifted that have the potential to affect the semantics of an Event: * The Trigger subobject of an Event is optional. If missing, an Event is never triggered, unless an alternate triggering scheme is introduced by an SBML Level 3 package. * The 'math' subelements of an Event Trigger, Delay, Priority, and EventAssignment are all optional. If any of these elements lack a 'math' subelement, and that information is not supplied in an SBML Level 3 package, it is mathematically equivalent to the Trigger, Delay, Priority, or EventAssignment not being present at all. * The ListOfEventAssignments may be empty, which is mathematically equivalent to the Event not having a ListOfEventAssignments at all. * Any 'math' subelement may return a Boolean or a numeric value in any context. If a numeric value is used in a Boolean context, a '0' is interpreted as 'False,' and all other values are interpreted as 'True.' If a Boolean value is used in a numeric context, a 'True' is interpreted as a 1, and a 'False' is interpreted as a 0. This means (for example) that a Trigger value that changes from 0.0 to anything else is equivalent to changing from 'False' to 'True.' See also Trigger, Priority, Delay, EventAssignment. """ __swig_setmethods__ = {} for _s in [SBase]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, Event, name, value) __swig_getmethods__ = {} for _s in [SBase]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, Event, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_Event __del__ = lambda self: None def __init__(self, *args): """ __init__(Event self, unsigned int level, unsigned int version) -> Event __init__(Event self, SBMLNamespaces sbmlns) -> Event __init__(Event self, Event orig) -> Event This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: Event(SBMLNamespaces sbmlns) Creates a new Event using the given SBMLNamespaces object 'sbmlns'. The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments. Parameter 'sbmlns' is an SBMLNamespaces object. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: Event(long level, long version) Creates a new Event using the given SBML 'level' and 'version' values. Parameter 'level' is a long integer, the SBML Level to assign to this Event. Parameter 'version' is a long integer, the SBML Version to assign to this Event. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: Event(Event orig) Copy constructor; creates a copy of this Event. Parameter 'orig' is the object to copy. """ this = _libsbml.new_Event(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(Event self) -> Event Creates and returns a deep copy of this Event object. Returns the (deep) copy of this Event object. """ return _libsbml.Event_clone(self) def initDefaults(self): """ initDefaults(Event self) Initializes the fields of this Event object to 'typical' default values. The SBML Event component has slightly different aspects and default attribute values in different SBML Levels and Versions. This method sets the values to certain common defaults, based mostly on what they are in SBML Level 2. Specifically: * Sets attribute 'useValuesFromTriggerTime' to 'True' """ return _libsbml.Event_initDefaults(self) def getElementBySId(self, id): """ getElementBySId(Event self, string id) -> SBase Returns the first child element found that has the given 'id' in the model-wide SId namespace, or 'None' if no such object is found. Parameter 'id' is string representing the id of the object to find. Returns pointer to the first element found with the given 'id'. """ return _libsbml.Event_getElementBySId(self, id) def getElementByMetaId(self, metaid): """ getElementByMetaId(Event self, string metaid) -> SBase Returns the first child element it can find with the given 'metaid', or 'None' if no such object is found. Parameter 'metaid' is string representing the metaid of the object to find. Returns pointer to the first element found with the given 'metaid'. """ return _libsbml.Event_getElementByMetaId(self, metaid) def getId(self): """ getId(Event self) -> string Returns the value of the 'id' attribute of this Event. Note: Because of the inconsistent behavior of this function with respect to assignments and rules, it is now recommended to use the getIdAttribute() function instead. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Returns the id of this Event. See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(). """ return _libsbml.Event_getId(self) def getName(self): """ getName(Event self) -> string Returns the value of the 'name' attribute of this Event. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns the name of this SBML object, or the empty string if not set or unsettable. See also getIdAttribute(), isSetName(), setName(), unsetName(). """ return _libsbml.Event_getName(self) def getTrigger(self, *args): """ getTrigger(Event self) -> Trigger getTrigger(Event self) -> Trigger Get the event trigger portion of this Event. Returns the Trigger object of this Event, or 'None' if the trigger is not set. """ return _libsbml.Event_getTrigger(self, *args) def getDelay(self, *args): """ getDelay(Event self) -> Delay getDelay(Event self) -> Delay Get the assignment delay portion of this Event, if there is one. Returns the delay of this Event if one is defined, or 'None' if none is defined. """ return _libsbml.Event_getDelay(self, *args) def getPriority(self, *args): """ getPriority(Event self) -> Priority getPriority(Event self) -> Priority (SBML Level 3 only) Get the event priority portion of this Event. Returns the Priority object of this Event, or 'None' if the Priority has not been set. Note: The element 'priority' is available in SBML Level 3, but is not present in lower Levels of SBML. """ return _libsbml.Event_getPriority(self, *args) def getTimeUnits(self): """ getTimeUnits(Event self) -> string Get the value of the 'timeUnits' attribute of this Event, if it has one. Returns the value of the attribute 'timeUnits' as a string. WARNING: Definitions of Event in SBML Level 2 Versions 1 and 2 included the additional attribute called 'timeUnits', but it was removed in SBML Level 2 Version 3. LibSBML supports this attribute for compatibility with previous versions of SBML Level 2, but its use is discouraged since models in Level 2 Versions 3 and 4 cannot contain it. If a Version 3 or 4 model sets the attribute, the consistency-checking method SBMLDocument.checkConsistency() will report an error. """ return _libsbml.Event_getTimeUnits(self) def getUseValuesFromTriggerTime(self): """ getUseValuesFromTriggerTime(Event self) -> bool Get the value of the 'useValuesFromTriggerTime' attribute of this Event. The optional Delay on Event and the fact that multiple events may be simultaneously executed means there are two times to consider when computing the results of an event: the time at which the event is triggered, and the time at which assignments are executed. It is also possible to distinguish between the time at which the EventAssignment's expression is calculated, and the time at which the assignment is made: the expression could be evaluated at the same time the assignments are performed, i.e., when the event is executed, but it could also be defined to be evaluated at the time the event is triggered. In SBML Level 2 versions prior to Version 4, the semantics of Event time delays were defined such that the expressions in the event's assignments were always evaluated at the time the event was triggered. This definition made it difficult to define an event whose assignment formulas were meant to be evaluated at the time the event was executed (i.e., after the time period defined by the value of the Delay element, or after any other simultaneous event may have been executed and changed the model state). In SBML Level 2 Version 4, the attribute 'useValuesFromTriggerTime' on Event allows a model to indicate the time at which the event's assignments are intended to be evaluated. In SBML Level 2, the attribute has a default value of 'True,' which corresponds to the interpretation of event assignments prior to Version 4: the values of the assignment formulas are computed at the moment the event is triggered, not after the delay. If 'useValuesFromTriggerTime'='False,' it means that the formulas in the event's assignments are to be computed after the delay, at the time the event is executed. In SBML Level 3, the attribute is mandatory, not optional, and all events must specify a value for it. Returns the value of the attribute 'useValuesFromTriggerTime' as a boolean. WARNING: The attribute 'useValuesFromTriggerTime' was introduced in SBML Level 2 Version 4. It is not valid in models defined using SBML Level 2 versions prior to Version 4. If a Level 2 Version 1-3 model sets the attribute, the consistency-checking method SBMLDocument.checkConsistency() will report an error. """ return _libsbml.Event_getUseValuesFromTriggerTime(self) def isSetId(self): """ isSetId(Event self) -> bool Predicate returning 'True' if this Event's 'id' attribute is set. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Returns 'True' if the 'id' attribute of this SBML object is set, 'False' otherwise. Note: Because of the inconsistent behavior of this function with respect to assignments and rules, it is recommended that callers use isSetIdAttribute() instead. See also getIdAttribute(), setIdAttribute(), unsetIdAttribute(), isSetIdAttribute(). """ return _libsbml.Event_isSetId(self) def isSetName(self): """ isSetName(Event self) -> bool Predicate returning 'True' if this Event's 'name' attribute is set. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns 'True' if the 'name' attribute of this SBML object is set, 'False' otherwise. See also getName(), setName(), unsetName(). """ return _libsbml.Event_isSetName(self) def isSetTrigger(self): """ isSetTrigger(Event self) -> bool Predicate for testing whether the trigger for this Event is set. Returns 'True' if the trigger of this Event is set, 'False' otherwise. """ return _libsbml.Event_isSetTrigger(self) def isSetDelay(self): """ isSetDelay(Event self) -> bool Predicate for testing whether the delay for this Event is set. Returns 'True' if the delay of this Event is set, 'False' otherwise. """ return _libsbml.Event_isSetDelay(self) def isSetPriority(self): """ isSetPriority(Event self) -> bool (SBML Level 3 only) Predicate for testing whether the priority for this Event is set. Returns 'True' if the priority of this Event is set, 'False' otherwise. Note: The element 'priority' is available in SBML Level 3, but is not present in lower Levels of SBML. """ return _libsbml.Event_isSetPriority(self) def isSetTimeUnits(self): """ isSetTimeUnits(Event self) -> bool Predicate for testing whether the 'timeUnits' attribute of this Event is set. Returns 'True' if the 'timeUnits' attribute of this Event is set, 'False' otherwise. WARNING: Definitions of Event in SBML Level 2 Versions 1 and 2 included the additional attribute called 'timeUnits', but it was removed in SBML Level 2 Version 3. LibSBML supports this attribute for compatibility with previous versions of SBML Level 2, but its use is discouraged since models in Level 2 Versions 3 and 4 cannot contain it. If a Version 3 or 4 model sets the attribute, the consistency-checking method SBMLDocument.checkConsistency() will report an error. """ return _libsbml.Event_isSetTimeUnits(self) def isSetUseValuesFromTriggerTime(self): """ isSetUseValuesFromTriggerTime(Event self) -> bool Predicate for testing whether the 'useValuesFromTriggerTime' attribute of this Event is set. Returns 'True' if the 'useValuesFromTriggerTime' attribute of this Event is set, 'False' otherwise. Note: In SBML Level 2, this attribute is optional and has a default value of 'True,' whereas in Level 3, this optional is mandatory and has no default value. """ return _libsbml.Event_isSetUseValuesFromTriggerTime(self) def setId(self, sid): """ setId(Event self, string sid) -> int Sets the value of the 'id' attribute of this Event. The string 'sid' is copied. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Parameter 'sid' is the string to use as the identifier of this object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE * LIBSBML_UNEXPECTED_ATTRIBUTE See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(). """ return _libsbml.Event_setId(self, sid) def setName(self, name): """ setName(Event self, string name) -> int Sets the value of the 'name' attribute of this Event. The string in 'name' is copied. Parameter 'name' is the new name for the SBML object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.Event_setName(self, name) def setTrigger(self, trigger): """ setTrigger(Event self, Trigger trigger) -> int Sets the trigger definition of this Event to a copy of the given Trigger object instance. Parameter 'trigger' is the Trigger object instance to use. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_LEVEL_MISMATCH * LIBSBML_VERSION_MISMATCH """ return _libsbml.Event_setTrigger(self, trigger) def setDelay(self, delay): """ setDelay(Event self, Delay delay) -> int Sets the delay definition of this Event to a copy of the given Delay object instance. Parameter 'delay' is the Delay object instance to use. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_LEVEL_MISMATCH * LIBSBML_VERSION_MISMATCH """ return _libsbml.Event_setDelay(self, delay) def setPriority(self, priority): """ setPriority(Event self, Priority priority) -> int (SBML Level 3 only) Sets the priority definition of this Event to a copy of the given Priority object instance. Parameter 'priority' is the Priority object instance to use. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_LEVEL_MISMATCH * LIBSBML_VERSION_MISMATCH * LIBSBML_UNEXPECTED_ATTRIBUTE Note: The element 'priority' is available in SBML Level 3, but is not present in lower Levels of SBML. """ return _libsbml.Event_setPriority(self, priority) def setTimeUnits(self, sid): """ setTimeUnits(Event self, string sid) -> int Sets the 'timeUnits' attribute of this Event to a copy of 'sid'. Parameter 'sid' is the identifier of the time units to use. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE * LIBSBML_UNEXPECTED_ATTRIBUTE WARNING: Definitions of Event in SBML Level 2 Versions 1 and 2 included the additional attribute called 'timeUnits', but it was removed in SBML Level 2 Version 3. LibSBML supports this attribute for compatibility with previous versions of SBML Level 2, but its use is discouraged since models in Level 2 Versions 3 and 4 cannot contain it. If a Version 3 or 4 model sets the attribute, the consistency-checking method SBMLDocument.checkConsistency() will report an error. """ return _libsbml.Event_setTimeUnits(self, sid) def setUseValuesFromTriggerTime(self, value): """ setUseValuesFromTriggerTime(Event self, bool value) -> int Sets the 'useValuesFromTriggerTime' attribute of this Event to a 'value'. The optional Delay on Event and the fact that multiple events may be simultaneously executed means there are two times to consider when computing the results of an event: the time at which the event is triggered, and the time at which assignments are executed. It is also possible to distinguish between the time at which the EventAssignment's expression is calculated, and the time at which the assignment is made: the expression could be evaluated at the same time the assignments are performed, i.e., when the event is executed, but it could also be defined to be evaluated at the time the event is triggered. In SBML Level 2 versions prior to Version 4, the semantics of Event time delays were defined such that the expressions in the event's assignments were always evaluated at the time the event was triggered. This definition made it difficult to define an event whose assignment formulas were meant to be evaluated at the time the event was executed (i.e., after the time period defined by the value of the Delay element, or after any other simultaneous event may have been executed and changed the model state). In SBML Level 2 Version 4, the attribute 'useValuesFromTriggerTime' on Event allows a model to indicate the time at which the event's assignments are intended to be evaluated. In SBML Level 2, the attribute has a default value of 'True,' which corresponds to the interpretation of event assignments prior to Version 4: the values of the assignment formulas are computed at the moment the event is triggered, not after the delay. If 'useValuesFromTriggerTime'='False,' it means that the formulas in the event's assignments are to be computed after the delay, at the time the event is executed. In SBML Level 3, the attribute is mandatory, not optional, and all events must specify a value for it. Parameter 'value' is the value of useValuesFromTriggerTime to use. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE WARNING: The attribute 'useValuesFromTriggerTime' was introduced in SBML Level 2 Version 4. It is not valid in models defined using SBML Level 2 versions prior to Version 4. If a Level 2 Version 1-3 model sets the attribute, the consistency-checking method SBMLDocument.checkConsistency() will report an error. """ return _libsbml.Event_setUseValuesFromTriggerTime(self, value) def unsetId(self): """ unsetId(Event self) -> int Unsets the value of the 'id' attribute of this Event. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The characters ( and ) are used for grouping, the character * 'zero or more times', and the character | indicates logical 'or'. The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Users need to be aware of some important API issues that are the result of the history of SBML and libSBML. Prior to SBML Level 3 Version 2, SBML defined 'id' and 'name' attributes on only a subset of SBML objects. To simplify the work of programmers, libSBML's API provided get, set, check, and unset on the SBase object class itself instead of on individual subobject classes. This made the get/set/etc. methods uniformly available on all objects in the libSBML API. LibSBML simply returned empty strings or otherwise did not act when the methods were applied to SBML objects that were not defined by the SBML specification to have 'id' or 'name' attributes. Additional complications arose with the rule and assignment objects: InitialAssignment, EventAssignment, AssignmentRule, and RateRule. In early versions of SBML, the rule object hierarchy was different, and in addition, then as now, they possess different attributes: 'variable' (for the rules and event assignments), 'symbol' (for initial assignments), or neither (for algebraic rules). Prior to SBML Level 3 Version 2, getId() would always return an empty string, and isSetId() would always return 'False' for objects of these classes. With the addition of 'id' and 'name' attributes on SBase in Level 3 Version 2, it became necessary to introduce a new way to interact with the attributes more consistently in libSBML to avoid breaking backward compatibility in the behavior of the original 'id' methods. For this reason, libSBML provides four functions (getIdAttribute(), setIdAttribute(), isSetIdAttribute(), and unsetIdAttribute()) that always act on the actual 'id' attribute inherited from SBase, regardless of the object's type. These new methods should be used instead of the older getId()/setId()/etc. methods unless the old behavior is somehow necessary. Regardless of the Level and Version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have identifiers). If the object in question does not posess an 'id' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the identifier to be set, nor will it read or write 'id' attributes for those objects. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(). """ return _libsbml.Event_unsetId(self) def unsetName(self): """ unsetName(Event self) -> int Unsets the value of the 'name' attribute of this Event. In SBML Level 3 Version 2, the 'id' and 'name' attributes were moved to SBase directly, instead of being defined individually for many (but not all) objects. LibSBML has for a long time provided functions defined on SBase itself to get, set, and unset those attributes, which would fail or otherwise return empty strings if executed on any object for which those attributes were not defined. Now that all SBase objects define those attributes, those functions now succeed for any object with the appropriate level and version. The 'name' attribute is optional and is not intended to be used for cross-referencing purposes within a model. Its purpose instead is to provide a human-readable label for the component. The data type of 'name' is the type string defined in XML Schema. SBML imposes no restrictions as to the content of 'name' attributes beyond those restrictions defined by the string type in XML Schema. The recommended practice for handling 'name' is as follows. If a software tool has the capability for displaying the content of 'name' attributes, it should display this content to the user as a component's label instead of the component's 'id'. If the user interface does not have this capability (e.g., because it cannot display or use special characters in symbol names), or if the 'name' attribute is missing on a given component, then the user interface should display the value of the 'id' attribute instead. (Script language interpreters are especially likely to display 'id' instead of 'name'.) As a consequence of the above, authors of systems that automatically generate the values of 'id' attributes should be aware some systems may display the 'id''s to the user. Authors therefore may wish to take some care to have their software create 'id' values that are: (a) reasonably easy for humans to type and read; and (b) likely to be meaningful, for example by making the 'id' attribute be an abbreviated form of the name attribute value. An additional point worth mentioning is although there are restrictions on the uniqueness of 'id' values, there are no restrictions on the uniqueness of 'name' values in a model. This allows software applications leeway in assigning component identifiers. Regardless of the level and version of the SBML, these functions allow client applications to use more generalized code in some situations (for instance, when manipulating objects that are all known to have names). If the object in question does not posess a 'name' attribute according to the SBML specification for the Level and Version in use, libSBML will not allow the name to be set, nor will it read or write 'name' attributes for those objects. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also getName(), setName(), isSetName(). """ return _libsbml.Event_unsetName(self) def unsetUseValuesFromTriggerTime(self): """ unsetUseValuesFromTriggerTime(Event self) -> int Unsets the value of the 'useValuesFromTriggerTime' attribute of this Event. The optional Delay on Event and the fact that multiple events may be simultaneously executed means there are two times to consider when computing the results of an event: the time at which the event is triggered, and the time at which assignments are executed. It is also possible to distinguish between the time at which the EventAssignment's expression is calculated, and the time at which the assignment is made: the expression could be evaluated at the same time the assignments are performed, i.e., when the event is executed, but it could also be defined to be evaluated at the time the event is triggered. In SBML Level 2 versions prior to Version 4, the semantics of Event time delays were defined such that the expressions in the event's assignments were always evaluated at the time the event was triggered. This definition made it difficult to define an event whose assignment formulas were meant to be evaluated at the time the event was executed (i.e., after the time period defined by the value of the Delay element, or after any other simultaneous event may have been executed and changed the model state). In SBML Level 2 Version 4, the attribute 'useValuesFromTriggerTime' on Event allows a model to indicate the time at which the event's assignments are intended to be evaluated. In SBML Level 2, the attribute has a default value of 'True,' which corresponds to the interpretation of event assignments prior to Version 4: the values of the assignment formulas are computed at the moment the event is triggered, not after the delay. If 'useValuesFromTriggerTime'='False,' it means that the formulas in the event's assignments are to be computed after the delay, at the time the event is executed. In SBML Level 3, the attribute is mandatory, not optional, and all events must specify a value for it. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED WARNING: The attribute 'useValuesFromTriggerTime' was introduced in SBML Level 2 Version 4. It is not valid in models defined using SBML Level 2 versions prior to Version 4. If a Level 2 Version 1-3 model sets the attribute, the consistency-checking method SBMLDocument.checkConsistency() will report an error. """ return _libsbml.Event_unsetUseValuesFromTriggerTime(self) def unsetDelay(self): """ unsetDelay(Event self) -> int Unsets the Delay of this Event. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.Event_unsetDelay(self) def unsetPriority(self): """ unsetPriority(Event self) -> int (SBML Level 3 only) Unsets the Priority of this Event. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED Note: The element 'priority' is available in SBML Level 3, but is not present in lower Levels of SBML. """ return _libsbml.Event_unsetPriority(self) def unsetTrigger(self): """ unsetTrigger(Event self) -> int Unsets the Trigger of this Event. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED Note: The element 'priority' is available in SBML Level 3, but is not present in lower Levels of SBML. """ return _libsbml.Event_unsetTrigger(self) def unsetTimeUnits(self): """ unsetTimeUnits(Event self) -> int Unsets the 'timeUnits' attribute of this Event. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE * LIBSBML_OPERATION_FAILED WARNING: Definitions of Event in SBML Level 2 Versions 1 and 2 included the additional attribute called 'timeUnits', but it was removed in SBML Level 2 Version 3. LibSBML supports this attribute for compatibility with previous versions of SBML Level 2, but its use is discouraged since models in Level 2 Versions 3 and 4 cannot contain it. If a Version 3 or 4 model sets the attribute, the consistency-checking method SBMLDocument.checkConsistency() will report an error. """ return _libsbml.Event_unsetTimeUnits(self) def addEventAssignment(self, ea): """ addEventAssignment(Event self, EventAssignment ea) -> int Appends a copy of the given EventAssignment to this Event. Parameter 'ea' is the EventAssignment object to add. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_LEVEL_MISMATCH * LIBSBML_VERSION_MISMATCH * LIBSBML_DUPLICATE_OBJECT_ID * LIBSBML_OPERATION_FAILED Note: This method should be used with some caution. The fact that this method copies the object passed to it means that the caller will be left holding a physically different object instance than the one contained inside this object. Changes made to the original object instance (such as resetting attribute values) will not affect the instance in this object. In addition, the caller should make sure to free the original object if it is no longer being used, or else a memory leak will result. Please see other methods on this class (particularly a corresponding method whose name begins with the word create) for alternatives that do not lead to these issues. See also createEventAssignment(). """ return _libsbml.Event_addEventAssignment(self, ea) def createEventAssignment(self): """ createEventAssignment(Event self) -> EventAssignment Creates a new, empty EventAssignment, adds it to this Event's list of event assignments and returns the EventAssignment. Returns the newly created EventAssignment object instance. See also addEventAssignment(). """ return _libsbml.Event_createEventAssignment(self) def createTrigger(self): """ createTrigger(Event self) -> Trigger Creates a new, empty Trigger, adds it to this Event and returns the Trigger. Returns the newly created Trigger object instance. """ return _libsbml.Event_createTrigger(self) def createDelay(self): """ createDelay(Event self) -> Delay Creates a new, empty Delay, adds it to this Event and returns the Delay. Returns the newly created Delay object instance. """ return _libsbml.Event_createDelay(self) def createPriority(self): """ createPriority(Event self) -> Priority (SBML Level 3 only) Creates a new, empty Priority, adds it to this Event and returns the Priority. Returns the newly created Priority object instance, or 'None' if the SBML level and version used for this Event does not define Priority children. Note: The element 'priority' is available in SBML Level 3, but is not present in lower Levels of SBML. """ return _libsbml.Event_createPriority(self) def getListOfEventAssignments(self, *args): """ getListOfEventAssignments(Event self) -> ListOfEventAssignments getListOfEventAssignments(Event self) -> ListOfEventAssignments Returns the list of event assignments for this Event. Returns the list of EventAssignments for this Event. """ return _libsbml.Event_getListOfEventAssignments(self, *args) def getEventAssignment(self, *args): """ getEventAssignment(Event self, unsigned int n) -> EventAssignment getEventAssignment(Event self, unsigned int n) -> EventAssignment getEventAssignment(Event self, string variable) -> EventAssignment getEventAssignment(Event self, string variable) -> EventAssignment This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getEventAssignment(string variable) Return the event assignment indicated by the given 'variable'. Parameter 'variable' is a string, the identifier of the variable whose EventAssignment is being sought. Returns the EventAssignment for the given 'variable', or 'None' if no such EventAssignment exists. ______________________________________________________________________ Method variant with the following signature: getEventAssignment(long n) Return a specific EventAssignment object of this Event. Parameter 'n' is an integer, the index of the EventAssignment object to return. Returns the nth EventAssignment of this Event. """ return _libsbml.Event_getEventAssignment(self, *args) def getNumEventAssignments(self): """ getNumEventAssignments(Event self) -> unsigned int Returns the number of EventAssignment objects attached to this Event. Returns the number of EventAssignments in this Event. """ return _libsbml.Event_getNumEventAssignments(self) def removeEventAssignment(self, *args): """ removeEventAssignment(Event self, unsigned int n) -> EventAssignment removeEventAssignment(Event self, string variable) -> EventAssignment This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: removeEventAssignment(string variable) Removes the EventAssignment object with the given 'variable' attribute from this Event object and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. If none of the EventAssignment objects in this Event object have the 'variable' attribute 'variable', then 'None' is returned. Parameter 'variable' is the 'variable' attribute of the EventAssignment object to remove. Returns the EventAssignment object removed. As mentioned above, the caller owns the returned object. 'None' is returned if no EventAssignment object with the 'variable' attribute exists in this Event object. ______________________________________________________________________ Method variant with the following signature: removeEventAssignment(long n) Removes the nth EventAssignment object from this Event object and returns a pointer to it. The caller owns the returned object and is responsible for deleting it. Parameter 'n' is the index of the EventAssignment object to remove. Returns the EventAssignment object removed. As mentioned above, the caller owns the returned item. 'None' is returned if the given index is out of range. """ return _libsbml.Event_removeEventAssignment(self, *args) def connectToChild(self): """connectToChild(Event self)""" return _libsbml.Event_connectToChild(self) def enablePackageInternal(self, pkgURI, pkgPrefix, flag): """ enablePackageInternal(Event self, string pkgURI, string pkgPrefix, bool flag) Internal implementation method. """ return _libsbml.Event_enablePackageInternal(self, pkgURI, pkgPrefix, flag) def updateSBMLNamespace(self, package, level, version): """ updateSBMLNamespace(Event self, string package, unsigned int level, unsigned int version) Internal implementation method. """ return _libsbml.Event_updateSBMLNamespace(self, package, level, version) def getTypeCode(self): """ getTypeCode(Event self) -> int Returns the libSBML type code of this object instance. LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for this object: SBML_EVENT (default). WARNING: The specific integer values of the possible type codes may be reused by different libSBML plug-ins for SBML Level 3. packages, To fully identify the correct code, it is necessary to invoke both getPackageName() and getTypeCode() (or ListOf.getItemTypeCode()). See also getElementName(), getPackageName(). """ return _libsbml.Event_getTypeCode(self) def getElementName(self): """ getElementName(Event self) -> string Returns the XML element name of this object, which for Event, is always ''event'.' Returns the name of this element, i.e., ''event'.' """ return _libsbml.Event_getElementName(self) def hasRequiredAttributes(self): """ hasRequiredAttributes(Event self) -> bool Predicate returning 'True' if all the required attributes for this Event object have been set. The required attributes for an Event object are: * 'useValuesfromTriggerTime' (required in SBML Level 3) Returns 'True' if the required attributes have been set, 'False' otherwise. """ return _libsbml.Event_hasRequiredAttributes(self) def hasRequiredElements(self): """ hasRequiredElements(Event self) -> bool Predicate returning 'True' if all the required elements for this Event object have been set. Note: The required elements for an Event object are: * 'trigger' (required in SBML Level 2 and Level 3 Version 1; optional in SBML Level 3 Version 2+ * 'listOfEventAssignments' (required in SBML Level 2; optional in Level 3) """ return _libsbml.Event_hasRequiredElements(self) Event_swigregister = _libsbml.Event_swigregister Event_swigregister(Event) class ListOfEvents(ListOf): """ A list of Event objects. The various ListOf___ classes in SBML are merely containers used for organizing the main components of an SBML model. In libSBML's implementation, ListOf___ classes are derived from the intermediate utility class ListOf, which is not defined by the SBML specifications but serves as a useful programmatic construct. ListOf is itself is in turn derived from SBase, which provides all of the various ListOf___ classes with common features defined by the SBML specification, such as 'metaid' attributes and annotations. The relationship between the lists and the rest of an SBML model is illustrated by the following (for SBML Level 2 Version 4): ... ... ... ... ... ... ... elements of subclasses of Rule ... ... ... ... SBML Level 3 Version 1 has essentially the same structure as Level 2 Version 4, depicted above, but SBML Level 3 Version 2 allows containers to contain zero or more of the relevant object, instead of requiring at least one. As such, libsbml will write out an otherwise-empty ListOf___ element that has any optional attribute set (such as 'id' or 'metaid'), that has an optional child (such as a 'notes' or 'annotation'), or that has attributes or children set from any SBML Level 3 package, whether or not the ListOf___ has any other children. Readers may wonder about the motivations for using the ListOf___ containers in SBML. A simpler approach in XML might be to place the components all directly at the top level of the model definition. The choice made in SBML is to group them within XML elements named after ListOfClassname, in part because it helps organize the components. More importantly, the fact that the container classes are derived from SBase means that software tools can add information about the lists themselves into each list container's 'annotation'. See also ListOfFunctionDefinitions, ListOfUnitDefinitions, ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments, ListOfSpecies, ListOfParameters, ListOfInitialAssignments, ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents. """ __swig_setmethods__ = {} for _s in [ListOf]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfEvents, name, value) __swig_getmethods__ = {} for _s in [ListOf]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, ListOfEvents, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(ListOfEvents self, unsigned int level, unsigned int version) -> ListOfEvents __init__(ListOfEvents self, SBMLNamespaces sbmlns) -> ListOfEvents This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: ListOfEvents(SBMLNamespaces sbmlns) Creates a new ListOfEvents object. The object is constructed such that it is valid for the SBML Level and Version combination determined by the SBMLNamespaces object in 'sbmlns'. Parameter 'sbmlns' is an SBMLNamespaces object that is used to determine the characteristics of the ListOfEvents object to be created. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: ListOfEvents(long level, long version) Creates a new ListOfEvents object. The object is constructed such that it is valid for the given SBML Level and Version combination. Parameter 'level' is the SBML Level. Parameter 'version' is the Version within the SBML Level. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. """ this = _libsbml.new_ListOfEvents(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(ListOfEvents self) -> ListOfEvents Creates and returns a deep copy of this ListOfEvents object. Returns the (deep) copy of this ListOfEvents object. """ return _libsbml.ListOfEvents_clone(self) def getItemTypeCode(self): """ getItemTypeCode(ListOfEvents self) -> int Returns the libSBML type code for the objects contained in this ListOf (i.e., Event objects, if the list is non-empty). LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for the objects contained in this ListOf: SBML_EVENT (default). See also getElementName(), getPackageName(). """ return _libsbml.ListOfEvents_getItemTypeCode(self) def getElementName(self): """ getElementName(ListOfEvents self) -> string Returns the XML element name of this object. For ListOfEvents, the XML element name is ''listOfEvents'.' Returns the name of this element, i.e., ''listOfEvents'.' """ return _libsbml.ListOfEvents_getElementName(self) def get(self, *args): """ get(ListOfEvents self, unsigned int n) -> Event get(ListOfEvents self, unsigned int n) -> Event get(ListOfEvents self, string sid) -> Event get(ListOfEvents self, string sid) -> Event This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: get(long n) Get an Event from the ListOfEvents. Parameter 'n' is the index number of the Event to get. Returns the nth Event in this ListOfEvents. See also size(). ______________________________________________________________________ Method variant with the following signature: get(string sid) Get an Event from the ListOfEvents based on its identifier. Parameter 'sid' is a string representing the identifier of the Event to get. Returns Event in this ListOfEvents with the given 'sid' or 'None' if no such Event exists. See also get(), size(). """ return _libsbml.ListOfEvents_get(self, *args) def remove(self, *args): """ remove(ListOfEvents self, unsigned int n) -> Event remove(ListOfEvents self, string sid) -> Event This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: remove(long n) Removes the nth item from this ListOfEvents items and returns a pointer to it. The caller owns the returned item and is responsible for deleting it. Parameter 'n' is the index of the item to remove. See also size(). ______________________________________________________________________ Method variant with the following signature: remove(string sid) Removes item in this ListOfEvents items with the given identifier. The caller owns the returned item and is responsible for deleting it. If none of the items in this list have the identifier 'sid', then 'None' is returned. Parameter 'sid' is the identifier of the item to remove. Returns the item removed. As mentioned above, the caller owns the returned item. """ return _libsbml.ListOfEvents_remove(self, *args) __swig_destroy__ = _libsbml.delete_ListOfEvents __del__ = lambda self: None ListOfEvents_swigregister = _libsbml.ListOfEvents_swigregister ListOfEvents_swigregister(ListOfEvents) class EventAssignment(SBase): """ An assignment to a variable by an SBML event. Event contains an optional element called 'listOfEventAssignments', of class ListOfEventAssignments. In every instance of an event definition in a model, the object's 'listOfEventAssignments' element must have a non-empty list of one or more 'eventAssignment' elements of class EventAssignment. The object class EventAssignment has one required attribute, 'variable', and a required element, 'math'. Being derived from SBase, it also has all the usual attributes and elements of its parent class. An Event object defines when the event can occur, the variables that are affected by the event, and how the variables are affected. The purpose of the EventAssignment object class is to define how variables are affected by an Event. In SBML Level 2, every Event object instance must have a nonempty list of event assignments; in SBML Level 3, the list of assignments is optional. The operation of an Event is divided into two phases (regardless of whether a delay is involved): one phase when the event is triggered, and the other when the event is executed. EventAssignment objects are interpreted when an event is executed. The effects are described below. The attribute 'variable' ====================================================================== The EventAssignment attribute 'variable' must be the identifier of an existing Compartment, Species, SpeciesReference, or Parameter instance defined in the model. In SBML Level 3 Version 2, this list was expanded to include identifiers of SBML Level 3 package variables that have both mathematical meaning and the ability to be assigned. When the event is executed, the value of the model component identified by 'variable' is changed by the EventAssignment to the value computed by the 'math' element; that is, a species' quantity, species reference's stoichiometry, compartment's size or parameter's value are reset to the value computed by 'math'. Certain restrictions are placed on what can appear in 'variable': * The object identified by the value of the EventAssignment attribute 'variable' must not have its 'constant' attribute set to or default to 'True.' (Constants cannot be affected by events.) * The 'variable' attribute must not contain the identifier of a reaction. In SBML Level 2 and SBML Level 3 Version 1, only species, species references, compartment and parameter values may be set by an Event. In SBML Level 3 Version 2, the 'variable' attribute may also be the identifier of an SBML Level 3 package element with mathematical meaning and the ability to be assigned a value. This situation may only arise if the SBML package is present in the SBML document with a package:required attribute of 'True' * The value of every 'variable' attribute must be unique among the set of EventAssignment structures within a given Event structure. In other words, a single event cannot have multiple EventAssignment objects assigning the same variable. (All of them would be performed at the same time when that particular Event triggers, resulting in indeterminacy.) However, separate Event instances can refer to the same variable. * A variable cannot be assigned a value in an EventAssignment object instance and also be assigned a value by an AssignmentRule; i.e., the value of an EventAssignment's 'variable' attribute cannot be the same as the value of a AssignmentRule' 'variable' attribute. (Assignment rules hold at all times, therefore it would be inconsistent to also define an event that reassigns the value of the same variable.) If the variable attribute of an EventAssignment object references an object in an SBML namespace that is not understood by the interpreter reading a given SBML document (that is, if the object is defined by an SBML Level 3 package that the software does not support), the event assignment must be ignored--the object's value will not need to be set, as the interpreter could not understand that package. If an interpreter cannot establish whether a referenced object is missing from the model or instead is defined in an SBML namespace not understood by the interpreter, it may produce a warning to the user. (The latter situation may only arise if an SBML package is present in the SBML document with a package:required attribute of 'true'.) Note that the time of assignment of the object identified by the value of the 'variable' attribute is always the time at which the Event is executed, not when it is triggered. The timing is controlled by the optional Delay in an Event. The time of assignment is not affected by the 'useValuesFromTriggerTime' attribute on Event---that attribute affects the time at which the EventAssignment's 'math' expression is evaluated. In other words, SBML allows decoupling the time at which the 'variable' is assigned from the time at which its value expression is calculated. The 'math' subelement in an EventAssignment ====================================================================== The MathML expression contained in an EventAssignment defines the new value of the variable being assigned by the Event. As mentioned above, the time at which the expression in 'math' is evaluated is determined by the attribute 'useValuesFromTriggerTime' on Event. If the attribute value is 'True,' the expression must be evaluated when the event is triggered; more precisely, the values of identifiers occurring in MathML elements in the EventAssignment's 'math' expression are the values they have at the point when the event triggered. If, instead, 'useValuesFromTriggerTime''s value is 'False,' it means the values at execution time should be used; that is, the values of identifiers occurring in MathML elements in the EventAssignment's 'math' expression are the values they have at the point when the event executed. SBML Level/Version differences ====================================================================== Between Version 4 and previous versions of SBML Level 2, the requirements regarding the matching of units between an EvengAssignment's formula and the units of the object identified by the 'variable' attribute changed. Previous versions required consistency, but in SBML Level 2 Version 4 and in SBML Level 3, unit consistency is only recommended. More precisely: * In the case of a species, an EventAssignment sets the referenced species' quantity (concentration or amount of substance) to the value determined by the formula in the EventAssignment's 'math' subelement. The units of the 'math' formula should (in SBML Level 2 Version 4 and in Level 3) or must (in previous Versions of Level 2) be identical to the units of the species. * (SBML Level 3 only.) In the case of a species reference, an EventAssignment sets the stoichiometry of the reactant or product referenced by the SpeciesReference object to the value determined by the formula in the 'math' element. The unit associated with the value produced by the 'math' formula should be 'dimensionless,' because reactant and product stoichiometries in reactions are dimensionless quantities. * In the case of a compartment, an EventAssignment sets the referenced compartment's size to the size determined by the formula in the 'math' subelement of the EventAssignment. The overall units of the formula should (in SBML Level 2 Version 4 and in Level 3) or must (in previous Versions of Level 2) be identical to the units specified for the size of the compartment identified by the EventAssignment's 'variable' attribute. * In the case of a parameter, an EventAssignment sets the referenced parameter's value to that determined by the formula in 'math'. The overall units of the formula should (in SBML Level 2 Version 4 and Level 3) or must (in previous Versions of Level 2) be identical to the units defined for the parameter. * (For SBML Level 3 Version 2 only) In the case of an object from an SBML Level 3 package, an EventAssignment sets the referenced object's value (as defined by that package) to the value of the formula in 'math'. The unit of measurement associated with the value produced by the formula should be the same as that object's units attribute value (if it has such an attribute), or be equal to the units of model components of that type (if objects of that class are defined by the package as having the same units). Note that the formula placed in the 'math' element has no assumed units. The consistency of the units of the formula, and the units of the entity which the assignment affects, must be explicitly established just as in the case of the value of the Delay subelement. An approach similar to the one discussed in the context of Delay may be used for the formula of an EventAssignment. Restrictions relaxed in SBML Level 3 Version 2 ====================================================================== In SBML Level 3 Version 2, the requirement that an EventAssignment have a 'math' subelement was relaxed, making it optional. In this case, the EventAssignment remains undefined, and unless that information is provided in some other form (such as with an SBML Level 3 package), the Event behaves as if it had no EventAssignment. See also Event. """ __swig_setmethods__ = {} for _s in [SBase]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, EventAssignment, name, value) __swig_getmethods__ = {} for _s in [SBase]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, EventAssignment, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_EventAssignment __del__ = lambda self: None def __init__(self, *args): """ __init__(EventAssignment self, unsigned int level, unsigned int version) -> EventAssignment __init__(EventAssignment self, SBMLNamespaces sbmlns) -> EventAssignment __init__(EventAssignment self, EventAssignment orig) -> EventAssignment This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: EventAssignment(SBMLNamespaces sbmlns) Creates a new EventAssignment using the given SBMLNamespaces object 'sbmlns'. The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments. Parameter 'sbmlns' is an SBMLNamespaces object. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: EventAssignment(long level, long version) Creates a new EventAssignment using the given SBML 'level' and 'version' values. Parameter 'level' is a long integer, the SBML Level to assign to this EventAssignment. Parameter 'version' is a long integer, the SBML Version to assign to this EventAssignment. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: EventAssignment(EventAssignment orig) Copy constructor; creates a copy of this EventAssignment. Parameter 'orig' is the object to copy. """ this = _libsbml.new_EventAssignment(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(EventAssignment self) -> EventAssignment Creates and returns a deep copy of this EventAssignment object. Returns the (deep) copy of this EventAssignment object. """ return _libsbml.EventAssignment_clone(self) def getVariable(self): """ getVariable(EventAssignment self) -> string Get the value of this EventAssignment's 'variable' attribute. Returns the identifier stored in the 'variable' attribute of this EventAssignment. """ return _libsbml.EventAssignment_getVariable(self) def getMath(self): """ getMath(EventAssignment self) -> ASTNode Get the mathematical expression in this EventAssignment's 'math' subelement. Returns the top ASTNode of an abstract syntax tree representing the mathematical formula in this EventAssignment, or 'None' if the math is not set. """ return _libsbml.EventAssignment_getMath(self) def isSetVariable(self): """ isSetVariable(EventAssignment self) -> bool Predicate for testing whether the attribute 'variable' of this EventAssignment is set. Returns 'True' if the 'variable' attribute of this EventAssignment is set, 'False' otherwise. """ return _libsbml.EventAssignment_isSetVariable(self) def isSetMath(self): """ isSetMath(EventAssignment self) -> bool Predicate for testing whether the 'math' subelement of this EventAssignment is set. Returns 'True' if this EventAssignment has a 'math' subelement, 'False' otherwise. """ return _libsbml.EventAssignment_isSetMath(self) def setVariable(self, sid): """ setVariable(EventAssignment self, string sid) -> int Sets the attribute 'variable' of this EventAssignment to a copy of the given identifier string. Parameter 'sid' is the identifier of an element defined in this model that can vary over time. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.EventAssignment_setVariable(self, sid) def unsetVariable(self): """ unsetVariable(EventAssignment self) -> int Unsets the attribute 'variable' of this EventAssignment. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.EventAssignment_unsetVariable(self) def setMath(self, math): """ setMath(EventAssignment self, ASTNode math) -> int Sets the 'math' subelement of this EventAssignment to a copy of the given ASTNode. Parameter 'math' is an ASTNode that will be copied and stored as the mathematical formula for this EventAssignment. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT """ return _libsbml.EventAssignment_setMath(self, math) def getDerivedUnitDefinition(self, *args): """ getDerivedUnitDefinition(EventAssignment self) -> UnitDefinition getDerivedUnitDefinition(EventAssignment self) -> UnitDefinition Calculates and returns a UnitDefinition that expresses the units of measurement assumed for the 'math' expression of this EventAssignment. The units are calculated based on the mathematical expression in the EventAssignment and the model quantities referenced by elements used within that expression. The method getDerivedUnitDefinition() returns the calculated units, to the extent that libSBML can compute them. Note: The functionality that facilitates unit analysis depends on the model as a whole. Thus, in cases where the object has not been added to a model or the model itself is incomplete, unit analysis is not possible and this method will return 'None.' WARNING: Note that it is possible the 'math' expression in the EventAssignment contains literal numbers or parameters with undeclared units. In those cases, it is not possible to calculate the units of the overall expression without making assumptions. LibSBML does not make assumptions about the units, and getDerivedUnitDefinition() only returns the units as far as it is able to determine them. For example, in an expression X + Y, if X has unambiguously-defined units and Y does not, it will return the units of X. When using this method, it is critical that callers also invoke the method containsUndeclaredUnits() to determine whether this situation holds. Callers should take suitable action in those situations. Returns a UnitDefinition that expresses the units of the math expression of this EventAssignment, or 'None' if one cannot be constructed. See also containsUndeclaredUnits(). """ return _libsbml.EventAssignment_getDerivedUnitDefinition(self, *args) def containsUndeclaredUnits(self, *args): """ containsUndeclaredUnits(EventAssignment self) -> bool containsUndeclaredUnits(EventAssignment self) -> bool Predicate returning 'True' if the math expression of this EventAssignment contains literal numbers or parameters with undeclared units. The units are calculated based on the mathematical expression in the EventAssignment and the model quantities referenced by elements used within that expression. The method getDerivedUnitDefinition() returns the calculated units, to the extent that libSBML can compute them. If the expression contains literal numbers or parameters with undeclared units, libSBML may not be able to compute the full units of the expression and will only return what it can compute. Callers should always use containsUndeclaredUnits() when using getDerivedUnitDefinition() to decide whether the returned units may be incomplete. Returns 'True' if the math expression of this EventAssignment includes parameters/numbers with undeclared units, 'False' otherwise. Note: A return value of 'True' indicates that the UnitDefinition returned by getDerivedUnitDefinition() may not accurately represent the units of the expression. See also getDerivedUnitDefinition(). """ return _libsbml.EventAssignment_containsUndeclaredUnits(self, *args) def getTypeCode(self): """ getTypeCode(EventAssignment self) -> int Returns the libSBML type code of this object instance. LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for this object: SBML_EVENT_ASSIGNMENT (default). WARNING: The specific integer values of the possible type codes may be reused by different libSBML plug-ins for SBML Level 3. packages, To fully identify the correct code, it is necessary to invoke both getPackageName() and getTypeCode() (or ListOf.getItemTypeCode()). See also getElementName(), getPackageName(). """ return _libsbml.EventAssignment_getTypeCode(self) def getElementName(self): """ getElementName(EventAssignment self) -> string Returns the XML element name of this object, which for EventAssignment, is always ''eventAssignment'.' Returns the name of this element, i.e., ''eventAssignment'.' """ return _libsbml.EventAssignment_getElementName(self) def hasRequiredAttributes(self): """ hasRequiredAttributes(EventAssignment self) -> bool Predicate returning 'True' if all the required attributes for this EventAssignment object have been set. The required attributes for a EventAssignment object are: * 'variable' Returns 'True' if the required attributes have been set, 'False' otherwise. """ return _libsbml.EventAssignment_hasRequiredAttributes(self) def hasRequiredElements(self): """ hasRequiredElements(EventAssignment self) -> bool Predicate returning 'True' if all the required elements for this EventAssignment object have been set. Note: The required elements for an EventAssignment object are: * 'math' in SBML Level 2 and Level 3 Version 1. (In SBML Level 3 Version 2+, it is no longer required.) Returns a boolean value indicating whether all the required elements for this object have been defined. """ return _libsbml.EventAssignment_hasRequiredElements(self) def getId(self): """ getId(EventAssignment self) -> string Returns the value of the 'variable' attribute of this EventAssignment (NOT the 'id'). Note: Because of the inconsistent behavior of this function with respect to assignments and rules, it is now recommended to use the getIdAttribute() or getVariable() instead. The 'variable' attribute of an EventAssignment indicates the element which the results of the 'math' are to be applied upon Event execution. Returns the variable of this EventAssignment. See also getIdAttribute(), setIdAttribute(), isSetIdAttribute(), unsetIdAttribute(), getVariable(). """ return _libsbml.EventAssignment_getId(self) def renameSIdRefs(self, oldid, newid): """ renameSIdRefs(EventAssignment self, string oldid, string newid) Replaces all uses of a given 'SIdRef' type attribute value with another value. In SBML, object identifiers are of a data type called SId. In SBML Level 3, an explicit data type called SIdRef was introduced for attribute values that refer to SId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to an identifier', but the effective data type was the same as SIdRef in Level 3. These and other methods of libSBML refer to the type SIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all attributes and (if appropriate) mathematical formulas in MathML content, comparing the referenced identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.EventAssignment_renameSIdRefs(self, oldid, newid) def renameUnitSIdRefs(self, oldid, newid): """ renameUnitSIdRefs(EventAssignment self, string oldid, string newid) Replaces all uses of a given 'UnitSIdRef' type attribute value with another value. In SBML, unit definitions have identifiers of type UnitSId. In SBML Level 3, an explicit data type called UnitSIdRef was introduced for attribute values that refer to UnitSId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to a unit identifier', but the effective data type was the same as UnitSIdRef in Level 3. These and other methods of libSBML refer to the type UnitSIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all unit identifier attribute values (including, if appropriate, inside mathematical formulas), comparing the referenced unit identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.EventAssignment_renameUnitSIdRefs(self, oldid, newid) def replaceSIDWithFunction(self, id, function): """ replaceSIDWithFunction(EventAssignment self, string id, ASTNode function) Internal implementation method. """ return _libsbml.EventAssignment_replaceSIDWithFunction(self, id, function) def divideAssignmentsToSIdByFunction(self, id, function): """ divideAssignmentsToSIdByFunction(EventAssignment self, string id, ASTNode function) Internal implementation method. """ return _libsbml.EventAssignment_divideAssignmentsToSIdByFunction(self, id, function) def multiplyAssignmentsToSIdByFunction(self, id, function): """ multiplyAssignmentsToSIdByFunction(EventAssignment self, string id, ASTNode function) Internal implementation method. """ return _libsbml.EventAssignment_multiplyAssignmentsToSIdByFunction(self, id, function) EventAssignment_swigregister = _libsbml.EventAssignment_swigregister EventAssignment_swigregister(EventAssignment) class ListOfEventAssignments(ListOf): """ A list of EventAssignment objects. The various ListOf___ classes in SBML are merely containers used for organizing the main components of an SBML model. In libSBML's implementation, ListOf___ classes are derived from the intermediate utility class ListOf, which is not defined by the SBML specifications but serves as a useful programmatic construct. ListOf is itself is in turn derived from SBase, which provides all of the various ListOf___ classes with common features defined by the SBML specification, such as 'metaid' attributes and annotations. The relationship between the lists and the rest of an SBML model is illustrated by the following (for SBML Level 2 Version 4): ... ... ... ... ... ... ... elements of subclasses of Rule ... ... ... ... SBML Level 3 Version 1 has essentially the same structure as Level 2 Version 4, depicted above, but SBML Level 3 Version 2 allows containers to contain zero or more of the relevant object, instead of requiring at least one. As such, libsbml will write out an otherwise-empty ListOf___ element that has any optional attribute set (such as 'id' or 'metaid'), that has an optional child (such as a 'notes' or 'annotation'), or that has attributes or children set from any SBML Level 3 package, whether or not the ListOf___ has any other children. Readers may wonder about the motivations for using the ListOf___ containers in SBML. A simpler approach in XML might be to place the components all directly at the top level of the model definition. The choice made in SBML is to group them within XML elements named after ListOfClassname, in part because it helps organize the components. More importantly, the fact that the container classes are derived from SBase means that software tools can add information about the lists themselves into each list container's 'annotation'. See also ListOfFunctionDefinitions, ListOfUnitDefinitions, ListOfCompartmentTypes, ListOfSpeciesTypes, ListOfCompartments, ListOfSpecies, ListOfParameters, ListOfInitialAssignments, ListOfRules, ListOfConstraints, ListOfReactions, ListOfEvents. """ __swig_setmethods__ = {} for _s in [ListOf]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, ListOfEventAssignments, name, value) __swig_getmethods__ = {} for _s in [ListOf]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, ListOfEventAssignments, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(ListOfEventAssignments self, unsigned int level, unsigned int version) -> ListOfEventAssignments __init__(ListOfEventAssignments self, SBMLNamespaces sbmlns) -> ListOfEventAssignments This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: ListOfEventAssignments(SBMLNamespaces sbmlns) Creates a new ListOfEventAssignments object. The object is constructed such that it is valid for the SBML Level and Version combination determined by the SBMLNamespaces object in 'sbmlns'. Parameter 'sbmlns' is an SBMLNamespaces object that is used to determine the characteristics of the ListOfEventAssignments object to be created. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: ListOfEventAssignments(long level, long version) Creates a new ListOfEventAssignments object. The object is constructed such that it is valid for the given SBML Level and Version combination. Parameter 'level' is the SBML Level. Parameter 'version' is the Version within the SBML Level. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. """ this = _libsbml.new_ListOfEventAssignments(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(ListOfEventAssignments self) -> ListOfEventAssignments Creates and returns a deep copy of this ListOfEventAssignments object. Returns the (deep) copy of this ListOfEventAssignments object. """ return _libsbml.ListOfEventAssignments_clone(self) def getItemTypeCode(self): """ getItemTypeCode(ListOfEventAssignments self) -> int Returns the libSBML type code for the objects contained in this ListOf (i.e., EventAssignment objects, if the list is non-empty). LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for the objects contained in this ListOf: SBML_EVENT_ASSIGNMENT (default). See also getElementName(), getPackageName(). """ return _libsbml.ListOfEventAssignments_getItemTypeCode(self) def getElementName(self): """ getElementName(ListOfEventAssignments self) -> string Returns the XML element name of this object. For ListOfEventAssignments, the XML element name is ''listOfEventAssignments'.' Returns the name of this element, i.e., ''listOfEventAssignments'.' """ return _libsbml.ListOfEventAssignments_getElementName(self) def get(self, *args): """ get(ListOfEventAssignments self, unsigned int n) -> EventAssignment get(ListOfEventAssignments self, unsigned int n) -> EventAssignment get(ListOfEventAssignments self, string sid) -> EventAssignment get(ListOfEventAssignments self, string sid) -> EventAssignment This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: get(long n) Get a EventAssignment from the ListOfEventAssignments. Parameter 'n' is the index number of the EventAssignment to get. Returns the nth EventAssignment in this ListOfEventAssignments. If the index 'n' is invalid, 'None' is returned. See also size(). ______________________________________________________________________ Method variant with the following signature: get(string sid) Get a EventAssignment from the ListOfEventAssignments based on its identifier. Parameter 'sid' is a string representing the identifier of the EventAssignment to get. Returns EventAssignment in this ListOfEventAssignments with the given 'sid' or 'None' if no such EventAssignment exists. See also get(), size(). """ return _libsbml.ListOfEventAssignments_get(self, *args) def remove(self, *args): """ remove(ListOfEventAssignments self, unsigned int n) -> EventAssignment remove(ListOfEventAssignments self, string sid) -> EventAssignment This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: remove(long n) Removes the nth item from this ListOfEventAssignments items and returns a pointer to it. The caller owns the returned item and is responsible for deleting it. Parameter 'n' is the index of the item to remove. See also size(). ______________________________________________________________________ Method variant with the following signature: remove(string sid) Removes item in this ListOfEventAssignments items with the given identifier. The caller owns the returned item and is responsible for deleting it. If none of the items in this list have the identifier 'sid', then 'None' is returned. Parameter 'sid' is the identifier of the item to remove. Returns the item removed. As mentioned above, the caller owns the returned item. """ return _libsbml.ListOfEventAssignments_remove(self, *args) def getElementBySId(self, id): """ getElementBySId(ListOfEventAssignments self, string id) -> SBase Returns the first child element found that has the given 'id' in the model-wide SId namespace, or 'None' if no such object is found. Note that EventAssignments do not actually have IDs, but the libsbml interface pretends that they do: no event assignment is returned by this function. Parameter 'id' is string representing the id of the object to find. Returns pointer to the first element found with the given 'id'. """ return _libsbml.ListOfEventAssignments_getElementBySId(self, id) __swig_destroy__ = _libsbml.delete_ListOfEventAssignments __del__ = lambda self: None ListOfEventAssignments_swigregister = _libsbml.ListOfEventAssignments_swigregister ListOfEventAssignments_swigregister(ListOfEventAssignments) class Trigger(SBase): """ The trigger expression for an SBML event. An Event object defines when the event can occur, the variables that are affected by the event, and how the variables are affected. The Trigger construct in SBML is used to define a mathematical expression that determines when an Event is triggered. A Trigger object in SBML Level 2 and Level 3 contains one subelement named 'math' containing a MathML expression. The expression is evaluated as a value of type 'boolean.' The exact moment at which the expression evaluates to 'True' is the time point when the Event is triggered. In SBML Level 3, Trigger has additional attributes that must be assigned values; they are discussed in a separate section below. In SBML Level 2 and SBML Level 3 Version 1, the 'math' subelement is required, and it must evaluate to a 'boolean' expression. In SBML Level 3 Version 2, those restrictions are relaxed: the 'math' element is optional, and numeric values are allowed in Boolean contexts (a '0' is interpreted as 'False,' and all other values are interpreted as 'True).' If a Trigger with no 'math' is present in an Event, that Event will never trigger, unless that missing information is included in an SBML Level 3 package. An event only triggers when its Trigger expression makes the transition in value from 'False' to 'True.' The event will also trigger at any subsequent time points when the trigger makes this transition; in other words, an event can be triggered multiple times during a simulation if its trigger condition makes the transition from 'False' to 'True' more than once. In SBML Level 3, the behavior at the very start of simulation (i.e., at t = 0, where t stands for time) is determined in part by the boolean flag 'initialValue'. This and other additional features introduced in SBML Level 3 are discussed further below. Version differences ====================================================================== SBML Level 3 Version 1 introduces two required attributes on the Trigger object: 'persistent' and 'initialValue'. The rest of this introduction describes these two attributes. The 'persistent' attribute on Trigger ...................................................................... In the interval between when an Event object triggers (i.e., its Trigger object expression transitions in value from 'False' to 'True)' and when its assignments are to be executed, conditions in the model may change such that the trigger expression transitions back from 'True' to 'False.' Should the event's assignments still be made if this happens? Answering this question is the purpose of the 'persistent' attribute on Trigger. If the boolean attribute 'persistent' has a value of 'True,' then once the event is triggered, all of its assignments are always performed when the time of execution is reached. The name persistent is meant to evoke the idea that the trigger expression does not have to be re- checked after it triggers if 'persistent'='True.' Conversely, if the attribute value is 'False,' then the trigger expression is not assumed to persist: if the expression transitions in value back to 'False' at any time between when the event triggered and when it is to be executed, the event is no longer considered to have triggered and its assignments are not executed. (If the trigger expression transitions once more to 'True' after that point, then the event is triggered, but this then constitutes a whole new event trigger-and-execute sequence.) The 'persistent' attribute can be especially useful when Event objects contain Delay objects, but it is relevant even in a model without delays if the model contains two or more events. As explained in the introduction to this section, the operation of all events in SBML (delayed or not) is conceptually divided into two phases, triggering and execution; however, unless events have priorities associated with them, SBML does not mandate a particular ordering of event execution in the case of simultaneous events. Models with multiple events can lead to situations where the execution of one event affects another event's trigger expression value. If that other event has 'persistent'='False,' and its trigger expression evaluates to 'False' before it is to be executed, the event must not be executed after all. The 'initialValue' attribute on Trigger ...................................................................... As mentioned above, an event triggers when the mathematical expression in its Trigger object transitions in value from 'False' to 'True.' An unanswered question concerns what happens at the start of a simulation: can event triggers make this transition at t = 0, where t stands for time? In order to determine whether an event may trigger at t = 0, it is necessary to know what value the Trigger object's 'math' expression had immediately prior to t = 0. This starting value of the trigger expression is determined by the value of the boolean attribute 'initialValue'. A value of 'True' means the trigger expression is taken to have the value 'True' immediately prior to t = 0. In that case, the trigger cannot transition in value from 'False' to 'True' at the moment simulation begins (because it has the value 'True' both before and after t = 0), and can only make the transition from 'False' to 'True' sometime after t = 0. (To do that, it would also first have to transition to 'False' before it could make the transition from 'False' back to 'True.)' Conversely, if 'initialValue'='False,' then the trigger expression is assumed to start with the value 'False,' and therefore may trigger at t = 0 if the expression evaluates to 'True' at that moment. See also Event, Delay, EventAssignment. """ __swig_setmethods__ = {} for _s in [SBase]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, Trigger, name, value) __swig_getmethods__ = {} for _s in [SBase]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, Trigger, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_Trigger __del__ = lambda self: None def __init__(self, *args): """ __init__(Trigger self, unsigned int level, unsigned int version) -> Trigger __init__(Trigger self, SBMLNamespaces sbmlns) -> Trigger __init__(Trigger self, Trigger orig) -> Trigger This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: Trigger(SBMLNamespaces sbmlns) Creates a new Trigger using the given SBMLNamespaces object 'sbmlns'. The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments. Parameter 'sbmlns' is an SBMLNamespaces object. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: Trigger(long level, long version) Creates a new Trigger using the given SBML 'level' and 'version' values. Parameter 'level' is a long integer, the SBML Level to assign to this Trigger. Parameter 'version' is a long integer, the SBML Version to assign to this Trigger. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: Trigger(Trigger orig) Copy constructor; creates a copy of this Trigger. Parameter 'orig' is the object to copy. """ this = _libsbml.new_Trigger(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(Trigger self) -> Trigger Creates and returns a deep copy of this Trigger object. Returns the (deep) copy of this Trigger object. """ return _libsbml.Trigger_clone(self) def getMath(self): """ getMath(Trigger self) -> ASTNode Get the mathematical formula for the trigger and return it as an AST. Returns the math of this Trigger, or 'None' if the math is not set. """ return _libsbml.Trigger_getMath(self) def getInitialValue(self): """ getInitialValue(Trigger self) -> bool (SBML Level 3 only) Get the value of the 'initialValue' attribute of this Trigger. Returns the boolean value stored as the 'initialValue' attribute value in this Trigger. Note: The attribute 'initialValue' is available in SBML Level 3, but is not present in lower Levels of SBML. """ return _libsbml.Trigger_getInitialValue(self) def getPersistent(self): """ getPersistent(Trigger self) -> bool (SBML Level 3 only) Get the value of the 'persistent' attribute of this Trigger. Returns the boolean value stored as the 'persistent' attribute value in this Trigger. Note: The attribute 'persistent' is available in SBML Level 3, but is not present in lower Levels of SBML. """ return _libsbml.Trigger_getPersistent(self) def isSetMath(self): """ isSetMath(Trigger self) -> bool Predicate to test whether the math for this trigger is set. Returns 'True' if the formula (meaning the 'math' subelement) of this Trigger is set, 'False' otherwise. """ return _libsbml.Trigger_isSetMath(self) def isSetInitialValue(self): """ isSetInitialValue(Trigger self) -> bool (SBML Level 3 only) Predicate to test whether the 'initialValue' attribute for this trigger is set. Returns 'True' if the initialValue attribute of this Trigger is set, 'False' otherwise. Note: The attribute 'initialValue' is available in SBML Level 3, but is not present in lower Levels of SBML. """ return _libsbml.Trigger_isSetInitialValue(self) def isSetPersistent(self): """ isSetPersistent(Trigger self) -> bool (SBML Level 3 only) Predicate to test whether the 'persistent' attribute for this trigger is set. Returns 'True' if the persistent attribute of this Trigger is set, 'False' otherwise. Note: The attribute 'persistent' is available in SBML Level 3, but is not present in lower Levels of SBML. """ return _libsbml.Trigger_isSetPersistent(self) def setMath(self, math): """ setMath(Trigger self, ASTNode math) -> int Sets the trigger expression of this Trigger instance to a copy of the given ASTNode. Parameter 'math' is an ASTNode representing a formula tree. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT """ return _libsbml.Trigger_setMath(self, math) def setInitialValue(self, initialValue): """ setInitialValue(Trigger self, bool initialValue) -> int (SBML Level 3 only) Sets the 'initialValue' attribute of this Trigger instance. Parameter 'initialValue' is a boolean representing the initialValue to be set. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE Note: The attribute 'initialValue' is available in SBML Level 3, but is not present in lower Levels of SBML. """ return _libsbml.Trigger_setInitialValue(self, initialValue) def setPersistent(self, persistent): """ setPersistent(Trigger self, bool persistent) -> int (SBML Level 3 only) Sets the 'persistent' attribute of this Trigger instance. Parameter 'persistent' is a boolean representing the persistent value to be set. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE Note: The attribute 'persistent' is available in SBML Level 3, but is not present in lower Levels of SBML. """ return _libsbml.Trigger_setPersistent(self, persistent) def unsetInitialValue(self): """ unsetInitialValue(Trigger self) -> int (SBML Level 3 only) Unsets the 'initialValue' attribute of this Trigger instance. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE Note: The attribute 'initialValue' is available in SBML Level 3, but is not present in lower Levels of SBML. """ return _libsbml.Trigger_unsetInitialValue(self) def unsetPersistent(self): """ unsetPersistent(Trigger self) -> int (SBML Level 3 only) Unsets the 'persistent' attribute of this Trigger instance. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE Note: The attribute 'persistent' is available in SBML Level 3, but is not present in lower Levels of SBML. """ return _libsbml.Trigger_unsetPersistent(self) def getTypeCode(self): """ getTypeCode(Trigger self) -> int Returns the libSBML type code of this object instance. LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for this object: SBML_TRIGGER (default). WARNING: The specific integer values of the possible type codes may be reused by different libSBML plug-ins for SBML Level 3. packages, To fully identify the correct code, it is necessary to invoke both getPackageName() and getTypeCode() (or ListOf.getItemTypeCode()). See also getElementName(), getPackageName(). """ return _libsbml.Trigger_getTypeCode(self) def getElementName(self): """ getElementName(Trigger self) -> string Returns the XML element name of this object, which for Trigger, is always ''trigger'.' Returns the name of this element, i.e., ''trigger'.' """ return _libsbml.Trigger_getElementName(self) def renameSIdRefs(self, oldid, newid): """ renameSIdRefs(Trigger self, string oldid, string newid) Replaces all uses of a given 'SIdRef' type attribute value with another value. In SBML, object identifiers are of a data type called SId. In SBML Level 3, an explicit data type called SIdRef was introduced for attribute values that refer to SId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to an identifier', but the effective data type was the same as SIdRef in Level 3. These and other methods of libSBML refer to the type SIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all attributes and (if appropriate) mathematical formulas in MathML content, comparing the referenced identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.Trigger_renameSIdRefs(self, oldid, newid) def renameUnitSIdRefs(self, oldid, newid): """ renameUnitSIdRefs(Trigger self, string oldid, string newid) Replaces all uses of a given 'UnitSIdRef' type attribute value with another value. In SBML, unit definitions have identifiers of type UnitSId. In SBML Level 3, an explicit data type called UnitSIdRef was introduced for attribute values that refer to UnitSId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to a unit identifier', but the effective data type was the same as UnitSIdRef in Level 3. These and other methods of libSBML refer to the type UnitSIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all unit identifier attribute values (including, if appropriate, inside mathematical formulas), comparing the referenced unit identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.Trigger_renameUnitSIdRefs(self, oldid, newid) def replaceSIDWithFunction(self, id, function): """ replaceSIDWithFunction(Trigger self, string id, ASTNode function) Internal implementation method. """ return _libsbml.Trigger_replaceSIDWithFunction(self, id, function) def hasRequiredElements(self): """ hasRequiredElements(Trigger self) -> bool Predicate returning 'True' if all the required elements for this Trigger object have been set. Note: The required elements for a Trigger object are: * 'math' inSBML Level 2 and Level 3 Version 1. (In SBML Level 3 Version 2+, it is no longer required.) Returns a boolean value indicating whether all the required elements for this object have been defined. """ return _libsbml.Trigger_hasRequiredElements(self) def hasRequiredAttributes(self): """ hasRequiredAttributes(Trigger self) -> bool Predicate returning 'True' if all the required attributes for this Trigger object have been set. The required attributes for a Trigger object are: * 'persistent' (required in SBML Level 3) * 'initialValue' (required in SBML Level 3) Returns a boolean value indicating whether all the required attributes for this object have been defined. """ return _libsbml.Trigger_hasRequiredAttributes(self) def removeFromParentAndDelete(self): """ removeFromParentAndDelete(Trigger self) -> int Finds this Trigger's Event parent and calls unsetTrigger() on it, indirectly deleting itself. Overridden from the SBase function since the parent is not a ListOf. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.Trigger_removeFromParentAndDelete(self) Trigger_swigregister = _libsbml.Trigger_swigregister Trigger_swigregister(Trigger) class Delay(SBase): """ A delay on the time of execution of an SBML event. An Event object defines when the event can occur, the variables that are affected by the event, and how the variables are affected. The effect of the event can optionally be delayed after the occurrence of the condition which invokes it. An event delay is defined using an object of class Delay. The object class Delay is derived from SBase and adds a single subelement called 'math'. This subelement is used to hold MathML content. The mathematical formula represented by 'math' must evaluate to a numerical value. It is used as the length of time between when the event is triggered and when the event's assignments are actually executed. If no delay is present on a given Event, a time delay of zero is assumed. The expression in 'math' must be evaluated at the time the event is triggered. The expression must always evaluate to a nonnegative number (otherwise, a nonsensical situation could arise where an event is defined to execute before it is triggered!). The units of the mathematical expression in a Delay ====================================================================== In SBML Level 2 versions before Version 4, the units of the numerical value computed by the Delay's 'math' expression are required to be in units of time, or the model is considered to have a unit consistency error. In Level 2 Version 4 as well as SBML Level 3, this requirement is relaxed; these specifications only stipulate that the units of the numerical value computed by a Delay instance's 'math' expression should match the model's units of time (meaning the definition of the 'time' units in the model). LibSBML respects these requirements, and depending on whether an earlier Version of SBML Level 2 is in use, libSBML may or may not flag unit inconsistencies as errors or merely warnings. Note that units are not predefined or assumed for the contents of 'math' in a Delay object; rather, they must be defined explicitly for each instance of a Delay object in a model. This is an important point to bear in mind when literal numbers are used in delay expressions. For example, the following Event instance would result in a warning logged by SBMLDocument.checkConsistency() about the fact that libSBML cannot verify the consistency of the units of the expression. The reason is that the formula inside the 'math' element does not have any declared units, whereas what is expected in this context is units of time: ... ... 1 ... ... The 1 within the mathematical formula of the 'delay' above has no units declared. To make the expression have the needed units of time, literal numbers should be avoided in favor of defining Parameter objects for each quantity, and declaring units for the Parameter values. The following fragment of SBML illustrates this approach: ... ... ... transcriptionDelay ... ... In SBML Level 3, an alternative approach is available in the form of the 'units' attribute, which SBML Level 3 allows to appear on MathML 'cn' elements. The value of this attribute can be used to indicate the unit of measurement to be associated with the number in the content of a 'cn' element. The attribute is named 'units' but, because it appears inside MathML element (which is in the XML namespace for MathML and not the namespace for SBML), it must always be prefixed with an XML namespace prefix for an SBML Level 3 namespace. The following is an example of this approach: ... ... 10 ... ... Restrictions relaxed in SBML Level 3 Version 2 ====================================================================== In SBML Level 3 Version 2, the requirement that a Delay have a 'math' subelement was relaxed, making it optional. In this case, the Delay remains undefined, and unless that information is provided in some other form (such as with an SBML Level 3 package), the Event behaves as if it had no Delay. """ __swig_setmethods__ = {} for _s in [SBase]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, Delay, name, value) __swig_getmethods__ = {} for _s in [SBase]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, Delay, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_Delay __del__ = lambda self: None def __init__(self, *args): """ __init__(Delay self, unsigned int level, unsigned int version) -> Delay __init__(Delay self, SBMLNamespaces sbmlns) -> Delay __init__(Delay self, Delay orig) -> Delay This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: Delay(SBMLNamespaces sbmlns) Creates a new Delay using the given SBMLNamespaces object 'sbmlns'. The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments. Parameter 'sbmlns' is an SBMLNamespaces object. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: Delay(long level, long version) Creates a new Delay using the given SBML 'level' and 'version' values. Parameter 'level' is a long integer, the SBML Level to assign to this Delay. Parameter 'version' is a long integer, the SBML Version to assign to this Delay. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: Delay(Delay orig) Copy constructor; creates a copy of this Delay. Parameter 'orig' is the object to copy. """ this = _libsbml.new_Delay(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(Delay self) -> Delay Creates and returns a deep copy of this Delay object. Returns the (deep) copy of this Delay object. """ return _libsbml.Delay_clone(self) def getMath(self): """ getMath(Delay self) -> ASTNode Get the mathematical formula for the delay and return it as an AST. Returns the math of this Delay, or 'None' if the math is not set. """ return _libsbml.Delay_getMath(self) def isSetMath(self): """ isSetMath(Delay self) -> bool Predicate to test whether the formula for this delay is set. Returns 'True' if the formula (meaning the 'math' subelement) of this Delay is set, 'False' otherwise. """ return _libsbml.Delay_isSetMath(self) def setMath(self, math): """ setMath(Delay self, ASTNode math) -> int Sets the delay expression of this Delay instance to a copy of the given ASTNode. Parameter 'math' is an ASTNode representing a formula tree. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT """ return _libsbml.Delay_setMath(self, math) def getDerivedUnitDefinition(self, *args): """ getDerivedUnitDefinition(Delay self) -> UnitDefinition getDerivedUnitDefinition(Delay self) -> UnitDefinition Calculates and returns a UnitDefinition that expresses the units of measurement assumed for the 'math' expression of this Delay. Delay elements in SBML express a time delay for an Event. Beginning with SBML Level 2 Version 2, the units of that time are calculated based on the mathematical expression and the model quantities referenced by elements used within that expression. (In SBML Level 2 Version 1, there exists an attribute on Event called 'timeUnits'. This attribute can be used to set the units of the Delay expression explicitly.) The method Delay.getDerivedUnitDefinition() returns what libSBML computes the units to be, to the extent that libSBML can compute them. Note: The functionality that facilitates unit analysis depends on the model as a whole. Thus, in cases where the object has not been added to a model or the model itself is incomplete, unit analysis is not possible and this method will return 'None.' WARNING: Note that it is possible the 'math' expression in the Delay contains literal numbers or parameters with undeclared units. In those cases, it is not possible to calculate the units of the overall expression without making assumptions. LibSBML does not make assumptions about the units, and Delay.getDerivedUnitDefinition() only returns the units as far as it is able to determine them. For example, in an expression X + Y, if X has unambiguously-defined units and Y does not, it will return the units of X. When using this method, it is critical that callers also invoke the method Delay.containsUndeclaredUnits() to determine whether this situation holds. Callers should take suitable action in those situations. Returns a UnitDefinition that expresses the units of the math expression of this Delay, or 'None' if one cannot be constructed. See also containsUndeclaredUnits(). """ return _libsbml.Delay_getDerivedUnitDefinition(self, *args) def containsUndeclaredUnits(self, *args): """ containsUndeclaredUnits(Delay self) -> bool containsUndeclaredUnits(Delay self) -> bool Predicate returning 'True' if the 'math' expression in this Delay instance contains parameters with undeclared units or literal numbers. Delay elements in SBML express a time delay for an Event. Beginning with SBML Level 2 Version 2, the units of that time are calculated based on the mathematical expression and the model quantities referenced by elements used within that expression. (In SBML Level 2 Version 1, there exists an attribute on Event called 'timeUnits'. This attribute can be used to set the units of the Delay expression explicitly.) The method Delay.getDerivedUnitDefinition() returns what libSBML computes the units to be, to the extent that libSBML can compute them. If the expression contains literal numbers or parameters with undeclared units, libSBML may not be able to compute the full units of the expression and will only return what it can compute. Callers should always use Delay.containsUndeclaredUnits() when using Delay.getDerivedUnitDefinition() to decide whether the returned units may be incomplete. Returns 'True' if the math expression of this Delay includes numbers/parameters with undeclared units, 'False' otherwise. Note: A return value of 'True' indicates that the UnitDefinition returned by Delay.getDerivedUnitDefinition() may not accurately represent the units of the expression. See also getDerivedUnitDefinition(). """ return _libsbml.Delay_containsUndeclaredUnits(self, *args) def getTypeCode(self): """ getTypeCode(Delay self) -> int Returns the libSBML type code of this object instance. LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for this object: SBML_DELAY (default). WARNING: The specific integer values of the possible type codes may be reused by different libSBML plug-ins for SBML Level 3. packages, To fully identify the correct code, it is necessary to invoke both getPackageName() and getTypeCode() (or ListOf.getItemTypeCode()). See also getElementName(), getPackageName(). """ return _libsbml.Delay_getTypeCode(self) def getElementName(self): """ getElementName(Delay self) -> string Returns the XML element name of this object, which for Delay, is always ''delay'.' Returns the name of this element, i.e., ''delay'.' See also getTypeCode(). """ return _libsbml.Delay_getElementName(self) def hasRequiredElements(self): """ hasRequiredElements(Delay self) -> bool Predicate returning 'True' if all the required elements for this Delay object have been set. Note: The required elements for a Delay object are: * 'math' inSBML Level 2 and Level 3 Version 1. (In SBML Level 3 Version 2+, it is no longer required.) Returns a boolean value indicating whether all the required elements for this object have been defined. """ return _libsbml.Delay_hasRequiredElements(self) def removeFromParentAndDelete(self): """ removeFromParentAndDelete(Delay self) -> int Finds this Delay's Event parent and calls unsetDelay() on it, indirectly deleting itself. Overridden from the SBase function since the parent is not a ListOf. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.Delay_removeFromParentAndDelete(self) def renameSIdRefs(self, oldid, newid): """ renameSIdRefs(Delay self, string oldid, string newid) Replaces all uses of a given 'SIdRef' type attribute value with another value. In SBML, object identifiers are of a data type called SId. In SBML Level 3, an explicit data type called SIdRef was introduced for attribute values that refer to SId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to an identifier', but the effective data type was the same as SIdRef in Level 3. These and other methods of libSBML refer to the type SIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all attributes and (if appropriate) mathematical formulas in MathML content, comparing the referenced identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.Delay_renameSIdRefs(self, oldid, newid) def renameUnitSIdRefs(self, oldid, newid): """ renameUnitSIdRefs(Delay self, string oldid, string newid) Replaces all uses of a given 'UnitSIdRef' type attribute value with another value. In SBML, unit definitions have identifiers of type UnitSId. In SBML Level 3, an explicit data type called UnitSIdRef was introduced for attribute values that refer to UnitSId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to a unit identifier', but the effective data type was the same as UnitSIdRef in Level 3. These and other methods of libSBML refer to the type UnitSIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all unit identifier attribute values (including, if appropriate, inside mathematical formulas), comparing the referenced unit identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.Delay_renameUnitSIdRefs(self, oldid, newid) def replaceSIDWithFunction(self, id, function): """ replaceSIDWithFunction(Delay self, string id, ASTNode function) Internal implementation method. """ return _libsbml.Delay_replaceSIDWithFunction(self, id, function) Delay_swigregister = _libsbml.Delay_swigregister Delay_swigregister(Delay) class Priority(SBase): """ The priority of execution of an SBML event. The Priority object class (which was introduced in SBML Level 3 Version 1), like Delay, is derived from SBase and contains a MathML formula stored in the element 'math'. This formula is used to compute a dimensionless numerical value that influences the order in which a simulator is to perform the assignments of two or more events that happen to be executed simultaneously. The formula may evaluate to any 'float' value (and thus may be a positive or negative number, or zero), with positive numbers taken to signifying a higher priority than zero or negative numbers. If no Priority object is present on a given Event object, no priority is defined for that event. The interpretation of priorities on events in a model ====================================================================== For the purposes of SBML, simultaneous event execution is defined as the situation in which multiple events have identical times of execution. The time of execution is calculated as the sum of the time at which a given event's Trigger is triggered plus its Delay duration, if any. Here, identical times means mathematically equal instants in time. (In practice, simulation software adhering to this specification may have to rely on numerical equality instead of strict mathematical equality; robust models will ensure that this difference will not cause significant discrepancies from expected behavior.) If no Priority subobjects are defined for two or more Event objects, then those events are still executed simultaneously but their order of execution is undefined by the SBML Level 3 specification. A software implementation may choose to execute such simultaneous events in any order, as long as each event is executed only once and the requirements of checking the 'persistent' attribute (and acting accordingly) are satisfied. If Priority subobjects are defined for two or more simultaneously- triggered events, the order in which those particular events must be executed is dictated by their Priority objects, as follows. If the values calculated using the two Priority objects' 'math' expressions differ, then the event having the higher priority value must be executed before the event with the lower value. If, instead, the two priority values are mathematically equal, then the two events must be triggered in a random order. It is important to note that a random order is not the same as an undefined order: given multiple runs of the same model with identical conditions, an undefined ordering would permit a system to execute the events in (for example) the same order every time (according to whatever scheme may have been implemented by the system), whereas the explicit requirement for random ordering means that the order of execution in different simulation runs depends on random chance. In other words, given two events A and B, a randomly-determined order must lead to an equal chance of executing A first or B first, every time those two events are executed simultaneously. A model may contain a mixture of events, some of which have Priority subobjects and some do not. Should a combination of simultaneous events arise in which some events have priorities defined and others do not, the set of events with defined priorities must trigger in the order determined by their Priority objects, and the set of events without Priority objects must be executed in an undefined order with respect to each other and with respect to the events with Priority subobjects. (Note that undefined order does not necessarily mean random order, although a random ordering would be a valid implementation of this requirement.) The following example may help further clarify these points. Suppose a model contains four events that should be executed simultaneously, with two of the events having Priority objects with the same value and the other two events having Priority objects with the same, but different, value. The two events with the higher priorities must be executed first, in a random order with respect to each other, and the remaining two events must be executed after them, again in a random order, for a total of four possible and equally-likely event executions: A-B-C-D, A-B-D-C, B-A-C-D, and B-A-D-C. If, instead, the model contains four events all having the same Priority values, there are 4! or 24 possible orderings, each of which must be equally likely to be chosen. Finally, if none of the four events has a Priority subobject defined, or even if exactly one of the four events has a defined Priority, there are again 24 possible orderings, but the likelihood of choosing any particular ordering is undefined; the simulator can choose between events as it wishes. (The SBML specification only defines the effects of priorities on Event objects with respect to other Event objects with priorities. Putting a priority on a single Event object in a model does not cause it to fall within that scope.) Evaluation of Priority expressions ====================================================================== An event's Priority object 'math' expression must be evaluated at the time the Event is to be executed. During a simulation, all simultaneous events have their Priority values calculated, and the event with the highest priority is selected for next execution. Note that it is possible for the execution of one Event object to cause the Priority value of another simultaneously-executing Event object to change (as well as to trigger other events, as already noted). Thus, after executing one event, and checking whether any other events in the model have been triggered, all remaining simultaneous events that either (i) have Trigger objects with attributes 'persistent'='False' or (ii) have Trigger expressions that did not transition from 'True' to 'False,' must have their Priority expression reevaluated. The highest-priority remaining event must then be selected for execution next. Units of Priority object's mathematical expressions ====================================================================== The unit associated with the value of a Priority object's 'math' expression should be 'dimensionless.' This is because the priority expression only serves to provide a relative ordering between different events, and only has meaning with respect to other Priority object expressions. The value of Priority objects is not comparable to any other kind of object in an SBML model. Note: The Priority construct exists only in SBML Level 3; it cannot be used in SBML Level 2 or Level 1 models. Restrictions relaxed in SBML Level 3 Version 2 ====================================================================== In SBML Level 3 Version 2, the requirement that a Priority have a 'math' subelement was relaxed, making it optional. In this case, the Priority remains undefined, and unless that information is provided in some other form (such as with an SBML Level 3 package), the Event behaves as if it had no Priority. See also Event, Delay, EventAssignment. """ __swig_setmethods__ = {} for _s in [SBase]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, Priority, name, value) __swig_getmethods__ = {} for _s in [SBase]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, Priority, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_Priority __del__ = lambda self: None def __init__(self, *args): """ __init__(Priority self, unsigned int level, unsigned int version) -> Priority __init__(Priority self, SBMLNamespaces sbmlns) -> Priority __init__(Priority self, Priority orig) -> Priority This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: Priority(SBMLNamespaces sbmlns) Creates a new Priority object using the given SBMLNamespaces object 'sbmlns'. The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments. Parameter 'sbmlns' is an SBMLNamespaces object. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. Note: The Priority construct exists only in SBML Level 3; it cannot be used in SBML Level 2 or Level 1 models. ______________________________________________________________________ Method variant with the following signature: Priority(long level, long version) Creates a new Priority object using the given SBML 'level' and 'version' values. Parameter 'level' is a long integer, the SBML Level to assign to this Priority. Parameter 'version' is a long integer, the SBML Version to assign to this Priority. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. Note: The Priority construct exists only in SBML Level 3; it cannot be used in SBML Level 2 or Level 1 models. ______________________________________________________________________ Method variant with the following signature: Priority(Priority orig) Copy constructor; creates a copy of this Priority. Parameter 'orig' is the object to copy. """ this = _libsbml.new_Priority(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(Priority self) -> Priority Creates and returns a deep copy of this Priority object. Returns the (deep) copy of this Priority object. """ return _libsbml.Priority_clone(self) def getMath(self): """ getMath(Priority self) -> ASTNode Get the mathematical formula for the priority and return it as an AST. Returns the math of this Priority, or 'None' if the math is not set. """ return _libsbml.Priority_getMath(self) def isSetMath(self): """ isSetMath(Priority self) -> bool Predicate to test whether the formula for this delay is set. Returns 'True' if the formula (meaning the 'math' subelement) of this Priority is set, 'False' otherwise. """ return _libsbml.Priority_isSetMath(self) def setMath(self, math): """ setMath(Priority self, ASTNode math) -> int Sets the math expression of this Priority instance to a copy of the given ASTNode. Parameter 'math' is an ASTNode representing a formula tree. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT """ return _libsbml.Priority_setMath(self, math) def getTypeCode(self): """ getTypeCode(Priority self) -> int Returns the libSBML type code of this object instance. LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for this object: SBML_PRIORITY (default). WARNING: The specific integer values of the possible type codes may be reused by different libSBML plug-ins for SBML Level 3. packages, To fully identify the correct code, it is necessary to invoke both getPackageName() and getTypeCode() (or ListOf.getItemTypeCode()). See also getElementName(), getPackageName(). """ return _libsbml.Priority_getTypeCode(self) def getElementName(self): """ getElementName(Priority self) -> string Returns the XML element name of this object, which for Priority, is always ''priority'.' Returns the name of this element, i.e., ''priority'.' See also getTypeCode(). """ return _libsbml.Priority_getElementName(self) def hasRequiredElements(self): """ hasRequiredElements(Priority self) -> bool Predicate returning 'True' if all the required elements for this Priority object have been set. Note: The required elements for a Priority object are: * 'math' inSBML Level 2 and Level 3 Version 1. (In SBML Level 3 Version 2+, it is no longer required.) Returns a boolean value indicating whether all the required elements for this object have been defined. """ return _libsbml.Priority_hasRequiredElements(self) def removeFromParentAndDelete(self): """ removeFromParentAndDelete(Priority self) -> int Finds this Priority's Event parent and calls unsetPriority() on it, indirectly deleting itself. Overridden from the SBase function since the parent is not a ListOf. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.Priority_removeFromParentAndDelete(self) def renameSIdRefs(self, oldid, newid): """ renameSIdRefs(Priority self, string oldid, string newid) Replaces all uses of a given 'SIdRef' type attribute value with another value. In SBML, object identifiers are of a data type called SId. In SBML Level 3, an explicit data type called SIdRef was introduced for attribute values that refer to SId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to an identifier', but the effective data type was the same as SIdRef in Level 3. These and other methods of libSBML refer to the type SIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all attributes and (if appropriate) mathematical formulas in MathML content, comparing the referenced identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.Priority_renameSIdRefs(self, oldid, newid) def renameUnitSIdRefs(self, oldid, newid): """ renameUnitSIdRefs(Priority self, string oldid, string newid) Replaces all uses of a given 'UnitSIdRef' type attribute value with another value. In SBML, unit definitions have identifiers of type UnitSId. In SBML Level 3, an explicit data type called UnitSIdRef was introduced for attribute values that refer to UnitSId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to a unit identifier', but the effective data type was the same as UnitSIdRef in Level 3. These and other methods of libSBML refer to the type UnitSIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all unit identifier attribute values (including, if appropriate, inside mathematical formulas), comparing the referenced unit identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.Priority_renameUnitSIdRefs(self, oldid, newid) def replaceSIDWithFunction(self, id, function): """ replaceSIDWithFunction(Priority self, string id, ASTNode function) Internal implementation method. """ return _libsbml.Priority_replaceSIDWithFunction(self, id, function) Priority_swigregister = _libsbml.Priority_swigregister Priority_swigregister(Priority) class SBO(_object): """ Facilities for using the Systems Biology Ontology. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. The values of 'id' attributes on SBML components allow the components to be cross-referenced within a model. The values of 'name' attributes on SBML components provide the opportunity to assign them meaningful labels suitable for display to humans. The specific identifiers and labels used in a model necessarily must be unrestricted by SBML, so that software and users are free to pick whatever they need. However, this freedom makes it more difficult for software tools to determine, without additional human intervention, the semantics of models more precisely than the semantics provided by the SBML object classes defined in other sections of this document. For example, there is nothing inherent in a parameter with identifier k that would indicate to a software tool it is a first-order rate constant (if that's what k happened to be in some given model). However, one may need to convert a model between different representations (e.g., Henri-Michaelis- Menten versus elementary steps), or to use it with different modeling approaches (discrete or continuous). One may also need to relate the model components with other description formats such as SBGN (http://www.sbgn.org/) using deeper semantics. Although an advanced software tool might be able to deduce the semantics of some model components through detailed analysis of the kinetic rate expressions and other parts of the model, this quickly becomes infeasible for any but the simplest of models. An approach to solving this problem is to associate model components with terms from carefully curated controlled vocabularies (CVs). This is the purpose of the optional 'sboTerm' attribute provided on the SBML class SBase. The 'sboTerm' attribute always refers to terms belonging to the Systems Biology Ontology (SBO). Use of SBO ====================================================================== Labeling model components with terms from shared controlled vocabularies allows a software tool to identify each component using identifiers that are not tool-specific. An example of where this is useful is the desire by many software developers to provide users with meaningful names for reaction rate equations. Software tools with editing interfaces frequently provide these names in menus or lists of choices for users. However, without a standardized set of names or identifiers shared between developers, a given software package cannot reliably interpret the names or identifiers of reactions used in models written by other tools. The first solution that might come to mind is to stipulate that certain common reactions always have the same name (e.g., 'Michaelis- Menten'), but this is simply impossible to do: not only do humans often disagree on the names themselves, but it would not allow for correction of errors or updates to the list of predefined names except by issuing new releases of the SBML specification---to say nothing of many other limitations with this approach. Moreover, the parameters and variables that appear in rate expressions also need to be identified in a way that software tools can interpret mechanically, implying that the names of these entities would also need to be regulated. The Systems Biology Ontology (SBO) provides terms for identifying most elements of SBML. The relationship implied by an 'sboTerm' on an SBML model component is is-a between the characteristic of the component meant to be described by SBO on this element and the SBO term identified by the value of the 'sboTerm'. By adding SBO term references on the components of a model, a software tool can provide additional details using independent, shared vocabularies that can enable other software tools to recognize precisely what the component is meant to be. Those tools can then act on that information. For example, if the SBO identifier ''SBO:0000049'' is assigned to the concept of 'first-order irreversible mass-action kinetics, continuous framework', and a given KineticLaw object in a model has an 'sboTerm' attribute with this value, then regardless of the identifier and name given to the reaction itself, a software tool could use this to inform users that the reaction is a first-order irreversible mass-action reaction. This kind of reverse engineering of the meaning of reactions in a model would be difficult to do otherwise, especially for more complex reaction types. The presence of SBO labels on Compartment, Species, and Reaction objects in SBML can help map those entities to equivalent concepts in other standards, such as (but not limited to) BioPAX (http://www.biopax.org/), PSI-MI (http://www.psidev.info), or the Systems Biology Graphical Notation (SBGN, http://www.sbgn.org/). Such mappings can be used in conversion procedures, or to build interfaces, with SBO becoming a kind of 'glue' between standards of representation. The presence of the label on a kinetic expression can also allow software tools to make more intelligent decisions about reaction rate expressions. For example, an application could recognize certain types of reaction formulas as being ones it knows how to solve with optimized procedures. The application could then use internal, optimized code implementing the rate formula indexed by identifiers such as ''SBO:0000049'' appearing in SBML models. Finally, SBO labels may be very valuable when it comes to model integration, by helping identify interfaces, convert mathematical expressions and parameters etc. Although the use of SBO can be beneficial, it is critical to keep in mind that the presence of an 'sboTerm' value on an object must not change the fundamental mathematical meaning of the model. An SBML model must be defined such that it stands on its own and does not depend on additional information added by SBO terms for a correct mathematical interpretation. SBO term definitions will not imply any alternative mathematical semantics for any SBML object labeled with that term. Two important reasons motivate this principle. First, it would be too limiting to require all software tools to be able to understand the SBO vocabularies in addition to understanding SBML. Supporting SBO is not only additional work for the software developer; for some kinds of applications, it may not make sense. If SBO terms on a model are optional, it follows that the SBML model must remain unambiguous and fully interpretable without them, because an application reading the model may ignore the terms. Second, we believe allowing the use of 'sboTerm' to alter the mathematical meaning of a model would allow too much leeway to shoehorn inconsistent concepts into SBML objects, ultimately reducing the interoperability of the models. Relationships between SBO and SBML ====================================================================== The goal of SBO labeling for SBML is to clarify to the fullest extent possible the nature of each element in a model. The approach taken in SBO begins with a hierarchically-structured set of controlled vocabularies with six main divisions: (1) entity, (2) participant role, (3) quantitative parameter, (4) modeling framework, (5) mathematical expression, and (6) interaction. The web site for SBO (http://biomodels.net) should be consulted for the current version of the ontology. The Systems Biology Ontology (SBO) is not part of SBML; it is being developed separately, to allow the modeling community to evolve the ontology independently of SBML. However, the terms in the ontology are being designed keeping SBML components in mind, and are classified into subsets that can be directly related with SBML components such as reaction rate expressions, parameters, and others. The use of 'sboTerm' attributes is optional, and the presence of 'sboTerm' on an element does not change the way the model is interpreted. Annotating SBML elements with SBO terms adds additional semantic information that may be used to convert the model into another model, or another format. Although SBO support provides an important source of information to understand the meaning of a model, software does not need to support 'sboTerm' to be considered SBML-compliant. """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, SBO, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, SBO, name) __repr__ = _swig_repr def isQuantitativeParameter(term): """ isQuantitativeParameter(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Note: The 'quantitative parameter' SBO term is now known as 'systems description parameter'. Returns 'True' if 'term' is-a SBO 'quantiative parameter', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isQuantitativeParameter(term) isQuantitativeParameter = staticmethod(isQuantitativeParameter) def isParticipantRole(term): """ isParticipantRole(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'participant role', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isParticipantRole(term) isParticipantRole = staticmethod(isParticipantRole) def isModellingFramework(term): """ isModellingFramework(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'modeling framework', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isModellingFramework(term) isModellingFramework = staticmethod(isModellingFramework) def isMathematicalExpression(term): """ isMathematicalExpression(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'mathematical expression', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isMathematicalExpression(term) isMathematicalExpression = staticmethod(isMathematicalExpression) def isKineticConstant(term): """ isKineticConstant(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'kinetic constant', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isKineticConstant(term) isKineticConstant = staticmethod(isKineticConstant) def isReactant(term): """ isReactant(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'reactant', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isReactant(term) isReactant = staticmethod(isReactant) def isProduct(term): """ isProduct(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'product', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isProduct(term) isProduct = staticmethod(isProduct) def isModifier(term): """ isModifier(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'modifier', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isModifier(term) isModifier = staticmethod(isModifier) def isRateLaw(term): """ isRateLaw(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'rate law', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isRateLaw(term) isRateLaw = staticmethod(isRateLaw) def isEvent(term): """ isEvent(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'event', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isEvent(term) isEvent = staticmethod(isEvent) def isPhysicalParticipant(term): """ isPhysicalParticipant(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'physical participant, 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isPhysicalParticipant(term) isPhysicalParticipant = staticmethod(isPhysicalParticipant) def isParticipant(term): """ isParticipant(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'participant', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isParticipant(term) isParticipant = staticmethod(isParticipant) def isInteraction(term): """ isInteraction(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Note: The 'interaction' SBO term is now known as 'occurring entity representation'. Returns 'True' if 'term' is-a SBO 'interaction', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isInteraction(term) isInteraction = staticmethod(isInteraction) def isEntity(term): """ isEntity(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Note: The 'entity' SBO term is now known as 'physical entity representation'. Returns 'True' if 'term' is-a SBO 'entity', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isEntity(term) isEntity = staticmethod(isEntity) def isFunctionalEntity(term): """ isFunctionalEntity(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'functional entity', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isFunctionalEntity(term) isFunctionalEntity = staticmethod(isFunctionalEntity) def isMaterialEntity(term): """ isMaterialEntity(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'material entity', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isMaterialEntity(term) isMaterialEntity = staticmethod(isMaterialEntity) def isConservationLaw(term): """ isConservationLaw(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'conservation law', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isConservationLaw(term) isConservationLaw = staticmethod(isConservationLaw) def isSteadyStateExpression(term): """ isSteadyStateExpression(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'steady state expression', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isSteadyStateExpression(term) isSteadyStateExpression = staticmethod(isSteadyStateExpression) def isFunctionalCompartment(term): """ isFunctionalCompartment(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'functional compartment', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isFunctionalCompartment(term) isFunctionalCompartment = staticmethod(isFunctionalCompartment) def isContinuousFramework(term): """ isContinuousFramework(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'continuous framework', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isContinuousFramework(term) isContinuousFramework = staticmethod(isContinuousFramework) def isDiscreteFramework(term): """ isDiscreteFramework(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'discrete framework', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isDiscreteFramework(term) isDiscreteFramework = staticmethod(isDiscreteFramework) def isLogicalFramework(term): """ isLogicalFramework(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'logical framework', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isLogicalFramework(term) isLogicalFramework = staticmethod(isLogicalFramework) def isMetadataRepresentation(term): """ isMetadataRepresentation(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'metadata representation', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isMetadataRepresentation(term) isMetadataRepresentation = staticmethod(isMetadataRepresentation) def isOccurringEntityRepresentation(term): """ isOccurringEntityRepresentation(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'occurring entity representation', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isOccurringEntityRepresentation(term) isOccurringEntityRepresentation = staticmethod(isOccurringEntityRepresentation) def isPhysicalEntityRepresentation(term): """ isPhysicalEntityRepresentation(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'physical entity representation', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isPhysicalEntityRepresentation(term) isPhysicalEntityRepresentation = staticmethod(isPhysicalEntityRepresentation) def isSystemsDescriptionParameter(term): """ isSystemsDescriptionParameter(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'systems description parameter', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isSystemsDescriptionParameter(term) isSystemsDescriptionParameter = staticmethod(isSystemsDescriptionParameter) def isQuantitativeSystemsDescriptionParameter(term): """ isQuantitativeSystemsDescriptionParameter(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'quantiative systems description parameter', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isQuantitativeSystemsDescriptionParameter(term) isQuantitativeSystemsDescriptionParameter = staticmethod(isQuantitativeSystemsDescriptionParameter) def isObselete(term): """ isObselete(unsigned int term) -> bool Predicate for checking whether the given term is obsolete. Returns 'True' if 'term' is-a SBO 'obsolete' term, 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isObselete(term) isObselete = staticmethod(isObselete) def intToString(sboTerm): """ intToString(int sboTerm) -> string Returns the integer as a correctly formatted SBO identifier string. Returns the given integer sboTerm as a zero-padded seven digit string. Note: If the sboTerm is not in the correct range (0000000-9999999), an empty string is returned. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_intToString(sboTerm) intToString = staticmethod(intToString) def stringToInt(sboTerm): """ stringToInt(string sboTerm) -> int Returns the string as a correctly formatted SBO integer portion. Returns the given string sboTerm as an integer. If the sboTerm is not in the correct format (a zero-padded, seven digit string), -1 is returned. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_stringToInt(sboTerm) stringToInt = staticmethod(stringToInt) def checkTerm(*args): """ checkTerm(string sboTerm) -> bool checkTerm(int sboTerm) -> bool This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: checkTerm(string sboTerm) Checks the format of the given SBO identifier string. Returns 'True' if sboTerm is in the correct format (a zero-padded, seven digit string), 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. ______________________________________________________________________ Method variant with the following signature: checkTerm(int sboTerm) Checks the format of the given SBO identifier, given in the form of the integer portion alone. Returns 'True' if sboTerm is in the range (0000000-9999999), 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_checkTerm(*args) checkTerm = staticmethod(checkTerm) def getParentBranch(term): """ getParentBranch(unsigned int term) -> unsigned int Internal implementation method. """ return _libsbml.SBO_getParentBranch(term) getParentBranch = staticmethod(getParentBranch) def __init__(self): """ __init__(SBO self) -> SBO @internal """ this = _libsbml.new_SBO() try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_SBO __del__ = lambda self: None SBO_swigregister = _libsbml.SBO_swigregister SBO_swigregister(SBO) def SBO_isQuantitativeParameter(term): """ SBO_isQuantitativeParameter(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Note: The 'quantitative parameter' SBO term is now known as 'systems description parameter'. Returns 'True' if 'term' is-a SBO 'quantiative parameter', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isQuantitativeParameter(term) def SBO_isParticipantRole(term): """ SBO_isParticipantRole(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'participant role', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isParticipantRole(term) def SBO_isModellingFramework(term): """ SBO_isModellingFramework(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'modeling framework', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isModellingFramework(term) def SBO_isMathematicalExpression(term): """ SBO_isMathematicalExpression(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'mathematical expression', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isMathematicalExpression(term) def SBO_isKineticConstant(term): """ SBO_isKineticConstant(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'kinetic constant', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isKineticConstant(term) def SBO_isReactant(term): """ SBO_isReactant(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'reactant', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isReactant(term) def SBO_isProduct(term): """ SBO_isProduct(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'product', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isProduct(term) def SBO_isModifier(term): """ SBO_isModifier(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'modifier', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isModifier(term) def SBO_isRateLaw(term): """ SBO_isRateLaw(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'rate law', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isRateLaw(term) def SBO_isEvent(term): """ SBO_isEvent(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'event', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isEvent(term) def SBO_isPhysicalParticipant(term): """ SBO_isPhysicalParticipant(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'physical participant, 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isPhysicalParticipant(term) def SBO_isParticipant(term): """ SBO_isParticipant(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'participant', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isParticipant(term) def SBO_isInteraction(term): """ SBO_isInteraction(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Note: The 'interaction' SBO term is now known as 'occurring entity representation'. Returns 'True' if 'term' is-a SBO 'interaction', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isInteraction(term) def SBO_isEntity(term): """ SBO_isEntity(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Note: The 'entity' SBO term is now known as 'physical entity representation'. Returns 'True' if 'term' is-a SBO 'entity', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isEntity(term) def SBO_isFunctionalEntity(term): """ SBO_isFunctionalEntity(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'functional entity', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isFunctionalEntity(term) def SBO_isMaterialEntity(term): """ SBO_isMaterialEntity(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'material entity', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isMaterialEntity(term) def SBO_isConservationLaw(term): """ SBO_isConservationLaw(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'conservation law', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isConservationLaw(term) def SBO_isSteadyStateExpression(term): """ SBO_isSteadyStateExpression(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'steady state expression', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isSteadyStateExpression(term) def SBO_isFunctionalCompartment(term): """ SBO_isFunctionalCompartment(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'functional compartment', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isFunctionalCompartment(term) def SBO_isContinuousFramework(term): """ SBO_isContinuousFramework(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'continuous framework', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isContinuousFramework(term) def SBO_isDiscreteFramework(term): """ SBO_isDiscreteFramework(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'discrete framework', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isDiscreteFramework(term) def SBO_isLogicalFramework(term): """ SBO_isLogicalFramework(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'logical framework', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isLogicalFramework(term) def SBO_isMetadataRepresentation(term): """ SBO_isMetadataRepresentation(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'metadata representation', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isMetadataRepresentation(term) def SBO_isOccurringEntityRepresentation(term): """ SBO_isOccurringEntityRepresentation(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'occurring entity representation', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isOccurringEntityRepresentation(term) def SBO_isPhysicalEntityRepresentation(term): """ SBO_isPhysicalEntityRepresentation(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'physical entity representation', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isPhysicalEntityRepresentation(term) def SBO_isSystemsDescriptionParameter(term): """ SBO_isSystemsDescriptionParameter(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'systems description parameter', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isSystemsDescriptionParameter(term) def SBO_isQuantitativeSystemsDescriptionParameter(term): """ SBO_isQuantitativeSystemsDescriptionParameter(unsigned int term) -> bool Returns 'True' if the given term identifier comes from the stated branch of SBO. Returns 'True' if 'term' is-a SBO 'quantiative systems description parameter', 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isQuantitativeSystemsDescriptionParameter(term) def SBO_isObselete(term): """ SBO_isObselete(unsigned int term) -> bool Predicate for checking whether the given term is obsolete. Returns 'True' if 'term' is-a SBO 'obsolete' term, 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_isObselete(term) def SBO_intToString(sboTerm): """ SBO_intToString(int sboTerm) -> string Returns the integer as a correctly formatted SBO identifier string. Returns the given integer sboTerm as a zero-padded seven digit string. Note: If the sboTerm is not in the correct range (0000000-9999999), an empty string is returned. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_intToString(sboTerm) def SBO_stringToInt(sboTerm): """ SBO_stringToInt(string sboTerm) -> int Returns the string as a correctly formatted SBO integer portion. Returns the given string sboTerm as an integer. If the sboTerm is not in the correct format (a zero-padded, seven digit string), -1 is returned. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_stringToInt(sboTerm) def SBO_checkTerm(*args): """ checkTerm(string sboTerm) -> bool SBO_checkTerm(int sboTerm) -> bool This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: checkTerm(string sboTerm) Checks the format of the given SBO identifier string. Returns 'True' if sboTerm is in the correct format (a zero-padded, seven digit string), 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. ______________________________________________________________________ Method variant with the following signature: checkTerm(int sboTerm) Checks the format of the given SBO identifier, given in the form of the integer portion alone. Returns 'True' if sboTerm is in the range (0000000-9999999), 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBO_checkTerm(*args) def SBO_getParentBranch(term): """ SBO_getParentBranch(unsigned int term) -> unsigned int Internal implementation method. """ return _libsbml.SBO_getParentBranch(term) class SyntaxChecker(_object): """ Methods for checking the validity of SBML identifiers. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. This utility class provides static methods for checking the syntax of identifiers and other text used in an SBML model. The methods allow callers to verify that strings such as SBML identifiers and XHTML notes text conform to the SBML specifications. """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, SyntaxChecker, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, SyntaxChecker, name) __repr__ = _swig_repr def isValidSBMLSId(sid): """ isValidSBMLSId(string sid) -> bool Returns 'True' or 'False' depending on whether the argument string conforms to the syntax of SBML identifiers. In SBML, identifiers that are the values of 'id' attributes on objects must conform to a data type called SId in the SBML specifications. LibSBML does not provide an explicit SId data type; it uses ordinary character strings, which is easier for applications to support. (LibSBML does, however, test for identifier validity at various times, such as when reading in models from files and data streams.) This method provides programs with the ability to test explicitly that the identifier strings they create conform to the SBML identifier syntax. Parameter 'sid' is string to be checked for conformance to SBML identifier syntax. Returns 'True' if the string conforms to type SBML data type SId, 'False' otherwise. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The equality of SId and SId-derived values in SBML is determined by an exact character sequence match; i.e., comparisons of these identifiers must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also SyntaxChecker.isValidUnitSId() , SyntaxChecker.isValidXMLID() . """ return _libsbml.SyntaxChecker_isValidSBMLSId(sid) isValidSBMLSId = staticmethod(isValidSBMLSId) def isValidXMLID(id): """ isValidXMLID(string id) -> bool Returns 'True' or 'False' depending on whether the argument string conforms to the XML data type ID. The optional attribute named 'metaid', present on every major SBML component type, is for supporting metadata annotations using RDF (Resource Description Format). The attribute value has the data type XML ID, the XML identifier type, which means each 'metaid' value must be globally unique within an SBML file. The latter point is important, because the uniqueness criterion applies across any attribute with type ID anywhere in the file, not just the 'metaid' attribute used by SBML---something to be aware of if your application- specific XML content inside the 'annotation' subelement happens to use the XML ID type. Although SBML itself specifies the use of XML ID only for the 'metaid' attribute, SBML-compatible applications should be careful if they use XML ID's in XML portions of a model that are not defined by SBML, such as in the application-specific content of the 'annotation' subelement. Finally, note that LibSBML does not provide an explicit XML ID data type; it uses ordinary character strings, which is easier for applications to support. This method provides programs with the ability to test explicitly that the identifier strings they create conform to the SBML identifier syntax. Parameter 'id' is string to be checked for conformance to the syntax of XML ID. Returns 'True' if the string is a syntactically-valid value for the XML type ID, 'False' otherwise. Note: The following is a summary of the definition of the XML 1.0 data type ID. We express the syntax using an extended form of BNF notation:

NCNameChar ::= letter | digit | '.' | '-' | '_' | ':' | CombiningChar | Extender ID ::= ( letter | '_' | ':' ) NCNameChar*

The characters ( and ) are used for grouping, the character * means "zero or more times", and the character | indicates logical "or". The production letter consists of the basic upper and lower case alphabetic characters of the Latin alphabet along with a large number of related characters defined by Unicode 2.0; similarly, the production digit consists of the numerals 0..9 along with related Unicode 2.0 characters. The CombiningChar production is a list of characters that add such things as accents to the preceding character. (For example, the Unicode character \#x030A when combined with a produces a.) The Extender production is a list of characters that extend the shape of the preceding character. Please consult the XML 1.0 specification for the complete definitions of letter, digit, CombiningChar, and Extender.

Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also SyntaxChecker.isValidSBMLSId() , SyntaxChecker.isValidUnitSId() . """ return _libsbml.SyntaxChecker_isValidXMLID(id) isValidXMLID = staticmethod(isValidXMLID) def isValidXMLanyURI(uri): """ isValidXMLanyURI(string uri) -> bool Returns 'True' or 'False' depending on whether the 'uri' argument string conforms to the XML data type anyURI. Type anyURI is defined by XML Schema 1.0. It is a character string data type whose values are interpretable as URIs (Universal Resource Identifiers) as described by the W3C document RFC 3986. LibSBML does not provide an explicit XML anyURI data type; it uses ordinary character strings, which is easier for applications to support. LibSBML does, however, test for anyURI validity at various times, such as when reading in models from files and data streams. This method provides programs with the ability to test explicitly that the strings they create conform to the XML anyURI syntax. Parameter 'uri' is string to be checked for conformance to the syntax of anyURI. Returns 'True' if the string is a syntactically-valid value for the XML type anyURI, 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SyntaxChecker_isValidXMLanyURI(uri) isValidXMLanyURI = staticmethod(isValidXMLanyURI) def isValidUnitSId(units): """ isValidUnitSId(string units) -> bool Returns 'True' or 'False' depending on whether the argument string conforms to the syntax of SBML unit identifiers. In SBML, the identifiers of units (of both the predefined units and user-defined units) must conform to a data type called UnitSId in the SBML specifications. LibSBML does not provide an explicit UnitSId data type; it uses ordinary character strings, which is easier for applications to support. LibSBML does, however, test for identifier validity at various times, such as when reading in models from files and data streams. This method provides programs with the ability to test explicitly that the identifier strings they create conform to the SBML identifier syntax. Parameter 'units' is string to be checked for conformance to SBML unit identifier syntax. Returns 'True' if the string conforms to type SBML data type UnitSId, 'False' otherwise. Note: The following is a summary of the definition of the SBML identifier type UnitSId, which defines the permitted syntax of identifiers. We express the syntax using an extended form of BNF notation:

letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar*

The characters ( and ) are used for grouping, the character * "zero or more times", and the character | indicates logical "or". The equality of SBML unit identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case- sensitive manner. In addition, there are a few conditions for the uniqueness of unit identifiers in an SBML model. Please consult the SBML specifications for the exact formulations.

Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also SyntaxChecker.isValidSBMLSId() , SyntaxChecker.isValidXMLID() . """ return _libsbml.SyntaxChecker_isValidUnitSId(units) isValidUnitSId = staticmethod(isValidUnitSId) def hasExpectedXHTMLSyntax(xhtml, sbmlns=None): """ hasExpectedXHTMLSyntax(XMLNode xhtml, SBMLNamespaces sbmlns=None) -> bool hasExpectedXHTMLSyntax(XMLNode xhtml) -> bool Returns 'True' or 'False' depending on whether the given XMLNode object contains valid XHTML content. The optional SBML element named 'notes', present on every major SBML component type (and in SBML Level 3, the 'message' subelement of Constraint), is intended as a place for storing optional information intended to be seen by humans. An example use of the 'notes' element would be to contain formatted user comments about the model element in which the 'notes' element is enclosed. Every object derived directly or indirectly from type SBase can have a separate value for 'notes', allowing users considerable freedom when adding comments to their models. The format of 'notes' elements conform to the definition of XHTML 1.0. However, the content cannot be entirely free-form; it must satisfy certain requirements defined in the SBML specifications for specific SBML Levels. To help verify the formatting of 'notes' content, libSBML provides the static utility method SyntaxChecker.hasExpectedXHTMLSyntax(); this method implements a verification process that lets callers check whether the content of a given XMLNode object conforms to the SBML requirements for 'notes' and 'message' structure. Developers are urged to consult the appropriate SBML specification document for the Level and Version of their model for more in-depth explanations of using 'notes' in SBML. The SBML Level 2 and 3 specifications have considerable detail about how 'notes' element content must be structured. An aspect of XHTML validity is that the content is declared to be in the XML namespace for XHTML 1.0. There is more than one way in which this can be done in XML. In particular, a model might not contain the declaration within the 'notes' or 'message' subelement itself, but might instead place the declaration on an enclosing element and use an XML namespace prefix within the 'notes' element to refer to it. In other words, the following is valid: A Simple Mitotic Oscillator A minimal cascade model for the mitotic oscillator. ... rest of model ... Contrast the above with the following, self-contained version, which places the XML namespace declaration within the element itself: </head> <body> <center><h2>A Simple Mitotic Oscillator</h2></center> <p>A minimal cascade model for the mitotic oscillator.</p> </body> </html> </notes> ... rest of model ... </sbml> Both of the above are valid XML. The purpose of the 'sbmlns' argument to this method is to allow callers to check the validity of 'notes' and 'message' subelements whose XML namespace declarations have been put elsewhere in the manner illustrated above. Callers can can pass in the SBMLNamespaces object of a higher-level model component if the XMLNode object does not itself have the XML namespace declaration for XHTML 1.0. Parameter 'xhtml' is the XMLNode to be checked for conformance. Parameter 'sbmlns' is the SBMLNamespaces associated with the object. Returns 'True' if the XMLNode content conforms, 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.SyntaxChecker_hasExpectedXHTMLSyntax(xhtml, sbmlns) hasExpectedXHTMLSyntax = staticmethod(hasExpectedXHTMLSyntax) def isValidInternalSId(sid): """ isValidInternalSId(string sid) -> bool Internal implementation method. """ return _libsbml.SyntaxChecker_isValidInternalSId(sid) isValidInternalSId = staticmethod(isValidInternalSId) def isValidInternalUnitSId(sid): """ isValidInternalUnitSId(string sid) -> bool Internal implementation method. """ return _libsbml.SyntaxChecker_isValidInternalUnitSId(sid) isValidInternalUnitSId = staticmethod(isValidInternalUnitSId) def __init__(self): """ __init__(SyntaxChecker self) -> SyntaxChecker @internal """ this = _libsbml.new_SyntaxChecker() try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_SyntaxChecker __del__ = lambda self: None SyntaxChecker_swigregister = _libsbml.SyntaxChecker_swigregister SyntaxChecker_swigregister(SyntaxChecker) def SyntaxChecker_isValidSBMLSId(sid): """ SyntaxChecker_isValidSBMLSId(string sid) -> bool Returns 'True' or 'False' depending on whether the argument string conforms to the syntax of SBML identifiers. In SBML, identifiers that are the values of 'id' attributes on objects must conform to a data type called SId in the SBML specifications. LibSBML does not provide an explicit SId data type; it uses ordinary character strings, which is easier for applications to support. (LibSBML does, however, test for identifier validity at various times, such as when reading in models from files and data streams.) This method provides programs with the ability to test explicitly that the identifier strings they create conform to the SBML identifier syntax. Parameter 'sid' is string to be checked for conformance to SBML identifier syntax. Returns 'True' if the string conforms to type SBML data type SId, 'False' otherwise. The identifier given by an object's 'id' attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier. The data type of 'id' is always SId or a type derived from that, such as UnitSId, depending on the object in question. All data types are defined as follows: letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* The equality of SId and SId-derived values in SBML is determined by an exact character sequence match; i.e., comparisons of these identifiers must be performed in a case-sensitive manner. This applies to all uses of SId, SIdRef, and derived types. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also SyntaxChecker.isValidUnitSId() , SyntaxChecker.isValidXMLID() . """ return _libsbml.SyntaxChecker_isValidSBMLSId(sid) def SyntaxChecker_isValidXMLID(id): """ SyntaxChecker_isValidXMLID(string id) -> bool Returns 'True' or 'False' depending on whether the argument string conforms to the XML data type ID. The optional attribute named 'metaid', present on every major SBML component type, is for supporting metadata annotations using RDF (Resource Description Format). The attribute value has the data type XML ID, the XML identifier type, which means each 'metaid' value must be globally unique within an SBML file. The latter point is important, because the uniqueness criterion applies across any attribute with type ID anywhere in the file, not just the 'metaid' attribute used by SBML---something to be aware of if your application- specific XML content inside the 'annotation' subelement happens to use the XML ID type. Although SBML itself specifies the use of XML ID only for the 'metaid' attribute, SBML-compatible applications should be careful if they use XML ID's in XML portions of a model that are not defined by SBML, such as in the application-specific content of the 'annotation' subelement. Finally, note that LibSBML does not provide an explicit XML ID data type; it uses ordinary character strings, which is easier for applications to support. This method provides programs with the ability to test explicitly that the identifier strings they create conform to the SBML identifier syntax. Parameter 'id' is string to be checked for conformance to the syntax of XML ID. Returns 'True' if the string is a syntactically-valid value for the XML type ID, 'False' otherwise. Note: The following is a summary of the definition of the XML 1.0 data type ID. We express the syntax using an extended form of BNF notation: <p> <nobr>NCNameChar ::= letter | digit | '.' | '-' | '_' | ':' | CombiningChar | Extender </nobr> ID ::= ( letter | '_' | ':' ) NCNameChar* <p> The characters ( and ) are used for grouping, the character * means "zero or more times", and the character | indicates logical "or". The production letter consists of the basic upper and lower case alphabetic characters of the Latin alphabet along with a large number of related characters defined by Unicode 2.0; similarly, the production digit consists of the numerals 0..9 along with related Unicode 2.0 characters. The CombiningChar production is a list of characters that add such things as accents to the preceding character. (For example, the Unicode character \#x030A when combined with a produces a.) The Extender production is a list of characters that extend the shape of the preceding character. Please consult the XML 1.0 specification for the complete definitions of letter, digit, CombiningChar, and Extender. <p> Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also SyntaxChecker.isValidSBMLSId() , SyntaxChecker.isValidUnitSId() . """ return _libsbml.SyntaxChecker_isValidXMLID(id) def SyntaxChecker_isValidXMLanyURI(uri): """ SyntaxChecker_isValidXMLanyURI(string uri) -> bool Returns 'True' or 'False' depending on whether the 'uri' argument string conforms to the XML data type anyURI. Type anyURI is defined by XML Schema 1.0. It is a character string data type whose values are interpretable as URIs (Universal Resource Identifiers) as described by the W3C document RFC 3986. LibSBML does not provide an explicit XML anyURI data type; it uses ordinary character strings, which is easier for applications to support. LibSBML does, however, test for anyURI validity at various times, such as when reading in models from files and data streams. This method provides programs with the ability to test explicitly that the strings they create conform to the XML anyURI syntax. Parameter 'uri' is string to be checked for conformance to the syntax of anyURI. Returns 'True' if the string is a syntactically-valid value for the XML type anyURI, 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SyntaxChecker_isValidXMLanyURI(uri) def SyntaxChecker_isValidUnitSId(units): """ SyntaxChecker_isValidUnitSId(string units) -> bool Returns 'True' or 'False' depending on whether the argument string conforms to the syntax of SBML unit identifiers. In SBML, the identifiers of units (of both the predefined units and user-defined units) must conform to a data type called UnitSId in the SBML specifications. LibSBML does not provide an explicit UnitSId data type; it uses ordinary character strings, which is easier for applications to support. LibSBML does, however, test for identifier validity at various times, such as when reading in models from files and data streams. This method provides programs with the ability to test explicitly that the identifier strings they create conform to the SBML identifier syntax. Parameter 'units' is string to be checked for conformance to SBML unit identifier syntax. Returns 'True' if the string conforms to type SBML data type UnitSId, 'False' otherwise. Note: The following is a summary of the definition of the SBML identifier type UnitSId, which defines the permitted syntax of identifiers. We express the syntax using an extended form of BNF notation: <p> letter ::= 'a'..'z','A'..'Z' digit ::= '0'..'9' idChar ::= letter | digit | '_' SId ::= ( letter | '_' ) idChar* <p> The characters ( and ) are used for grouping, the character * "zero or more times", and the character | indicates logical "or". The equality of SBML unit identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case- sensitive manner. In addition, there are a few conditions for the uniqueness of unit identifiers in an SBML model. Please consult the SBML specifications for the exact formulations. <p> Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also SyntaxChecker.isValidSBMLSId() , SyntaxChecker.isValidXMLID() . """ return _libsbml.SyntaxChecker_isValidUnitSId(units) def SyntaxChecker_hasExpectedXHTMLSyntax(xhtml, sbmlns=None): """ hasExpectedXHTMLSyntax(XMLNode xhtml, SBMLNamespaces sbmlns=None) -> bool SyntaxChecker_hasExpectedXHTMLSyntax(XMLNode xhtml) -> bool Returns 'True' or 'False' depending on whether the given XMLNode object contains valid XHTML content. The optional SBML element named 'notes', present on every major SBML component type (and in SBML Level 3, the 'message' subelement of Constraint), is intended as a place for storing optional information intended to be seen by humans. An example use of the 'notes' element would be to contain formatted user comments about the model element in which the 'notes' element is enclosed. Every object derived directly or indirectly from type SBase can have a separate value for 'notes', allowing users considerable freedom when adding comments to their models. The format of 'notes' elements conform to the definition of XHTML 1.0. However, the content cannot be entirely free-form; it must satisfy certain requirements defined in the SBML specifications for specific SBML Levels. To help verify the formatting of 'notes' content, libSBML provides the static utility method SyntaxChecker.hasExpectedXHTMLSyntax(); this method implements a verification process that lets callers check whether the content of a given XMLNode object conforms to the SBML requirements for 'notes' and 'message' structure. Developers are urged to consult the appropriate SBML specification document for the Level and Version of their model for more in-depth explanations of using 'notes' in SBML. The SBML Level 2 and 3 specifications have considerable detail about how 'notes' element content must be structured. An aspect of XHTML validity is that the content is declared to be in the XML namespace for XHTML 1.0. There is more than one way in which this can be done in XML. In particular, a model might not contain the declaration within the 'notes' or 'message' subelement itself, but might instead place the declaration on an enclosing element and use an XML namespace prefix within the 'notes' element to refer to it. In other words, the following is valid: <sbml xmlns='http://www.sbml.org/sbml/level2/version3' level='2' version='3' xmlns:xhtml='http://www.w3.org/1999/xhtml'> <model> <notes> <xhtml:body> <xhtml:center><xhtml:h2>A Simple Mitotic Oscillator</xhtml:h2></xhtml:center> <xhtml:p>A minimal cascade model for the mitotic oscillator.</xhtml:p> </xhtml:body> </notes> ... rest of model ... </sbml> Contrast the above with the following, self-contained version, which places the XML namespace declaration within the <notes> element itself: <sbml xmlns='http://www.sbml.org/sbml/level2/version3' level='2' version='3'> <model> <notes> <html xmlns='http://www.w3.org/1999/xhtml'> <head> <title/> </head> <body> <center><h2>A Simple Mitotic Oscillator</h2></center> <p>A minimal cascade model for the mitotic oscillator.</p> </body> </html> </notes> ... rest of model ... </sbml> Both of the above are valid XML. The purpose of the 'sbmlns' argument to this method is to allow callers to check the validity of 'notes' and 'message' subelements whose XML namespace declarations have been put elsewhere in the manner illustrated above. Callers can can pass in the SBMLNamespaces object of a higher-level model component if the XMLNode object does not itself have the XML namespace declaration for XHTML 1.0. Parameter 'xhtml' is the XMLNode to be checked for conformance. Parameter 'sbmlns' is the SBMLNamespaces associated with the object. Returns 'True' if the XMLNode content conforms, 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.SyntaxChecker_hasExpectedXHTMLSyntax(xhtml, sbmlns) def SyntaxChecker_isValidInternalSId(sid): """ SyntaxChecker_isValidInternalSId(string sid) -> bool Internal implementation method. """ return _libsbml.SyntaxChecker_isValidInternalSId(sid) def SyntaxChecker_isValidInternalUnitSId(sid): """ SyntaxChecker_isValidInternalUnitSId(string sid) -> bool Internal implementation method. """ return _libsbml.SyntaxChecker_isValidInternalUnitSId(sid) class StoichiometryMath(SBase): """ Stochiometry expressions in SBML Level 2 reactions. Stoichiometries in SBML Level 2 ====================================================================== In SBML Level 2, product and reactant stoichiometries can be specified using either the 'stoichiometry' attribute or a 'stoichiometryMath' element in a SpeciesReference object. The 'stoichiometry' attribute is of type 'float' and should contain values greater than zero (0). The 'stoichiometryMath' element is implemented as an element containing a MathML expression. These two are mutually exclusive; only one of 'stoichiometry' or 'stoichiometryMath' should be defined in a given SpeciesReference instance. When neither the attribute nor the element is present, the value of 'stoichiometry' in the enclosing SpeciesReference instance defaults to '1.' For maximum interoperability, SpeciesReference's 'stoichiometry' attribute should be used in preference to 'stoichiometryMath' when a species' stoichiometry is a simple scalar number (integer or decimal). When the stoichiometry is a rational number, or when it is a more complicated formula, 'stoichiometryMath' must be used. The MathML expression in 'stoichiometryMath' may also refer to identifiers of entities in a model (except reaction identifiers). However, the only species identifiers that can be used in 'stoichiometryMath' are those referenced in the enclosing Reaction's list of reactants, products and modifiers. The 'stoichiometry' attribute and the 'stoichiometryMath' element, when either is used, is each interpreted as a factor applied to the reaction rate to produce the rate of change of the species identified by the 'species' attribute in the enclosing SpeciesReference. This is the normal interpretation of a stoichiometry, but in SBML, one additional consideration has to be taken into account. The reaction rate, which is the result of the KineticLaw's 'math' element, is always in the model's substance per time units. However, the rate of change of the species will involve the species' substance units (i.e., the units identified by the Species object's 'substanceUnits' attribute), and these units may be different from the model's default substance units. If the units are different, the stoichiometry must incorporate a conversion factor for converting the model's substance units to the species' substance units. The conversion factor is assumed to be included in the scalar value of the 'stoichiometry' attribute if 'stoichiometry' is used. If instead 'stoichiometryMath' is used, then the product of the model's 'substance' units times the 'stoichiometryMath' units must match the substance units of the species. Note that in either case, if the species' units and the model's default substance units are the same, the stoichiometry ends up being a dimensionless number and equivalent to the standard chemical stoichiometry found in textbooks. Examples and more explanations of this are given in the SBML specification. The following is a simple example of a species reference for species ''X0',' with stoichiometry '2,' in a list of reactants within a reaction having the identifier ''J1':' <model> ... <listOfReactions> <reaction id='J1'> <listOfReactants> <speciesReference species='X0' stoichiometry='2'> </listOfReactants> ... </reaction> ... </listOfReactions> ... </model> The following is a more complex example of a species reference for species ''X0',' with a stoichiometry formula consisting of a rational number: <model> ... <listOfReactions> <reaction id='J1'> <listOfReactants> <speciesReference species='X0'> <stoichiometryMath> <math xmlns='http://www.w3.org/1998/Math/MathML'> <cn type='rational'> 3 <sep/> 2 </cn> </math> </stoichiometryMath> </speciesReference> </listOfReactants> ... </reaction> ... </listOfReactions> ... </model> Additional discussions of stoichiometries and implications for species and reactions are included in the documentation of SpeciesReference class. Stoichiometries in SBML Level 3 ====================================================================== The StoichiometryMath construct is not defined in SBML Level 3. Instead, Level 3 defines the identifier of SpeciesReference objects as a stand-in for the stoichiometry of the reactant or product being referenced, and allows that identifier to be used elsewhere in SBML models, including (for example) InitialAssignment objects. This makes it possible to achieve the same effect as StoichiometryMath, but with other SBML objects. For instance, to produce a stoichiometry value that is a rational number, a model can use InitialAssignment to assign the identifier of a SpeciesReference object to a MathML expression evaluating to a rational number. This is analogous to the same way that, in Level 2, the model would use StoichiometryMath with a MathML expression evaluating to a rational number. In SBML Level 2, the stoichiometry of a reactant or product is a combination of both a biochemical stoichiometry (meaning, the standard stoichiometry of a species in a reaction) and any necessary unit conversion factors. The introduction of an explicit attribute on the Species object for a conversion factor allows Level 3 to avoid having to overload the meaning of stoichiometry. In Level 3, the stoichiometry given by a SpeciesReference object in a reaction is a 'proper' biochemical stoichiometry, meaning a dimensionless number free of unit conversions. See also SpeciesReference, Reaction. """ __swig_setmethods__ = {} for _s in [SBase]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, StoichiometryMath, name, value) __swig_getmethods__ = {} for _s in [SBase]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, StoichiometryMath, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_StoichiometryMath __del__ = lambda self: None def __init__(self, *args): """ __init__(StoichiometryMath self, unsigned int level, unsigned int version) -> StoichiometryMath __init__(StoichiometryMath self, SBMLNamespaces sbmlns) -> StoichiometryMath __init__(StoichiometryMath self, StoichiometryMath orig) -> StoichiometryMath This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: StoichiometryMath(SBMLNamespaces sbmlns) Creates a new StoichiometryMath object using the given SBMLNamespaces object 'sbmlns'. The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments. Parameter 'sbmlns' is an SBMLNamespaces object. Throws SBMLConstructorException: Thrown if the given 'sbmlns' is inconsistent or incompatible with this object. Note: The StoichiometryMath construct exists only in SBML Level 2. It is an optional construct available for defining the stoichiometries of reactants and products in Reaction objects. Note that a different mechanism is used in SBML Level 3, where StoichiometryMath is not available. Please consult the top of this libSBML StoichiometryMath documentation for more information about the differences between SBML Level 2 and 3 with respect to stoichiometries. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: StoichiometryMath(long level, long version) Creates a new StoichiometryMath object using the given SBML 'level' values. Parameter 'level' is a long integer, the SBML Level to assign to this StoichiometryMath. Parameter 'version' is a long integer, the SBML Version to assign to this StoichiometryMath. Throws SBMLConstructorException: Thrown if the given 'level' and 'version' combination are invalid or if this object is incompatible with the given level and version. Note: The StoichiometryMath construct exists only in SBML Level 2. It is an optional construct available for defining the stoichiometries of reactants and products in Reaction objects. Note that a different mechanism is used in SBML Level 3, where StoichiometryMath is not available. Please consult the top of this libSBML StoichiometryMath documentation for more information about the differences between SBML Level 2 and 3 with respect to stoichiometries. Note: Attempting to add an object to an SBMLDocument having a different combination of SBML Level, Version and XML namespaces than the object itself will result in an error at the time a caller attempts to make the addition. A parent object must have compatible Level, Version and XML namespaces. (Strictly speaking, a parent may also have more XML namespaces than a child, but the reverse is not permitted.) The restriction is necessary to ensure that an SBML model has a consistent overall structure. This requires callers to manage their objects carefully, but the benefit is increased flexibility in how models can be created by permitting callers to create objects bottom-up if desired. In situations where objects are not yet attached to parents (e.g., SBMLDocument), knowledge of the intented SBML Level and Version help libSBML determine such things as whether it is valid to assign a particular value to an attribute. ______________________________________________________________________ Method variant with the following signature: StoichiometryMath(StoichiometryMath orig) Copy constructor; creates a copy of this StoichiometryMath. Parameter 'orig' is the object to copy. """ this = _libsbml.new_StoichiometryMath(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(StoichiometryMath self) -> StoichiometryMath Creates and returns a deep copy of this StoichiometryMath object. Returns the (deep) copy of this StoichiometryMath object. """ return _libsbml.StoichiometryMath_clone(self) def getMath(self): """ getMath(StoichiometryMath self) -> ASTNode Retrieves the mathematical formula within this StoichiometryMath and return it as an AST. Returns the math of this StoichiometryMath, or 'None' if the math is not set. Note: The StoichiometryMath construct exists only in SBML Level 2. It is an optional construct available for defining the stoichiometries of reactants and products in Reaction objects. Note that a different mechanism is used in SBML Level 3, where StoichiometryMath is not available. Please consult the top of this libSBML StoichiometryMath documentation for more information about the differences between SBML Level 2 and 3 with respect to stoichiometries. """ return _libsbml.StoichiometryMath_getMath(self) def isSetMath(self): """ isSetMath(StoichiometryMath self) -> bool Predicate to test whether the math for this StoichiometryMath object is set. Returns 'True' if the formula (meaning the 'math' subelement) of this StoichiometryMath is set, 'False' otherwise. Note: The StoichiometryMath construct exists only in SBML Level 2. It is an optional construct available for defining the stoichiometries of reactants and products in Reaction objects. Note that a different mechanism is used in SBML Level 3, where StoichiometryMath is not available. Please consult the top of this libSBML StoichiometryMath documentation for more information about the differences between SBML Level 2 and 3 with respect to stoichiometries. """ return _libsbml.StoichiometryMath_isSetMath(self) def setMath(self, math): """ setMath(StoichiometryMath self, ASTNode math) -> int Sets the 'math' expression of this StoichiometryMath instance to a copy of the given ASTNode. Parameter 'math' is an ASTNode representing a formula tree. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT Note: The StoichiometryMath construct exists only in SBML Level 2. It is an optional construct available for defining the stoichiometries of reactants and products in Reaction objects. Note that a different mechanism is used in SBML Level 3, where StoichiometryMath is not available. Please consult the top of this libSBML StoichiometryMath documentation for more information about the differences between SBML Level 2 and 3 with respect to stoichiometries. """ return _libsbml.StoichiometryMath_setMath(self, math) def getDerivedUnitDefinition(self, *args): """ getDerivedUnitDefinition(StoichiometryMath self) -> UnitDefinition getDerivedUnitDefinition(StoichiometryMath self) -> UnitDefinition Calculates and returns a UnitDefinition object that expresses the units returned by the math expression in this StoichiometryMath object. The units are calculated based on the mathematical expression in the StoichiometryMath and the model quantities referenced by <ci> elements used within that expression. The StoichiometryMath.getDerivedUnitDefinition() method returns the calculated units. Note that the functionality that facilitates unit analysis depends on the model as a whole. Thus, in cases where the object has not been added to a model or the model itself is incomplete, unit analysis is not possible and this method will return 'None.' Returns a UnitDefinition that expresses the units of the math, or 'None' if one cannot be constructed. WARNING: Note that it is possible the 'math' expression in the StoichiometryMath instance contains literal numbers or parameters with undeclared units. In those cases, it is not possible to calculate the units of the overall expression without making assumptions. LibSBML does not make assumptions about the units, and StoichiometryMath.getDerivedUnitDefinition() only returns the units as far as it is able to determine them. For example, in an expression X + Y, if X has unambiguously-defined units and Y does not, it will return the units of X. When using this method, it is critical that callers also invoke the method StoichiometryMath.containsUndeclaredUnits() to determine whether this situation holds. Callers should take suitable action in those situations. See also containsUndeclaredUnits(). """ return _libsbml.StoichiometryMath_getDerivedUnitDefinition(self, *args) def containsUndeclaredUnits(self, *args): """ containsUndeclaredUnits(StoichiometryMath self) -> bool containsUndeclaredUnits(StoichiometryMath self) -> bool Predicate returning 'True' if the math expression of this StoichiometryMath object contains literal numbers or parameters with undeclared units. The StoichiometryMath.getDerivedUnitDefinition() method returns what libSBML computes the units of the Stoichiometry to be, to the extent that libSBML can compute them. However, if the expression contains literal numbers or parameters with undeclared units, libSBML may not be able to compute the full units of the expression and will only return what it can compute. Callers should always use StoichiometryMath.containsUndeclaredUnits() when using StoichiometryMath.getDerivedUnitDefinition() to decide whether the returned units may be incomplete. Returns 'True' if the math expression of this StoichiometryMath includes numbers/parameters with undeclared units, 'False' otherwise. Note: A return value of 'True' indicates that the UnitDefinition returned by StoichiometryMath.getDerivedUnitDefinition() may not accurately represent the units of the expression. See also getDerivedUnitDefinition(). """ return _libsbml.StoichiometryMath_containsUndeclaredUnits(self, *args) def getTypeCode(self): """ getTypeCode(StoichiometryMath self) -> int Returns the libSBML type code of this object instance. LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters SBML_. In the Python language interface for libSBML, the type codes are defined as static integer constants in the interface class 'libsbml'. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the SBase.getPackageName() method on the object. The exception to this is lists: all SBML-style list elements have the type SBML_LIST_OF, regardless of what package they are from. Returns the SBML type code for this object: SBML_STOICHIOMETRY_MATH (default). WARNING: The specific integer values of the possible type codes may be reused by different libSBML plug-ins for SBML Level 3. packages, To fully identify the correct code, it is necessary to invoke both getPackageName() and getTypeCode() (or ListOf.getItemTypeCode()). See also getElementName(), getPackageName(). """ return _libsbml.StoichiometryMath_getTypeCode(self) def getElementName(self): """ getElementName(StoichiometryMath self) -> string Returns the XML element name of this object, which for StoichiometryMath, is always ''stoichiometryMath'.' Returns the name of this element, i.e., ''stoichiometryMath'.' """ return _libsbml.StoichiometryMath_getElementName(self) def hasRequiredElements(self): """ hasRequiredElements(StoichiometryMath self) -> bool Predicate returning 'True' if all the required elements for this StoichiometryMath object have been set. Note: The required elements for a StoichiometryMath object are: * 'math' Returns a boolean value indicating whether all the required elements for this object have been defined. """ return _libsbml.StoichiometryMath_hasRequiredElements(self) def removeFromParentAndDelete(self): """ removeFromParentAndDelete(StoichiometryMath self) -> int Finds this StoichiometryMath's SpeciesReference parent and calls unsetStoichiometryMath() on it, indirectly deleting itself. Overridden from the SBase function since the parent is not a ListOf. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.StoichiometryMath_removeFromParentAndDelete(self) def renameSIdRefs(self, oldid, newid): """ renameSIdRefs(StoichiometryMath self, string oldid, string newid) Replaces all uses of a given 'SIdRef' type attribute value with another value. In SBML, object identifiers are of a data type called SId. In SBML Level 3, an explicit data type called SIdRef was introduced for attribute values that refer to SId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to an identifier', but the effective data type was the same as SIdRef in Level 3. These and other methods of libSBML refer to the type SIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all attributes and (if appropriate) mathematical formulas in MathML content, comparing the referenced identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.StoichiometryMath_renameSIdRefs(self, oldid, newid) def renameUnitSIdRefs(self, oldid, newid): """ renameUnitSIdRefs(StoichiometryMath self, string oldid, string newid) Replaces all uses of a given 'UnitSIdRef' type attribute value with another value. In SBML, unit definitions have identifiers of type UnitSId. In SBML Level 3, an explicit data type called UnitSIdRef was introduced for attribute values that refer to UnitSId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to a unit identifier', but the effective data type was the same as UnitSIdRef in Level 3. These and other methods of libSBML refer to the type UnitSIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all unit identifier attribute values (including, if appropriate, inside mathematical formulas), comparing the referenced unit identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.StoichiometryMath_renameUnitSIdRefs(self, oldid, newid) def replaceSIDWithFunction(self, id, function): """ replaceSIDWithFunction(StoichiometryMath self, string id, ASTNode function) Internal implementation method. """ return _libsbml.StoichiometryMath_replaceSIDWithFunction(self, id, function) StoichiometryMath_swigregister = _libsbml.StoichiometryMath_swigregister StoichiometryMath_swigregister(StoichiometryMath) class SBMLNamespaces(_object): """ Set of SBML Level + Version + namespace triples. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. There are differences in the definitions of components between different SBML Levels, as well as Versions within Levels. For example, the 'sboTerm' attribute was not introduced until Level 2 Version 2, and then only on certain component classes; the SBML Level 2 Version 3 specification moved the 'sboTerm' attribute to the SBase class, thereby allowing nearly all components to have SBO annotations. As a result of differences such as those, libSBML needs to track the SBML Level and Version of every object created. The purpose of the SBMLNamespaces object class is to make it easier to communicate SBML Level and Version data between libSBML constructors and other methods. The SBMLNamespaces object class tracks 3-tuples (triples) consisting of SBML Level, Version, and the corresponding SBML XML namespace. The plural name (SBMLNamespaces) is not a mistake, because in SBML Level 3, objects may have extensions added by Level 3 packages used by a given model and therefore may have multiple namespaces associated with them; however, until the introduction of SBML Level 3, the SBMLNamespaces object only records one SBML Level/Version/namespace combination at a time. Most constructors for SBML objects in libSBML take a SBMLNamespaces object as an argument, thereby allowing the constructor to produce the proper combination of attributes and other internal data structures for the given SBML Level and Version. """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLNamespaces, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, SBMLNamespaces, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_SBMLNamespaces __del__ = lambda self: None def __init__(self, *args): """ __init__(SBMLNamespaces self, unsigned int level, unsigned int version) -> SBMLNamespaces __init__(SBMLNamespaces self, unsigned int level) -> SBMLNamespaces __init__(SBMLNamespaces self) -> SBMLNamespaces __init__(SBMLNamespaces self, unsigned int level, unsigned int version, string pkgName, unsigned int pkgVersion, string pkgPrefix) -> SBMLNamespaces __init__(SBMLNamespaces self, unsigned int level, unsigned int version, string pkgName, unsigned int pkgVersion) -> SBMLNamespaces __init__(SBMLNamespaces self, SBMLNamespaces orig) -> SBMLNamespaces This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: SBMLNamespaces(SBMLNamespaces orig) Copy constructor; creates a copy of a SBMLNamespaces. Parameter 'orig' is the SBMLNamespaces instance to copy. ______________________________________________________________________ Method variant with the following signature: SBMLNamespaces(long level = SBML_DEFAULT_LEVEL, long version = SBML_DEFAULT_VERSION) Creates a new SBMLNamespaces object corresponding to the given SBML 'level' and 'version'. SBMLNamespaces objects are used in libSBML to communicate SBML Level and Version data between constructors and other methods. The SBMLNamespaces object class holds triples consisting of SBML Level, Version, and the corresponding SBML XML namespace. Most constructors for SBML objects in libSBML take a SBMLNamespaces object as an argument, thereby allowing the constructor to produce the proper combination of attributes and other internal data structures for the given SBML Level and Version. The plural name (SBMLNamespaces) is not a mistake, because in SBML Level 3, objects may have extensions added by Level 3 packages used by a given model and therefore may have multiple namespaces associated with them. In SBML Levels below Level 3, the SBMLNamespaces object only records one SBML Level/Version/namespace combination at a time. Most constructors for SBML objects in libSBML take a SBMLNamespaces object as an argument, thereby allowing the constructor to produce the proper combination of attributes and other internal data structures for the given SBML Level and Version. Parameter 'level' is the SBML level. Parameter 'version' is the SBML version. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. ______________________________________________________________________ Method variant with the following signature: SBMLNamespaces(long level, long version, string &pkgName, long pkgVersion, string pkgPrefix = '') (For extensions) Creates a new SBMLNamespaces object corresponding to the combination of (1) the given SBML 'level' and 'version', and (2) the given 'package' with the 'package' 'version'. SBMLNamespaces objects are used in libSBML to communicate SBML Level and Version data between constructors and other methods. The SBMLNamespaces object class holds triples consisting of SBML Level, Version, and the corresponding SBML XML namespace. Most constructors for SBML objects in libSBML take a SBMLNamespaces object as an argument, thereby allowing the constructor to produce the proper combination of attributes and other internal data structures for the given SBML Level and Version. The plural name (SBMLNamespaces) is not a mistake, because in SBML Level 3, objects may have extensions added by Level 3 packages used by a given model and therefore may have multiple namespaces associated with them. In SBML Levels below Level 3, the SBMLNamespaces object only records one SBML Level/Version/namespace combination at a time. Most constructors for SBML objects in libSBML take a SBMLNamespaces object as an argument, thereby allowing the constructor to produce the proper combination of attributes and other internal data structures for the given SBML Level and Version. Parameter 'level' is the SBML Level. Parameter 'version' is the SBML Version. Parameter 'pkgName' is the string of package name (e.g. 'layout', 'multi'). Parameter 'pkgVersion' is the package version. Parameter 'pkgPrefix' is the prefix of the package namespace (e.g. 'layout', 'multi') to be added. The package's name will be used if the given string is empty (default). Throws SBMLExtensionException: if the extension module that supports the combination of the given SBML Level, SBML Version, package name, and package version has not been registered with libSBML. Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ this = _libsbml.new_SBMLNamespaces(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(SBMLNamespaces self) -> SBMLNamespaces Creates and returns a deep copy of this SBMLNamespaces object. Returns the (deep) copy of this SBMLNamespaces object. """ return _libsbml.SBMLNamespaces_clone(self) def getSBMLNamespaceURI(level, version): """ getSBMLNamespaceURI(unsigned int level, unsigned int version) -> string Returns a string representing the SBML XML namespace for the given 'level' and 'version' of SBML. Parameter 'level' is the SBML level. Parameter 'version' is the SBML version. Returns a string representing the SBML namespace that reflects the SBML Level and Version specified. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBMLNamespaces_getSBMLNamespaceURI(level, version) getSBMLNamespaceURI = staticmethod(getSBMLNamespaceURI) def getSupportedNamespaces(): """ getSupportedNamespaces() -> List const * Returns a list of all supported SBMLNamespaces in this version of libsbml. Returns a list with supported SBML namespaces. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBMLNamespaces_getSupportedNamespaces() getSupportedNamespaces = staticmethod(getSupportedNamespaces) def freeSBMLNamespaces(supportedNS): """ freeSBMLNamespaces(List * supportedNS) Frees the list of supported namespaces as generated by getSupportedNamespaces(). Parameter 'supportedNS' is the list to be freed. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBMLNamespaces_freeSBMLNamespaces(supportedNS) freeSBMLNamespaces = staticmethod(freeSBMLNamespaces) def getURI(self): """ getURI(SBMLNamespaces self) -> string Returns a string representing the SBML XML namespace of this object. Returns a string representing the SBML namespace that reflects the SBML Level and Version of this object. """ return _libsbml.SBMLNamespaces_getURI(self) def getLevel(self, *args): """ getLevel(SBMLNamespaces self) -> unsigned int getLevel(SBMLNamespaces self) -> unsigned int Get the SBML Level of this SBMLNamespaces object. Returns the SBML Level of this SBMLNamespaces object. """ return _libsbml.SBMLNamespaces_getLevel(self, *args) def getVersion(self, *args): """ getVersion(SBMLNamespaces self) -> unsigned int getVersion(SBMLNamespaces self) -> unsigned int Get the SBML Version of this SBMLNamespaces object. Returns the SBML Version of this SBMLNamespaces object. """ return _libsbml.SBMLNamespaces_getVersion(self, *args) def getNamespaces(self, *args): """ getNamespaces(SBMLNamespaces self) -> XMLNamespaces getNamespaces(SBMLNamespaces self) -> XMLNamespaces Get the XML namespaces list for this SBMLNamespaces object. SBMLNamespaces objects are used in libSBML to communicate SBML Level and Version data between constructors and other methods. The SBMLNamespaces object class holds triples consisting of SBML Level, Version, and the corresponding SBML XML namespace. Most constructors for SBML objects in libSBML take a SBMLNamespaces object as an argument, thereby allowing the constructor to produce the proper combination of attributes and other internal data structures for the given SBML Level and Version. The plural name (SBMLNamespaces) is not a mistake, because in SBML Level 3, objects may have extensions added by Level 3 packages used by a given model and therefore may have multiple namespaces associated with them. In SBML Levels below Level 3, the SBMLNamespaces object only records one SBML Level/Version/namespace combination at a time. Most constructors for SBML objects in libSBML take a SBMLNamespaces object as an argument, thereby allowing the constructor to produce the proper combination of attributes and other internal data structures for the given SBML Level and Version. Returns the XML namespaces of this SBMLNamespaces object. """ return _libsbml.SBMLNamespaces_getNamespaces(self, *args) def addNamespaces(self, xmlns): """ addNamespaces(SBMLNamespaces self, XMLNamespaces xmlns) -> int Add the given XML namespaces list to the set of namespaces within this SBMLNamespaces object. The following code gives an example of how one could add the XHTML namespace to the list of namespaces recorded by the top-level <sbml> element of a model. It gives the new namespace a prefix of html. sbmlDoc = None try: sbmlDoc = SBMLDocument(3, 1) except ValueError: # Do something to handle exceptional situation. Candidate # causes include invalid combinations of SBML Level and Version # (impossible if hardwired as given here), running out of memory, and # unknown system exceptions. namespaces = sbmlDoc.getNamespaces() if namespaces == None: # Do something to handle case of no namespaces. status = namespaces.add('http://www.w3.org/1999/xhtml', 'html') if status != LIBSBML_OPERATION_SUCCESS: # Do something to handle failure. Parameter 'xmlns' is the XML namespaces to be added. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_INVALID_OBJECT """ return _libsbml.SBMLNamespaces_addNamespaces(self, xmlns) def addNamespace(self, uri, prefix): """ addNamespace(SBMLNamespaces self, string uri, string prefix) -> int Add an XML namespace (a pair of URI and prefix) to the set of namespaces within this SBMLNamespaces object. Parameter 'uri' is the XML namespace to be added. Parameter 'prefix' is the prefix of the namespace to be added. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_INVALID_OBJECT """ return _libsbml.SBMLNamespaces_addNamespace(self, uri, prefix) def removeNamespace(self, uri): """ removeNamespace(SBMLNamespaces self, string uri) -> int Removes an XML namespace from the set of namespaces within this SBMLNamespaces object. Parameter 'uri' is the XML namespace to be added. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INDEX_EXCEEDS_SIZE """ return _libsbml.SBMLNamespaces_removeNamespace(self, uri) def addPackageNamespace(self, *args): """ addPackageNamespace(SBMLNamespaces self, string pkgName, unsigned int pkgVersion, string prefix) -> int addPackageNamespace(SBMLNamespaces self, string pkgName, unsigned int pkgVersion) -> int Add an XML namespace (a pair of URI and prefix) of a package extension to the set of namespaces within this SBMLNamespaces object. The SBML Level and SBML Version of this object is used. Parameter 'pkgName' is the string of package name (e.g. 'layout', 'multi'). Parameter 'pkgVersion' is the package version. Parameter 'prefix' is the prefix of the package namespace to be added. The package's name will be used if the given string is empty (default). Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE Note: An XML namespace of a non-registered package extension can't be added by this function (LIBSBML_INVALID_ATTRIBUTE_VALUE will be returned). See also addNamespace(). Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.SBMLNamespaces_addPackageNamespace(self, *args) def addPackageNamespaces(self, xmlns): """ addPackageNamespaces(SBMLNamespaces self, XMLNamespaces xmlns) -> int Add the XML namespaces of package extensions in the given XMLNamespace object to the set of namespaces within this SBMLNamespaces object (Non-package XML namespaces are not added by this function). Parameter 'xmlns' is the XML namespaces to be added. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE Note: XML namespaces of a non-registered package extensions are not added (just ignored) by this function. LIBSBML_INVALID_ATTRIBUTE_VALUE will be returned if the given xmlns is 'None.' """ return _libsbml.SBMLNamespaces_addPackageNamespaces(self, xmlns) def removePackageNamespace(self, level, version, pkgName, pkgVersion): """ removePackageNamespace(SBMLNamespaces self, unsigned int level, unsigned int version, string pkgName, unsigned int pkgVersion) -> int Removes an XML namespace of a package extension from the set of namespaces within this SBMLNamespaces object. Parameter 'level' is the SBML level. Parameter 'version' is the SBML version. Parameter 'pkgName' is the string of package name (e.g. 'layout', 'multi'). Parameter 'pkgVersion' is the package version. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE * LIBSBML_INDEX_EXCEEDS_SIZE """ return _libsbml.SBMLNamespaces_removePackageNamespace(self, level, version, pkgName, pkgVersion) def addPkgNamespace(self, *args): """ addPkgNamespace(SBMLNamespaces self, string pkgName, unsigned int pkgVersion, string prefix) -> int addPkgNamespace(SBMLNamespaces self, string pkgName, unsigned int pkgVersion) -> int Internal implementation method. """ return _libsbml.SBMLNamespaces_addPkgNamespace(self, *args) def addPkgNamespaces(self, xmlns): """ addPkgNamespaces(SBMLNamespaces self, XMLNamespaces xmlns) -> int Internal implementation method. """ return _libsbml.SBMLNamespaces_addPkgNamespaces(self, xmlns) def removePkgNamespace(self, level, version, pkgName, pkgVersion): """ removePkgNamespace(SBMLNamespaces self, unsigned int level, unsigned int version, string pkgName, unsigned int pkgVersion) -> int Internal implementation method. """ return _libsbml.SBMLNamespaces_removePkgNamespace(self, level, version, pkgName, pkgVersion) def isSBMLNamespace(uri): """ isSBMLNamespace(string uri) -> bool Predicate returning 'True' if the given URL is one of SBML XML namespaces. Parameter 'uri' is the URI of namespace. Returns 'True' if the 'uri' is one of SBML namespaces, 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBMLNamespaces_isSBMLNamespace(uri) isSBMLNamespace = staticmethod(isSBMLNamespace) def isValidCombination(self): """ isValidCombination(SBMLNamespaces self) -> bool Predicate returning 'True' if the given set of namespaces represent a valid set Returns 'True' if the set of namespaces is valid, 'False' otherwise. """ return _libsbml.SBMLNamespaces_isValidCombination(self) def getPackageName(self): """ getPackageName(SBMLNamespaces self) -> string Returns the name of the main package for this namespace. Returns the name of the main package for this namespace. 'core' will be returned if this namespace is defined in the SBML core. """ return _libsbml.SBMLNamespaces_getPackageName(self) __metaclass__ = AutoProperty def __eq__(self, rhs): if ((self is None) and (rhs is None)): return True if ((self is None) or (rhs is None)): return False if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return True return False def __ne__(self, rhs): if ((self is None) and (rhs is None)): return False if ((self is None) or (rhs is None)): return True if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return False return True SBMLNamespaces_swigregister = _libsbml.SBMLNamespaces_swigregister SBMLNamespaces_swigregister(SBMLNamespaces) def SBMLNamespaces_getSBMLNamespaceURI(level, version): """ SBMLNamespaces_getSBMLNamespaceURI(unsigned int level, unsigned int version) -> string Returns a string representing the SBML XML namespace for the given 'level' and 'version' of SBML. Parameter 'level' is the SBML level. Parameter 'version' is the SBML version. Returns a string representing the SBML namespace that reflects the SBML Level and Version specified. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBMLNamespaces_getSBMLNamespaceURI(level, version) def SBMLNamespaces_getSupportedNamespaces(): """ SBMLNamespaces_getSupportedNamespaces() -> List const * Returns a list of all supported SBMLNamespaces in this version of libsbml. Returns a list with supported SBML namespaces. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBMLNamespaces_getSupportedNamespaces() def SBMLNamespaces_freeSBMLNamespaces(supportedNS): """ SBMLNamespaces_freeSBMLNamespaces(List * supportedNS) Frees the list of supported namespaces as generated by getSupportedNamespaces(). Parameter 'supportedNS' is the list to be freed. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBMLNamespaces_freeSBMLNamespaces(supportedNS) def SBMLNamespaces_isSBMLNamespace(uri): """ SBMLNamespaces_isSBMLNamespace(string uri) -> bool Predicate returning 'True' if the given URL is one of SBML XML namespaces. Parameter 'uri' is the URI of namespace. Returns 'True' if the 'uri' is one of SBML namespaces, 'False' otherwise. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.SBMLNamespaces_isSBMLNamespace(uri) class SBMLTransforms(_object): """ Internal implementation method. """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLTransforms, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, SBMLTransforms, name) __repr__ = _swig_repr def replaceFD(*args): """ replaceFD(ASTNode math, FunctionDefinition fd, IdList idsToExclude=None) replaceFD(ASTNode math, FunctionDefinition fd) replaceFD(ASTNode math, ListOfFunctionDefinitions lofd, IdList idsToExclude=None) replaceFD(ASTNode math, ListOfFunctionDefinitions lofd) """ return _libsbml.SBMLTransforms_replaceFD(*args) replaceFD = staticmethod(replaceFD) def expandInitialAssignments(m): """ expandInitialAssignments(Model m) -> bool Internal implementation method. """ return _libsbml.SBMLTransforms_expandInitialAssignments(m) expandInitialAssignments = staticmethod(expandInitialAssignments) def evaluateASTNode(node, m=None): """ evaluateASTNode(ASTNode node, Model m=None) -> double evaluateASTNode(ASTNode node) -> double Internal implementation method. """ return _libsbml.SBMLTransforms_evaluateASTNode(node, m) evaluateASTNode = staticmethod(evaluateASTNode) def expandL3V2InitialAssignments(m): """ expandL3V2InitialAssignments(Model m) -> bool Internal implementation method. """ return _libsbml.SBMLTransforms_expandL3V2InitialAssignments(m) expandL3V2InitialAssignments = staticmethod(expandL3V2InitialAssignments) def mapComponentValues(m): """mapComponentValues(Model m) -> IdList""" return _libsbml.SBMLTransforms_mapComponentValues(m) mapComponentValues = staticmethod(mapComponentValues) def clearComponentValues(): """clearComponentValues()""" return _libsbml.SBMLTransforms_clearComponentValues() clearComponentValues = staticmethod(clearComponentValues) def nodeContainsId(node, ids): """nodeContainsId(ASTNode node, IdList ids) -> bool""" return _libsbml.SBMLTransforms_nodeContainsId(node, ids) nodeContainsId = staticmethod(nodeContainsId) def __init__(self): """ __init__(SBMLTransforms self) -> SBMLTransforms Internal implementation method. """ this = _libsbml.new_SBMLTransforms() try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_SBMLTransforms __del__ = lambda self: None SBMLTransforms_swigregister = _libsbml.SBMLTransforms_swigregister SBMLTransforms_swigregister(SBMLTransforms) def SBMLTransforms_replaceFD(*args): """ replaceFD(ASTNode math, FunctionDefinition fd, IdList idsToExclude=None) replaceFD(ASTNode math, FunctionDefinition fd) replaceFD(ASTNode math, ListOfFunctionDefinitions lofd, IdList idsToExclude=None) SBMLTransforms_replaceFD(ASTNode math, ListOfFunctionDefinitions lofd) """ return _libsbml.SBMLTransforms_replaceFD(*args) def SBMLTransforms_expandInitialAssignments(m): """ SBMLTransforms_expandInitialAssignments(Model m) -> bool Internal implementation method. """ return _libsbml.SBMLTransforms_expandInitialAssignments(m) def SBMLTransforms_evaluateASTNode(node, m=None): """ evaluateASTNode(ASTNode node, Model m=None) -> double SBMLTransforms_evaluateASTNode(ASTNode node) -> double Internal implementation method. """ return _libsbml.SBMLTransforms_evaluateASTNode(node, m) def SBMLTransforms_expandL3V2InitialAssignments(m): """ SBMLTransforms_expandL3V2InitialAssignments(Model m) -> bool Internal implementation method. """ return _libsbml.SBMLTransforms_expandL3V2InitialAssignments(m) def SBMLTransforms_mapComponentValues(m): """SBMLTransforms_mapComponentValues(Model m) -> IdList""" return _libsbml.SBMLTransforms_mapComponentValues(m) def SBMLTransforms_clearComponentValues(): """SBMLTransforms_clearComponentValues()""" return _libsbml.SBMLTransforms_clearComponentValues() def SBMLTransforms_nodeContainsId(node, ids): """SBMLTransforms_nodeContainsId(ASTNode node, IdList ids) -> bool""" return _libsbml.SBMLTransforms_nodeContainsId(node, ids) CNV_TYPE_BOOL = _libsbml.CNV_TYPE_BOOL CNV_TYPE_DOUBLE = _libsbml.CNV_TYPE_DOUBLE CNV_TYPE_INT = _libsbml.CNV_TYPE_INT CNV_TYPE_SINGLE = _libsbml.CNV_TYPE_SINGLE CNV_TYPE_STRING = _libsbml.CNV_TYPE_STRING class ConversionOption(_object): """ A single configuration setting for an SBML converter. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. It is a class used in the implementation of extra functionality provided by libSBML. LibSBML provides a number of converters that can perform transformations on SBML documents. These converters allow their behaviors to be controlled by setting property values. Converter properties are communicated using objects of class ConversionProperties, and within such objects, individual options are encapsulated using ConversionOption objects. A ConversionOption object consists of four parts: * A key, acting as the name of the option. * A value of this option. * A type for the value; the type code is chosen from a set of integer constants whose names all begin with the prefix CNV_TYPE_. (See the separate subsection below for more information.) * A description consisting of a text string that describes the option in some way. There are no constraints on the values of keys or descriptions; authors of SBML converters are free to choose them as they see fit. Conversion option data types ====================================================================== An option in ConversionOption must have a data type declared, to indicate whether it is a string value, an integer, and so forth. The possible types of values are taken from a set of constants whose symbol names begin with the prefix CNV_TYPE_. The following are the possible values: <p> <center> Enumerator Meaning CNV_TYPE_BOOL Indicates the value type is a Boolean. CNV_TYPE_DOUBLE Indicates the value type is a double-sized float. CNV_TYPE_INT Indicates the value type is an integer. CNV_TYPE_SINGLE Indicates the value type is a float. CNV_TYPE_STRING Indicates the value type is a string. </center> See also ConversionProperties. """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, ConversionOption, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, ConversionOption, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(ConversionOption self, string key, string value, ConversionOptionType_t type=CNV_TYPE_STRING, string description) -> ConversionOption __init__(ConversionOption self, string key, string value, ConversionOptionType_t type=CNV_TYPE_STRING) -> ConversionOption __init__(ConversionOption self, string key, string value) -> ConversionOption __init__(ConversionOption self, string key) -> ConversionOption __init__(ConversionOption self, string key, char const * value, string description) -> ConversionOption __init__(ConversionOption self, string key, char const * value) -> ConversionOption __init__(ConversionOption self, string key, bool value, string description) -> ConversionOption __init__(ConversionOption self, string key, bool value) -> ConversionOption __init__(ConversionOption self, string key, double value, string description) -> ConversionOption __init__(ConversionOption self, string key, double value) -> ConversionOption __init__(ConversionOption self, string key, float value, string description) -> ConversionOption __init__(ConversionOption self, string key, float value) -> ConversionOption __init__(ConversionOption self, string key, int value, string description) -> ConversionOption __init__(ConversionOption self, string key, int value) -> ConversionOption __init__(ConversionOption self, ConversionOption orig) -> ConversionOption This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: ConversionOption(string key, double value, string description='') Creates a new ConversionOption specialized for double-type options. Parameter 'key' is the key for this option. Parameter 'value' is the value for this option. Parameter 'description' is an optional description. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> ______________________________________________________________________ Method variant with the following signature: ConversionOption(string key, int value, string description='') Creates a new ConversionOption specialized for integer-type options. Parameter 'key' is the key for this option. Parameter 'value' is the value for this option. Parameter 'description' is an optional description. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> ______________________________________________________________________ Method variant with the following signature: ConversionOption(string key, float value, string description='') Creates a new ConversionOption specialized for float-type options. Parameter 'key' is the key for this option. Parameter 'value' is the value for this option. Parameter 'description' is an optional description. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> ______________________________________________________________________ Method variant with the following signature: ConversionOption(string key, string value='', ConversionOptionType_t type=CNV_TYPE_STRING, string description='') Creates a new ConversionOption. This is the general constructor, taking arguments for all aspects of an option. Other constructors exist with different arguments. The conversion 'type' argument value must be one of the constants whose names begin with the characters CNV_TYPE_ in the interface class libsbml. Parameter 'key' is the key for this option. Parameter 'value' is an optional value for this option. Parameter 'type' is the type of this option. Parameter 'description' is the description for this option. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> ______________________________________________________________________ Method variant with the following signature: ConversionOption(ConversionOption orig) Copy constructor; creates a copy of an ConversionOption object. Parameter 'orig' is the ConversionOption object to copy. ______________________________________________________________________ Method variant with the following signature: ConversionOption(string key, bool value, string description='') Creates a new ConversionOption specialized for Boolean-type options. Parameter 'key' is the key for this option. Parameter 'value' is the value for this option. Parameter 'description' is an optional description. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> ______________________________________________________________________ Method variant with the following signature: ConversionOption(string key, string value, string description='') Creates a new ConversionOption specialized for string-type options. Parameter 'key' is the key for this option. Parameter 'value' is the value for this option. Parameter 'description' is an optional description. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> """ this = _libsbml.new_ConversionOption(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_ConversionOption __del__ = lambda self: None def clone(self): """ clone(ConversionOption self) -> ConversionOption Creates and returns a deep copy of this ConversionOption object. Returns the (deep) copy of this ConversionOption object. """ return _libsbml.ConversionOption_clone(self) def getKey(self): """ getKey(ConversionOption self) -> string Returns the key for this option. Returns the key, as a string. """ return _libsbml.ConversionOption_getKey(self) def setKey(self, key): """ setKey(ConversionOption self, string key) Sets the key for this option. Parameter 'key' is a string representing the key to set. """ return _libsbml.ConversionOption_setKey(self, key) def getValue(self): """ getValue(ConversionOption self) -> string Returns the value of this option. Returns the value of this option, as a string. """ return _libsbml.ConversionOption_getValue(self) def setValue(self, value): """ setValue(ConversionOption self, string value) Sets the value for this option. Parameter 'value' is the value to set, as a string. """ return _libsbml.ConversionOption_setValue(self, value) def getDescription(self): """ getDescription(ConversionOption self) -> string Returns the description string for this option. Returns the description of this option. """ return _libsbml.ConversionOption_getDescription(self) def setDescription(self, description): """ setDescription(ConversionOption self, string description) Sets the description text for this option. Parameter 'description' is the description to set for this option. """ return _libsbml.ConversionOption_setDescription(self, description) def getType(self): """ getType(ConversionOption self) -> ConversionOptionType_t Returns the type of this option Returns the type of this option. """ return _libsbml.ConversionOption_getType(self) def setType(self, type): """ setType(ConversionOption self, ConversionOptionType_t type) Sets the type of this option. The conversion 'type' argument value must be one of the constants whose names begin with the characters CNV_TYPE_ in the interface class libsbml. Parameter 'type' is the type value to use. """ return _libsbml.ConversionOption_setType(self, type) def getBoolValue(self): """ getBoolValue(ConversionOption self) -> bool Returns the value of this option as a Boolean. Returns the value of this option. """ return _libsbml.ConversionOption_getBoolValue(self) def setBoolValue(self, value): """ setBoolValue(ConversionOption self, bool value) Set the value of this option to a given Boolean value. Invoking this method will also set the type of the option to CNV_TYPE_BOOL. Parameter 'value' is the Boolean value to set. """ return _libsbml.ConversionOption_setBoolValue(self, value) def getDoubleValue(self): """ getDoubleValue(ConversionOption self) -> double Returns the value of this option as a 'float.' Returns the value of this option. """ return _libsbml.ConversionOption_getDoubleValue(self) def setDoubleValue(self, value): """ setDoubleValue(ConversionOption self, double value) Set the value of this option to a given 'float' value. Invoking this method will also set the type of the option to CNV_TYPE_DOUBLE. Parameter 'value' is the value to set. """ return _libsbml.ConversionOption_setDoubleValue(self, value) def getFloatValue(self): """ getFloatValue(ConversionOption self) -> float Returns the value of this option as a 'float.' Returns the value of this option as a float. """ return _libsbml.ConversionOption_getFloatValue(self) def setFloatValue(self, value): """ setFloatValue(ConversionOption self, float value) Set the value of this option to a given 'float' value. Invoking this method will also set the type of the option to CNV_TYPE_SINGLE. Parameter 'value' is the value to set. """ return _libsbml.ConversionOption_setFloatValue(self, value) def getIntValue(self): """ getIntValue(ConversionOption self) -> int Returns the value of this option as an 'integer.' Returns the value of this option, as an int. """ return _libsbml.ConversionOption_getIntValue(self) def setIntValue(self, value): """ setIntValue(ConversionOption self, int value) Set the value of this option to a given 'int' value. Invoking this method will also set the type of the option to CNV_TYPE_INT. Parameter 'value' is the value to set. """ return _libsbml.ConversionOption_setIntValue(self, value) ConversionOption_swigregister = _libsbml.ConversionOption_swigregister ConversionOption_swigregister(ConversionOption) class ConversionProperties(_object): """ Set of configuration option values for a converter. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. It is a class used in the implementation of extra functionality provided by libSBML. LibSBML provides a number of converters that can perform transformations on SBML documents. The properties of SBML converters are communicated using objects of class ConversionProperties, and within such objects, individual options are encapsulated using ConversionOption objects. The ConversionProperties class provides numerous methods for setting and getting options. ConversionProperties objects are also used to determine the target SBML namespace when an SBML converter's behavior depends on the intended Level+Version combination of SBML. In addition, it is conceivable that conversions may be affected by SBML Level 3 packages being used by an SBML document; consequently, the packages in use are also communicated by the values of the SBML namespaces set on a ConversionProperties object. General information about the use of SBML converters ====================================================================== The use of all the converters follows a similar approach. First, one creates a ConversionProperties object and calls ConversionProperties.addOption() on this object with one argument: a text string that identifies the desired converter. (The text string is specific to each converter; consult the documentation for a given converter to find out how it should be enabled.) Next, for some converters, the caller can optionally set some converter-specific properties using additional calls to ConversionProperties.addOption(). Many converters provide the ability to configure their behavior to some extent; this is realized through the use of properties that offer different options. The default property values for each converter can be interrogated using the method SBMLConverter.getDefaultProperties() on the converter class in question . Finally, the caller should invoke the method SBMLDocument.convert() with the ConversionProperties object as an argument. Example of invoking an SBML converter ...................................................................... The following code fragment illustrates an example using SBMLReactionConverter, which is invoked using the option string ''replaceReactions':' config = ConversionProperties() if config != None: config.addOption('replaceReactions') In the case of SBMLReactionConverter, there are no options to affect its behavior, so the next step is simply to invoke the converter on an SBMLDocument object. Continuing the example code: # Assume that the variable 'document' has been set to an SBMLDocument object. status = document.convert(config) if status != LIBSBML_OPERATION_SUCCESS: # Handle error somehow. print('Error: conversion failed due to the following:') document.printErrors() Here is an example of using a converter that offers an option. The following code invokes SBMLStripPackageConverter to remove the SBML Level 3 Layout package from a model. It sets the name of the package to be removed by adding a value for the option named ''package'' defined by that converter: def strip_layout_example(document): config = ConversionProperties() if config != None: config.addOption('stripPackage') config.addOption('package', 'layout') status = document.convert(config) if status != LIBSBML_OPERATION_SUCCESS: # Handle error somehow. print('Error: unable to strip the Layout package.') print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip()) else: # Handle error somehow. print('Error: unable to create ConversionProperties object') Available SBML converters in libSBML ...................................................................... LibSBML provides a number of built-in converters; by convention, their names end in Converter. The following are the built-in converters provided by libSBML 5.17.2: @copydetails doc_list_of_libsbml_converters See also ConversionOption, SBMLNamespaces. """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, ConversionProperties, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, ConversionProperties, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(ConversionProperties self, SBMLNamespaces targetNS=None) -> ConversionProperties __init__(ConversionProperties self) -> ConversionProperties __init__(ConversionProperties self, ConversionProperties orig) -> ConversionProperties This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: ConversionProperties(ConversionProperties orig) Copy constructor. Parameter 'orig' is the object to copy. ______________________________________________________________________ Method variant with the following signature: ConversionProperties(SBMLNamespaces targetNS=None) Constructor that initializes the conversion properties with a specific SBML target namespace. Parameter 'targetNS' is the target namespace to convert to. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> """ this = _libsbml.new_ConversionProperties(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(ConversionProperties self) -> ConversionProperties Creates and returns a deep copy of this ConversionProperties object. Returns the (deep) copy of this ConversionProperties object. """ return _libsbml.ConversionProperties_clone(self) __swig_destroy__ = _libsbml.delete_ConversionProperties __del__ = lambda self: None def getTargetNamespaces(self): """ getTargetNamespaces(ConversionProperties self) -> SBMLNamespaces Returns the current target SBML namespace. Returns the SBMLNamepaces object expressing the target namespace. """ return _libsbml.ConversionProperties_getTargetNamespaces(self) def hasTargetNamespaces(self): """ hasTargetNamespaces(ConversionProperties self) -> bool Returns 'True' if the target SBML namespace has been set. Returns 'True' if the target namespace has been set, 'False' otherwise. """ return _libsbml.ConversionProperties_hasTargetNamespaces(self) def setTargetNamespaces(self, targetNS): """ setTargetNamespaces(ConversionProperties self, SBMLNamespaces targetNS) Sets the target namespace. Parameter 'targetNS' is the target namespace to use. """ return _libsbml.ConversionProperties_setTargetNamespaces(self, targetNS) def getDescription(self, key): """ getDescription(ConversionProperties self, string key) -> string Returns the description string for a given option in this properties object. Parameter 'key' is the key for the option. Returns the description text of the option with the given key. """ return _libsbml.ConversionProperties_getDescription(self, key) def getType(self, key): """ getType(ConversionProperties self, string key) -> ConversionOptionType_t Returns the type of a given option in this properties object. Parameter 'key' is the key for the option. Returns the type of the option with the given key. """ return _libsbml.ConversionProperties_getType(self, key) def getOption(self, *args): """ getOption(ConversionProperties self, string key) -> ConversionOption getOption(ConversionProperties self, int index) -> ConversionOption This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getOption(int index) Returns the ConversionOption object for the given 'index'. Parameter 'index' is the index for the option. Returns the option with the given 'index'. ______________________________________________________________________ Method variant with the following signature: getOption(string key) Returns the ConversionOption object for a given key. Parameter 'key' is the key for the option. Returns the option with the given key. """ return _libsbml.ConversionProperties_getOption(self, *args) def addOption(self, *args): """ addOption(ConversionProperties self, ConversionOption option) addOption(ConversionProperties self, string key, string value, ConversionOptionType_t type=CNV_TYPE_STRING, string description) addOption(ConversionProperties self, string key, string value, ConversionOptionType_t type=CNV_TYPE_STRING) addOption(ConversionProperties self, string key, string value) addOption(ConversionProperties self, string key) addOption(ConversionProperties self, string key, char const * value, string description) addOption(ConversionProperties self, string key, char const * value) addOption(ConversionProperties self, string key, bool value, string description) addOption(ConversionProperties self, string key, bool value) addOption(ConversionProperties self, string key, double value, string description) addOption(ConversionProperties self, string key, double value) addOption(ConversionProperties self, string key, float value, string description) addOption(ConversionProperties self, string key, float value) addOption(ConversionProperties self, string key, int value, string description) addOption(ConversionProperties self, string key, int value) This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: addOption(string key, double value, string description='') Adds a new ConversionOption object with the given parameters. Parameter 'key' is the key for the new option. Parameter 'value' is the double value of that option. Parameter 'description' is (optional) the description for the option. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> ______________________________________________________________________ Method variant with the following signature: addOption(ConversionOption option) Adds a copy of the given option to this properties object. Parameter 'option' is the option to add. ______________________________________________________________________ Method variant with the following signature: addOption(string key, int value, string description='') Adds a new ConversionOption object with the given parameters. Parameter 'key' is the key for the new option. Parameter 'value' is the integer value of that option. Parameter 'description' is (optional) the description for the option. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> ______________________________________________________________________ Method variant with the following signature: addOption(string key, float value, string description='') Adds a new ConversionOption object with the given parameters. Parameter 'key' is the key for the new option. Parameter 'value' is the float value of that option. Parameter 'description' is (optional) the description for the option. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> ______________________________________________________________________ Method variant with the following signature: addOption(string key, string value='', ConversionOptionType_t type=CNV_TYPE_STRING, string description='') Adds a new ConversionOption object with the given parameters. Parameter 'key' is the key for the new option. Parameter 'value' is (optional) the value of that option. Parameter 'type' is (optional) the type of the option (see the documentation for ConversionOption for more information about the types). Parameter 'description' is (optional) the description for the option. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> ______________________________________________________________________ Method variant with the following signature: addOption(string key, bool value, string description='') Adds a new ConversionOption object with the given parameters. Parameter 'key' is the key for the new option. Parameter 'value' is the boolean value of that option. Parameter 'description' is (optional) the description for the option. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> ______________________________________________________________________ Method variant with the following signature: addOption(string key, string value, string description='') Adds a new ConversionOption object with the given parameters. Parameter 'key' is the key for the new option. Parameter 'value' is the string value of that option. Parameter 'description' is (optional) the description for the option. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> """ return _libsbml.ConversionProperties_addOption(self, *args) def removeOption(self, key): """ removeOption(ConversionProperties self, string key) -> ConversionOption Removes the option with the given key from this properties object. Parameter 'key' is the key for the new option to remove. Returns the removed option. """ return _libsbml.ConversionProperties_removeOption(self, key) def hasOption(self, key): """ hasOption(ConversionProperties self, string key) -> bool Returns 'True' if this properties object contains an option with the given key. Parameter 'key' is the key of the option to find. Returns 'True' if an option with the given 'key' exists in this properties object, 'False' otherwise. """ return _libsbml.ConversionProperties_hasOption(self, key) def getValue(self, key): """ getValue(ConversionProperties self, string key) -> string Returns the value of the given option as a string. Parameter 'key' is the key for the option. Returns the string value of the option with the given key. """ return _libsbml.ConversionProperties_getValue(self, key) def setValue(self, key, value): """ setValue(ConversionProperties self, string key, string value) Sets the value of the given option to a string. Parameter 'key' is the key for the option. Parameter 'value' is the new value. """ return _libsbml.ConversionProperties_setValue(self, key, value) def getBoolValue(self, key): """ getBoolValue(ConversionProperties self, string key) -> bool Returns the value of the given option as a Boolean. Parameter 'key' is the key for the option. Returns the boolean value of the option with the given key. """ return _libsbml.ConversionProperties_getBoolValue(self, key) def setBoolValue(self, key, value): """ setBoolValue(ConversionProperties self, string key, bool value) Sets the value of the given option to a Boolean. Parameter 'key' is the key for the option. Parameter 'value' is the new Boolean value. """ return _libsbml.ConversionProperties_setBoolValue(self, key, value) def getDoubleValue(self, key): """ getDoubleValue(ConversionProperties self, string key) -> double Returns the value of the given option as a 'float.' Parameter 'key' is the key for the option. Returns the double value of the option with the given key. """ return _libsbml.ConversionProperties_getDoubleValue(self, key) def setDoubleValue(self, key, value): """ setDoubleValue(ConversionProperties self, string key, double value) Sets the value of the given option to a 'float.' Parameter 'key' is the key for the option. Parameter 'value' is the new double value. """ return _libsbml.ConversionProperties_setDoubleValue(self, key, value) def getFloatValue(self, key): """ getFloatValue(ConversionProperties self, string key) -> float Returns the value of the given option as a 'float.' Parameter 'key' is the key for the option. Returns the float value of the option with the given key. """ return _libsbml.ConversionProperties_getFloatValue(self, key) def setFloatValue(self, key, value): """ setFloatValue(ConversionProperties self, string key, float value) Sets the value of the given option to a 'float.' Parameter 'key' is the key for the option. Parameter 'value' is the new float value. """ return _libsbml.ConversionProperties_setFloatValue(self, key, value) def getIntValue(self, key): """ getIntValue(ConversionProperties self, string key) -> int Returns the value of the given option as an integer. Parameter 'key' is the key for the option. Returns the int value of the option with the given key. """ return _libsbml.ConversionProperties_getIntValue(self, key) def setIntValue(self, key, value): """ setIntValue(ConversionProperties self, string key, int value) Sets the value of the given option to an integer. Parameter 'key' is the key for the option. Parameter 'value' is the new integer value. """ return _libsbml.ConversionProperties_setIntValue(self, key, value) def getNumOptions(self): """ getNumOptions(ConversionProperties self) -> int Returns the number of options in this Conversion Properties object Returns the number of options in this properties object. """ return _libsbml.ConversionProperties_getNumOptions(self) ConversionProperties_swigregister = _libsbml.ConversionProperties_swigregister ConversionProperties_swigregister(ConversionProperties) class SBMLConverter(_object): """ Base class for SBML converters. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. It is a class used in the implementation of extra functionality provided by libSBML. The SBMLConverter class is the base class for the various SBML converters: classes of objects that transform or convert SBML documents. These transformations can involve essentially anything that can be written algorithmically; examples include converting the units of measurement in a model, or converting from one Level+Version combination of SBML to another. Applications can also create their own converters by subclassing SBMLConverter and following the examples of the existing converters. General information about the use of SBML converters ====================================================================== The use of all the converters follows a similar approach. First, one creates a ConversionProperties object and calls ConversionProperties.addOption() on this object with one argument: a text string that identifies the desired converter. (The text string is specific to each converter; consult the documentation for a given converter to find out how it should be enabled.) Next, for some converters, the caller can optionally set some converter-specific properties using additional calls to ConversionProperties.addOption(). Many converters provide the ability to configure their behavior to some extent; this is realized through the use of properties that offer different options. The default property values for each converter can be interrogated using the method SBMLConverter.getDefaultProperties() on the converter class in question . Finally, the caller should invoke the method SBMLDocument.convert() with the ConversionProperties object as an argument. Example of invoking an SBML converter ...................................................................... The following code fragment illustrates an example using SBMLReactionConverter, which is invoked using the option string ''replaceReactions':' config = ConversionProperties() if config != None: config.addOption('replaceReactions') In the case of SBMLReactionConverter, there are no options to affect its behavior, so the next step is simply to invoke the converter on an SBMLDocument object. Continuing the example code: # Assume that the variable 'document' has been set to an SBMLDocument object. status = document.convert(config) if status != LIBSBML_OPERATION_SUCCESS: # Handle error somehow. print('Error: conversion failed due to the following:') document.printErrors() Here is an example of using a converter that offers an option. The following code invokes SBMLStripPackageConverter to remove the SBML Level 3 Layout package from a model. It sets the name of the package to be removed by adding a value for the option named ''package'' defined by that converter: def strip_layout_example(document): config = ConversionProperties() if config != None: config.addOption('stripPackage') config.addOption('package', 'layout') status = document.convert(config) if status != LIBSBML_OPERATION_SUCCESS: # Handle error somehow. print('Error: unable to strip the Layout package.') print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip()) else: # Handle error somehow. print('Error: unable to create ConversionProperties object') Available SBML converters in libSBML ...................................................................... LibSBML provides a number of built-in converters; by convention, their names end in Converter. The following are the built-in converters provided by libSBML 5.17.2: @copydetails doc_list_of_libsbml_converters """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLConverter, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, SBMLConverter, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(SBMLConverter self) -> SBMLConverter __init__(SBMLConverter self, string name) -> SBMLConverter __init__(SBMLConverter self, SBMLConverter orig) -> SBMLConverter This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: SBMLConverter() Creates a new SBMLConverter object. ______________________________________________________________________ Method variant with the following signature: SBMLConverter(SBMLConverter orig) Copy constructor. This creates a copy of an SBMLConverter object. Parameter 'orig' is the SBMLConverter object to copy. ______________________________________________________________________ Method variant with the following signature: SBMLConverter(string name) Creates a new SBMLConverter object with a given name. Parameter 'name' is the name for the converter to create. """ if self.__class__ == SBMLConverter: _self = None else: _self = self this = _libsbml.new_SBMLConverter(_self, *args) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_SBMLConverter __del__ = lambda self: None def clone(self): """ clone(SBMLConverter self) -> SBMLConverter Creates and returns a deep copy of this SBMLConverter object. Returns the (deep) copy of this SBMLConverter object. """ return _libsbml.SBMLConverter_clone(self) def getDocument(self, *args): """ getDocument(SBMLConverter self) -> SBMLDocument getDocument(SBMLConverter self) -> SBMLDocument Returns the SBML document that is the subject of the conversions. Returns the current SBMLDocument object. """ return _libsbml.SBMLConverter_getDocument(self, *args) def getDefaultProperties(self): """ getDefaultProperties(SBMLConverter self) -> ConversionProperties Returns the default properties of this converter. A given converter exposes one or more properties that can be adjusted in order to influence the behavior of the converter. This method returns the default property settings for this converter. It is meant to be called in order to discover all the settings for the converter object. The run-time properties of the converter object can be adjusted by using the method SBMLConverter.setProperties(). Returns the default properties for the converter. See also setProperties(), matchesProperties(). """ return _libsbml.SBMLConverter_getDefaultProperties(self) def getTargetNamespaces(self): """ getTargetNamespaces(SBMLConverter self) -> SBMLNamespaces Returns the target SBML namespaces of the currently set properties. SBML namespaces are used by libSBML to express the Level+Version of the SBML document (and, possibly, any SBML Level 3 packages in use). Some converters' behavior is affected by the SBML namespace configured in the converter. For example, in SBMLLevelVersionConverter (the converter for converting SBML documents from one Level+Version combination to another), the actions are fundamentally dependent on the SBML namespaces targeted. Returns the SBMLNamespaces object that describes the SBML namespaces in effect, or 'None' if none are set. """ return _libsbml.SBMLConverter_getTargetNamespaces(self) def matchesProperties(self, props): """ matchesProperties(SBMLConverter self, ConversionProperties props) -> bool Returns 'True' if this converter matches the given properties. Given a ConversionProperties object 'props', this method checks that 'props' possesses an option value to enable this converter. If it does, this method returns 'True.' Parameter 'props' is the properties to match. Returns 'True' if the properties 'props' would match the necessary properties for this type of converter, 'False' otherwise. """ return _libsbml.SBMLConverter_matchesProperties(self, props) def setDocument(self, doc): """ setDocument(SBMLConverter self, SBMLDocument doc) -> int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: setDocument(SBMLDocument doc) Sets the SBML document to be converted. Parameter 'doc' is the document to use for this conversion. Returns integer value indicating the success/failure of the operation. The set of possible values that may be returned ultimately depends on the specific subclass of SBMLConverter being used, but the default method can return the following: * LIBSBML_OPERATION_SUCCESS ______________________________________________________________________ Method variant with the following signature: setDocument(SBMLDocument doc) Sets the SBML document to be converted. Parameter 'doc' is the document to use for this conversion. Returns integer value indicating the success/failure of the operation. The set of possible values that may be returned ultimately depends on the specific subclass of SBMLConverter being used, but the default method can return the following: * LIBSBML_OPERATION_SUCCESS """ return _libsbml.SBMLConverter_setDocument(self, doc) def setProperties(self, props): """ setProperties(SBMLConverter self, ConversionProperties props) -> int Sets the configuration properties to be used by this converter. Parameter 'props' is the ConversionProperties object defining the properties to set. Returns integer value indicating the success/failure of the operation. The set of possible values that may be returned ultimately depends on the specific subclass of SBMLConverter being used, but the default method can return the following values: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also getProperties(), matchesProperties(). """ return _libsbml.SBMLConverter_setProperties(self, props) def getProperties(self): """ getProperties(SBMLConverter self) -> ConversionProperties Returns the current properties in effect for this converter. A given converter exposes one or more properties that can be adjusted in order to influence the behavior of the converter. This method returns the current properties for this converter; in other words, the settings in effect at this moment. To change the property values, you can use SBMLConverter.setProperties(). Returns the currently set configuration properties. See also setProperties(), matchesProperties(). """ return _libsbml.SBMLConverter_getProperties(self) def convert(self): """ convert(SBMLConverter self) -> int Perform the conversion. This method causes the converter to do the actual conversion work, that is, to convert the SBMLDocument object set by SBMLConverter.setDocument() and with the configuration options set by SBMLConverter.setProperties(). Returns integer value indicating the success/failure of the operation. The set of possible values that may be returned depends on the converter subclass; please consult the documentation for the relevant class to find out what the possibilities are. """ return _libsbml.SBMLConverter_convert(self) def getName(self): """ getName(SBMLConverter self) -> string Returns the name of this converter. Returns a string, the name of this converter. """ return _libsbml.SBMLConverter_getName(self) def __disown__(self): self.this.disown() _libsbml.disown_SBMLConverter(self) return weakref_proxy(self) SBMLConverter_swigregister = _libsbml.SBMLConverter_swigregister SBMLConverter_swigregister(SBMLConverter) class SBMLConverterRegistry(_object): """ Registry of all libSBML SBML converters. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. It is a class used in the implementation of extra functionality provided by libSBML. LibSBML provides facilities for transforming and converting SBML documents in various ways. These transformations can involve essentially anything that can be written algorithmically; examples include converting the units of measurement in a model, or converting from one Level+Version combination of SBML to another. Converters are implemented as objects derived from the class SBMLConverter. The converter registry, implemented as a singleton object of class SBMLConverterRegistry, maintains a list of known converters and provides methods for discovering them. Callers can use the method SBMLConverterRegistry.getNumConverters() to find out how many converters are registered, then use SBMLConverterRegistry.getConverterByIndex() to iterate over each one; alternatively, callers can use SBMLConverterRegistry.getConverterFor() to search for a converter having specific properties. """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLConverterRegistry, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, SBMLConverterRegistry, name) def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") __repr__ = _swig_repr def getInstance(): """ getInstance() -> SBMLConverterRegistry Returns the singleton instance for the converter registry. Prior to using the registry, callers have to obtain a copy of the registry. This static method provides the means for doing that. Returns the singleton for the converter registry. """ return _libsbml.SBMLConverterRegistry_getInstance() getInstance = staticmethod(getInstance) def addConverter(self, converter): """ addConverter(SBMLConverterRegistry self, SBMLConverter converter) -> int Adds the given converter to the registry of SBML converters. Parameter 'converter' is the converter to add to the registry. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT """ return _libsbml.SBMLConverterRegistry_addConverter(self, converter) def getConverterByIndex(self, index): """ getConverterByIndex(SBMLConverterRegistry self, int index) -> SBMLConverter Returns the converter with the given index number. Converters are given arbitrary index numbers by the registry. Callers can use the method SBMLConverterRegistry.getNumConverters() to find out how many converters are registered, then use this method to iterate over the list and obtain each one in turn. Parameter 'index' is the zero-based index of the converter to fetch. Returns the converter with the given index number, or 'None' if the number is less than '0' or there is no converter at the given index position. """ return _libsbml.SBMLConverterRegistry_getConverterByIndex(self, index) def getConverterFor(self, props): """ getConverterFor(SBMLConverterRegistry self, ConversionProperties props) -> SBMLConverter Returns the converter that best matches the given configuration properties. Many converters provide the ability to configure their behavior. This is realized through the use of properties that offer different options. The present method allows callers to search for converters that have specific property values. Callers can do this by creating a ConversionProperties object, adding the desired option(s) to the object, then passing the object to this method. Parameter 'props' is a ConversionProperties object defining the properties to match against. Returns the converter matching the properties, or 'None' if no suitable converter is found. See also getConverterByIndex(). """ return _libsbml.SBMLConverterRegistry_getConverterFor(self, props) def getNumConverters(self): """ getNumConverters(SBMLConverterRegistry self) -> int Returns the number of converters known by the registry. Returns the number of registered converters. See also getConverterByIndex(). """ return _libsbml.SBMLConverterRegistry_getNumConverters(self) __swig_destroy__ = _libsbml.delete_SBMLConverterRegistry __del__ = lambda self: None SBMLConverterRegistry_swigregister = _libsbml.SBMLConverterRegistry_swigregister SBMLConverterRegistry_swigregister(SBMLConverterRegistry) def SBMLConverterRegistry_getInstance(): """ SBMLConverterRegistry_getInstance() -> SBMLConverterRegistry Returns the singleton instance for the converter registry. Prior to using the registry, callers have to obtain a copy of the registry. This static method provides the means for doing that. Returns the singleton for the converter registry. """ return _libsbml.SBMLConverterRegistry_getInstance() class SBMLFunctionDefinitionConverter(SBMLConverter): """ Converter to expand user-defined functions in-line. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. It is a class used in the implementation of extra functionality provided by libSBML. This converter manipulates user-defined functions in an SBML file. When invoked on a model, it performs the following operations: * Reads the list of user-defined functions in the model (i.e., the list of FunctionDefinition objects); * Looks for invocations of the function in mathematical expressions throughout the model; and * For each invocation found, replaces the invocation with a in-line copy of the function's body, similar to how macro expansions might be performed in scripting and programming languages. For example, suppose the model contains a function definition representing the function f(x, y) = x * y. Further suppose this functions invoked somewhere else in the model, in a mathematical formula, as f(s, p). The outcome of running SBMLFunctionDefinitionConverter on the model will be to replace the call to f with the expression s * p. Configuration and use of SBMLFunctionDefinitionConverter ====================================================================== SBMLFunctionDefinitionConverter is enabled by creating a ConversionProperties object with the option ''expandFunctionDefinitions',' and passing this properties object to SBMLDocument.convert(). The converter accepts one option: * ''skipIds':' if set, it should be a string containing a comma- separated list of identifiers (SBML 'id' values) that are to be skipped during function conversion. Functions whose identifiers are found in this list will not be converted. General information about the use of SBML converters ====================================================================== The use of all the converters follows a similar approach. First, one creates a ConversionProperties object and calls ConversionProperties.addOption() on this object with one argument: a text string that identifies the desired converter. (The text string is specific to each converter; consult the documentation for a given converter to find out how it should be enabled.) Next, for some converters, the caller can optionally set some converter-specific properties using additional calls to ConversionProperties.addOption(). Many converters provide the ability to configure their behavior to some extent; this is realized through the use of properties that offer different options. The default property values for each converter can be interrogated using the method SBMLConverter.getDefaultProperties() on the converter class in question . Finally, the caller should invoke the method SBMLDocument.convert() with the ConversionProperties object as an argument. Example of invoking an SBML converter ...................................................................... The following code fragment illustrates an example using SBMLReactionConverter, which is invoked using the option string ''replaceReactions':' config = ConversionProperties() if config != None: config.addOption('replaceReactions') In the case of SBMLReactionConverter, there are no options to affect its behavior, so the next step is simply to invoke the converter on an SBMLDocument object. Continuing the example code: # Assume that the variable 'document' has been set to an SBMLDocument object. status = document.convert(config) if status != LIBSBML_OPERATION_SUCCESS: # Handle error somehow. print('Error: conversion failed due to the following:') document.printErrors() Here is an example of using a converter that offers an option. The following code invokes SBMLStripPackageConverter to remove the SBML Level 3 Layout package from a model. It sets the name of the package to be removed by adding a value for the option named ''package'' defined by that converter: def strip_layout_example(document): config = ConversionProperties() if config != None: config.addOption('stripPackage') config.addOption('package', 'layout') status = document.convert(config) if status != LIBSBML_OPERATION_SUCCESS: # Handle error somehow. print('Error: unable to strip the Layout package.') print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip()) else: # Handle error somehow. print('Error: unable to create ConversionProperties object') Available SBML converters in libSBML ...................................................................... LibSBML provides a number of built-in converters; by convention, their names end in Converter. The following are the built-in converters provided by libSBML 5.17.2: @copydetails doc_list_of_libsbml_converters """ __swig_setmethods__ = {} for _s in [SBMLConverter]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLFunctionDefinitionConverter, name, value) __swig_getmethods__ = {} for _s in [SBMLConverter]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, SBMLFunctionDefinitionConverter, name) __repr__ = _swig_repr def init(): """ init() Internal implementation method. """ return _libsbml.SBMLFunctionDefinitionConverter_init() init = staticmethod(init) def __init__(self, *args): """ __init__(SBMLFunctionDefinitionConverter self) -> SBMLFunctionDefinitionConverter __init__(SBMLFunctionDefinitionConverter self, SBMLFunctionDefinitionConverter obj) -> SBMLFunctionDefinitionConverter This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: SBMLFunctionDefinitionConverter() Creates a new SBMLFunctionDefinitionConverter object. ______________________________________________________________________ Method variant with the following signature: SBMLFunctionDefinitionConverter(SBMLFunctionDefinitionConvert er obj) Copy constructor; creates a copy of an SBMLFunctionDefinitionConverter object. Parameter 'obj' is the SBMLFunctionDefinitionConverter object to copy. """ this = _libsbml.new_SBMLFunctionDefinitionConverter(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(SBMLFunctionDefinitionConverter self) -> SBMLFunctionDefinitionConverter Creates and returns a deep copy of this SBMLFunctionDefinitionConverter object. Returns a (deep) copy of this converter. """ return _libsbml.SBMLFunctionDefinitionConverter_clone(self) __swig_destroy__ = _libsbml.delete_SBMLFunctionDefinitionConverter __del__ = lambda self: None def matchesProperties(self, props): """ matchesProperties(SBMLFunctionDefinitionConverter self, ConversionProperties props) -> bool Returns 'True' if this converter object's properties match the given properties. A typical use of this method involves creating a ConversionProperties object, setting the options desired, and then calling this method on an SBMLFunctionDefinitionConverter object to find out if the object's property values match the given ones. This method is also used by SBMLConverterRegistry.getConverterFor() to search across all registered converters for one matching particular properties. Parameter 'props' is the properties to match. Returns 'True' if this converter's properties match, 'False' otherwise. """ return _libsbml.SBMLFunctionDefinitionConverter_matchesProperties(self, props) def convert(self): """ convert(SBMLFunctionDefinitionConverter self) -> int Perform the conversion. This method causes the converter to do the actual conversion work, that is, to convert the SBMLDocument object set by SBMLConverter.setDocument() and with the configuration options set by SBMLConverter.setProperties(). Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_INVALID_OBJECT * LIBSBML_CONV_INVALID_SRC_DOCUMENT """ return _libsbml.SBMLFunctionDefinitionConverter_convert(self) def getDefaultProperties(self): """ getDefaultProperties(SBMLFunctionDefinitionConverter self) -> ConversionProperties Returns the default properties of this converter. A given converter exposes one or more properties that can be adjusted in order to influence the behavior of the converter. This method returns the default property settings for this converter. It is meant to be called in order to discover all the settings for the converter object. Returns the ConversionProperties object describing the default properties for this converter. """ return _libsbml.SBMLFunctionDefinitionConverter_getDefaultProperties(self) SBMLFunctionDefinitionConverter_swigregister = _libsbml.SBMLFunctionDefinitionConverter_swigregister SBMLFunctionDefinitionConverter_swigregister(SBMLFunctionDefinitionConverter) def SBMLFunctionDefinitionConverter_init(): """ SBMLFunctionDefinitionConverter_init() Internal implementation method. """ return _libsbml.SBMLFunctionDefinitionConverter_init() class SBMLIdConverter(SBMLConverter): """ Converter for replacing object identifiers. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. It is a class used in the implementation of extra functionality provided by libSBML. This converter translates all instances of a given identifier (i.e., SBML object 'id' attribute value) of type 'SId' in a Model to another identifier. It does this based on a list of source identifiers, translating each one to its corresponding replacement value in a list of replacement identifiers. It also updates all references to the identifiers so replaced. (More technically, it replaces all values known as type 'SIdRef' in the SBML Level 3 specifications.) This converter only searches the global SId namespace for the Model child of the SBMLDocument. It does not replace any IDs or SIdRefs for LocalParameters, nor does it replace any UnitSIds or UnitSIdRefs. It likewise does not replace any IDs in a new namespace introduced by a package, such as the PortSId namespace from the Hierarchical Model Composition package, nor any Model objects that are not the direct child of the SBMLDocument, such as the ModelDefinitions from the Hierarchical Model Composition package. If, however, a package introduces a new element with an 'id' attribute of type SId, any attribute of type SIdRef, or child of type SIdRef (such as a new Math child of a package element), those IDs will be replaced if they match a source identifier. Configuration and use of SBMLIdConverter ====================================================================== SBMLIdConverter is enabled by creating a ConversionProperties object with the option ''renameSIds',' and passing this properties object to SBMLDocument.convert(). The converter accepts two options, and both must be set or else no conversion is performed: * ''currentIds':' A comma-separated list of identifiers to replace. * ''newIds':' A comma-separated list of identifiers to use as the replacements. The values should correspond one-to-one with the identifiers in ''currentIds'' that should be replaced. General information about the use of SBML converters ====================================================================== The use of all the converters follows a similar approach. First, one creates a ConversionProperties object and calls ConversionProperties.addOption() on this object with one argument: a text string that identifies the desired converter. (The text string is specific to each converter; consult the documentation for a given converter to find out how it should be enabled.) Next, for some converters, the caller can optionally set some converter-specific properties using additional calls to ConversionProperties.addOption(). Many converters provide the ability to configure their behavior to some extent; this is realized through the use of properties that offer different options. The default property values for each converter can be interrogated using the method SBMLConverter.getDefaultProperties() on the converter class in question . Finally, the caller should invoke the method SBMLDocument.convert() with the ConversionProperties object as an argument. Example of invoking an SBML converter ...................................................................... The following code fragment illustrates an example using SBMLReactionConverter, which is invoked using the option string ''replaceReactions':' config = ConversionProperties() if config != None: config.addOption('replaceReactions') In the case of SBMLReactionConverter, there are no options to affect its behavior, so the next step is simply to invoke the converter on an SBMLDocument object. Continuing the example code: # Assume that the variable 'document' has been set to an SBMLDocument object. status = document.convert(config) if status != LIBSBML_OPERATION_SUCCESS: # Handle error somehow. print('Error: conversion failed due to the following:') document.printErrors() Here is an example of using a converter that offers an option. The following code invokes SBMLStripPackageConverter to remove the SBML Level 3 Layout package from a model. It sets the name of the package to be removed by adding a value for the option named ''package'' defined by that converter: def strip_layout_example(document): config = ConversionProperties() if config != None: config.addOption('stripPackage') config.addOption('package', 'layout') status = document.convert(config) if status != LIBSBML_OPERATION_SUCCESS: # Handle error somehow. print('Error: unable to strip the Layout package.') print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip()) else: # Handle error somehow. print('Error: unable to create ConversionProperties object') Available SBML converters in libSBML ...................................................................... LibSBML provides a number of built-in converters; by convention, their names end in Converter. The following are the built-in converters provided by libSBML 5.17.2: @copydetails doc_list_of_libsbml_converters """ __swig_setmethods__ = {} for _s in [SBMLConverter]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLIdConverter, name, value) __swig_getmethods__ = {} for _s in [SBMLConverter]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, SBMLIdConverter, name) __repr__ = _swig_repr def init(): """ init() Internal implementation method. """ return _libsbml.SBMLIdConverter_init() init = staticmethod(init) def __init__(self, *args): """ __init__(SBMLIdConverter self) -> SBMLIdConverter __init__(SBMLIdConverter self, SBMLIdConverter obj) -> SBMLIdConverter This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: SBMLIdConverter(SBMLIdConverter obj) Copy constructor; creates a copy of an SBMLIdConverter object. Parameter 'obj' is the SBMLIdConverter object to copy. ______________________________________________________________________ Method variant with the following signature: SBMLIdConverter() Creates a new SBMLIdConverter object. """ this = _libsbml.new_SBMLIdConverter(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(SBMLIdConverter self) -> SBMLIdConverter Creates and returns a deep copy of this SBMLIdConverter object. Returns a (deep) copy of this converter. """ return _libsbml.SBMLIdConverter_clone(self) __swig_destroy__ = _libsbml.delete_SBMLIdConverter __del__ = lambda self: None def matchesProperties(self, props): """ matchesProperties(SBMLIdConverter self, ConversionProperties props) -> bool Returns 'True' if this converter object's properties match the given properties. A typical use of this method involves creating a ConversionProperties object, setting the options desired, and then calling this method on an SBMLIdConverter object to find out if the object's property values match the given ones. This method is also used by SBMLConverterRegistry.getConverterFor() to search across all registered converters for one matching particular properties. Parameter 'props' is the properties to match. Returns 'True' if this converter's properties match, 'False' otherwise. """ return _libsbml.SBMLIdConverter_matchesProperties(self, props) def convert(self): """ convert(SBMLIdConverter self) -> int Perform the conversion. This method causes the converter to do the actual conversion work, that is, to convert the SBMLDocument object set by SBMLConverter.setDocument() and with the configuration options set by SBMLConverter.setProperties(). Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_INVALID_OBJECT * LIBSBML_UNEXPECTED_ATTRIBUTE * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.SBMLIdConverter_convert(self) def getDefaultProperties(self): """ getDefaultProperties(SBMLIdConverter self) -> ConversionProperties Returns the default properties of this converter. A given converter exposes one or more properties that can be adjusted in order to influence the behavior of the converter. This method returns the default property settings for this converter. It is meant to be called in order to discover all the settings for the converter object. Returns the ConversionProperties object describing the default properties for this converter. """ return _libsbml.SBMLIdConverter_getDefaultProperties(self) SBMLIdConverter_swigregister = _libsbml.SBMLIdConverter_swigregister SBMLIdConverter_swigregister(SBMLIdConverter) def SBMLIdConverter_init(): """ SBMLIdConverter_init() Internal implementation method. """ return _libsbml.SBMLIdConverter_init() class SBMLInferUnitsConverter(SBMLConverter): """ Converter for inferring and setting parameter units. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. It is a class used in the implementation of extra functionality provided by libSBML. This SBML converter takes an SBML document and attempts to infer units for any Parameter objects whose units are undeclared. It then sets the 'units' attribute of those parameters to the units inferred (if necessary, creating new UnitDefinition objects on the model in the process). Configuration and use of SBMLInferUnitsConverter ====================================================================== SBMLInferUnitsConverter is enabled by creating a ConversionProperties object with the option ''inferUnits',' and passing this properties object to SBMLDocument.convert(). The converter offers no other options. General information about the use of SBML converters ====================================================================== The use of all the converters follows a similar approach. First, one creates a ConversionProperties object and calls ConversionProperties.addOption() on this object with one argument: a text string that identifies the desired converter. (The text string is specific to each converter; consult the documentation for a given converter to find out how it should be enabled.) Next, for some converters, the caller can optionally set some converter-specific properties using additional calls to ConversionProperties.addOption(). Many converters provide the ability to configure their behavior to some extent; this is realized through the use of properties that offer different options. The default property values for each converter can be interrogated using the method SBMLConverter.getDefaultProperties() on the converter class in question . Finally, the caller should invoke the method SBMLDocument.convert() with the ConversionProperties object as an argument. Example of invoking an SBML converter ...................................................................... The following code fragment illustrates an example using SBMLReactionConverter, which is invoked using the option string ''replaceReactions':' config = ConversionProperties() if config != None: config.addOption('replaceReactions') In the case of SBMLReactionConverter, there are no options to affect its behavior, so the next step is simply to invoke the converter on an SBMLDocument object. Continuing the example code: # Assume that the variable 'document' has been set to an SBMLDocument object. status = document.convert(config) if status != LIBSBML_OPERATION_SUCCESS: # Handle error somehow. print('Error: conversion failed due to the following:') document.printErrors() Here is an example of using a converter that offers an option. The following code invokes SBMLStripPackageConverter to remove the SBML Level 3 Layout package from a model. It sets the name of the package to be removed by adding a value for the option named ''package'' defined by that converter: def strip_layout_example(document): config = ConversionProperties() if config != None: config.addOption('stripPackage') config.addOption('package', 'layout') status = document.convert(config) if status != LIBSBML_OPERATION_SUCCESS: # Handle error somehow. print('Error: unable to strip the Layout package.') print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip()) else: # Handle error somehow. print('Error: unable to create ConversionProperties object') Available SBML converters in libSBML ...................................................................... LibSBML provides a number of built-in converters; by convention, their names end in Converter. The following are the built-in converters provided by libSBML 5.17.2: @copydetails doc_list_of_libsbml_converters """ __swig_setmethods__ = {} for _s in [SBMLConverter]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLInferUnitsConverter, name, value) __swig_getmethods__ = {} for _s in [SBMLConverter]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, SBMLInferUnitsConverter, name) __repr__ = _swig_repr def init(): """ init() Internal implementation method. """ return _libsbml.SBMLInferUnitsConverter_init() init = staticmethod(init) def __init__(self, *args): """ __init__(SBMLInferUnitsConverter self) -> SBMLInferUnitsConverter __init__(SBMLInferUnitsConverter self, SBMLInferUnitsConverter obj) -> SBMLInferUnitsConverter This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: SBMLInferUnitsConverter() Creates a new SBMLInferUnitsConverter object. ______________________________________________________________________ Method variant with the following signature: SBMLInferUnitsConverter(SBMLInferUnitsConverter obj) Copy constructor; creates a copy of an SBMLInferUnitsConverter object. Parameter 'obj' is the SBMLInferUnitsConverter object to copy. """ this = _libsbml.new_SBMLInferUnitsConverter(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_SBMLInferUnitsConverter __del__ = lambda self: None def clone(self): """ clone(SBMLInferUnitsConverter self) -> SBMLInferUnitsConverter Creates and returns a deep copy of this SBMLInferUnitsConverter object. Returns a (deep) copy of this converter. """ return _libsbml.SBMLInferUnitsConverter_clone(self) def matchesProperties(self, props): """ matchesProperties(SBMLInferUnitsConverter self, ConversionProperties props) -> bool Returns 'True' if this converter object's properties match the given properties. A typical use of this method involves creating a ConversionProperties object, setting the options desired, and then calling this method on an SBMLInferUnitsConverter object to find out if the object's property values match the given ones. This method is also used by SBMLConverterRegistry.getConverterFor() to search across all registered converters for one matching particular properties. Parameter 'props' is the properties to match. Returns 'True' if this converter's properties match, 'False' otherwise. """ return _libsbml.SBMLInferUnitsConverter_matchesProperties(self, props) def convert(self): """ convert(SBMLInferUnitsConverter self) -> int Perform the conversion. This method causes the converter to do the actual conversion work, that is, to convert the SBMLDocument object set by SBMLConverter.setDocument() and with the configuration options set by SBMLConverter.setProperties(). Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_INVALID_OBJECT * LIBSBML_CONV_INVALID_SRC_DOCUMENT """ return _libsbml.SBMLInferUnitsConverter_convert(self) def getDefaultProperties(self): """ getDefaultProperties(SBMLInferUnitsConverter self) -> ConversionProperties Returns the default properties of this converter. A given converter exposes one or more properties that can be adjusted in order to influence the behavior of the converter. This method returns the default property settings for this converter. It is meant to be called in order to discover all the settings for the converter object. Returns the ConversionProperties object describing the default properties for this converter. """ return _libsbml.SBMLInferUnitsConverter_getDefaultProperties(self) SBMLInferUnitsConverter_swigregister = _libsbml.SBMLInferUnitsConverter_swigregister SBMLInferUnitsConverter_swigregister(SBMLInferUnitsConverter) def SBMLInferUnitsConverter_init(): """ SBMLInferUnitsConverter_init() Internal implementation method. """ return _libsbml.SBMLInferUnitsConverter_init() class SBMLInitialAssignmentConverter(SBMLConverter): """ Converter that removes SBML initial assignments. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. It is a class used in the implementation of extra functionality provided by libSBML. This is an SBML converter for replacing InitialAssignment objects, when possible, by setting the initial value attributes on the model objects being assigned. In other words, for every object that is the target of an initial assignment in the model, the converter evaluates the mathematical expression of the assignment to get a numerical value, and then sets the corresponding attribute of the object to the value. The effects for different kinds of SBML components are as follows: <center> +------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Component | Effect | +------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Compartment | Sets the value of the size attribute. | | Species | Sets the value of either the initialAmount or the initialConcentration attributes, depending on the value of the Species object's hasOnlySubstanceUnits attribute. | | Parameter | Sets the value of the value attribute. | | SpeciesReference | Sets the value of the stoichiometry attribute in the Reaction object where the SpeciesReference object appears. | +------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------+ </center> Configuration and use of SBMLInitialAssignmentConverter ====================================================================== SBMLInitialAssignmentConverter is enabled by creating a ConversionProperties object with the option ''expandInitialAssignments',' and passing this properties object to SBMLDocument.convert(). The converter offers no other options. General information about the use of SBML converters ====================================================================== The use of all the converters follows a similar approach. First, one creates a ConversionProperties object and calls ConversionProperties.addOption() on this object with one argument: a text string that identifies the desired converter. (The text string is specific to each converter; consult the documentation for a given converter to find out how it should be enabled.) Next, for some converters, the caller can optionally set some converter-specific properties using additional calls to ConversionProperties.addOption(). Many converters provide the ability to configure their behavior to some extent; this is realized through the use of properties that offer different options. The default property values for each converter can be interrogated using the method SBMLConverter.getDefaultProperties() on the converter class in question . Finally, the caller should invoke the method SBMLDocument.convert() with the ConversionProperties object as an argument. Example of invoking an SBML converter ...................................................................... The following code fragment illustrates an example using SBMLReactionConverter, which is invoked using the option string ''replaceReactions':' config = ConversionProperties() if config != None: config.addOption('replaceReactions') In the case of SBMLReactionConverter, there are no options to affect its behavior, so the next step is simply to invoke the converter on an SBMLDocument object. Continuing the example code: # Assume that the variable 'document' has been set to an SBMLDocument object. status = document.convert(config) if status != LIBSBML_OPERATION_SUCCESS: # Handle error somehow. print('Error: conversion failed due to the following:') document.printErrors() Here is an example of using a converter that offers an option. The following code invokes SBMLStripPackageConverter to remove the SBML Level 3 Layout package from a model. It sets the name of the package to be removed by adding a value for the option named ''package'' defined by that converter: def strip_layout_example(document): config = ConversionProperties() if config != None: config.addOption('stripPackage') config.addOption('package', 'layout') status = document.convert(config) if status != LIBSBML_OPERATION_SUCCESS: # Handle error somehow. print('Error: unable to strip the Layout package.') print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip()) else: # Handle error somehow. print('Error: unable to create ConversionProperties object') Available SBML converters in libSBML ...................................................................... LibSBML provides a number of built-in converters; by convention, their names end in Converter. The following are the built-in converters provided by libSBML 5.17.2: @copydetails doc_list_of_libsbml_converters """ __swig_setmethods__ = {} for _s in [SBMLConverter]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLInitialAssignmentConverter, name, value) __swig_getmethods__ = {} for _s in [SBMLConverter]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, SBMLInitialAssignmentConverter, name) __repr__ = _swig_repr def init(): """ init() Internal implementation method. """ return _libsbml.SBMLInitialAssignmentConverter_init() init = staticmethod(init) def __init__(self, *args): """ __init__(SBMLInitialAssignmentConverter self) -> SBMLInitialAssignmentConverter __init__(SBMLInitialAssignmentConverter self, SBMLInitialAssignmentConverter obj) -> SBMLInitialAssignmentConverter This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: SBMLInitialAssignmentConverter(SBMLInitialAssignmentConverter obj) Copy constructor; creates a copy of an SBMLInitialAssignmentConverter object. Parameter 'obj' is the SBMLInitialAssignmentConverter object to copy. ______________________________________________________________________ Method variant with the following signature: SBMLInitialAssignmentConverter() Creates a new SBMLInitialAssignmentConverter object. """ this = _libsbml.new_SBMLInitialAssignmentConverter(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(SBMLInitialAssignmentConverter self) -> SBMLInitialAssignmentConverter Creates and returns a deep copy of this SBMLInitialAssignmentConverter object. Returns a (deep) copy of this converter. """ return _libsbml.SBMLInitialAssignmentConverter_clone(self) __swig_destroy__ = _libsbml.delete_SBMLInitialAssignmentConverter __del__ = lambda self: None def matchesProperties(self, props): """ matchesProperties(SBMLInitialAssignmentConverter self, ConversionProperties props) -> bool Returns 'True' if this converter object's properties match the given properties. A typical use of this method involves creating a ConversionProperties object, setting the options desired, and then calling this method on an SBMLInitialAssignmentConverter object to find out if the object's property values match the given ones. This method is also used by SBMLConverterRegistry.getConverterFor() to search across all registered converters for one matching particular properties. Parameter 'props' is the properties to match. Returns 'True' if this converter's properties match, 'False' otherwise. """ return _libsbml.SBMLInitialAssignmentConverter_matchesProperties(self, props) def convert(self): """ convert(SBMLInitialAssignmentConverter self) -> int Perform the conversion. This method causes the converter to do the actual conversion work, that is, to convert the SBMLDocument object set by SBMLConverter.setDocument() and with the configuration options set by SBMLConverter.setProperties(). Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_INVALID_OBJECT """ return _libsbml.SBMLInitialAssignmentConverter_convert(self) def getDefaultProperties(self): """ getDefaultProperties(SBMLInitialAssignmentConverter self) -> ConversionProperties Returns the default properties of this converter. A given converter exposes one or more properties that can be adjusted in order to influence the behavior of the converter. This method returns the default property settings for this converter. It is meant to be called in order to discover all the settings for the converter object. Returns the ConversionProperties object describing the default properties for this converter. """ return _libsbml.SBMLInitialAssignmentConverter_getDefaultProperties(self) SBMLInitialAssignmentConverter_swigregister = _libsbml.SBMLInitialAssignmentConverter_swigregister SBMLInitialAssignmentConverter_swigregister(SBMLInitialAssignmentConverter) def SBMLInitialAssignmentConverter_init(): """ SBMLInitialAssignmentConverter_init() Internal implementation method. """ return _libsbml.SBMLInitialAssignmentConverter_init() class SBMLLevelVersionConverter(SBMLConverter): """ Whole-document SBML Level/Version converter. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. It is a class used in the implementation of extra functionality provided by libSBML. This SBML converter takes an SBML document having one SBML Level+Version combination, and attempts to convert it to an SBML document having a different Level+Version combination. This class is also the basis for SBMLDocument.setLevelAndVersion(). Configuration and use of SBMLLevelVersionConverter ====================================================================== SBMLLevelVersionConverter is enabled by creating a ConversionProperties object with the option ''setLevelAndVersion',' and passing this properties object to SBMLDocument.convert(). The target SBML Level and Version combination are determined by the value of the SBML namespace set on the ConversionProperties object (using ConversionProperties.setTargetNamespaces()). In addition, this converter offers the following options: * ''strict':' If this option has the value 'True,' then the validity of the SBML document will be strictly preserved. This means that SBML validation will be performed, and if the original model is not valid or semantics cannot be preserved in the converted model, then conversion will not be performed. Conversely, if this option is set to 'False,' model conversion will always be performed; if any errors are detected related to altered semantics, the errors will be logged in the usual way (i.e., the error log on the SBMLDocument object). * ''addDefaultUnits':' By default, a conversion from SBML Level 2 to Level 3 will explicitly add UnitDefinition objects and unit attributes on the Model object to define units that are implicitly defined in SBML Level 2. This is usually desirable because in SBML Level 3, there are no default units and a conversion from Level 2 that did not add unit definitions would actually result in a loss of information. However, some users or software tools may not need or want this, or worse, may be fooled into thinking that libSBML has somehow inferred the proper units for model quantities. (It has not; it merely adds generic predefined units.) This option lets callers control this behavior. General information about the use of SBML converters ====================================================================== The use of all the converters follows a similar approach. First, one creates a ConversionProperties object and calls ConversionProperties.addOption() on this object with one argument: a text string that identifies the desired converter. (The text string is specific to each converter; consult the documentation for a given converter to find out how it should be enabled.) Next, for some converters, the caller can optionally set some converter-specific properties using additional calls to ConversionProperties.addOption(). Many converters provide the ability to configure their behavior to some extent; this is realized through the use of properties that offer different options. The default property values for each converter can be interrogated using the method SBMLConverter.getDefaultProperties() on the converter class in question . Finally, the caller should invoke the method SBMLDocument.convert() with the ConversionProperties object as an argument. Example of invoking an SBML converter ...................................................................... The following code fragment illustrates an example using SBMLReactionConverter, which is invoked using the option string ''replaceReactions':' config = ConversionProperties() if config != None: config.addOption('replaceReactions') In the case of SBMLReactionConverter, there are no options to affect its behavior, so the next step is simply to invoke the converter on an SBMLDocument object. Continuing the example code: # Assume that the variable 'document' has been set to an SBMLDocument object. status = document.convert(config) if status != LIBSBML_OPERATION_SUCCESS: # Handle error somehow. print('Error: conversion failed due to the following:') document.printErrors() Here is an example of using a converter that offers an option. The following code invokes SBMLStripPackageConverter to remove the SBML Level 3 Layout package from a model. It sets the name of the package to be removed by adding a value for the option named ''package'' defined by that converter: def strip_layout_example(document): config = ConversionProperties() if config != None: config.addOption('stripPackage') config.addOption('package', 'layout') status = document.convert(config) if status != LIBSBML_OPERATION_SUCCESS: # Handle error somehow. print('Error: unable to strip the Layout package.') print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip()) else: # Handle error somehow. print('Error: unable to create ConversionProperties object') Available SBML converters in libSBML ...................................................................... LibSBML provides a number of built-in converters; by convention, their names end in Converter. The following are the built-in converters provided by libSBML 5.17.2: @copydetails doc_list_of_libsbml_converters """ __swig_setmethods__ = {} for _s in [SBMLConverter]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLLevelVersionConverter, name, value) __swig_getmethods__ = {} for _s in [SBMLConverter]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, SBMLLevelVersionConverter, name) __repr__ = _swig_repr def init(): """ init() Internal implementation method. """ return _libsbml.SBMLLevelVersionConverter_init() init = staticmethod(init) def __init__(self, *args): """ __init__(SBMLLevelVersionConverter self) -> SBMLLevelVersionConverter __init__(SBMLLevelVersionConverter self, SBMLLevelVersionConverter obj) -> SBMLLevelVersionConverter This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: SBMLLevelVersionConverter() Creates a new SBMLLevelVersionConverter object. ______________________________________________________________________ Method variant with the following signature: SBMLLevelVersionConverter(SBMLLevelVersionConverter obj) Copy constructor; creates a copy of an SBMLLevelVersionConverter object. Parameter 'obj' is the SBMLLevelVersionConverter object to copy. """ this = _libsbml.new_SBMLLevelVersionConverter(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_SBMLLevelVersionConverter __del__ = lambda self: None def clone(self): """ clone(SBMLLevelVersionConverter self) -> SBMLLevelVersionConverter Creates and returns a deep copy of this SBMLLevelVersionConverter object. Returns a (deep) copy of this converter. """ return _libsbml.SBMLLevelVersionConverter_clone(self) def matchesProperties(self, props): """ matchesProperties(SBMLLevelVersionConverter self, ConversionProperties props) -> bool Returns 'True' if this converter object's properties match the given properties. A typical use of this method involves creating a ConversionProperties object, setting the options desired, and then calling this method on an SBMLLevelVersionConverter object to find out if the object's property values match the given ones. This method is also used by SBMLConverterRegistry.getConverterFor() to search across all registered converters for one matching particular properties. Parameter 'props' is the properties to match. Returns 'True' if this converter's properties match, 'False' otherwise. """ return _libsbml.SBMLLevelVersionConverter_matchesProperties(self, props) def convert(self): """ convert(SBMLLevelVersionConverter self) -> int Perform the conversion. This method causes the converter to do the actual conversion work, that is, to convert the SBMLDocument object set by SBMLConverter.setDocument() and with the configuration options set by SBMLConverter.setProperties(). Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_CONV_INVALID_TARGET_NAMESPACE * LIBSBML_CONV_PKG_CONVERSION_NOT_AVAILABLE * LIBSBML_CONV_INVALID_SRC_DOCUMENT """ return _libsbml.SBMLLevelVersionConverter_convert(self) def getDefaultProperties(self): """ getDefaultProperties(SBMLLevelVersionConverter self) -> ConversionProperties Returns the default properties of this converter. A given converter exposes one or more properties that can be adjusted in order to influence the behavior of the converter. This method returns the default property settings for this converter. It is meant to be called in order to discover all the settings for the converter object. Returns the ConversionProperties object describing the default properties for this converter. """ return _libsbml.SBMLLevelVersionConverter_getDefaultProperties(self) def getTargetLevel(self): """ getTargetLevel(SBMLLevelVersionConverter self) -> unsigned int Returns the target SBML Level for the conversion. Returns an integer indicating the SBML Level. """ return _libsbml.SBMLLevelVersionConverter_getTargetLevel(self) def getTargetVersion(self): """ getTargetVersion(SBMLLevelVersionConverter self) -> unsigned int Returns the target SBML Version for the conversion. Returns an integer indicating the Version within the SBML Level. """ return _libsbml.SBMLLevelVersionConverter_getTargetVersion(self) def getValidityFlag(self): """ getValidityFlag(SBMLLevelVersionConverter self) -> bool Returns the flag indicating whether the conversion has been set to 'strict'. Returns 'True' if strict validity has been requested, 'False' otherwise. """ return _libsbml.SBMLLevelVersionConverter_getValidityFlag(self) def getAddDefaultUnits(self): """ getAddDefaultUnits(SBMLLevelVersionConverter self) -> bool Returns the flag indicating whether default units should be added when converting to L3 or not. Returns 'True' if default units should be added, 'False' otherwise. """ return _libsbml.SBMLLevelVersionConverter_getAddDefaultUnits(self) SBMLLevelVersionConverter_swigregister = _libsbml.SBMLLevelVersionConverter_swigregister SBMLLevelVersionConverter_swigregister(SBMLLevelVersionConverter) def SBMLLevelVersionConverter_init(): """ SBMLLevelVersionConverter_init() Internal implementation method. """ return _libsbml.SBMLLevelVersionConverter_init() class SBMLLevel1Version1Converter(SBMLConverter): """ Whole-document SBML Level/Version converter. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. It is a class used in the implementation of extra functionality provided by libSBML. This SBML converter takes an SBML document having one SBML Level+Version combination, and attempts to convert it to an SBML document having a different Level+Version combination. This converter (SBMLLevel1Version1Converter) converts models to SBML Level 1 Version 1, to the extent possible by the limited features of that Level/Version combination of SBML. Configuration and use of SBMLLevel1Version1Converter ====================================================================== SBMLLevel1Version1Converter is enabled by creating a ConversionProperties object with the option ''convertToL1V1',' and passing this properties object to SBMLDocument.convert(). The target SBML Level and Version combination are determined by the value of the SBML namespace set on the ConversionProperties object (using ConversionProperties.setTargetNamespaces()). In addition, this converter offers the following options: * ''changePow':' Mathematical expressions for exponentiation of the form pow(s1, 2) will be converted to the expression s1^2. * ''inlineCompartmentSizes':' Back in the days of SBML Level 1 Version 1, many software tools assumed that the 'kinetic laws' of SBML were written in terms of units of concentration/time. These tools would not expect (and thus not handle) rate expressions such as CompartmentOfS1 * k * S1. When the option ''inlineCompartmentSizes'' is enabled, libSBML will replace the references to compartments (such as ''CompartmentOfS1'' in this example) with their initial sizes. This is not strictly correct in all cases; in particular, if the compartment volume varies during simulation, this conversion will not reflect the expected behavior. However, many models do not have time- varying compartment sizes, so this option makes it easy to get modern SBML rate expressions into a form that old software tools may better understand. General information about the use of SBML converters ====================================================================== The use of all the converters follows a similar approach. First, one creates a ConversionProperties object and calls ConversionProperties.addOption() on this object with one argument: a text string that identifies the desired converter. (The text string is specific to each converter; consult the documentation for a given converter to find out how it should be enabled.) Next, for some converters, the caller can optionally set some converter-specific properties using additional calls to ConversionProperties.addOption(). Many converters provide the ability to configure their behavior to some extent; this is realized through the use of properties that offer different options. The default property values for each converter can be interrogated using the method SBMLConverter.getDefaultProperties() on the converter class in question . Finally, the caller should invoke the method SBMLDocument.convert() with the ConversionProperties object as an argument. Example of invoking an SBML converter ...................................................................... The following code fragment illustrates an example using SBMLReactionConverter, which is invoked using the option string ''replaceReactions':' config = ConversionProperties() if config != None: config.addOption('replaceReactions') In the case of SBMLReactionConverter, there are no options to affect its behavior, so the next step is simply to invoke the converter on an SBMLDocument object. Continuing the example code: # Assume that the variable 'document' has been set to an SBMLDocument object. status = document.convert(config) if status != LIBSBML_OPERATION_SUCCESS: # Handle error somehow. print('Error: conversion failed due to the following:') document.printErrors() Here is an example of using a converter that offers an option. The following code invokes SBMLStripPackageConverter to remove the SBML Level 3 Layout package from a model. It sets the name of the package to be removed by adding a value for the option named ''package'' defined by that converter: def strip_layout_example(document): config = ConversionProperties() if config != None: config.addOption('stripPackage') config.addOption('package', 'layout') status = document.convert(config) if status != LIBSBML_OPERATION_SUCCESS: # Handle error somehow. print('Error: unable to strip the Layout package.') print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip()) else: # Handle error somehow. print('Error: unable to create ConversionProperties object') Available SBML converters in libSBML ...................................................................... LibSBML provides a number of built-in converters; by convention, their names end in Converter. The following are the built-in converters provided by libSBML 5.17.2: @copydetails doc_list_of_libsbml_converters """ __swig_setmethods__ = {} for _s in [SBMLConverter]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLLevel1Version1Converter, name, value) __swig_getmethods__ = {} for _s in [SBMLConverter]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, SBMLLevel1Version1Converter, name) __repr__ = _swig_repr def init(): """ init() Internal implementation method. """ return _libsbml.SBMLLevel1Version1Converter_init() init = staticmethod(init) def __init__(self, *args): """ __init__(SBMLLevel1Version1Converter self) -> SBMLLevel1Version1Converter __init__(SBMLLevel1Version1Converter self, SBMLLevel1Version1Converter obj) -> SBMLLevel1Version1Converter This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: SBMLLevel1Version1Converter() Creates a new SBMLLevel1Version1Converter object. ______________________________________________________________________ Method variant with the following signature: SBMLLevel1Version1Converter(SBMLLevel1Version1Converter obj) Copy constructor; creates a copy of an SBMLLevel1Version1Converter object. Parameter 'obj' is the SBMLLevel1Version1Converter object to copy. """ this = _libsbml.new_SBMLLevel1Version1Converter(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_SBMLLevel1Version1Converter __del__ = lambda self: None def clone(self): """ clone(SBMLLevel1Version1Converter self) -> SBMLLevel1Version1Converter Creates and returns a deep copy of this SBMLLevel1Version1Converter object. Returns a (deep) copy of this converter. """ return _libsbml.SBMLLevel1Version1Converter_clone(self) def matchesProperties(self, props): """ matchesProperties(SBMLLevel1Version1Converter self, ConversionProperties props) -> bool Returns 'True' if this converter object's properties match the given properties. A typical use of this method involves creating a ConversionProperties object, setting the options desired, and then calling this method on an SBMLLevel1Version1Converter object to find out if the object's property values match the given ones. This method is also used by SBMLConverterRegistry.getConverterFor() to search across all registered converters for one matching particular properties. Parameter 'props' is the properties to match. Returns 'True' if this converter's properties match, 'False' otherwise. """ return _libsbml.SBMLLevel1Version1Converter_matchesProperties(self, props) def convert(self): """ convert(SBMLLevel1Version1Converter self) -> int Perform the conversion. This method causes the converter to do the actual conversion work, that is, to convert the SBMLDocument object set by SBMLConverter.setDocument() and with the configuration options set by SBMLConverter.setProperties(). Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_CONV_INVALID_TARGET_NAMESPACE * LIBSBML_CONV_PKG_CONVERSION_NOT_AVAILABLE * LIBSBML_CONV_INVALID_SRC_DOCUMENT """ return _libsbml.SBMLLevel1Version1Converter_convert(self) def getDefaultProperties(self): """ getDefaultProperties(SBMLLevel1Version1Converter self) -> ConversionProperties Returns the default properties of this converter. A given converter exposes one or more properties that can be adjusted in order to influence the behavior of the converter. This method returns the default property settings for this converter. It is meant to be called in order to discover all the settings for the converter object. Returns the ConversionProperties object describing the default properties for this converter. """ return _libsbml.SBMLLevel1Version1Converter_getDefaultProperties(self) SBMLLevel1Version1Converter_swigregister = _libsbml.SBMLLevel1Version1Converter_swigregister SBMLLevel1Version1Converter_swigregister(SBMLLevel1Version1Converter) def SBMLLevel1Version1Converter_init(): """ SBMLLevel1Version1Converter_init() Internal implementation method. """ return _libsbml.SBMLLevel1Version1Converter_init() class SBMLLocalParameterConverter(SBMLConverter): """ Converter to turn local parameters into global ones. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. It is a class used in the implementation of extra functionality provided by libSBML. This converter essentially promotes local parameters to global parameters. It works by examining every Reaction object for LocalParameter objects, then creating Parameter objects on the model for each one found, and finally removing the original LocalParameter objects. It creates new identifiers for the fresh Parameter objects by concatenating the identifier of the reaction with the identifier of the original LocalParameter object. This converter can be useful for software applications that do not have the ability to handle local parameters on reactions. Such applications could check incoming models for local parameters and run those models through this converter before proceeding with other steps. Configuration and use of SBMLLocalParameterConverter ====================================================================== SBMLLocalParameterConverter is enabled by creating a ConversionProperties object with the option ''promoteLocalParameters',' and passing this properties object to SBMLDocument.convert(). The converter offers no other options. General information about the use of SBML converters ====================================================================== The use of all the converters follows a similar approach. First, one creates a ConversionProperties object and calls ConversionProperties.addOption() on this object with one argument: a text string that identifies the desired converter. (The text string is specific to each converter; consult the documentation for a given converter to find out how it should be enabled.) Next, for some converters, the caller can optionally set some converter-specific properties using additional calls to ConversionProperties.addOption(). Many converters provide the ability to configure their behavior to some extent; this is realized through the use of properties that offer different options. The default property values for each converter can be interrogated using the method SBMLConverter.getDefaultProperties() on the converter class in question . Finally, the caller should invoke the method SBMLDocument.convert() with the ConversionProperties object as an argument. Example of invoking an SBML converter ...................................................................... The following code fragment illustrates an example using SBMLReactionConverter, which is invoked using the option string ''replaceReactions':' config = ConversionProperties() if config != None: config.addOption('replaceReactions') In the case of SBMLReactionConverter, there are no options to affect its behavior, so the next step is simply to invoke the converter on an SBMLDocument object. Continuing the example code: # Assume that the variable 'document' has been set to an SBMLDocument object. status = document.convert(config) if status != LIBSBML_OPERATION_SUCCESS: # Handle error somehow. print('Error: conversion failed due to the following:') document.printErrors() Here is an example of using a converter that offers an option. The following code invokes SBMLStripPackageConverter to remove the SBML Level 3 Layout package from a model. It sets the name of the package to be removed by adding a value for the option named ''package'' defined by that converter: def strip_layout_example(document): config = ConversionProperties() if config != None: config.addOption('stripPackage') config.addOption('package', 'layout') status = document.convert(config) if status != LIBSBML_OPERATION_SUCCESS: # Handle error somehow. print('Error: unable to strip the Layout package.') print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip()) else: # Handle error somehow. print('Error: unable to create ConversionProperties object') Available SBML converters in libSBML ...................................................................... LibSBML provides a number of built-in converters; by convention, their names end in Converter. The following are the built-in converters provided by libSBML 5.17.2: @copydetails doc_list_of_libsbml_converters """ __swig_setmethods__ = {} for _s in [SBMLConverter]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLLocalParameterConverter, name, value) __swig_getmethods__ = {} for _s in [SBMLConverter]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, SBMLLocalParameterConverter, name) __repr__ = _swig_repr def init(): """ init() Internal implementation method. """ return _libsbml.SBMLLocalParameterConverter_init() init = staticmethod(init) def __init__(self, *args): """ __init__(SBMLLocalParameterConverter self) -> SBMLLocalParameterConverter __init__(SBMLLocalParameterConverter self, SBMLLocalParameterConverter obj) -> SBMLLocalParameterConverter This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: SBMLLocalParameterConverter(SBMLLocalParameterConverter obj) Copy constructor; creates a copy of an SBMLLocalParameterConverter object. Parameter 'obj' is the SBMLLocalParameterConverter object to copy. ______________________________________________________________________ Method variant with the following signature: SBMLLocalParameterConverter() Creates a new SBMLLocalParameterConverter object. """ this = _libsbml.new_SBMLLocalParameterConverter(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(SBMLLocalParameterConverter self) -> SBMLLocalParameterConverter Creates and returns a deep copy of this SBMLLocalParameterConverter object. Returns a (deep) copy of this converter. """ return _libsbml.SBMLLocalParameterConverter_clone(self) __swig_destroy__ = _libsbml.delete_SBMLLocalParameterConverter __del__ = lambda self: None def matchesProperties(self, props): """ matchesProperties(SBMLLocalParameterConverter self, ConversionProperties props) -> bool Returns 'True' if this converter object's properties match the given properties. A typical use of this method involves creating a ConversionProperties object, setting the options desired, and then calling this method on an SBMLLocalParameterConverter object to find out if the object's property values match the given ones. This method is also used by SBMLConverterRegistry.getConverterFor() to search across all registered converters for one matching particular properties. Parameter 'props' is the properties to match. Returns 'True' if this converter's properties match, 'False' otherwise. """ return _libsbml.SBMLLocalParameterConverter_matchesProperties(self, props) def convert(self): """ convert(SBMLLocalParameterConverter self) -> int Perform the conversion. This method causes the converter to do the actual conversion work, that is, to convert the SBMLDocument object set by SBMLConverter.setDocument() and with the configuration options set by SBMLConverter.setProperties(). Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_INVALID_OBJECT """ return _libsbml.SBMLLocalParameterConverter_convert(self) def getDefaultProperties(self): """ getDefaultProperties(SBMLLocalParameterConverter self) -> ConversionProperties Returns the default properties of this converter. A given converter exposes one or more properties that can be adjusted in order to influence the behavior of the converter. This method returns the default property settings for this converter. It is meant to be called in order to discover all the settings for the converter object. Returns the ConversionProperties object describing the default properties for this converter. """ return _libsbml.SBMLLocalParameterConverter_getDefaultProperties(self) SBMLLocalParameterConverter_swigregister = _libsbml.SBMLLocalParameterConverter_swigregister SBMLLocalParameterConverter_swigregister(SBMLLocalParameterConverter) def SBMLLocalParameterConverter_init(): """ SBMLLocalParameterConverter_init() Internal implementation method. """ return _libsbml.SBMLLocalParameterConverter_init() class SBMLReactionConverter(SBMLConverter): """ Converter to replace reactions with SBML rate rules. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. It is a class used in the implementation of extra functionality provided by libSBML. This converter will take an SBML model and replace the definitions of reactions in the model with definitions of SBML rate rules. Equivalent RateRule objects are only created for species mentioned in reactions that have KineticLaw subobjects, since those are the only reactions that have an effect on the rates of change of species in the model; however, the converter removes all Reaction objects in the model after it is done. Configuration and use of SBMLReactionConverter ====================================================================== SBMLReactionConverter is enabled by creating a ConversionProperties object with the option ''replaceReactions',' and passing this properties object to SBMLDocument.convert(). This converter does not offer any additional configuration options. General information about the use of SBML converters ====================================================================== The use of all the converters follows a similar approach. First, one creates a ConversionProperties object and calls ConversionProperties.addOption() on this object with one argument: a text string that identifies the desired converter. (The text string is specific to each converter; consult the documentation for a given converter to find out how it should be enabled.) Next, for some converters, the caller can optionally set some converter-specific properties using additional calls to ConversionProperties.addOption(). Many converters provide the ability to configure their behavior to some extent; this is realized through the use of properties that offer different options. The default property values for each converter can be interrogated using the method SBMLConverter.getDefaultProperties() on the converter class in question . Finally, the caller should invoke the method SBMLDocument.convert() with the ConversionProperties object as an argument. Example of invoking an SBML converter ...................................................................... The following code fragment illustrates an example using SBMLReactionConverter, which is invoked using the option string ''replaceReactions':' config = ConversionProperties() if config != None: config.addOption('replaceReactions') In the case of SBMLReactionConverter, there are no options to affect its behavior, so the next step is simply to invoke the converter on an SBMLDocument object. Continuing the example code: # Assume that the variable 'document' has been set to an SBMLDocument object. status = document.convert(config) if status != LIBSBML_OPERATION_SUCCESS: # Handle error somehow. print('Error: conversion failed due to the following:') document.printErrors() Here is an example of using a converter that offers an option. The following code invokes SBMLStripPackageConverter to remove the SBML Level 3 Layout package from a model. It sets the name of the package to be removed by adding a value for the option named ''package'' defined by that converter: def strip_layout_example(document): config = ConversionProperties() if config != None: config.addOption('stripPackage') config.addOption('package', 'layout') status = document.convert(config) if status != LIBSBML_OPERATION_SUCCESS: # Handle error somehow. print('Error: unable to strip the Layout package.') print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip()) else: # Handle error somehow. print('Error: unable to create ConversionProperties object') Available SBML converters in libSBML ...................................................................... LibSBML provides a number of built-in converters; by convention, their names end in Converter. The following are the built-in converters provided by libSBML 5.17.2: @copydetails doc_list_of_libsbml_converters """ __swig_setmethods__ = {} for _s in [SBMLConverter]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLReactionConverter, name, value) __swig_getmethods__ = {} for _s in [SBMLConverter]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, SBMLReactionConverter, name) __repr__ = _swig_repr def init(): """ init() Internal implementation method. """ return _libsbml.SBMLReactionConverter_init() init = staticmethod(init) def __init__(self, *args): """ __init__(SBMLReactionConverter self) -> SBMLReactionConverter __init__(SBMLReactionConverter self, SBMLReactionConverter obj) -> SBMLReactionConverter This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: SBMLReactionConverter(SBMLReactionConverter obj) Copy constructor; creates a copy of an SBMLReactionConverter object. Parameter 'obj' is the SBMLReactionConverter object to copy. ______________________________________________________________________ Method variant with the following signature: SBMLReactionConverter() Creates a new SBMLReactionConverter object. """ this = _libsbml.new_SBMLReactionConverter(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(SBMLReactionConverter self) -> SBMLReactionConverter Creates and returns a deep copy of this SBMLReactionConverter object. Returns a (deep) copy of this converter. """ return _libsbml.SBMLReactionConverter_clone(self) __swig_destroy__ = _libsbml.delete_SBMLReactionConverter __del__ = lambda self: None def matchesProperties(self, props): """ matchesProperties(SBMLReactionConverter self, ConversionProperties props) -> bool Returns 'True' if this converter object's properties match the given properties. A typical use of this method involves creating a ConversionProperties object, setting the options desired, and then calling this method on an SBMLReactionConverter object to find out if the object's property values match the given ones. This method is also used by SBMLConverterRegistry.getConverterFor() to search across all registered converters for one matching particular properties. Parameter 'props' is the properties to match. Returns 'True' if this converter's properties match, 'False' otherwise. """ return _libsbml.SBMLReactionConverter_matchesProperties(self, props) def convert(self): """ convert(SBMLReactionConverter self) -> int Perform the conversion. This method causes the converter to do the actual conversion work, that is, to convert the SBMLDocument object set by SBMLConverter.setDocument() and with the configuration options set by SBMLConverter.setProperties(). Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_INVALID_OBJECT * LIBSBML_CONV_INVALID_SRC_DOCUMENT """ return _libsbml.SBMLReactionConverter_convert(self) def getDefaultProperties(self): """ getDefaultProperties(SBMLReactionConverter self) -> ConversionProperties Returns the default properties of this converter. A given converter exposes one or more properties that can be adjusted in order to influence the behavior of the converter. This method returns the default property settings for this converter. It is meant to be called in order to discover all the settings for the converter object. Returns the ConversionProperties object describing the default properties for this converter. """ return _libsbml.SBMLReactionConverter_getDefaultProperties(self) def setDocument(self, doc): """ setDocument(SBMLReactionConverter self, SBMLDocument doc) -> int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: setDocument(SBMLDocument doc) Sets the current SBML document to the given SBMLDocument object. Parameter 'doc' is the document to use for this conversion. WARNING: Even though the 'doc' is '', it is immediately cast to a non- version, which is then usually changed by the converter upon a successful conversion. This function is here solely to preserve backwards compatibility. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS ______________________________________________________________________ Method variant with the following signature: setDocument(SBMLDocument doc) Sets the current SBML document to the given SBMLDocument object. Parameter 'doc' is the document to use for this conversion. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS """ return _libsbml.SBMLReactionConverter_setDocument(self, doc) SBMLReactionConverter_swigregister = _libsbml.SBMLReactionConverter_swigregister SBMLReactionConverter_swigregister(SBMLReactionConverter) def SBMLReactionConverter_init(): """ SBMLReactionConverter_init() Internal implementation method. """ return _libsbml.SBMLReactionConverter_init() class SBMLRuleConverter(SBMLConverter): """ Converter that sorts SBML rules and assignments. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. It is a class used in the implementation of extra functionality provided by libSBML. This converter reorders assignments in a model. Specifically, it sorts the list of assignment rules (i.e., the AssignmentRule objects contained in the ListOfAssignmentRules within the Model object) and the initial assignments (i.e., the InitialAssignment objects contained in the ListOfInitialAssignments) such that, within each set, assignments that depend on prior values are placed after the values are set. For example, if there is an assignment rule stating a = b + 1, and another rule stating b = 3, the list of rules is sorted and the rules are arranged so that the rule for b = 3 appears before the rule for a = b + 1. Similarly, if dependencies of this sort exist in the list of initial assignments in the model, the initial assignments are sorted as well. Beginning with SBML Level 2, assignment rules have no ordering required---the order in which the rules appear in an SBML file has no significance. Software tools, however, may need to reorder assignments for purposes of evaluating them. For example, for simulators that use time integration methods, it would be a good idea to reorder assignment rules such as the following, b = a + 10 seconds a = time so that the evaluation of the rules is independent of integrator step sizes. (This is due to the fact that, in this case, the order in which the rules are evaluated changes the result.) SBMLRuleConverter can be used to reorder the SBML objects regardless of whether the input file contained them in the desired order. Note that the two sets of SBML assignments (list of assignment rules on the one hand, and list of initial assignments on the other hand) are handled independently. In an SBML model, these entities are treated differently and no amount of sorting can deal with inter- dependencies between assignments of the two kinds. Configuration and use of SBMLRuleConverter ====================================================================== SBMLRuleConverter is enabled by creating a ConversionProperties object with the option ''sortRules',' and passing this properties object to SBMLDocument.convert(). This converter offers no other options. General information about the use of SBML converters ====================================================================== The use of all the converters follows a similar approach. First, one creates a ConversionProperties object and calls ConversionProperties.addOption() on this object with one argument: a text string that identifies the desired converter. (The text string is specific to each converter; consult the documentation for a given converter to find out how it should be enabled.) Next, for some converters, the caller can optionally set some converter-specific properties using additional calls to ConversionProperties.addOption(). Many converters provide the ability to configure their behavior to some extent; this is realized through the use of properties that offer different options. The default property values for each converter can be interrogated using the method SBMLConverter.getDefaultProperties() on the converter class in question . Finally, the caller should invoke the method SBMLDocument.convert() with the ConversionProperties object as an argument. Example of invoking an SBML converter ...................................................................... The following code fragment illustrates an example using SBMLReactionConverter, which is invoked using the option string ''replaceReactions':' config = ConversionProperties() if config != None: config.addOption('replaceReactions') In the case of SBMLReactionConverter, there are no options to affect its behavior, so the next step is simply to invoke the converter on an SBMLDocument object. Continuing the example code: # Assume that the variable 'document' has been set to an SBMLDocument object. status = document.convert(config) if status != LIBSBML_OPERATION_SUCCESS: # Handle error somehow. print('Error: conversion failed due to the following:') document.printErrors() Here is an example of using a converter that offers an option. The following code invokes SBMLStripPackageConverter to remove the SBML Level 3 Layout package from a model. It sets the name of the package to be removed by adding a value for the option named ''package'' defined by that converter: def strip_layout_example(document): config = ConversionProperties() if config != None: config.addOption('stripPackage') config.addOption('package', 'layout') status = document.convert(config) if status != LIBSBML_OPERATION_SUCCESS: # Handle error somehow. print('Error: unable to strip the Layout package.') print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip()) else: # Handle error somehow. print('Error: unable to create ConversionProperties object') Available SBML converters in libSBML ...................................................................... LibSBML provides a number of built-in converters; by convention, their names end in Converter. The following are the built-in converters provided by libSBML 5.17.2: @copydetails doc_list_of_libsbml_converters """ __swig_setmethods__ = {} for _s in [SBMLConverter]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLRuleConverter, name, value) __swig_getmethods__ = {} for _s in [SBMLConverter]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, SBMLRuleConverter, name) __repr__ = _swig_repr def init(): """ init() Internal implementation method. """ return _libsbml.SBMLRuleConverter_init() init = staticmethod(init) def __init__(self, *args): """ __init__(SBMLRuleConverter self) -> SBMLRuleConverter __init__(SBMLRuleConverter self, SBMLRuleConverter obj) -> SBMLRuleConverter This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: SBMLRuleConverter(SBMLRuleConverter obj) Copy constructor; creates a copy of an SBMLLevelVersionConverter object. Parameter 'obj' is the SBMLLevelVersionConverter object to copy. ______________________________________________________________________ Method variant with the following signature: SBMLRuleConverter() Creates a new SBMLLevelVersionConverter object. """ this = _libsbml.new_SBMLRuleConverter(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(SBMLRuleConverter self) -> SBMLRuleConverter Creates and returns a deep copy of this SBMLLevelVersionConverter object. Returns a (deep) copy of this converter. """ return _libsbml.SBMLRuleConverter_clone(self) __swig_destroy__ = _libsbml.delete_SBMLRuleConverter __del__ = lambda self: None def matchesProperties(self, props): """ matchesProperties(SBMLRuleConverter self, ConversionProperties props) -> bool Returns 'True' if this converter object's properties match the given properties. A typical use of this method involves creating a ConversionProperties object, setting the options desired, and then calling this method on an SBMLLevelVersionConverter object to find out if the object's property values match the given ones. This method is also used by SBMLConverterRegistry.getConverterFor() to search across all registered converters for one matching particular properties. Parameter 'props' is the properties to match. Returns 'True' if this converter's properties match, 'False' otherwise. """ return _libsbml.SBMLRuleConverter_matchesProperties(self, props) def convert(self): """ convert(SBMLRuleConverter self) -> int Perform the conversion. This method causes the converter to do the actual conversion work, that is, to convert the SBMLDocument object set by SBMLConverter.setDocument() and with the configuration options set by SBMLConverter.setProperties(). Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT * LIBSBML_CONV_INVALID_SRC_DOCUMENT """ return _libsbml.SBMLRuleConverter_convert(self) def getDefaultProperties(self): """ getDefaultProperties(SBMLRuleConverter self) -> ConversionProperties Returns the default properties of this converter. A given converter exposes one or more properties that can be adjusted in order to influence the behavior of the converter. This method returns the default property settings for this converter. It is meant to be called in order to discover all the settings for the converter object. Returns the ConversionProperties object describing the default properties for this converter. """ return _libsbml.SBMLRuleConverter_getDefaultProperties(self) SBMLRuleConverter_swigregister = _libsbml.SBMLRuleConverter_swigregister SBMLRuleConverter_swigregister(SBMLRuleConverter) def SBMLRuleConverter_init(): """ SBMLRuleConverter_init() Internal implementation method. """ return _libsbml.SBMLRuleConverter_init() class SBMLStripPackageConverter(SBMLConverter): """ Converter that removes SBML Level 3 packages. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. It is a class used in the implementation of extra functionality provided by libSBML. This SBML converter takes an SBML document and removes (strips) an SBML Level 3 package from it. No conversion is performed; the package constructs are simply removed from the SBML document. The package to be stripped is determined by the value of the option ''package'' on the conversion properties. Configuration and use of SBMLStripPackageConverter ====================================================================== SBMLStripPackageConverter is enabled by creating a ConversionProperties object with the option ''stripPackage',' and passing this properties object to SBMLDocument.convert(). This converter takes one required option: * ''package':' the value of this option should be a text string, the nickname of the SBML Level 3 package to be stripped from the model. In addition, the converter understands an additional optional: * ''stripAllUnrecognized':' if set to 'True,' the converter will remove all SBML Level 3 package constructs for Level 3 packages that this copy of libSBML does not recognize. Note that what a given copy of libSBML recognizes is determined by which plug-ins it has been configured to include. If this option is enabled, it may remove SBML Level 3 package constructs that are legitimate in the sense that they are officially defined SBML constructs, but not recognized because the running copy of libSBML has not had support enabled for them. General information about the use of SBML converters ====================================================================== The use of all the converters follows a similar approach. First, one creates a ConversionProperties object and calls ConversionProperties.addOption() on this object with one argument: a text string that identifies the desired converter. (The text string is specific to each converter; consult the documentation for a given converter to find out how it should be enabled.) Next, for some converters, the caller can optionally set some converter-specific properties using additional calls to ConversionProperties.addOption(). Many converters provide the ability to configure their behavior to some extent; this is realized through the use of properties that offer different options. The default property values for each converter can be interrogated using the method SBMLConverter.getDefaultProperties() on the converter class in question . Finally, the caller should invoke the method SBMLDocument.convert() with the ConversionProperties object as an argument. Example of invoking an SBML converter ...................................................................... The following code fragment illustrates an example using SBMLReactionConverter, which is invoked using the option string ''replaceReactions':' config = ConversionProperties() if config != None: config.addOption('replaceReactions') In the case of SBMLReactionConverter, there are no options to affect its behavior, so the next step is simply to invoke the converter on an SBMLDocument object. Continuing the example code: # Assume that the variable 'document' has been set to an SBMLDocument object. status = document.convert(config) if status != LIBSBML_OPERATION_SUCCESS: # Handle error somehow. print('Error: conversion failed due to the following:') document.printErrors() Here is an example of using a converter that offers an option. The following code invokes SBMLStripPackageConverter to remove the SBML Level 3 Layout package from a model. It sets the name of the package to be removed by adding a value for the option named ''package'' defined by that converter: def strip_layout_example(document): config = ConversionProperties() if config != None: config.addOption('stripPackage') config.addOption('package', 'layout') status = document.convert(config) if status != LIBSBML_OPERATION_SUCCESS: # Handle error somehow. print('Error: unable to strip the Layout package.') print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip()) else: # Handle error somehow. print('Error: unable to create ConversionProperties object') Available SBML converters in libSBML ...................................................................... LibSBML provides a number of built-in converters; by convention, their names end in Converter. The following are the built-in converters provided by libSBML 5.17.2: @copydetails doc_list_of_libsbml_converters """ __swig_setmethods__ = {} for _s in [SBMLConverter]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLStripPackageConverter, name, value) __swig_getmethods__ = {} for _s in [SBMLConverter]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, SBMLStripPackageConverter, name) __repr__ = _swig_repr def init(): """ init() Internal implementation method. """ return _libsbml.SBMLStripPackageConverter_init() init = staticmethod(init) def __init__(self, *args): """ __init__(SBMLStripPackageConverter self) -> SBMLStripPackageConverter __init__(SBMLStripPackageConverter self, SBMLStripPackageConverter obj) -> SBMLStripPackageConverter This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: SBMLStripPackageConverter() Creates a new SBMLStripPackageConverter object. ______________________________________________________________________ Method variant with the following signature: SBMLStripPackageConverter(SBMLStripPackageConverter obj) Copy constructor; creates a copy of an SBMLStripPackageConverter object. Parameter 'obj' is the SBMLStripPackageConverter object to copy. """ this = _libsbml.new_SBMLStripPackageConverter(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_SBMLStripPackageConverter __del__ = lambda self: None def clone(self): """ clone(SBMLStripPackageConverter self) -> SBMLStripPackageConverter Creates and returns a deep copy of this SBMLStripPackageConverter object. Returns the (deep) copy of this converter object. """ return _libsbml.SBMLStripPackageConverter_clone(self) def matchesProperties(self, props): """ matchesProperties(SBMLStripPackageConverter self, ConversionProperties props) -> bool Returns 'True' if this converter object's properties match the given properties. A typical use of this method involves creating a ConversionProperties object, setting the options desired, and then calling this method on an SBMLStripPackageConverter object to find out if the object's property values match the given ones. This method is also used by SBMLConverterRegistry.getConverterFor() to search across all registered converters for one matching particular properties. Parameter 'props' is the properties to match. Returns 'True' if this converter's properties match, 'False' otherwise. """ return _libsbml.SBMLStripPackageConverter_matchesProperties(self, props) def convert(self): """ convert(SBMLStripPackageConverter self) -> int Perform the conversion. This method causes the converter to do the actual conversion work, that is, to convert the SBMLDocument object set by SBMLConverter.setDocument() and with the configuration options set by SBMLConverter.setProperties(). Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_INVALID_ATTRIBUTE_VALUE * LIBSBML_CONV_PKG_CONSIDERED_UNKNOWN """ return _libsbml.SBMLStripPackageConverter_convert(self) def getDefaultProperties(self): """ getDefaultProperties(SBMLStripPackageConverter self) -> ConversionProperties Returns the default properties of this converter. A given converter exposes one or more properties that can be adjusted in order to influence the behavior of the converter. This method returns the default property settings for this converter. It is meant to be called in order to discover all the settings for the converter object. Returns the ConversionProperties object describing the default properties for this converter. """ return _libsbml.SBMLStripPackageConverter_getDefaultProperties(self) def getPackageToStrip(self): """ getPackageToStrip(SBMLStripPackageConverter self) -> string Returns the package to be stripped. """ return _libsbml.SBMLStripPackageConverter_getPackageToStrip(self) def isStripAllUnrecognizedPackages(self): """ isStripAllUnrecognizedPackages(SBMLStripPackageConverter self) -> bool Returns a boolean indicating whether all unrecognized packages should be removed. """ return _libsbml.SBMLStripPackageConverter_isStripAllUnrecognizedPackages(self) SBMLStripPackageConverter_swigregister = _libsbml.SBMLStripPackageConverter_swigregister SBMLStripPackageConverter_swigregister(SBMLStripPackageConverter) def SBMLStripPackageConverter_init(): """ SBMLStripPackageConverter_init() Internal implementation method. """ return _libsbml.SBMLStripPackageConverter_init() class SBMLUnitsConverter(SBMLConverter): """ Converts a model's existing units to SI units. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. It is a class used in the implementation of extra functionality provided by libSBML. This SBML converter converts the units in a model to base SI units, that is, using only the units metre, kilogram, second, ampere, kelvin, mole and candela. Unit conversion will only be performed on models that are fully unit consistent, meaning that all objects have units associated with them and there are no literal numbers with unspecified units. In the case of an SBML Level 3 model involving math expressions, this means that the 'timeUnits' attribute on the Model object must be set, and if there are any reactions in the model, the 'extentUnits' attribute on the Model object must also be set. Configuration and use of SBMLUnitsConverter ====================================================================== SBMLUnitsConverter is enabled by creating a ConversionProperties object with the option ''units',' and passing this properties object to SBMLDocument.convert(). This converter takes one optional option: * ''removeUnusedUnits':' the value of this property should be a Boolean. If it is 'True,' it tells the unit convert to remove any unused UnitDefinition objects after conversion is complete. ('Unused' units are units that are not referenced by any object in the model.) If the value is 'False,' unused UnitDefinition objects are not removed from the model. The default is 'True.' General information about the use of SBML converters ====================================================================== The use of all the converters follows a similar approach. First, one creates a ConversionProperties object and calls ConversionProperties.addOption() on this object with one argument: a text string that identifies the desired converter. (The text string is specific to each converter; consult the documentation for a given converter to find out how it should be enabled.) Next, for some converters, the caller can optionally set some converter-specific properties using additional calls to ConversionProperties.addOption(). Many converters provide the ability to configure their behavior to some extent; this is realized through the use of properties that offer different options. The default property values for each converter can be interrogated using the method SBMLConverter.getDefaultProperties() on the converter class in question . Finally, the caller should invoke the method SBMLDocument.convert() with the ConversionProperties object as an argument. Example of invoking an SBML converter ...................................................................... The following code fragment illustrates an example using SBMLReactionConverter, which is invoked using the option string ''replaceReactions':' config = ConversionProperties() if config != None: config.addOption('replaceReactions') In the case of SBMLReactionConverter, there are no options to affect its behavior, so the next step is simply to invoke the converter on an SBMLDocument object. Continuing the example code: # Assume that the variable 'document' has been set to an SBMLDocument object. status = document.convert(config) if status != LIBSBML_OPERATION_SUCCESS: # Handle error somehow. print('Error: conversion failed due to the following:') document.printErrors() Here is an example of using a converter that offers an option. The following code invokes SBMLStripPackageConverter to remove the SBML Level 3 Layout package from a model. It sets the name of the package to be removed by adding a value for the option named ''package'' defined by that converter: def strip_layout_example(document): config = ConversionProperties() if config != None: config.addOption('stripPackage') config.addOption('package', 'layout') status = document.convert(config) if status != LIBSBML_OPERATION_SUCCESS: # Handle error somehow. print('Error: unable to strip the Layout package.') print('LibSBML returned error: ' + OperationReturnValue_toString(status).strip()) else: # Handle error somehow. print('Error: unable to create ConversionProperties object') Available SBML converters in libSBML ...................................................................... LibSBML provides a number of built-in converters; by convention, their names end in Converter. The following are the built-in converters provided by libSBML 5.17.2: @copydetails doc_list_of_libsbml_converters """ __swig_setmethods__ = {} for _s in [SBMLConverter]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLUnitsConverter, name, value) __swig_getmethods__ = {} for _s in [SBMLConverter]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, SBMLUnitsConverter, name) __repr__ = _swig_repr def init(): """ init() Internal implementation method. """ return _libsbml.SBMLUnitsConverter_init() init = staticmethod(init) def __init__(self, *args): """ __init__(SBMLUnitsConverter self) -> SBMLUnitsConverter __init__(SBMLUnitsConverter self, SBMLUnitsConverter obj) -> SBMLUnitsConverter This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: SBMLUnitsConverter() Creates a new SBMLUnitsConverter object. ______________________________________________________________________ Method variant with the following signature: SBMLUnitsConverter(SBMLUnitsConverter obj) Copy constructor; creates a copy of an SBMLUnitsConverter object. Parameter 'obj' is the SBMLUnitsConverter object to copy. """ this = _libsbml.new_SBMLUnitsConverter(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_SBMLUnitsConverter __del__ = lambda self: None def clone(self): """ clone(SBMLUnitsConverter self) -> SBMLUnitsConverter Creates and returns a deep copy of this SBMLUnitsConverter object. Returns a (deep) copy of this converter. """ return _libsbml.SBMLUnitsConverter_clone(self) def matchesProperties(self, props): """ matchesProperties(SBMLUnitsConverter self, ConversionProperties props) -> bool Returns 'True' if this converter object's properties match the given properties. A typical use of this method involves creating a ConversionProperties object, setting the options desired, and then calling this method on an SBMLUnitsConverter object to find out if the object's property values match the given ones. This method is also used by SBMLConverterRegistry.getConverterFor() to search across all registered converters for one matching particular properties. Parameter 'props' is the properties to match. Returns 'True' if this converter's properties match, 'False' otherwise. """ return _libsbml.SBMLUnitsConverter_matchesProperties(self, props) def convert(self): """ convert(SBMLUnitsConverter self) -> int Perform the conversion. This method causes the converter to do the actual conversion work, that is, to convert the SBMLDocument object set by SBMLConverter.setDocument() and with the configuration options set by SBMLConverter.setProperties(). Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_INVALID_OBJECT * LIBSBML_CONV_CONVERSION_NOT_AVAILABLE * LIBSBML_CONV_INVALID_SRC_DOCUMENT """ return _libsbml.SBMLUnitsConverter_convert(self) def getDefaultProperties(self): """ getDefaultProperties(SBMLUnitsConverter self) -> ConversionProperties Returns the default properties of this converter. A given converter exposes one or more properties that can be adjusted in order to influence the behavior of the converter. This method returns the default property settings for this converter. It is meant to be called in order to discover all the settings for the converter object. Returns the ConversionProperties object describing the default properties for this converter. """ return _libsbml.SBMLUnitsConverter_getDefaultProperties(self) SBMLUnitsConverter_swigregister = _libsbml.SBMLUnitsConverter_swigregister SBMLUnitsConverter_swigregister(SBMLUnitsConverter) def SBMLUnitsConverter_init(): """ SBMLUnitsConverter_init() Internal implementation method. """ return _libsbml.SBMLUnitsConverter_init() class SBMLValidator(_object): """ Base class for SBML validators. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. LibSBML implements facilities for verifying that a given SBML document is valid according to the SBML specifications; it also exposes the validation interface so that user programs and SBML Level 3 package authors may use the facilities to implement new validators. There are two main interfaces to libSBML's validation facilities, based on the classes Validator and SBMLValidator. The Validator class is the basis of the system for validating an SBML document against the validation rules defined in the SBML specifications. The scheme used by Validator relies is compact and uses the visitor programming pattern, but it relies on C/C++ features and is not directly accessible from language bindings. SBMLValidator offers a framework for straightforward class-based extensibility, so that user code can subclass SBMLValidator to implement new validation systems, different validators can be introduced or turned off at run- time, and interfaces can be provided in the libSBML language bindings. SBMLValidator can call Validator functionality internally (as is the case in the current implementation of SBMLInternalValidator) or use entirely different implementation approaches, as necessary. Users of libSBML may already be familiar with the facilities encompassed by the validation system, in the form of the consistency- checking methods defined on SBMLDocument. The methods SBMLDocument.setConsistencyChecks(), SBMLDocument.checkConsistency(), SBMLDocument.checkInternalConsistency() and other method of that sort are in fact implemented via SBMLValidator, specifically as methods on the class SBMLInternalValidator. Authors may use SBMLValidator as the base class for their own validator extensions to libSBML. The class SBMLInternalValidator may serve as a code example for how to implement such things. """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLValidator, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, SBMLValidator, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(SBMLValidator self) -> SBMLValidator __init__(SBMLValidator self, SBMLValidator orig) -> SBMLValidator This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: SBMLValidator() Creates a new SBMLValidator. ______________________________________________________________________ Method variant with the following signature: SBMLValidator(SBMLValidator orig) Copy constructor; creates a copy of an SBMLValidator object. Parameter 'orig' is the object to copy. """ if self.__class__ == SBMLValidator: _self = None else: _self = self this = _libsbml.new_SBMLValidator(_self, *args) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_SBMLValidator __del__ = lambda self: None def clone(self): """ clone(SBMLValidator self) -> SBMLValidator Creates and returns a deep copy of this SBMLValidator object. Returns the (deep) copy of this SBMLValidator object. """ return _libsbml.SBMLValidator_clone(self) def getDocument(self, *args): """ getDocument(SBMLValidator self) -> SBMLDocument getDocument(SBMLValidator self) -> SBMLDocument Returns the current SBML document in use by this validator. Returns the current SBML document. See also setDocument(). """ return _libsbml.SBMLValidator_getDocument(self, *args) def setDocument(self, doc): """ setDocument(SBMLValidator self, SBMLDocument doc) -> int Sets the current SBML document to the given SBMLDocument object. Parameter 'doc' is the document to use for this validation. Returns integer value indicating success/failure of the function. This particular function only does one thing irrespective of user input or object state, and thus will only return a single value: * LIBSBML_OPERATION_SUCCESS See also getDocument(). """ return _libsbml.SBMLValidator_setDocument(self, doc) def clearFailures(self): """ clearFailures(SBMLValidator self) Clears this validator's list of failures. If you are validating multiple SBML documents with the same validator, call this method after you have processed the list of failures from the last validation run and before validating the next document. """ return _libsbml.SBMLValidator_clearFailures(self) def logFailure(self, err): """ logFailure(SBMLValidator self, SBMLError err) Adds the given failure to this list of Validators failures. Parameter 'err' is an SBMLError object representing an error or warning. """ return _libsbml.SBMLValidator_logFailure(self, err) def validate(self, *args): """ validate(SBMLValidator self) -> unsigned int validate(SBMLValidator self, SBMLDocument d) -> unsigned int validate(SBMLValidator self, string filename) -> unsigned int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: validate(string filename) Validates the SBML document located at the given 'filename'. This is a convenience method that saves callers the trouble of using SBMLReader to read the document first. Parameter 'filename' is the path to the file to be read and validated. Returns the number of validation failures that occurred. The objects describing the actual failures can be retrieved using getFailures(). ______________________________________________________________________ Method variant with the following signature: validate() Runs this validator on the current SBML document. Returns an integer value indicating the success/failure of the validation. The possible values returned by this function are determined by the specific subclasses of this class. ______________________________________________________________________ Method variant with the following signature: validate(SBMLDocument d) Validates the given SBMLDocument object. This is identical to calling setDocument() followed by validate(). Parameter 'd' is the SBML document to validate. Returns the number of validation failures that occurred. The objects describing the actual failures can be retrieved using getFailures(). """ return _libsbml.SBMLValidator_validate(self, *args) def getErrorLog(self): """ getErrorLog(SBMLValidator self) -> SBMLErrorLog Returns the list of errors or warnings logged during parsing, consistency checking, or attempted translation of this model. Note that this refers to the SBMLDocument object's error log (i.e., the list returned by SBMLDocument.getErrorLog()). That list of errors and warnings is separate from the validation failures tracked by this validator (i.e., the list returned by getFailures()). Returns the SBMLErrorLog used for the SBMLDocument. """ return _libsbml.SBMLValidator_getErrorLog(self) def getModel(self, *args): """ getModel(SBMLValidator self) -> Model getModel(SBMLValidator self) -> Model Returns the Model object stored in the SBMLDocument. It is important to note that this method does not create a Model instance. The model in the SBMLDocument must have been created at some prior time, for example using SBMLDocument.createModel() or SBMLDocument.setModel(). This method returns 'None' if a model does not yet exist. Returns the Model contained in this validator's SBMLDocument object. See also SBMLDocument.setModel(), SBMLDocument.createModel(). """ return _libsbml.SBMLValidator_getModel(self, *args) def getNumFailures(self): """ getNumFailures(SBMLValidator self) -> unsigned int Returns the number of failures encountered in the last validation run. This method returns the number of failures logged by this validator. This number only reflects this validator's actions; the number may not be the same as the number of errors and warnings logged on the SBMLDocument object's error log (i.e., the object returned by SBMLDocument.getErrorLog()), because other parts of libSBML may log errors and warnings beyond those found by this validator. Returns the number of errors logged by this validator. """ return _libsbml.SBMLValidator_getNumFailures(self) def getFailure(self, n): """ getFailure(SBMLValidator self, unsigned int n) -> SBMLError Returns the failure object at index n in this validator's list of failures logged during the last run. Callers should use getNumFailures() first, to find out the number of entries in this validator's list of failures. Parameter 'n' is an integer indicating the index of the object to return from the failures list; index values start at 0. Returns the failure at the given index number. See also getNumFailures(). """ return _libsbml.SBMLValidator_getFailure(self, n) def __disown__(self): self.this.disown() _libsbml.disown_SBMLValidator(self) return weakref_proxy(self) SBMLValidator_swigregister = _libsbml.SBMLValidator_swigregister SBMLValidator_swigregister(SBMLValidator) class SBMLExternalValidator(SBMLValidator): """ Internal implementation method. """ __swig_setmethods__ = {} for _s in [SBMLValidator]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLExternalValidator, name, value) __swig_getmethods__ = {} for _s in [SBMLValidator]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, SBMLExternalValidator, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(SBMLExternalValidator self) -> SBMLExternalValidator __init__(SBMLExternalValidator self, SBMLExternalValidator orig) -> SBMLExternalValidator Internal implementation method. """ this = _libsbml.new_SBMLExternalValidator(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(SBMLExternalValidator self) -> SBMLValidator Internal implementation method. """ return _libsbml.SBMLExternalValidator_clone(self) __swig_destroy__ = _libsbml.delete_SBMLExternalValidator __del__ = lambda self: None def validate(self): """ validate(SBMLExternalValidator self) -> unsigned int Internal implementation method. """ return _libsbml.SBMLExternalValidator_validate(self) def getProgram(self): """ getProgram(SBMLExternalValidator self) -> string Internal implementation method. """ return _libsbml.SBMLExternalValidator_getProgram(self) def setProgram(self, program): """ setProgram(SBMLExternalValidator self, string program) Internal implementation method. """ return _libsbml.SBMLExternalValidator_setProgram(self, program) def getOutputFileName(self): """ getOutputFileName(SBMLExternalValidator self) -> string Internal implementation method. """ return _libsbml.SBMLExternalValidator_getOutputFileName(self) def setOutputFileName(self, outputFileName): """ setOutputFileName(SBMLExternalValidator self, string outputFileName) Internal implementation method. """ return _libsbml.SBMLExternalValidator_setOutputFileName(self, outputFileName) def getSBMLFileName(self): """ getSBMLFileName(SBMLExternalValidator self) -> string Internal implementation method. """ return _libsbml.SBMLExternalValidator_getSBMLFileName(self) def setSBMLFileName(self, sbmlFileName): """ setSBMLFileName(SBMLExternalValidator self, string sbmlFileName) Internal implementation method. """ return _libsbml.SBMLExternalValidator_setSBMLFileName(self, sbmlFileName) def clearArguments(self): """ clearArguments(SBMLExternalValidator self) Internal implementation method. """ return _libsbml.SBMLExternalValidator_clearArguments(self) def addArgument(self, arg): """ addArgument(SBMLExternalValidator self, string arg) Internal implementation method. """ return _libsbml.SBMLExternalValidator_addArgument(self, arg) def getNumArguments(self): """ getNumArguments(SBMLExternalValidator self) -> unsigned int Internal implementation method. """ return _libsbml.SBMLExternalValidator_getNumArguments(self) def getArgument(self, n): """ getArgument(SBMLExternalValidator self, unsigned int n) -> string Internal implementation method. """ return _libsbml.SBMLExternalValidator_getArgument(self, n) SBMLExternalValidator_swigregister = _libsbml.SBMLExternalValidator_swigregister SBMLExternalValidator_swigregister(SBMLExternalValidator) class XMLAttributes(_object): """ A list of attributes on an XML element. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. In libSBML's XML interface layer, attributes on an element are stored as a list of values kept in an XMLAttributes object. XMLAttributes has methods for adding and removing individual attributes as well as performing other actions on the list of attributes. Classes in libSBML that represent nodes in an XML document (i.e., XMLNode and its parent class, XMLToken) use XMLAttributes objects to manage attributes on XML elements. Attributes on an XML element can be written in one of two forms: * name='value' * prefix:name='value' An attribute in XML must always have a value, and the value must always be a quoted string; i.e., it is always name='value' and not name=value. An empty value is represented simply as an empty string; i.e., name=''. In cases when a prefix is provided with an attribute name, general XML validity rules require that the prefix is an XML namespace prefix that has been declared somewhere else (possibly as an another attribute on the same element). However, the XMLAttributes class does not test for the proper existence or declaration of XML namespaces -- callers must arrange to do this themselves in some other way. This class only provides facilities for tracking and manipulating attributes and their prefix/URI/name/value components. Note: Note that although XMLAttributes provides operations that can manipulate attributes based on a numerical index, XML attributes are in fact unordered when they appear in files and data streams. The XMLAttributes class provides some list-like facilities, but it is only for the convenience of callers. (For example, it permits callers to loop across all attributes more easily.) Users should keep in mind that the order in which attributes are stored in XMLAttributes objects has no real impact on the order in which the attributes are read or written from an XML file or data stream. See also XMLTriple, XMLNode, XMLToken. """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, XMLAttributes, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, XMLAttributes, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_XMLAttributes __del__ = lambda self: None def __init__(self, *args): """ __init__(XMLAttributes self) -> XMLAttributes __init__(XMLAttributes self, XMLAttributes orig) -> XMLAttributes This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: XMLAttributes() Creates a new, empty XMLAttributes object. ______________________________________________________________________ Method variant with the following signature: XMLAttributes(XMLAttributes orig) Copy constructor; creates a copy of this XMLAttributes object. 'orig' the XMLAttributes object to copy. """ this = _libsbml.new_XMLAttributes(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(XMLAttributes self) -> XMLAttributes Creates and returns a deep copy of this XMLAttributes object. Returns the (deep) copy of this XMLAttributes object. """ return _libsbml.XMLAttributes_clone(self) def add(self, *args): """ add(XMLAttributes self, string name, string value, string namespaceURI, string prefix) -> int add(XMLAttributes self, string name, string value, string namespaceURI) -> int add(XMLAttributes self, string name, string value) -> int add(XMLAttributes self, XMLTriple triple, string value) -> int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: add( XMLTriple triple, string value) Adds an attribute to this list of attributes. Some explanations are in order about the behavior of XMLAttributes with respect to namespace prefixes and namespace URIs. XMLAttributes does not verify the consistency of different uses of an XML namespace and the prefix used to refer to it in a given context. It cannot, because the prefix used for a given XML namespace in an XML document may intentionally be different on different elements in the document. Consequently, callers need to manage their own prefix-to-namespace mappings, and need to ensure that the desired prefix is used in any given context. When called with attribute names, prefixes and namespace URIs, XMLAttributes pays attention to the namespace URIs and not the prefixes: a match is established by a combination of attribute name and namespace URI, and if on different occasions a different prefix is used for the same name/namespace combination, the prefix associated with the namespace on that attribute is overwritten. Some examples will hopefully clarify this. Here are the results of a sequence of calls to the XMLAttributes add methods with different argument combinations. First, we create the object and add one attribute: XMLAttributes att = new XMLAttributes(); att->add('myattribute', '1', 'myuri'); The above adds an attribute named myattribute in the namespace myuri, and with the attribute value 1. No namespace prefix is associated with the attribute (but the attribute is recorded to exist in the namespace myuri). If this attribute object were written out in XML, it would look like the following (and note that, since no namespace prefix was assigned, none is written out): <center> myattribute='1' </center> Continuing with this series of examples, suppose we invoke the add method again as follows: att->add('myattribute', '2'); The above adds a new attribute also named myattribute, but in a different XML namespace: it is placed in the namespace with no URI, which is to say, the default XML namespace. Both attributes coexist on this XMLAttributes object; both can be independently retrieved. att->add('myattribute', '3'); The code above now replaces the value of the attribute myattribute that resides in the default namespace. The attribute in the namespace myuri remains untouched. att->add('myattribute', '4', 'myuri'); The code above replaces the value of the attribute myattribute that resides in the myuri namespace. The attribute in the default namespace remains untouched. att->add('myattribute', '5', 'myuri', 'foo'); The code above replaces the value of the attribute myattribute that resides in the myuri namespace. It also now assigns a namespace prefix, foo, to the attribute. The attribute myattribute in the default namespace remains untouched. If this XMLAttributes object were written out in XML, it would look like the following: <center> myattribute='3' foo:myattribute='5' </center> Pressing on, now suppose we call the add method as follows: att->add('myattribute', '6', 'myuri', 'bar'); The code above replaces the value of the attribute myattribute that resides in the myuri namespace. It also assigns a different prefix to the attribute. The namespace of the attribute remains myuri. att->add('myattribute', '7', '', 'foo'); The code above replaces the value of the attribute myattribute that resides in the default namespace. It also now assigns a namespace prefix, foo, to that attribute. If this XMLAttributes object were written out in XML, it would look like the following: <center> bar:myattribute='6' foo:myattribute='7' </center> Parameter 'triple' is an XMLTriple object describing the attribute to be added. Parameter 'value' is a string, the value of the attribute. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT - this value is returned if any of the arguments are 'None.' To set an empty value for the attribute, use an empty string rather than 'None.' Note: If an attribute with the same name and XML namespace URI already exists in the list of attributes held by this XMLAttributes object, then the previous value of that attribute will be replaced with the new value provided to this method. See also add(), getIndex(), getIndex(), hasAttribute(), hasAttribute(). ______________________________________________________________________ Method variant with the following signature: add( string name , string value , string namespaceURI = '' , string prefix = '') Adds an attribute to this list of attributes. Some explanations are in order about the behavior of XMLAttributes with respect to namespace prefixes and namespace URIs. XMLAttributes does not verify the consistency of different uses of an XML namespace and the prefix used to refer to it in a given context. It cannot, because the prefix used for a given XML namespace in an XML document may intentionally be different on different elements in the document. Consequently, callers need to manage their own prefix-to-namespace mappings, and need to ensure that the desired prefix is used in any given context. When called with attribute names, prefixes and namespace URIs, XMLAttributes pays attention to the namespace URIs and not the prefixes: a match is established by a combination of attribute name and namespace URI, and if on different occasions a different prefix is used for the same name/namespace combination, the prefix associated with the namespace on that attribute is overwritten. Some examples will hopefully clarify this. Here are the results of a sequence of calls to the XMLAttributes add methods with different argument combinations. First, we create the object and add one attribute: XMLAttributes att = new XMLAttributes(); att->add('myattribute', '1', 'myuri'); The above adds an attribute named myattribute in the namespace myuri, and with the attribute value 1. No namespace prefix is associated with the attribute (but the attribute is recorded to exist in the namespace myuri). If this attribute object were written out in XML, it would look like the following (and note that, since no namespace prefix was assigned, none is written out): <center> myattribute='1' </center> Continuing with this series of examples, suppose we invoke the add method again as follows: att->add('myattribute', '2'); The above adds a new attribute also named myattribute, but in a different XML namespace: it is placed in the namespace with no URI, which is to say, the default XML namespace. Both attributes coexist on this XMLAttributes object; both can be independently retrieved. att->add('myattribute', '3'); The code above now replaces the value of the attribute myattribute that resides in the default namespace. The attribute in the namespace myuri remains untouched. att->add('myattribute', '4', 'myuri'); The code above replaces the value of the attribute myattribute that resides in the myuri namespace. The attribute in the default namespace remains untouched. att->add('myattribute', '5', 'myuri', 'foo'); The code above replaces the value of the attribute myattribute that resides in the myuri namespace. It also now assigns a namespace prefix, foo, to the attribute. The attribute myattribute in the default namespace remains untouched. If this XMLAttributes object were written out in XML, it would look like the following: <center> myattribute='3' foo:myattribute='5' </center> Pressing on, now suppose we call the add method as follows: att->add('myattribute', '6', 'myuri', 'bar'); The code above replaces the value of the attribute myattribute that resides in the myuri namespace. It also assigns a different prefix to the attribute. The namespace of the attribute remains myuri. att->add('myattribute', '7', '', 'foo'); The code above replaces the value of the attribute myattribute that resides in the default namespace. It also now assigns a namespace prefix, foo, to that attribute. If this XMLAttributes object were written out in XML, it would look like the following: <center> bar:myattribute='6' foo:myattribute='7' </center> Parameter 'name' is a string, the unprefixed name of the attribute. Parameter 'value' is a string, the value of the attribute. Parameter 'namespaceURI' is a string, the namespace URI of the attribute. Parameter 'prefix' is a string, a prefix for the XML namespace. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT - this value is returned if any of the arguments are 'None.' To set an empty 'prefix' and/or 'name' value, use an empty string rather than 'None.' Note: If an attribute with the same name and XML namespace URI already exists in the list of attributes held by this XMLAttributes object, then the previous value of that attribute will be replaced with the new value provided to this method. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> See also add(), getIndex(), getIndex(), hasAttribute(), hasAttribute(). Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.XMLAttributes_add(self, *args) def removeResource(self, n): """ removeResource(XMLAttributes self, int n) -> int Internal implementation method. """ return _libsbml.XMLAttributes_removeResource(self, n) def remove(self, *args): """ remove(XMLAttributes self, int n) -> int remove(XMLAttributes self, string name, string uri) -> int remove(XMLAttributes self, string name) -> int remove(XMLAttributes self, XMLTriple triple) -> int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: remove(XMLTriple triple) Removes a specific attribute from this list of attributes. Parameter 'triple' is an XMLTriple describing the attribute to be removed. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INDEX_EXCEEDS_SIZE The value LIBSBML_INDEX_EXCEEDS_SIZE is returned if there is no attribute matching the properties of the given 'triple'. See also remove(), remove(). ______________________________________________________________________ Method variant with the following signature: remove(int n) Removes the nth attribute from this list of attributes. Parameter 'n' is an integer the index of the resource to be deleted. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INDEX_EXCEEDS_SIZE The value LIBSBML_INDEX_EXCEEDS_SIZE is returned if there is no attribute at the given index 'n'. Note: Note that although XMLAttributes provides operations that can manipulate attributes based on a numerical index, XML attributes are in fact unordered when they appear in files and data streams. The XMLAttributes class provides some list-like facilities, but it is only for the convenience of callers. (For example, it permits callers to loop across all attributes more easily.) Users should keep in mind that the order in which attributes are stored in XMLAttributes objects has no real impact on the order in which the attributes are read or written from an XML file or data stream. See also getLength(), remove(), remove(). ______________________________________________________________________ Method variant with the following signature: remove(string name, string uri = '') Removes a named attribute from this list of attributes. Parameter 'name' is a string, the unprefixed name of the attribute to be removed. Parameter 'uri' is a string, the namespace URI of the attribute to be removed. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INDEX_EXCEEDS_SIZE The value LIBSBML_INDEX_EXCEEDS_SIZE is returned if there is no attribute with the given 'name' (and 'uri' if specified). See also remove(), remove(). Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.XMLAttributes_remove(self, *args) def clear(self): """ clear(XMLAttributes self) -> int Removes all attributes in this XMLAttributes object. Returns integer value indicating success/failure of the function. This particular function only does one thing irrespective of user input or object state, and thus will only return a single value: * LIBSBML_OPERATION_SUCCESS See also remove(), remove(), remove(). """ return _libsbml.XMLAttributes_clear(self) def getIndex(self, *args): """ getIndex(XMLAttributes self, string name) -> int getIndex(XMLAttributes self, string name, string uri) -> int getIndex(XMLAttributes self, XMLTriple triple) -> int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getIndex(XMLTriple triple) Returns the index of the attribute defined by the given XMLTriple object. Parameter 'triple' is an XMLTriple describing the attribute being sought. Returns the index of an attribute described by the given XMLTriple object, or -1 if no such attribute is present. See also hasAttribute(), hasAttribute(). ______________________________________________________________________ Method variant with the following signature: getIndex(string name, string uri) Returns the index of the attribute having a given name and XML namespace URI. Parameter 'name' is a string, the name of the attribute being sought. Parameter 'uri' is a string, the namespace URI of the attribute being sought. Returns the index of an attribute with the given local name and namespace URI, or -1 if no such attribute is present. See also hasAttribute(), hasAttribute(). ______________________________________________________________________ Method variant with the following signature: getIndex(string name) Returns the index of an attribute having a given name. Note: This method does not check XML namespaces. Thus, if there are multiple attributes with the same local 'name' but different namespaces, this method will return the first one found. Callers should use the more specific methods XMLAttributes.getIndex() or XMLAttributes.getIndex() to find attributes in particular namespaces. Parameter 'name' is a string, the name of the attribute whose index is begin sought. Returns the index of an attribute with the given local name, or -1 if no such attribute is present. See also hasAttribute(), hasAttribute(). """ return _libsbml.XMLAttributes_getIndex(self, *args) def getLength(self): """ getLength(XMLAttributes self) -> int Returns the number of attributes in this list of attributes. Returns the number of attributes contained in this XMLAttributes object. """ return _libsbml.XMLAttributes_getLength(self) def getNumAttributes(self): """ getNumAttributes(XMLAttributes self) -> int Returns the number of attributes in this list of attributes. This function is merely an alias of XMLAttributes.getLength() introduced for consistency with other libXML classes. Returns the number of attributes contained in this XMLAttributes object. """ return _libsbml.XMLAttributes_getNumAttributes(self) def getName(self, index): """ getName(XMLAttributes self, int index) -> string Returns the name of the nth attribute in this list of attributes. Parameter 'index' is an integer, the position of the attribute whose name is being sought. Returns the local name of the nth attribute. Note: If 'index' is out of range, this method will return an empty string. Callers should use XMLAttributes.getLength() to check the number of attributes contained in this object or XMLAttributes.hasAttribute() to test for the existence of an attribute at a given position. Note: Note that although XMLAttributes provides operations that can manipulate attributes based on a numerical index, XML attributes are in fact unordered when they appear in files and data streams. The XMLAttributes class provides some list-like facilities, but it is only for the convenience of callers. (For example, it permits callers to loop across all attributes more easily.) Users should keep in mind that the order in which attributes are stored in XMLAttributes objects has no real impact on the order in which the attributes are read or written from an XML file or data stream. See also getLength(), hasAttribute(). """ return _libsbml.XMLAttributes_getName(self, index) def getPrefix(self, index): """ getPrefix(XMLAttributes self, int index) -> string Returns the namespace prefix of the nth attribute in this attribute set. Parameter 'index' is an integer, the position of the attribute whose namespace prefix is being sought. Returns the XML namespace prefix of the nth attribute. Note: If 'index' is out of range, this method will return an empty string. Callers should use XMLAttributes.getLength() to check the number of attributes contained in this object or XMLAttributes.hasAttribute() to test for the existence of an attribute at a given position. Note: Note that although XMLAttributes provides operations that can manipulate attributes based on a numerical index, XML attributes are in fact unordered when they appear in files and data streams. The XMLAttributes class provides some list-like facilities, but it is only for the convenience of callers. (For example, it permits callers to loop across all attributes more easily.) Users should keep in mind that the order in which attributes are stored in XMLAttributes objects has no real impact on the order in which the attributes are read or written from an XML file or data stream. See also getLength(), hasAttribute(). """ return _libsbml.XMLAttributes_getPrefix(self, index) def getPrefixedName(self, index): """ getPrefixedName(XMLAttributes self, int index) -> string Returns the prefix name of the nth attribute in this attribute set. Parameter 'index' is an integer, the position of the attribute whose prefixed name is being sought. Returns the prefixed name of the nth attribute. Note: If 'index' is out of range, this method will return an empty string. Callers should use XMLAttributes.getLength() to check the number of attributes contained in this object or XMLAttributes.hasAttribute() to test for the existence of an attribute at a given position. Note: Note that although XMLAttributes provides operations that can manipulate attributes based on a numerical index, XML attributes are in fact unordered when they appear in files and data streams. The XMLAttributes class provides some list-like facilities, but it is only for the convenience of callers. (For example, it permits callers to loop across all attributes more easily.) Users should keep in mind that the order in which attributes are stored in XMLAttributes objects has no real impact on the order in which the attributes are read or written from an XML file or data stream. See also getLength(), hasAttribute(). """ return _libsbml.XMLAttributes_getPrefixedName(self, index) def getURI(self, index): """ getURI(XMLAttributes self, int index) -> string Returns the XML namespace URI of the nth attribute in this attribute set. Parameter 'index' is an integer, the position of the attribute whose namespace URI is being sought. Returns the XML namespace URI of the nth attribute. Note: If 'index' is out of range, this method will return an empty string. Callers should use XMLAttributes.getLength() to check the number of attributes contained in this object or XMLAttributes.hasAttribute() to test for the existence of an attribute at a given position. Note: Note that although XMLAttributes provides operations that can manipulate attributes based on a numerical index, XML attributes are in fact unordered when they appear in files and data streams. The XMLAttributes class provides some list-like facilities, but it is only for the convenience of callers. (For example, it permits callers to loop across all attributes more easily.) Users should keep in mind that the order in which attributes are stored in XMLAttributes objects has no real impact on the order in which the attributes are read or written from an XML file or data stream. See also getLength(), hasAttribute(). """ return _libsbml.XMLAttributes_getURI(self, index) def getValue(self, *args): """ getValue(XMLAttributes self, int index) -> string getValue(XMLAttributes self, string name) -> string getValue(XMLAttributes self, string name, string uri) -> string getValue(XMLAttributes self, XMLTriple triple) -> string This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getValue(XMLTriple triple) Return the value of an attribute described by a given XMLTriple object. Parameter 'triple' is an XMLTriple describing the attribute whose value is being sought. Returns The attribute value as a string. Note: If an attribute with the properties given by 'triple' does not exist in this XMLAttributes object, this method will return an empty string. Callers can use XMLAttributes.hasAttribute() to test for an attribute's existence. See also hasAttribute(), hasAttribute(). ______________________________________________________________________ Method variant with the following signature: getValue(int index) Returns the value of the nth attribute in this list of attributes. Parameter 'index' is an integer, the position of the attribute whose value is being sought. Returns the XML value of the nth attribute. Note: If 'index' is out of range, this method will return an empty string. Callers should use XMLAttributes.getLength() to check the number of attributes contained in this object or XMLAttributes.hasAttribute() to test for the existence of an attribute at a given position. Note: Note that although XMLAttributes provides operations that can manipulate attributes based on a numerical index, XML attributes are in fact unordered when they appear in files and data streams. The XMLAttributes class provides some list-like facilities, but it is only for the convenience of callers. (For example, it permits callers to loop across all attributes more easily.) Users should keep in mind that the order in which attributes are stored in XMLAttributes objects has no real impact on the order in which the attributes are read or written from an XML file or data stream. See also getLength(), hasAttribute(). ______________________________________________________________________ Method variant with the following signature: getValue(string name) Returns a named attribute's value. Parameter 'name' is a string, the unprefixed name of the attribute whose value is being sought. Returns The attribute value as a string. Note: If an attribute with the given local 'name' does not exist in this XMLAttributes object, this method will return an empty string. Callers can use XMLAttributes.hasAttribute() to test for an attribute's existence. This method also does not check the XML namespace of the named attribute. Thus, if there are multiple attributes with the same local 'name' but different namespaces, this method will return the value of the first such attribute found. Callers should use the more specific methods XMLAttributes.getIndex() or XMLAttributes.getIndex() to find attributes in particular namespaces. See also hasAttribute(), hasAttribute(). ______________________________________________________________________ Method variant with the following signature: getValue(string name, string uri) Returns a named attribute's value. Parameter 'name' is a string, the name of the attribute whose value is being sought. Parameter 'uri' is a string, the XML namespace URI of the attribute. Returns The attribute value as a string. Note: If an attribute with the given 'name' and namespace 'uri' does not exist in this XMLAttributes object, this method will return an empty string. Callers can use XMLAttributes.hasAttribute() to test for an attribute's existence. See also hasAttribute(), hasAttribute(). """ return _libsbml.XMLAttributes_getValue(self, *args) def hasAttribute(self, *args): """ hasAttribute(XMLAttributes self, int index) -> bool hasAttribute(XMLAttributes self, string name, string uri) -> bool hasAttribute(XMLAttributes self, string name) -> bool hasAttribute(XMLAttributes self, XMLTriple triple) -> bool This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: hasAttribute(XMLTriple triple) Returns 'True' if an attribute with the given properties exists. Parameter 'triple' is an XMLTriple describing the attribute to be tested. Returns 'True' if an attribute with the given XML triple exists in this XMLAttributes object, 'False' otherwise. See also add(), add(). ______________________________________________________________________ Method variant with the following signature: hasAttribute(int index) Returns 'True' if an attribute exists at a given index. Parameter 'index' is an integer, the position of the attribute to be tested. Returns 'True' if an attribute with the given index exists in this XMLAttributes object, 'False' otherwise. Note: Note that although XMLAttributes provides operations that can manipulate attributes based on a numerical index, XML attributes are in fact unordered when they appear in files and data streams. The XMLAttributes class provides some list-like facilities, but it is only for the convenience of callers. (For example, it permits callers to loop across all attributes more easily.) Users should keep in mind that the order in which attributes are stored in XMLAttributes objects has no real impact on the order in which the attributes are read or written from an XML file or data stream. ______________________________________________________________________ Method variant with the following signature: hasAttribute(string name, string uri='') Returns 'True' if an attribute with a given name and namespace URI exists. Parameter 'name' is a string, the unprefixed name of the attribute. Parameter 'uri' is a string, the XML namespace URI of the attribute. Returns 'True' if an attribute with the given local name and XML namespace URI exists in this XMLAttributes object, 'False' otherwise. See also add(), add(). """ return _libsbml.XMLAttributes_hasAttribute(self, *args) def isEmpty(self): """ isEmpty(XMLAttributes self) -> bool Returns 'True' if this list of attributes is empty. Returns 'True' if this XMLAttributes object is empty, 'False' otherwise. """ return _libsbml.XMLAttributes_isEmpty(self) def __eq__(self, rhs): if ((self is None) and (rhs is None)): return True if ((self is None) or (rhs is None)): return False if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return True return False def __ne__(self, rhs): if ((self is None) and (rhs is None)): return False if ((self is None) or (rhs is None)): return True if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return False return True XMLAttributes_swigregister = _libsbml.XMLAttributes_swigregister XMLAttributes_swigregister(XMLAttributes) class XMLNamespaces(_object): """ An XML Namespace. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. This class serves to organize functionality for tracking XML namespaces in a document or data stream. The namespace declarations are stored as a list of pairs of XML namespace URIs and prefix strings. These correspond to the parts of a namespace declaration on an XML element. For example, in the following XML fragment, <annotation> <mysim:nodecolors xmlns:mysim='urn:lsid:mysim.org' mysim:bgcolor='green' mysim:fgcolor='white'/> </annotation> there is one namespace declaration. Its URI is urn:lsid:mysim.org and its prefix is mysim. This pair could be stored as one item in an XMLNamespaces list. XMLNamespaces provides various methods for manipulating the list of prefix-URI pairs. Individual namespaces stored in a given XMLNamespace object instance can be retrieved based on their index using XMLNamespaces.getPrefix(), or by their characteristics such as their URI or position in the list. """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, XMLNamespaces, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, XMLNamespaces, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_XMLNamespaces __del__ = lambda self: None def __init__(self, *args): """ __init__(XMLNamespaces self) -> XMLNamespaces __init__(XMLNamespaces self, XMLNamespaces orig) -> XMLNamespaces This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: XMLNamespaces() Creates a new empty list of XML namespace declarations. ______________________________________________________________________ Method variant with the following signature: XMLNamespaces(XMLNamespaces orig) Copy constructor; creates a copy of this XMLNamespaces list. Parameter 'orig' is the XMLNamespaces object to copy. """ this = _libsbml.new_XMLNamespaces(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(XMLNamespaces self) -> XMLNamespaces Creates and returns a deep copy of this XMLNamespaces object. Returns the (deep) copy of this XMLNamespaces object. """ return _libsbml.XMLNamespaces_clone(self) def add(self, *args): """ add(XMLNamespaces self, string uri, string prefix) -> int add(XMLNamespaces self, string uri) -> int Appends an XML namespace prefix and URI pair to this list of namespace declarations. An XMLNamespaces object stores a list of pairs of namespaces and their prefixes. If there is an XML namespace with the given 'uri' prefix in this list, then its corresponding URI will be overwritten by the new 'uri' unless the uri represents the core sbml namespace. Calling programs could use one of the other XMLNamespaces methods, such as XMLNamespaces.hasPrefix() and XMLNamespaces.hasURI() to inquire whether a given prefix and/or URI is already present in this XMLNamespaces object. If the 'uri' represents the sbml namespaces then it will not be overwritten, as this has potentially serious consequences. If it is necessary to replace the sbml namespace the namespace should be removed prior to adding the new namespace. Parameter 'uri' is a string, the uri for the namespace. Parameter 'prefix' is a string, the prefix for the namespace. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT * LIBSBML_OPERATION_FAILED </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.XMLNamespaces_add(self, *args) def remove(self, *args): """ remove(XMLNamespaces self, int index) -> int remove(XMLNamespaces self, string prefix) -> int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: remove(int index) Removes an XML Namespace stored in the given position of this list. Parameter 'index' is an integer, position of the namespace to remove. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INDEX_EXCEEDS_SIZE ______________________________________________________________________ Method variant with the following signature: remove(string prefix) Removes an XML Namespace with the given prefix. Parameter 'prefix' is a string, prefix of the required namespace. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INDEX_EXCEEDS_SIZE See also remove(). """ return _libsbml.XMLNamespaces_remove(self, *args) def clear(self): """ clear(XMLNamespaces self) -> int Clears (deletes) all XML namespace declarations in this XMLNamespaces object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also remove(). """ return _libsbml.XMLNamespaces_clear(self) def getIndex(self, uri): """ getIndex(XMLNamespaces self, string uri) -> int Look up the index of an XML namespace declaration by URI. An XMLNamespaces object stores a list of pairs of namespaces and their prefixes. If this XMLNamespaces object contains a pair with the given URI 'uri', this method returns its index in the list. Parameter 'uri' is a string, the URI of the sought-after namespace. Returns the index of the given declaration, or -1 if not present. """ return _libsbml.XMLNamespaces_getIndex(self, uri) def containsUri(self, uri): """ containsUri(XMLNamespaces self, string uri) -> bool Tests whether the given uri is contained in this set of namespaces. """ return _libsbml.XMLNamespaces_containsUri(self, uri) def getIndexByPrefix(self, prefix): """ getIndexByPrefix(XMLNamespaces self, string prefix) -> int Look up the index of an XML namespace declaration by 'prefix'. An XMLNamespaces object stores a list of pairs of namespaces and their prefixes. If this XMLNamespaces object contains a pair with the given prefix 'prefix', this method returns its index in the list. Parameter 'prefix' is a string, the prefix string of the sought-after namespace. Returns the index of the given declaration, or -1 if not present. """ return _libsbml.XMLNamespaces_getIndexByPrefix(self, prefix) def getLength(self): """ getLength(XMLNamespaces self) -> int Returns the total number of URI-and-prefix pairs stored in this particular XMLNamespaces instance. Returns the number of namespaces in this list. """ return _libsbml.XMLNamespaces_getLength(self) def getNumNamespaces(self): """ getNumNamespaces(XMLNamespaces self) -> int Returns the total number of URI-and-prefix pairs stored in this particular XMLNamespaces instance. Returns the number of namespaces in this list. This function is an alias for getLength introduced for consistency with other XML classes. """ return _libsbml.XMLNamespaces_getNumNamespaces(self) def getPrefix(self, *args): """ getPrefix(XMLNamespaces self, int index) -> string getPrefix(XMLNamespaces self, string uri) -> string This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getPrefix(int index) Look up the prefix of an XML namespace declaration by its position. An XMLNamespaces object stores a list of pairs of namespaces and their prefixes. This method returns the prefix of the nth element in that list (if it exists). Callers should use XMLAttributes.getLength() first to find out how many namespaces are stored in the list. Parameter 'index' is an integer, position of the sought-after prefix. Returns the prefix of an XML namespace declaration in this list (by position), or an empty string if the 'index' is out of range. See also getLength(). ______________________________________________________________________ Method variant with the following signature: getPrefix(string uri) Look up the prefix of an XML namespace declaration by its URI. An XMLNamespaces object stores a list of pairs of namespaces and their prefixes. This method returns the prefix for a pair that has the given 'uri'. Parameter 'uri' is a string, the URI of the prefix being sought. Returns the prefix of an XML namespace declaration given its URI, or an empty string if no such 'uri' exists in this XMLNamespaces object. """ return _libsbml.XMLNamespaces_getPrefix(self, *args) def getURI(self, *args): """ getURI(XMLNamespaces self, int index) -> string getURI(XMLNamespaces self, string prefix) -> string getURI(XMLNamespaces self) -> string This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getURI(int index) Look up the URI of an XML namespace declaration by its position. An XMLNamespaces object stores a list of pairs of namespaces and their prefixes. This method returns the URI of the nth element in that list (if it exists). Callers should use XMLAttributes.getLength() first to find out how many namespaces are stored in the list. Parameter 'index' is an integer, position of the required URI. Returns the URI of an XML namespace declaration in this list (by position), or an empty string if the 'index' is out of range. See also getLength(). ______________________________________________________________________ Method variant with the following signature: getURI(string prefix = '') Look up the URI of an XML namespace declaration by its prefix. An XMLNamespaces object stores a list of pairs of namespaces and their prefixes. This method returns the namespace URI for a pair that has the given 'prefix'. Parameter 'prefix' is a string, the prefix of the required URI. Returns the URI of an XML namespace declaration having the given 'prefix', or an empty string if no such prefix-and-URI pair exists in this XMLNamespaces object. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> See also getURI(). Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.XMLNamespaces_getURI(self, *args) def isEmpty(self): """ isEmpty(XMLNamespaces self) -> bool Predicate returning 'True' or 'False' depending on whether this XMLNamespaces list is empty. Returns 'True' if this XMLNamespaces list is empty, 'False' otherwise. """ return _libsbml.XMLNamespaces_isEmpty(self) def hasURI(self, uri): """ hasURI(XMLNamespaces self, string uri) -> bool Predicate returning 'True' or 'False' depending on whether an XML Namespace with the given URI is contained in this XMLNamespaces list. Parameter 'uri' is a string, the uri for the namespace. Returns 'True' if an XML Namespace with the given URI is contained in this XMLNamespaces list, 'False' otherwise. """ return _libsbml.XMLNamespaces_hasURI(self, uri) def hasPrefix(self, prefix): """ hasPrefix(XMLNamespaces self, string prefix) -> bool Predicate returning 'True' or 'False' depending on whether an XML Namespace with the given prefix is contained in this XMLNamespaces list. Parameter 'prefix' is a string, the prefix for the namespace. Returns 'True' if an XML Namespace with the given URI is contained in this XMLNamespaces list, 'False' otherwise. """ return _libsbml.XMLNamespaces_hasPrefix(self, prefix) def hasNS(self, uri, prefix): """ hasNS(XMLNamespaces self, string uri, string prefix) -> bool Predicate returning 'True' or 'False' depending on whether an XML Namespace with the given URI and prefix pair is contained in this XMLNamespaces list. Parameter 'uri' is a string, the URI for the namespace. Parameter 'prefix' is a string, the prefix for the namespace. Returns 'True' if an XML Namespace with the given uri/prefix pair is contained in this XMLNamespaces list, 'False' otherwise. """ return _libsbml.XMLNamespaces_hasNS(self, uri, prefix) def __eq__(self, rhs): if ((self is None) and (rhs is None)): return True if ((self is None) or (rhs is None)): return False if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return True return False def __ne__(self, rhs): if ((self is None) and (rhs is None)): return False if ((self is None) or (rhs is None)): return True if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return False return True XMLNamespaces_swigregister = _libsbml.XMLNamespaces_swigregister XMLNamespaces_swigregister(XMLNamespaces) class XMLToken(_object): """ A token in an XML stream. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. The libSBML XML parser interface can read an XML file or data stream and convert the contents into tokens. The tokens represent items in the XML stream, either XML elements (start or end tags) or text that appears as content inside an element. The XMLToken class is libSBML's low-level representation of these entities. Each XMLToken has the following information associated with it: <ol> * Qualified name: every XML element or XML attribute has a name (e.g., for the element <mytag>, the name is 'mytag'), but this name may be qualified with a namespace (e.g., it may appear as <someNamespace:mytag> in the input). An XMLToken stores the name of a token, along with any namespace qualification present, through the use of an XMLTriple object. This object stores the bare name of the element, its XML namespace prefix (if any), and the XML namespace with which that prefix is associated. * Namespaces: An XML token can have one or more XML namespaces associated with it. These namespaces may be specified explicitly on the element or inherited from parent elements. In libSBML, a list of namespaces is stored in an XMLNamespaces object. An XMLToken possesses a field for storing an XMLNamespaces object. * Attributes: XML elements can have attributes associated with them, and these attributes can have values assigned to them. The set of attribute-value pairs is stored in an XMLAttributes object stored in an XMLToken object. (Note: only elements can have attributes -- text blocks cannot have them in XML.) * Line number: the line number in the input where the token appears. * Column number: the column number in the input where the token appears. </ol> The XMLToken class serves as base class for XMLNode. XML lends itself to a tree-structured representation, and in libSBML, the nodes in an XML document tree are XMLNode objects. Most higher-level libSBML classes and methods that offer XML-level functionality (such as the methods on SBase for interacting with annotations) work with XMLNode objects rather than XMLToken objects directly. See also XMLNode, XMLTriple, XMLAttributes, XMLNamespaces. """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, XMLToken, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, XMLToken, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_XMLToken __del__ = lambda self: None def __init__(self, *args): """ __init__(XMLToken self) -> XMLToken __init__(XMLToken self, XMLTriple triple, XMLAttributes attributes, XMLNamespaces namespaces, unsigned int const line=0, unsigned int const column=0) -> XMLToken __init__(XMLToken self, XMLTriple triple, XMLAttributes attributes, XMLNamespaces namespaces, unsigned int const line=0) -> XMLToken __init__(XMLToken self, XMLTriple triple, XMLAttributes attributes, XMLNamespaces namespaces) -> XMLToken __init__(XMLToken self, XMLTriple triple, XMLAttributes attributes, unsigned int const line=0, unsigned int const column=0) -> XMLToken __init__(XMLToken self, XMLTriple triple, XMLAttributes attributes, unsigned int const line=0) -> XMLToken __init__(XMLToken self, XMLTriple triple, XMLAttributes attributes) -> XMLToken __init__(XMLToken self, XMLTriple triple, unsigned int const line=0, unsigned int const column=0) -> XMLToken __init__(XMLToken self, XMLTriple triple, unsigned int const line=0) -> XMLToken __init__(XMLToken self, XMLTriple triple) -> XMLToken __init__(XMLToken self, string chars, unsigned int const line=0, unsigned int const column=0) -> XMLToken __init__(XMLToken self, string chars, unsigned int const line=0) -> XMLToken __init__(XMLToken self, string chars) -> XMLToken __init__(XMLToken self, XMLToken orig) -> XMLToken This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: XMLToken() Creates a new empty XMLToken object. ______________________________________________________________________ Method variant with the following signature: XMLToken(XMLToken orig) Copy constructor; creates a copy of this XMLToken object. Parameter 'orig' is the XMLToken object to copy. ______________________________________________________________________ Method variant with the following signature: XMLToken( XMLTriple triple , XMLAttributes attributes , long line = 0 , long column = 0 ) Creates an XML start element with attributes. Parameter 'triple' is an XMLTriple object describing the start tag. Parameter 'attributes' is XMLAttributes, the attributes to set on the element to be created. Parameter 'line' is a long integer, the line number to associate with the token (default = 0). Parameter 'column' is a long integer, the column number to associate with the token (default = 0). The XML namespace component of this XMLToken object will be left empty. See the other variants of the XMLToken constructors for versions that take namespace arguments. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. ______________________________________________________________________ Method variant with the following signature: XMLToken( XMLTriple triple , long line = 0 , long column = 0 ) Creates an XML end element. Parameter 'triple' is an XMLTriple object describing the end tag. Parameter 'line' is a long integer, the line number to associate with the token (default = 0). Parameter 'column' is a long integer, the column number to associate with the token (default = 0). </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. ______________________________________________________________________ Method variant with the following signature: XMLToken( XMLTriple triple , XMLAttributes attributes , XMLNamespaces namespaces , long line = 0 , long column = 0 ) Creates an XML start element with attributes and namespace declarations. Parameter 'triple' is an XMLTriple object describing the start tag. Parameter 'attributes' is XMLAttributes, the attributes to set on the element to be created. Parameter 'namespaces' is XMLNamespaces, the namespaces to set on the element to be created. Parameter 'line' is a long integer, the line number to associate with the token (default = 0). Parameter 'column' is a long integer, the column number to associate with the token (default = 0). </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. ______________________________________________________________________ Method variant with the following signature: XMLToken( string chars , long line = 0 , long column = 0 ) Creates a text object. Parameter 'chars' is a string, the text to be added to the XMLToken object. Parameter 'line' is a long integer, the line number to associate with the token (default = 0). Parameter 'column' is a long integer, the column number to associate with the token (default = 0). </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ this = _libsbml.new_XMLToken(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(XMLToken self) -> XMLToken Creates and returns a deep copy of this XMLToken object. Returns the (deep) copy of this XMLToken object. """ return _libsbml.XMLToken_clone(self) def getAttributes(self): """ getAttributes(XMLToken self) -> XMLAttributes Returns the attributes of the XML element represented by this token. Returns the attributes of this XML element, stored in an XMLAttributes object. """ return _libsbml.XMLToken_getAttributes(self) def setAttributes(self, attributes): """ setAttributes(XMLToken self, XMLAttributes attributes) -> int Sets the attributes on the XML element represented by this token. This operation only makes sense for XML start elements. This method will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is not an XML start element. Parameter 'attributes' is an XMLAttributes object to be assigned to this XMLToken object, thereby setting the XML attributes associated with this token. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_INVALID_XML_OPERATION * LIBSBML_INVALID_OBJECT Note: This function replaces any existing XMLAttributes object on this XMLToken object with the one given by 'attributes'. """ return _libsbml.XMLToken_setAttributes(self, attributes) def addAttr(self, *args): """ addAttr(XMLToken self, string name, string value, string namespaceURI, string prefix) -> int addAttr(XMLToken self, string name, string value, string namespaceURI) -> int addAttr(XMLToken self, string name, string value) -> int addAttr(XMLToken self, XMLTriple triple, string value) -> int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: addAttr( XMLTriple triple, string value) Adds an attribute to the XML element represented by this token. This operation only makes sense for XML start elements. This method will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is not an XML start element. Parameter 'triple' is an XMLTriple object defining the attribute, its value, and optionally its XML namespace (if any is provided). Parameter 'value' is a string, the value assigned to the attribute. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT * LIBSBML_INVALID_XML_OPERATION Note: If an attribute with the same name and XML namespace URI already exists on this XMLToken object, then the previous value will be replaced with the new value provided to this method. ______________________________________________________________________ Method variant with the following signature: addAttr( string name , string value , string namespaceURI = '' , string prefix = '') Adds an attribute to the XML element represented by this token. This operation only makes sense for XML start elements. This method will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is not an XML start element. Parameter 'name' is a string, the so-called 'local part' of the attribute name; that is, the attribute name without any namespace qualifier or prefix. Parameter 'value' is a string, the value assigned to the attribute. Parameter 'namespaceURI' is a string, the XML namespace URI of the attribute. Parameter 'prefix' is a string, the prefix for the XML namespace. Recall that in XML, the complete form of an attribute on an XML element is the following: <center> prefix:name='value' </center> The name part is the name of the attribute, the 'value' part is the value assigned to the attribute (and it is always a quoted string), and the prefix part is an optional XML namespace prefix. Internally in libSBML, this data is stored in an XMLAttributes object associated with this XMLToken. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT * LIBSBML_INVALID_XML_OPERATION Note: If an attribute with the same name and XML namespace URI already exists on this XMLToken object, then the previous value will be replaced with the new value provided to this method. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.XMLToken_addAttr(self, *args) def removeAttr(self, *args): """ removeAttr(XMLToken self, int n) -> int removeAttr(XMLToken self, string name, string uri) -> int removeAttr(XMLToken self, string name) -> int removeAttr(XMLToken self, XMLTriple triple) -> int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: removeAttr(XMLTriple triple) Removes an attribute from the XML element represented by this token. This operation only makes sense for XML start elements. This method will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is not an XML start element. Parameter 'triple' is an XMLTriple describing the attribute to be removed. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_XML_OPERATION * LIBSBML_INDEX_EXCEEDS_SIZE The value LIBSBML_INDEX_EXCEEDS_SIZE is returned if there is no attribute on this element matching the properties of the given 'triple'. See also hasAttr(). ______________________________________________________________________ Method variant with the following signature: removeAttr(int n) Removes the nth attribute from the XML element represented by this token. This operation only makes sense for XML start elements. This method will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is not an XML start element. Parameter 'n' is an integer the index of the resource to be deleted. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_XML_OPERATION * LIBSBML_INDEX_EXCEEDS_SIZE The value LIBSBML_INDEX_EXCEEDS_SIZE is returned if there is no attribute on this element at the given index 'n'. See also getAttrIndex(), getAttrIndex(), getAttributesLength(). ______________________________________________________________________ Method variant with the following signature: removeAttr(string name, string uri = '') Removes an attribute from the XML element represented by this token. This operation only makes sense for XML start elements. This method will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is not an XML start element. Parameter 'name' is a string, the name of the attribute to be removed. Parameter 'uri' is a string, the XML namespace URI of the attribute to be removed. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_XML_OPERATION * LIBSBML_INDEX_EXCEEDS_SIZE The value LIBSBML_INDEX_EXCEEDS_SIZE is returned if there is no attribute on this element with the given 'name' (and 'uri' if specified). See also hasAttr(). Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.XMLToken_removeAttr(self, *args) def clearAttributes(self): """ clearAttributes(XMLToken self) -> int Removes all attributes of this XMLToken object. This operation only makes sense for XML start elements. This method will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is not an XML start element. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_XML_OPERATION """ return _libsbml.XMLToken_clearAttributes(self) def getAttrIndex(self, *args): """ getAttrIndex(XMLToken self, string name, string uri) -> int getAttrIndex(XMLToken self, string name) -> int getAttrIndex(XMLToken self, XMLTriple triple) -> int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getAttrIndex(XMLTriple triple) Returns the index of the attribute defined by the given XMLTriple object. Parameter 'triple' is the XMLTriple object that defines the attribute whose index is being sought. Returns the index of an attribute with the given XMLTriple object, or -1 if no such attribute is present on this token. ______________________________________________________________________ Method variant with the following signature: getAttrIndex(string name, string uri='') Returns the index of the attribute with the given name and namespace URI. Parameter 'name' is a string, the name of the attribute. Parameter 'uri' is a string, the namespace URI of the attribute. Returns the index of an attribute with the given local name and namespace URI, or -1 if it is not present on this token. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> """ return _libsbml.XMLToken_getAttrIndex(self, *args) def getAttributesLength(self): """ getAttributesLength(XMLToken self) -> int Returns the number of attributes on this XMLToken object. Returns the number of attributes possessed by this token. See also hasAttr(). """ return _libsbml.XMLToken_getAttributesLength(self) def getAttrName(self, index): """ getAttrName(XMLToken self, int index) -> string Returns the name of the nth attribute in this token's list of attributes. Parameter 'index' is an integer, the position of the attribute whose name is being sought. Returns the name of the attribute located at position 'n' in the list of attributes possessed by this XMLToken object. Note: If 'index' is out of range, this method will return an empty string. XMLToken.hasAttr() can be used to test for an attribute's existence explicitly, and XMLToken.getAttributesLength() can be used to find out the number of attributes possessed by this token. See also hasAttr(), getAttributesLength(). """ return _libsbml.XMLToken_getAttrName(self, index) def getAttrPrefix(self, index): """ getAttrPrefix(XMLToken self, int index) -> string Returns the prefix of the nth attribute in this token's list of attributes. Parameter 'index' is an integer, the position of the attribute whose prefix is being sought. Returns the XML namespace prefix of the attribute located at position 'n' in the list of attributes possessed by this XMLToken object. Note: If 'index' is out of range, this method will return an empty string. XMLToken.hasAttr() can be used to test for an attribute's existence explicitly, and XMLToken.getAttributesLength() can be used to find out the number of attributes possessed by this token. See also hasAttr(), getAttributesLength(). """ return _libsbml.XMLToken_getAttrPrefix(self, index) def getAttrPrefixedName(self, index): """ getAttrPrefixedName(XMLToken self, int index) -> string Returns the prefixed name of the nth attribute in this token's list of attributes. In this context, prefixed name means the name of the attribute prefixed with the XML namespace prefix assigned to the attribute. This will be a string of the form prefix:name. Parameter 'index' is an integer, the position of the attribute whose prefixed name is being sought. Returns the prefixed name of the attribute located at position 'n' in the list of attributes possessed by this XMLToken object. Note: If 'index' is out of range, this method will return an empty string. XMLToken.hasAttr() can be used to test for an attribute's existence explicitly, and XMLToken.getAttributesLength() can be used to find out the number of attributes possessed by this token. """ return _libsbml.XMLToken_getAttrPrefixedName(self, index) def getAttrURI(self, index): """ getAttrURI(XMLToken self, int index) -> string Returns the XML namespace URI of the nth attribute in this token's list of attributes. Parameter 'index' is an integer, the position of the attribute whose namespace URI is being sought. Returns the XML namespace URI of the attribute located at position 'n' in the list of attributes possessed by this XMLToken object. Note: If 'index' is out of range, this method will return an empty string. XMLToken.hasAttr() can be used to test for an attribute's existence explicitly, and XMLToken.getAttributesLength() can be used to find out the number of attributes possessed by this token. """ return _libsbml.XMLToken_getAttrURI(self, index) def getAttrValue(self, *args): """ getAttrValue(XMLToken self, int index) -> string getAttrValue(XMLToken self, string name, string uri) -> string getAttrValue(XMLToken self, string name) -> string getAttrValue(XMLToken self, XMLTriple triple) -> string This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getAttrValue(XMLTriple triple) Returns the value of the attribute specified by a given XMLTriple object. Parameter 'triple' is an XMLTriple describing the attribute whose value is being sought. Returns The value of the attribute, as a string. Note: If an attribute defined by the given 'triple' does not exist on this token object, this method will return an empty string. XMLToken.hasAttr() can be used to test explicitly for the existence of an attribute with the properties of a given triple. ______________________________________________________________________ Method variant with the following signature: getAttrValue(int index) Returns the value of the nth attribute in this token's list of attributes. Parameter 'index' is an integer, the position of the attribute whose value is required. Returns the value of the attribute located at position 'n' in the list of attributes possessed by this XMLToken object. Note: If 'index' is out of range, this method will return an empty string. XMLToken.hasAttr() can be used to test for an attribute's existence explicitly, and XMLToken.getAttributesLength() can be used to find out the number of attributes possessed by this token. ______________________________________________________________________ Method variant with the following signature: getAttrValue(string name, string uri='') Returns the value of the attribute with a given name and XML namespace URI. Parameter 'name' is a string, the name of the attribute whose value is being sought. Parameter 'uri' is a string, the XML namespace URI of the attribute. Returns The value of the attribute, as a string. Note: If an attribute with the given 'name' and 'uri' does not exist on this token object, this method will return an empty string. XMLToken.hasAttr() can be used to test explicitly for the presence of an attribute with a given name and namespace. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> """ return _libsbml.XMLToken_getAttrValue(self, *args) def hasAttr(self, *args): """ hasAttr(XMLToken self, int index) -> bool hasAttr(XMLToken self, string name, string uri) -> bool hasAttr(XMLToken self, string name) -> bool hasAttr(XMLToken self, XMLTriple triple) -> bool This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: hasAttr(XMLTriple triple) Returns 'True' if an attribute defined by a given XMLTriple object exists. Parameter 'triple' is an XMLTriple object describing the attribute being sought. Returns 'True' if an attribute matching the properties of the given XMLTriple object exists in the list of attributes on this token, 'False' otherwise. ______________________________________________________________________ Method variant with the following signature: hasAttr(int index) Returns 'True' if an attribute with the given index exists. Parameter 'index' is an integer, the position of the attribute. Returns 'True' if this token object possesses an attribute with the given index, 'False' otherwise. ______________________________________________________________________ Method variant with the following signature: hasAttr(string name, string uri='') Returns 'True' if an attribute with a given name and namespace URI exists. Parameter 'name' is a string, the name of the attribute being sought. Parameter 'uri' is a string, the XML namespace URI of the attribute being sought. Returns 'True' if an attribute with the given local name and namespace URI exists in the list of attributes on this token object, 'False' otherwise. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> """ return _libsbml.XMLToken_hasAttr(self, *args) def isAttributesEmpty(self): """ isAttributesEmpty(XMLToken self) -> bool Returns 'True' if this token has no attributes. Returns 'True' if the list of attributes on XMLToken object is empty, 'False' otherwise. """ return _libsbml.XMLToken_isAttributesEmpty(self) def getNamespaces(self): """ getNamespaces(XMLToken self) -> XMLNamespaces Returns the XML namespaces declared for this token. Returns the XML namespace declarations for this XML element. """ return _libsbml.XMLToken_getNamespaces(self) def setNamespaces(self, namespaces): """ setNamespaces(XMLToken self, XMLNamespaces namespaces) -> int Sets the XML namespaces on this XML element. This operation only makes sense for XML start elements. This method will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is not an XML start element. Parameter 'namespaces' is the XMLNamespaces object to be assigned to this XMLToken object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_INVALID_XML_OPERATION * LIBSBML_INVALID_OBJECT Note: This function replaces any existing XMLNamespaces object on this XMLToken object with the new one given by 'namespaces'. """ return _libsbml.XMLToken_setNamespaces(self, namespaces) def addNamespace(self, *args): """ addNamespace(XMLToken self, string uri, string prefix) -> int addNamespace(XMLToken self, string uri) -> int Appends an XML namespace declaration to this token. The namespace added will be defined by the given XML namespace URI and an optional prefix. If this XMLToken object already possesses an XML namespace declaration with the given 'prefix', then the existing XML namespace URI will be overwritten by the new one given by 'uri'. This operation only makes sense for XML start elements. This method will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is not an XML start element. Parameter 'uri' is a string, the XML namespace URI for the namespace. Parameter 'prefix' is a string, the namespace prefix to use. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_XML_OPERATION </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.XMLToken_addNamespace(self, *args) def removeNamespace(self, *args): """ removeNamespace(XMLToken self, int index) -> int removeNamespace(XMLToken self, string prefix) -> int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: removeNamespace(int index) Removes the nth XML namespace declaration. This operation only makes sense for XML start elements. This method will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is not an XML start element. Parameter 'index' is an integer, the position of the namespace to be removed. The position in this context refers to the position of the namespace in the XMLNamespaces object stored in this XMLToken object. Callers can use one of the getNamespace___() methods to find the index number of a given namespace. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_XML_OPERATION * LIBSBML_INDEX_EXCEEDS_SIZE See also getNamespaceIndex(), getNamespaceIndexByPrefix(), getNamespacesLength(). ______________________________________________________________________ Method variant with the following signature: removeNamespace(string prefix) Removes an XML namespace declaration having a given prefix. This operation only makes sense for XML start elements. This method will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is not an XML start element. Parameter 'prefix' is a string, the prefix of the namespace to be removed. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_XML_OPERATION * LIBSBML_INDEX_EXCEEDS_SIZE The value LIBSBML_INDEX_EXCEEDS_SIZE is returned if there is no namespace with the given 'prefix' on this element. See also getNamespaceIndexByPrefix(). """ return _libsbml.XMLToken_removeNamespace(self, *args) def clearNamespaces(self): """ clearNamespaces(XMLToken self) -> int Removes all XML namespace declarations from this token. This operation only makes sense for XML start elements. This method will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is not an XML start element. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_XML_OPERATION * LIBSBML_OPERATION_FAILED """ return _libsbml.XMLToken_clearNamespaces(self) def getNamespaceIndex(self, uri): """ getNamespaceIndex(XMLToken self, string uri) -> int Returns the index of an XML namespace declaration based on its URI. Parameter 'uri' is a string, the XML namespace URI of the sought-after namespace. Returns the index of the given declaration, or -1 if no such namespace URI is present on this XMLToken object. """ return _libsbml.XMLToken_getNamespaceIndex(self, uri) def getNamespaceIndexByPrefix(self, prefix): """ getNamespaceIndexByPrefix(XMLToken self, string prefix) -> int Returns the index of an XML namespace declaration based on its prefix. Parameter 'prefix' is a string, the prefix of the sought-after XML namespace. Returns the index of the given declaration, or -1 if no such namespace URI is present on this XMLToken object. """ return _libsbml.XMLToken_getNamespaceIndexByPrefix(self, prefix) def getNamespacesLength(self): """ getNamespacesLength(XMLToken self) -> int Returns the number of XML namespaces declared on this token. Returns the number of XML namespaces stored in the XMLNamespaces object of this XMLToken object. """ return _libsbml.XMLToken_getNamespacesLength(self) def getNamespacePrefix(self, *args): """ getNamespacePrefix(XMLToken self, int index) -> string getNamespacePrefix(XMLToken self, string uri) -> string This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getNamespacePrefix(int index) Returns the prefix of the nth XML namespace declaration. Parameter 'index' is an integer, position of the required prefix. Returns the prefix of an XML namespace declaration in the XMLNamespaces (by position). Note: If 'index' is out of range, this method will return an empty string. XMLToken.getNamespacesLength() can be used to find out how many namespaces are defined on this XMLToken object. See also getNamespacesLength(). ______________________________________________________________________ Method variant with the following signature: getNamespacePrefix(string uri) Returns the prefix associated with a given XML namespace URI on this token. Parameter 'uri' is a string, the URI of the namespace whose prefix is being sought. Returns the prefix of an XML namespace declaration on this XMLToken object. Note: If there is no XML namespace with the given 'uri' declared on this XMLToken object, this method will return an empty string. """ return _libsbml.XMLToken_getNamespacePrefix(self, *args) def getNamespaceURI(self, *args): """ getNamespaceURI(XMLToken self, int index) -> string getNamespaceURI(XMLToken self, string prefix) -> string getNamespaceURI(XMLToken self) -> string This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getNamespaceURI(int index) Returns the URI of the nth XML namespace declared on this token. Parameter 'index' is an integer, the position of the sought-after XML namespace URI. Returns the URI of the nth XML namespace stored in the XMLNamespaces object in this XMLToken object. Note: If 'index' is out of range, this method will return an empty string. See also getNamespacesLength(). ______________________________________________________________________ Method variant with the following signature: getNamespaceURI(string prefix = '') Returns the URI of an XML namespace with a given prefix. Parameter 'prefix' is a string, the prefix of the sought-after XML namespace URI. Returns the URI of an XML namespace declaration given its prefix. Note: If there is no XML namespace with the given 'prefix' stored in the XMLNamespaces object of this XMLToken object, this method will return an empty string. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.XMLToken_getNamespaceURI(self, *args) def isNamespacesEmpty(self): """ isNamespacesEmpty(XMLToken self) -> bool Returns 'True' if there are no namespaces declared on this token. Returns 'True' if the XMLNamespaces object stored in this XMLToken token is empty, 'False' otherwise. """ return _libsbml.XMLToken_isNamespacesEmpty(self) def hasNamespaceURI(self, uri): """ hasNamespaceURI(XMLToken self, string uri) -> bool Returns 'True' if this token has an XML namespace with a given URI. Parameter 'uri' is a string, the URI of the XML namespace. Returns 'True' if an XML namespace with the given URI is contained in the XMLNamespaces object of this XMLToken object, 'False' otherwise. """ return _libsbml.XMLToken_hasNamespaceURI(self, uri) def hasNamespacePrefix(self, prefix): """ hasNamespacePrefix(XMLToken self, string prefix) -> bool Returns 'True' if this token has an XML namespace with a given prefix. Parameter 'prefix' is a string, the prefix for the XML namespace. Returns 'True' if an XML Namespace with the given URI is contained in the XMLNamespaces of this XMLToken, 'False' otherwise. """ return _libsbml.XMLToken_hasNamespacePrefix(self, prefix) def hasNamespaceNS(self, uri, prefix): """ hasNamespaceNS(XMLToken self, string uri, string prefix) -> bool Returns 'True' if this token has an XML namespace with a given prefix and URI combination. Parameter 'uri' is a string, the URI for the namespace. Parameter 'prefix' is a string, the prefix for the namespace. Returns 'True' if an XML namespace with the given URI/prefix pair is contained in the XMLNamespaces object of this XMLToken object, 'False' otherwise. """ return _libsbml.XMLToken_hasNamespaceNS(self, uri, prefix) def setTriple(self, triple): """ setTriple(XMLToken self, XMLTriple triple) -> int Sets the name, namespace prefix and namespace URI of this token. This operation only makes sense for XML start elements. This method will return LIBSBML_INVALID_XML_OPERATION if this XMLToken object is not an XML start element. Parameter 'triple' is the new XMLTriple to use for this XMLToken object. If this XMLToken already had an XMLTriple object stored within it, that object will be replaced. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_INVALID_XML_OPERATION * LIBSBML_INVALID_OBJECT """ return _libsbml.XMLToken_setTriple(self, triple) def getName(self): """ getName(XMLToken self) -> string Returns the (unqualified) name of token. Returns the (unqualified) name of token. """ return _libsbml.XMLToken_getName(self) def getPrefix(self): """ getPrefix(XMLToken self) -> string Returns the XML namespace prefix of token. Returns the XML namespace prefix of token. Note: If no XML namespace prefix has been assigned to this token, this method will return an empty string. """ return _libsbml.XMLToken_getPrefix(self) def getURI(self): """ getURI(XMLToken self) -> string Returns the XML namespace URI of token. Returns the XML namespace URI of token. """ return _libsbml.XMLToken_getURI(self) def getCharacters(self): """ getCharacters(XMLToken self) -> string Returns the character text of token. Returns the characters of this XML token. If this token is not a text token (i.e., it's an XML element and not character content), then this will return an empty string. See also isText(), isElement(). """ return _libsbml.XMLToken_getCharacters(self) def setCharacters(self, chars): """ setCharacters(XMLToken self, string chars) -> int Sets the characters for this XMLToken This method only makes sense for XMLToken objects that contains text. If this method is called on a token that represents an XML start or end tag, it will return the code LIBSBML_OPERATION_FAILED. Parameter 'chars' is string, characters to append to the text of this token. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also isText(), isElement(). """ return _libsbml.XMLToken_setCharacters(self, chars) def append(self, chars): """ append(XMLToken self, string chars) -> int Appends characters to the text content of token. This method only makes sense for XMLToken objects that contains text. If this method is called on a token that represents an XML start or end tag, it will return the code LIBSBML_OPERATION_FAILED. Parameter 'chars' is string, characters to append to the text of this token. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also isText(), isElement(). """ return _libsbml.XMLToken_append(self, chars) def getColumn(self): """ getColumn(XMLToken self) -> unsigned int Returns the column number at which this token occurs in the input. Returns the column at which this XMLToken occurred. """ return _libsbml.XMLToken_getColumn(self) def getLine(self): """ getLine(XMLToken self) -> unsigned int Returns the line number at which this token occurs in the input. Returns the line at which this XMLToken occurred. """ return _libsbml.XMLToken_getLine(self) def isElement(self): """ isElement(XMLToken self) -> bool Returns 'True' if this token represents an XML element. This generic predicate returns 'True' if the element is either a start or end tag, and 'False' if it's a text object. The related methods XMLToken:isStart(), XMLToken.isEnd() and XMLToken.isText() are more specific predicates. Returns 'True' if this XMLToken object represents an XML element, 'False' otherwise. See also isStart(), isEnd(), isText(). """ return _libsbml.XMLToken_isElement(self) def isEnd(self): """ isEnd(XMLToken self) -> bool Returns 'True' if this token represents an XML end element. Returns 'True' if this XMLToken object represents an XML end element, 'False' otherwise. See also isStart(), isElement(), isText(). """ return _libsbml.XMLToken_isEnd(self) def isEndFor(self, element): """ isEndFor(XMLToken self, XMLToken element) -> bool Returns 'True' if this token represents an XML end element for a particular start element. Parameter 'element' is XMLToken, the element with which the current object should be compared to determined whether the current object is a start element for the given one. Returns 'True' if this XMLToken object represents an XML end tag for the start tag given by 'element', 'False' otherwise. See also isElement(), isStart(), isEnd(), isText(). """ return _libsbml.XMLToken_isEndFor(self, element) def isEOF(self): """ isEOF(XMLToken self) -> bool Returns 'True' if this token is an end of file marker. Returns 'True' if this XMLToken object represents the end of the input, 'False' otherwise. See also setEOF(). """ return _libsbml.XMLToken_isEOF(self) def isStart(self): """ isStart(XMLToken self) -> bool Returns 'True' if this token represents an XML start element. Returns 'True' if this XMLToken is an XML start element, 'False' otherwise. See also isElement(), isEnd(), isText(). """ return _libsbml.XMLToken_isStart(self) def isText(self): """ isText(XMLToken self) -> bool Returns 'True' if this token represents an XML text element. Returns 'True' if this XMLToken is an XML text element, 'False' otherwise. See also isElement(), isStart(), isEnd(). """ return _libsbml.XMLToken_isText(self) def setEnd(self): """ setEnd(XMLToken self) -> int Declares that this token represents an XML element end tag. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also isStart(), isEnd(). """ return _libsbml.XMLToken_setEnd(self) def setEOF(self): """ setEOF(XMLToken self) -> int Declares that this token is an end-of-file/input marker. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also isEOF(). """ return _libsbml.XMLToken_setEOF(self) def unsetEnd(self): """ unsetEnd(XMLToken self) -> int Declares that this token no longer represents an XML start/end element. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.XMLToken_unsetEnd(self) def toString(self): """ toString(XMLToken self) -> string Prints a string representation of the underlying token stream. This method is intended for debugging purposes. Returns a text string representing this XMLToken object. """ return _libsbml.XMLToken_toString(self) def __eq__(self, rhs): if ((self is None) and (rhs is None)): return True if ((self is None) or (rhs is None)): return False if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return True return False def __ne__(self, rhs): if ((self is None) and (rhs is None)): return False if ((self is None) or (rhs is None)): return True if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return False return True XMLToken_swigregister = _libsbml.XMLToken_swigregister XMLToken_swigregister(XMLToken) class XMLNode(XMLToken): """ A node in libSBML's XML document tree. LibSBML implements an XML abstraction layer. This layer presents a uniform XML interface to calling programs regardless of which underlying XML parser libSBML has actually been configured to use. The basic data object in the XML abstraction is a node, represented by XMLNode. An XMLNode can contain any number of children. Each child is another XMLNode, thereby forming a tree. The methods XMLNode.getNumChildren() and XMLNode.getChild() can be used to access the tree structure starting from a given node. Each XMLNode is subclassed from XMLToken, and thus has the same methods available as XMLToken. These methods include XMLToken.getNamespaces(), XMLToken.getPrefix(), XMLToken.getName(), XMLToken.getURI(), and XMLToken.getAttributes(). Conversion between an XML string and an XMLNode ====================================================================== LibSBML provides the following utility functions for converting an XML string (e.g., <annotation>...</annotation>) to/from an XMLNode object. * XMLNode.toXMLString() returns a string representation of the XMLNode object. * XMLNode.convertXMLNodeToString() (static function) returns a string representation of the given XMLNode object. * XMLNode.convertStringToXMLNode() (static function) returns an XMLNode object converted from the given XML string. The returned XMLNode object by XMLNode.convertStringToXMLNode() is a dummy root (container) XMLNode if the given XML string has two or more top-level elements (e.g., "<p>...<p>..."). In the dummy root node, each top-level element in the given XML string is contained as a child XMLNode. XMLToken.isEOF() can be used to identify if the returned XMLNode object is a dummy node or not. Here is an example: xn = XMLNode.convertStringToXMLNode('<p></p>') if xn == None: # Do something to handle exceptional situation. elif xn.isEOF(): # Node is a dummy node. else: # None is not a dummy node. """ __swig_setmethods__ = {} for _s in [XMLToken]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, XMLNode, name, value) __swig_getmethods__ = {} for _s in [XMLToken]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, XMLNode, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_XMLNode __del__ = lambda self: None def __init__(self, *args): """ __init__(XMLNode self) -> XMLNode __init__(XMLNode self, XMLToken token) -> XMLNode __init__(XMLNode self, XMLTriple triple, XMLAttributes attributes, XMLNamespaces namespaces, unsigned int const line=0, unsigned int const column=0) -> XMLNode __init__(XMLNode self, XMLTriple triple, XMLAttributes attributes, XMLNamespaces namespaces, unsigned int const line=0) -> XMLNode __init__(XMLNode self, XMLTriple triple, XMLAttributes attributes, XMLNamespaces namespaces) -> XMLNode __init__(XMLNode self, XMLTriple triple, XMLAttributes attributes, unsigned int const line=0, unsigned int const column=0) -> XMLNode __init__(XMLNode self, XMLTriple triple, XMLAttributes attributes, unsigned int const line=0) -> XMLNode __init__(XMLNode self, XMLTriple triple, XMLAttributes attributes) -> XMLNode __init__(XMLNode self, XMLTriple triple, unsigned int const line=0, unsigned int const column=0) -> XMLNode __init__(XMLNode self, XMLTriple triple, unsigned int const line=0) -> XMLNode __init__(XMLNode self, XMLTriple triple) -> XMLNode __init__(XMLNode self, string chars, unsigned int const line=0, unsigned int const column=0) -> XMLNode __init__(XMLNode self, string chars, unsigned int const line=0) -> XMLNode __init__(XMLNode self, string chars) -> XMLNode __init__(XMLNode self, XMLInputStream stream) -> XMLNode __init__(XMLNode self, XMLNode orig) -> XMLNode This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: XMLNode(XMLToken token) Creates a new XMLNode by copying an XMLToken object. Parameter 'token' is XMLToken to be copied to XMLNode. ______________________________________________________________________ Method variant with the following signature: XMLNode( XMLTriple triple , XMLAttributes attributes , XMLNamespaces namespaces , long line = 0 , long column = 0 ) Creates a new start element XMLNode with the given set of attributes and namespace declarations. Parameter 'triple' is XMLTriple. Parameter 'attributes' is XMLAttributes, the attributes to set. Parameter 'namespaces' is XMLNamespaces, the namespaces to set. Parameter 'line' is a long integer, the line number (default = 0). Parameter 'column' is a long integer, the column number (default = 0). </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. ______________________________________________________________________ Method variant with the following signature: XMLNode(XMLNode orig) Copy constructor; creates a copy of this XMLNode. Parameter 'orig' is the XMLNode instance to copy. ______________________________________________________________________ Method variant with the following signature: XMLNode() Creates a new empty XMLNode with no children. ______________________________________________________________________ Method variant with the following signature: XMLNode( XMLTriple triple , XMLAttributes attributes , long line = 0 , long column = 0 ) Creates a start element XMLNode with the given set of attributes. Parameter 'triple' is XMLTriple. Parameter 'attributes' is XMLAttributes, the attributes to set. Parameter 'line' is a long integer, the line number (default = 0). Parameter 'column' is a long integer, the column number (default = 0). </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. ______________________________________________________________________ Method variant with the following signature: XMLNode( XMLTriple triple , long line = 0 , long column = 0 ) Creates an end element XMLNode. Parameter 'triple' is XMLTriple. Parameter 'line' is a long integer, the line number (default = 0). Parameter 'column' is a long integer, the column number (default = 0). </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. ______________________________________________________________________ Method variant with the following signature: XMLNode( string chars , long line = 0 , long column = 0 ) Creates a text XMLNode. Parameter 'chars' is a string, the text to be added to the XMLToken. Parameter 'line' is a long integer, the line number (default = 0). Parameter 'column' is a long integer, the column number (default = 0). </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ this = _libsbml.new_XMLNode(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(XMLNode self) -> XMLNode Creates and returns a deep copy of this XMLNode object. Returns the (deep) copy of this XMLNode object. """ return _libsbml.XMLNode_clone(self) def addChild(self, node): """ addChild(XMLNode self, XMLNode node) -> int Adds a copy of 'node' as a child of this XMLNode. The given 'node' is added at the end of the list of children. Parameter 'node' is the XMLNode to be added as child. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_INVALID_XML_OPERATION Note: The given node is added at the end of the children list. """ return _libsbml.XMLNode_addChild(self, node) def insertChild(self, n, node): """ insertChild(XMLNode self, unsigned int n, XMLNode node) -> XMLNode Inserts a copy of the given node as the nth child of this XMLNode. If the given index 'n' is out of range for this XMLNode instance, the 'node' is added at the end of the list of children. Even in that situation, this method does not throw an error. Parameter 'n' is an integer, the index at which the given node is inserted. Parameter 'node' is an XMLNode to be inserted as nth child. Returns a reference to the newly-inserted child 'node'. """ return _libsbml.XMLNode_insertChild(self, n, node) def removeChild(self, n): """ removeChild(XMLNode self, unsigned int n) -> XMLNode Removes the nth child of this XMLNode and returns the removed node. It is important to keep in mind that a given XMLNode may have more than one child. Calling this method erases all existing references to child nodes after the given position 'n'. If the index 'n' is greater than the number of child nodes in this XMLNode, this method takes no action (and returns 'None).' Parameter 'n' is an integer, the index of the node to be removed. Returns the removed child, or 'None' if 'n' is greater than the number of children in this node. Note: The caller owns the returned node and is responsible for deleting it. """ return _libsbml.XMLNode_removeChild(self, n) def removeChildren(self): """ removeChildren(XMLNode self) -> int Removes all children from this node. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS """ return _libsbml.XMLNode_removeChildren(self) def getChild(self, *args): """ getChild(XMLNode self, unsigned int n) -> XMLNode getChild(XMLNode self, unsigned int n) -> XMLNode getChild(XMLNode self, string name) -> XMLNode getChild(XMLNode self, string name) -> XMLNode This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getChild(long n) Returns the nth child of this XMLNode. If the index 'n' is greater than the number of child nodes, this method returns an empty node. Parameter 'n' is a long integereger, the index of the node to return. Returns the nth child of this XMLNode. ______________________________________________________________________ Method variant with the following signature: getChild(string name) Returns the first child of this XMLNode with the corresponding name. If no child with corrsponding name can be found, this method returns an empty node. Parameter 'name' is the name of the node to return. Returns the first child of this XMLNode with given name. """ return _libsbml.XMLNode_getChild(self, *args) def getIndex(self, name): """ getIndex(XMLNode self, string name) -> int Return the index of the first child of this XMLNode with the given name. Parameter 'name' is a string, the name of the child for which the index is required. Returns the index of the first child of this XMLNode with the given name, or '-1' if not present. """ return _libsbml.XMLNode_getIndex(self, name) def hasChild(self, name): """ hasChild(XMLNode self, string name) -> bool Return a boolean indicating whether this XMLNode has a child with the given name. Parameter 'name' is a string, the name of the child to be checked. Returns boolean indicating whether this XMLNode has a child with the given name. """ return _libsbml.XMLNode_hasChild(self, name) def equals(self, other, ignoreURI=False, ignoreAttributeValues=False): """ equals(XMLNode self, XMLNode other, bool ignoreURI=False, bool ignoreAttributeValues=False) -> bool equals(XMLNode self, XMLNode other, bool ignoreURI=False) -> bool equals(XMLNode self, XMLNode other) -> bool Compare this XMLNode against another XMLNode returning true if both nodes represent the same XML tree, or false otherwise. Parameter 'other' is another XMLNode to compare against. Parameter 'ignoreURI' is whether to ignore the namespace URI when doing the comparison. Parameter 'ignoreAttributeValues' is whetehr to ignore attribute values when doing the comparison. Returns boolean indicating whether this XMLNode represents the same XML tree as another. """ return _libsbml.XMLNode_equals(self, other, ignoreURI, ignoreAttributeValues) def getNumChildren(self): """ getNumChildren(XMLNode self) -> unsigned int Returns the number of children for this XMLNode. Returns the number of children for this XMLNode. """ return _libsbml.XMLNode_getNumChildren(self) def writeToStream(self, stream): """ writeToStream(XMLNode self, XMLOutputStream stream) Internal implementation method. """ return _libsbml.XMLNode_writeToStream(self, stream) def toXMLString(self): """ toXMLString(XMLNode self) -> string Returns a string representation of this XMLNode. Returns a string derived from this XMLNode. """ return _libsbml.XMLNode_toXMLString(self) def convertXMLNodeToString(node): """ convertXMLNodeToString(XMLNode node) -> string Returns a string representation of a given XMLNode. Parameter 'node' is the XMLNode to be represented as a string. Returns a string-form representation of 'node'. """ return _libsbml.XMLNode_convertXMLNodeToString(node) convertXMLNodeToString = staticmethod(convertXMLNodeToString) def convertStringToXMLNode(xmlstr, xmlns=None): """ convertStringToXMLNode(string xmlstr, XMLNamespaces xmlns=None) -> XMLNode convertStringToXMLNode(string xmlstr) -> XMLNode Returns an XMLNode which is derived from a string containing XML content. The XML namespace must be defined using argument 'xmlns' if the corresponding XML namespace attribute is not part of the string of the first argument. Parameter 'xmlstr' is string to be converted to a XML node. Parameter 'xmlns' is XMLNamespaces the namespaces to set (default value is 'None).' Note: The caller owns the returned XMLNode and is reponsible for deleting it. The returned XMLNode object is a dummy root (container) XMLNode if the top-level element in the given XML string is NOT <html>, <body>, <annotation>, or <notes>. In the dummy root node, each top-level element in the given XML string is contained as a child XMLNode. XMLToken.isEOF() can be used to identify if the returned XMLNode object is a dummy node. Returns a XMLNode which is converted from string 'xmlstr'. If the conversion failed, this method returns 'None.' </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.XMLNode_convertStringToXMLNode(xmlstr, xmlns) convertStringToXMLNode = staticmethod(convertStringToXMLNode) XMLNode_swigregister = _libsbml.XMLNode_swigregister XMLNode_swigregister(XMLNode) def XMLNode_convertXMLNodeToString(node): """ XMLNode_convertXMLNodeToString(XMLNode node) -> string Returns a string representation of a given XMLNode. Parameter 'node' is the XMLNode to be represented as a string. Returns a string-form representation of 'node'. """ return _libsbml.XMLNode_convertXMLNodeToString(node) def XMLNode_convertStringToXMLNode(xmlstr, xmlns=None): """ convertStringToXMLNode(string xmlstr, XMLNamespaces xmlns=None) -> XMLNode XMLNode_convertStringToXMLNode(string xmlstr) -> XMLNode Returns an XMLNode which is derived from a string containing XML content. The XML namespace must be defined using argument 'xmlns' if the corresponding XML namespace attribute is not part of the string of the first argument. Parameter 'xmlstr' is string to be converted to a XML node. Parameter 'xmlns' is XMLNamespaces the namespaces to set (default value is 'None).' Note: The caller owns the returned XMLNode and is reponsible for deleting it. The returned XMLNode object is a dummy root (container) XMLNode if the top-level element in the given XML string is NOT <html>, <body>, <annotation>, or <notes>. In the dummy root node, each top-level element in the given XML string is contained as a child XMLNode. XMLToken.isEOF() can be used to identify if the returned XMLNode object is a dummy node. Returns a XMLNode which is converted from string 'xmlstr'. If the conversion failed, this method returns 'None.' </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.XMLNode_convertStringToXMLNode(xmlstr, xmlns) class XMLTriple(_object): """ A qualified XML name. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. A 'triple' in the libSBML XML layer encapsulates the notion of qualified name, meaning an element name or an attribute name with an optional namespace qualifier. Triples by themselves are not entities in an XML stream -- they are not, for example, elements or attributes; rather, XMLTriple is used in libSBML to construct these other kinds of objects. An XMLTriple instance carries up to three data items: <ol> * The name of the attribute or element; that is, the attribute name as it appears in an XML document or data stream; * The XML namespace prefix (if any) of the attribute. For example, in the following fragment of XML, the namespace prefix is the string mysim and it appears on both the element someelement and the attribute attribA. When both the element and the attribute are stored as XMLTriple objects, their prefix is mysim. <mysim:someelement mysim:attribA='value' /> * The XML namespace URI with which the prefix is associated. In XML, every namespace used must be declared and mapped to a URI. </ol> XMLTriple objects are the lowest-level data item in the XML layer of libSBML. Other objects such as XMLToken make use of XMLTriple objects. See also XMLToken, XMLNode, XMLAttributes, XMLNamespaces. """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, XMLTriple, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, XMLTriple, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(XMLTriple self) -> XMLTriple __init__(XMLTriple self, string name, string uri, string prefix) -> XMLTriple __init__(XMLTriple self, string triplet, char const sepchar) -> XMLTriple __init__(XMLTriple self, string triplet) -> XMLTriple __init__(XMLTriple self, XMLTriple orig) -> XMLTriple This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: XMLTriple( string name , string uri , string prefix ) Creates a new XMLTriple object with a given 'name', 'uri' and and 'prefix'. Parameter 'name' is a string, the name for the entity represented by this object. Parameter 'uri' is a string, the XML namespace URI associated with the prefix. Parameter 'prefix' is a string, the XML namespace prefix for this triple. ______________________________________________________________________ Method variant with the following signature: XMLTriple(string triplet, char sepchar = ' ') Creates an XMLTriple object by splitting a given string at a given separator character. The 'triplet' in this case is a string that may be in one of the following three possible formats: <ol> * name * URIxname* URIxnamexprefix</ol> where x represents the separator character, 'sepchar'. Parameter 'triplet' is a string representing the triplet as shown above. Parameter 'sepchar' is a character, the sepchar used in the triplet. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. ______________________________________________________________________ Method variant with the following signature: XMLTriple() Creates a new, empty XMLTriple object. ______________________________________________________________________ Method variant with the following signature: XMLTriple(XMLTriple orig) Copy constructor; creates a copy of this XMLTriple object. Parameter 'orig' is the XMLTriple object to copy. """ this = _libsbml.new_XMLTriple(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(XMLTriple self) -> XMLTriple Creates and returns a deep copy of this XMLTriple object. Returns the (deep) copy of this XMLTriple object. """ return _libsbml.XMLTriple_clone(self) def getName(self): """ getName(XMLTriple self) -> string Returns the name portion of this XMLTriple object. Returns a string, the name portion of this XMLTriple object. """ return _libsbml.XMLTriple_getName(self) def getPrefix(self): """ getPrefix(XMLTriple self) -> string Returns the prefix portion of this XMLTriple object. Returns a string, the prefix portion of this XMLTriple object. """ return _libsbml.XMLTriple_getPrefix(self) def getURI(self): """ getURI(XMLTriple self) -> string Returns the URI portion of this XMLTriple object. Returns URI a string, the URI portion of this XMLTriple object. """ return _libsbml.XMLTriple_getURI(self) def getPrefixedName(self): """ getPrefixedName(XMLTriple self) -> string Returns the prefixed name from this XMLTriple. Returns a string, the prefixed name from this XMLTriple. This is constructed by concatenating the prefix stored in this XMLTriple object, followed by a colon character ':', followed by the name stored in this XMLTriple object. """ return _libsbml.XMLTriple_getPrefixedName(self) def isEmpty(self): """ isEmpty(XMLTriple self) -> bool Returns 'True' if this XMLTriple object is empty. Returns 'True' if this XMLTriple is empty, 'False' otherwise. """ return _libsbml.XMLTriple_isEmpty(self) def __eq__(self, rhs): if ((self is None) and (rhs is None)): return True if ((self is None) or (rhs is None)): return False if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return True return False def __ne__(self, rhs): if ((self is None) and (rhs is None)): return False if ((self is None) or (rhs is None)): return True if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return False return True __swig_destroy__ = _libsbml.delete_XMLTriple __del__ = lambda self: None XMLTriple_swigregister = _libsbml.XMLTriple_swigregister XMLTriple_swigregister(XMLTriple) class XMLOutputStream(_object): """ Interface to an XML output stream. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. SBML content is serialized using XML; the resulting data can be stored and read to/from a file or data stream. Low-level XML parsers such as Xerces provide facilities to read XML data. To permit the use of different XML parsers (Xerces, Expat or libxml2), libSBML implements an abstraction layer. XMLInputStream and XMLOutputStream are two parts of that abstraction layer. XMLOutputStream provides a wrapper above output streams to facilitate writing XML. XMLOutputStream keeps track of start and end elements, indentation, XML namespace prefixes, and more. The interface provides features for converting non-text data types into appropriate textual form; this takes the form of overloaded writeAttribute(...) methods that allow users to simply use the same method with any data type. For example, suppose an element 'testElement' has two attributes, 'size' and 'id,' and the attributes are variables in your code as follows: size = 3.2; id = 'id'; Then, the element and the attributes can be written to the standard output stream (provided as 'cout' in the libSBML language bindings) as follows: from libsbml import * size = 3.2; id = 'id'; # Create an XMLOutputStream object that will write to the standard # output stream, which is provide in libSBML's Python language # interface as the object 'libsbml.cout'. Since we imported * from # the libsbml module, we can simply refer to it as 'cout' here: output_stream = XMLOutputStream(cout) # Create the start element, write the attributes, and close the # element. The output is written immediately by each method. output_stream.startElement('testElement') output_stream.writeAttribute('size', size) output_stream.writeAttribute('id', id) output_stream.endElement('testElement') Other classes in SBML take XMLOutputStream objects as arguments, and use that to write elements and attributes seamlessly to the XML output stream. It is also worth noting that unlike XMLInputStream, XMLOutputStream is actually independent of the underlying XML parsers. It does not use the XML parser libraries at all. Note: The convenience of the XMLInputStream and XMLOutputStream abstraction may be useful for developers interested in creating parsers for other XML formats besides SBML. It can provide developers with a layer above more basic XML parsers, as well as some useful programmatic elements such as XMLToken, XMLError, etc. See also XMLInputStream. """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, XMLOutputStream, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, XMLOutputStream, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(XMLOutputStream self, ostream stream, string encoding, bool writeXMLDecl=True, string programName, string programVersion) -> XMLOutputStream __init__(XMLOutputStream self, ostream stream, string encoding, bool writeXMLDecl=True, string programName) -> XMLOutputStream __init__(XMLOutputStream self, ostream stream, string encoding, bool writeXMLDecl=True) -> XMLOutputStream __init__(XMLOutputStream self, ostream stream, string encoding) -> XMLOutputStream __init__(XMLOutputStream self, ostream stream) -> XMLOutputStream Creates a new XMLOutputStream that wraps the given @p stream. The functionality associated with the @p programName and @p programVersion arguments concerns an optional comment that libSBML can write at the beginning of the output stream. The comment is intended for human readers of the XML file, and has the following form: @verbatim <!-- Created by <program name> version <program version> on yyyy-MM-dd HH:mm with libSBML version <libsbml version>. --> @endverbatim This program information comment is a separate item from the XML declaration that this method can also write to this output stream. The comment is also not mandated by any SBML specification. This libSBML functionality is provided for the convenience of calling programs, and to help humans trace the origin of SBML files. LibSBML tries to produce human-readable XML output by automatically indenting the bodies of elements. Callers can manually control indentation further by using the XMLOutputStream::upIndent() and XMLOutputStream::downIndent() methods to increase and decrease, respectively, the current level of indentation in the XML output. @param stream the input stream to wrap. @param encoding the XML encoding to declare in the output. This value should be <code>"UTF-8"</code> for SBML documents. The default value is <code>"UTF-8"</code> if no value is supplied for this parameter. @param writeXMLDecl whether to write a standard XML declaration at the beginning of the content written on @p stream. The default is @c true. @param programName an optional program name to write as a comment in the output stream. @param programVersion an optional version identification string to write as a comment in the output stream. @htmlinclude warn-default-args-in-docs.html """ this = _libsbml.new_XMLOutputStream(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_XMLOutputStream __del__ = lambda self: None def endElement(self, *args): """ endElement(XMLOutputStream self, string name, string prefix) endElement(XMLOutputStream self, string name) endElement(XMLOutputStream self, XMLTriple triple, bool text=False) endElement(XMLOutputStream self, XMLTriple triple) This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: endElement(XMLTriple triple, bool text = false) Writes the given element to the stream. Parameter 'triple' is the XML element to write. Parameter 'text' is the text to put Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. ______________________________________________________________________ Method variant with the following signature: endElement(string name, string prefix = '') Writes the given XML end element name to this XMLOutputStream. Parameter 'name' is the name of the element. Parameter 'prefix' is an optional XML namespace prefix to write in front of the 'element' name. (The result has the form prefix:name.) </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.XMLOutputStream_endElement(self, *args) def setAutoIndent(self, indent): """ setAutoIndent(XMLOutputStream self, bool indent) Turns automatic indentation on or off for this XMLOutputStream. Parameter 'indent' is if 'True,' automatic indentation is turned on. """ return _libsbml.XMLOutputStream_setAutoIndent(self, indent) def startElement(self, *args): """ startElement(XMLOutputStream self, string name, string prefix) startElement(XMLOutputStream self, string name) startElement(XMLOutputStream self, XMLTriple triple) This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: startElement(XMLTriple triple) Writes the given XML start element prefix:name on this output stream. Parameter 'triple' is the start element to write. ______________________________________________________________________ Method variant with the following signature: startElement(string name, string prefix = '') Writes the given XML start element name to this XMLOutputStream. Parameter 'name' is the name of the element. Parameter 'prefix' is an optional XML namespace prefix to write in front of the 'element' name. (The result has the form prefix:name.) </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.XMLOutputStream_startElement(self, *args) def startEndElement(self, *args): """ startEndElement(XMLOutputStream self, string name, string prefix) startEndElement(XMLOutputStream self, string name) startEndElement(XMLOutputStream self, XMLTriple triple) This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: startEndElement(XMLTriple triple) Writes the given start element to this output stream. Parameter 'triple' is the XML element to write. ______________________________________________________________________ Method variant with the following signature: startEndElement(string name, string prefix = '') Writes the given XML start and end element name to this XMLOutputStream. Parameter 'name' is the name of the element. Parameter 'prefix' is an optional XML namespace prefix to write in front of the 'element' name. (The result has the form prefix:name.) </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.XMLOutputStream_startEndElement(self, *args) def writeAttribute(self, *args): """ writeAttribute(XMLOutputStream self, string name, string value) writeAttribute(XMLOutputStream self, string name, string prefix, string value) writeAttribute(XMLOutputStream self, XMLTriple triple, string value) writeAttribute(XMLOutputStream self, string name, char const * value) writeAttribute(XMLOutputStream self, string name, string prefix, char const * value) writeAttribute(XMLOutputStream self, XMLTriple triple, char const * value) writeAttribute(XMLOutputStream self, string name, bool const & value) writeAttribute(XMLOutputStream self, string name, string prefix, bool const & value) writeAttribute(XMLOutputStream self, XMLTriple triple, bool const & value) writeAttribute(XMLOutputStream self, string name, double const & value) writeAttribute(XMLOutputStream self, string name, string prefix, double const & value) writeAttribute(XMLOutputStream self, XMLTriple triple, double const & value) writeAttribute(XMLOutputStream self, string name, long const & value) writeAttribute(XMLOutputStream self, string name, string prefix, long const & value) writeAttribute(XMLOutputStream self, XMLTriple triple, long const & value) writeAttribute(XMLOutputStream self, string name, int const & value) writeAttribute(XMLOutputStream self, string name, string prefix, int const & value) writeAttribute(XMLOutputStream self, XMLTriple triple, int const & value) writeAttribute(XMLOutputStream self, string name, string prefix, unsigned int const & value) This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: writeAttribute(XMLTriple triple, string value) Writes the given attribute and value to this output stream. Parameter 'triple' is the attribute, in the form of an XMLTriple. Parameter 'value' is the value of the attribute. ______________________________________________________________________ Method variant with the following signature: writeAttribute(string name, string prefix, long value) Writes the given namespace-prefixed attribute value to this output stream. Parameter 'name' is the name of the attribute. Parameter 'prefix' is an XML namespace prefix to write in front of the 'element' name. (The result has the form prefix:name.) See other versions of this method for a variant that does not require a prefix. Parameter 'value' is the value of the attribute. ______________________________________________________________________ Method variant with the following signature: writeAttribute(string name, string prefix, string value) Writes the given namespace-prefixed attribute value to this output stream. Parameter 'name' is the name of the attribute. Parameter 'prefix' is an XML namespace prefix to write in front of the 'element' name. (The result has the form prefix:name.) See other versions of this method for a variant that does not require a prefix. Parameter 'value' is the value of the attribute. ______________________________________________________________________ Method variant with the following signature: writeAttribute(XMLTriple triple, bool value) Writes the given attribute and value to this output stream. Parameter 'triple' is the attribute, in the form of an XMLTriple. Parameter 'value' is the value of the attribute. ______________________________________________________________________ Method variant with the following signature: writeAttribute(string name, long value) Writes the given attribute and value to this output stream. Parameter 'name' is the name of the attribute. Parameter 'value' is the value of the attribute. ______________________________________________________________________ Method variant with the following signature: writeAttribute(XMLTriple triple, long value) Writes the given attribute and value to this output stream. Parameter 'triple' is the attribute, in the form of an XMLTriple. Parameter 'value' is the value of the attribute. ______________________________________________________________________ Method variant with the following signature: writeAttribute(XMLTriple triple, long value) Writes the given attribute and value to this output stream. Parameter 'triple' is the attribute, in the form of an XMLTriple. Parameter 'value' is the value of the attribute. ______________________________________________________________________ Method variant with the following signature: writeAttribute(string name, long value) Writes the given attribute and value to this output stream. Parameter 'name' is the name of the attribute. Parameter 'value' is the value of the attribute. ______________________________________________________________________ Method variant with the following signature: writeAttribute(string name, string value) Writes the given attribute and value to this output stream. Parameter 'name' is the name of the attribute. Parameter 'value' is the value of the attribute. ______________________________________________________________________ Method variant with the following signature: writeAttribute(string name, string value) Writes the given attribute and value to this output stream. Parameter 'name' is the name of the attribute. Parameter 'value' is the value of the attribute. ______________________________________________________________________ Method variant with the following signature: writeAttribute(string name, string prefix, long value) Writes the given namespace-prefixed attribute value to this output stream. Parameter 'name' is the name of the attribute. Parameter 'prefix' is an XML namespace prefix to write in front of the 'element' name. (The result has the form prefix:name.) See other versions of this method for a variant that does not require a prefix. Parameter 'value' is the value of the attribute. ______________________________________________________________________ Method variant with the following signature: writeAttribute(string name, string prefix, long value) Writes the given namespace-prefixed attribute value to this output stream. Parameter 'name' is the name of the attribute. Parameter 'prefix' is an XML namespace prefix to write in front of the 'element' name. (The result has the form prefix:name.) See other versions of this method for a variant that does not require a prefix. Parameter 'value' is the value of the attribute. ______________________________________________________________________ Method variant with the following signature: writeAttribute(string name, string prefix, int value) Writes the given namespace-prefixed attribute value to this output stream. Parameter 'name' is the name of the attribute. Parameter 'prefix' is an XML namespace prefix to write in front of the 'element' name. (The result has the form prefix:name.) See other versions of this method for a variant that does not require a prefix. Parameter 'value' is the value of the attribute. ______________________________________________________________________ Method variant with the following signature: writeAttribute(XMLTriple triple, long value) Writes the given attribute and value to this output stream. Parameter 'triple' is the attribute, in the form of an XMLTriple. Parameter 'value' is the value of the attribute. ______________________________________________________________________ Method variant with the following signature: writeAttribute(string name, int value) Writes the given attribute and value to this output stream. Parameter 'name' is the name of the attribute. Parameter 'value' is the value of the attribute. ______________________________________________________________________ Method variant with the following signature: writeAttribute(XMLTriple triple, int value) Writes the given attribute and value to this output stream. Parameter 'triple' is the attribute, in the form of an XMLTriple. Parameter 'value' is the value of the attribute. ______________________________________________________________________ Method variant with the following signature: writeAttribute(string name, bool value) Writes the given attribute and value to this output stream. Parameter 'name' is the name of the attribute. Parameter 'value' is the value of the attribute. ______________________________________________________________________ Method variant with the following signature: writeAttribute(XMLTriple triple, string value) Writes the given attribute and value to this output stream. Parameter 'triple' is the attribute, in the form of an XMLTriple. Parameter 'value' is the value of the attribute. ______________________________________________________________________ Method variant with the following signature: writeAttribute(string name, long value) Writes the given attribute and value to this output stream. Parameter 'name' is the name of the attribute. Parameter 'value' is the value of the attribute. ______________________________________________________________________ Method variant with the following signature: writeAttribute(string name, string prefix, string value) Writes the given namespace-prefixed attribute value to this output stream. Parameter 'name' is the name of the attribute. Parameter 'prefix' is an XML namespace prefix to write in front of the 'element' name. (The result has the form prefix:name.) See other versions of this method for a variant that does not require a prefix. Parameter 'value' is the value of the attribute. ______________________________________________________________________ Method variant with the following signature: writeAttribute(string name, string &prefix, bool value) Writes the given namespace-prefixed attribute value to this output stream. Parameter 'name' is the name of the attribute. Parameter 'prefix' is an XML namespace prefix to write in front of the 'element' name. (The result has the form prefix:name.) See other versions of this method for a variant that does not require a prefix. Parameter 'value' is the value of the attribute. """ if type(args[1]) == type(True): return _libsbml.XMLOutputStream_writeAttributeBool(self, *args) return _libsbml.XMLOutputStream_writeAttribute(self, *args) def writeXMLDecl(self): """ writeXMLDecl(XMLOutputStream self) Writes a standard XML declaration to this output stream. The XML declaration has the form <?xml version='1.0' encoding='UTF-8'?> Note that the SBML specifications require the use of UTF-8 encoding and version 1.0, so for SBML documents, the above is the standard XML declaration. """ return _libsbml.XMLOutputStream_writeXMLDecl(self) def writeComment(self, programName, programVersion, writeTimestamp=True): """ writeComment(XMLOutputStream self, string programName, string programVersion, bool writeTimestamp=True) writeComment(XMLOutputStream self, string programName, string programVersion) Writes an XML comment with the name and version of this program. The XML comment has the following form: <!-- Created by <program name> version <program version> on yyyy-MM-dd HH:mm with libSBML version <libsbml version>. --> See the class constructor for more information about this program comment. Parameter 'programName' is an optional program name to write as a comment in the output stream. Parameter 'programVersion' is an optional version identification string to write as a comment in the output stream. Parameter 'writeTimestamp' is an optional flag indicating that a timestamp should be written. Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.XMLOutputStream_writeComment(self, programName, programVersion, writeTimestamp) def downIndent(self): """ downIndent(XMLOutputStream self) Decreases the indentation level for this XMLOutputStream. LibSBML tries to produce human-readable XML output by automatically indenting the bodies of elements. Callers can manually control indentation further by using the XMLOutputStream.upIndent() and XMLOutputStream.downIndent() methods to increase and decrease, respectively, the current level of indentation in the XML output. See also upIndent(). """ return _libsbml.XMLOutputStream_downIndent(self) def upIndent(self): """ upIndent(XMLOutputStream self) Increases the indentation level for this XMLOutputStream. LibSBML tries to produce human-readable XML output by automatically indenting the bodies of elements. Callers can manually control indentation further by using the XMLOutputStream.upIndent() and XMLOutputStream.downIndent() methods to increase and decrease, respectively, the current level of indentation in the XML output. See also downIndent(). """ return _libsbml.XMLOutputStream_upIndent(self) def getSBMLNamespaces(self): """ getSBMLNamespaces(XMLOutputStream self) -> SBMLNamespaces Returns the SBMLNamespaces object attached to this output stream. Returns the SBMLNamespaces object, or 'None' if none has been set. """ return _libsbml.XMLOutputStream_getSBMLNamespaces(self) def setSBMLNamespaces(self, sbmlns): """ setSBMLNamespaces(XMLOutputStream self, SBMLNamespaces sbmlns) Sets the SBMLNamespaces object associated with this output stream. Parameter 'sbmlns' is the namespace object. """ return _libsbml.XMLOutputStream_setSBMLNamespaces(self, sbmlns) def getWriteComment(): """ getWriteComment() -> bool Returns a boolean, whether the output stream will write an XML comment at the top of the file. (Enabled by default.) """ return _libsbml.XMLOutputStream_getWriteComment() getWriteComment = staticmethod(getWriteComment) def setWriteComment(writeComment): """ setWriteComment(bool writeComment) sets a flag, whether the output stream will write an XML comment at the top of the file. (Enabled by default.) Parameter 'writeComment' is the flag. """ return _libsbml.XMLOutputStream_setWriteComment(writeComment) setWriteComment = staticmethod(setWriteComment) def getWriteTimestamp(): """ getWriteTimestamp() -> bool Returns a boolean, whether the output stream will write an XML comment with a timestamp at the top of the file. (Enabled by default.) """ return _libsbml.XMLOutputStream_getWriteTimestamp() getWriteTimestamp = staticmethod(getWriteTimestamp) def setWriteTimestamp(writeTimestamp): """ setWriteTimestamp(bool writeTimestamp) sets a flag, whether the output stream will write an XML comment with a timestamp at the top of the file. (Enabled by default.) Parameter 'writeTimestamp' is the flag. """ return _libsbml.XMLOutputStream_setWriteTimestamp(writeTimestamp) setWriteTimestamp = staticmethod(setWriteTimestamp) def getLibraryName(): """ getLibraryName() -> string Returns the name of the library to be used in comments ('libSBML' by default). """ return _libsbml.XMLOutputStream_getLibraryName() getLibraryName = staticmethod(getLibraryName) def setLibraryName(libraryName): """ setLibraryName(string libraryName) sets the name of the library writing the XML Parameter 'libraryName' is the name of the library to be used in comments. """ return _libsbml.XMLOutputStream_setLibraryName(libraryName) setLibraryName = staticmethod(setLibraryName) def getLibraryVersion(): """ getLibraryVersion() -> string Returns a string representing the version of the library writing the output. This is the value of getLibSBMLDottedVersion() by default. """ return _libsbml.XMLOutputStream_getLibraryVersion() getLibraryVersion = staticmethod(getLibraryVersion) def setLibraryVersion(libraryVersion): """ setLibraryVersion(string libraryVersion) sets the name of the library writing the output Parameter 'libraryVersion' is the version information as string. """ return _libsbml.XMLOutputStream_setLibraryVersion(libraryVersion) setLibraryVersion = staticmethod(setLibraryVersion) def getIndent(self): """ getIndent(XMLOutputStream self) -> unsigned int Internal implementation method. """ return _libsbml.XMLOutputStream_getIndent(self) def setIndent(self, indent): """ setIndent(XMLOutputStream self, unsigned int indent) Internal implementation method. """ return _libsbml.XMLOutputStream_setIndent(self, indent) def writeAttributeBool(self, *args): """ writeAttributeBool(XMLOutputStream self, string name, bool const & value) writeAttributeBool(XMLOutputStream self, XMLTriple name, bool const & value) @internal """ return _libsbml.XMLOutputStream_writeAttributeBool(self, *args) def __eq__(self, rhs): if ((self is None) and (rhs is None)): return True if ((self is None) or (rhs is None)): return False if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return True return False def __ne__(self, rhs): if ((self is None) and (rhs is None)): return False if ((self is None) or (rhs is None)): return True if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return False return True XMLOutputStream_swigregister = _libsbml.XMLOutputStream_swigregister XMLOutputStream_swigregister(XMLOutputStream) def XMLOutputStream_getWriteComment(): """ XMLOutputStream_getWriteComment() -> bool Returns a boolean, whether the output stream will write an XML comment at the top of the file. (Enabled by default.) """ return _libsbml.XMLOutputStream_getWriteComment() def XMLOutputStream_setWriteComment(writeComment): """ XMLOutputStream_setWriteComment(bool writeComment) sets a flag, whether the output stream will write an XML comment at the top of the file. (Enabled by default.) Parameter 'writeComment' is the flag. """ return _libsbml.XMLOutputStream_setWriteComment(writeComment) def XMLOutputStream_getWriteTimestamp(): """ XMLOutputStream_getWriteTimestamp() -> bool Returns a boolean, whether the output stream will write an XML comment with a timestamp at the top of the file. (Enabled by default.) """ return _libsbml.XMLOutputStream_getWriteTimestamp() def XMLOutputStream_setWriteTimestamp(writeTimestamp): """ XMLOutputStream_setWriteTimestamp(bool writeTimestamp) sets a flag, whether the output stream will write an XML comment with a timestamp at the top of the file. (Enabled by default.) Parameter 'writeTimestamp' is the flag. """ return _libsbml.XMLOutputStream_setWriteTimestamp(writeTimestamp) def XMLOutputStream_getLibraryName(): """ XMLOutputStream_getLibraryName() -> string Returns the name of the library to be used in comments ('libSBML' by default). """ return _libsbml.XMLOutputStream_getLibraryName() def XMLOutputStream_setLibraryName(libraryName): """ XMLOutputStream_setLibraryName(string libraryName) sets the name of the library writing the XML Parameter 'libraryName' is the name of the library to be used in comments. """ return _libsbml.XMLOutputStream_setLibraryName(libraryName) def XMLOutputStream_getLibraryVersion(): """ XMLOutputStream_getLibraryVersion() -> string Returns a string representing the version of the library writing the output. This is the value of getLibSBMLDottedVersion() by default. """ return _libsbml.XMLOutputStream_getLibraryVersion() def XMLOutputStream_setLibraryVersion(libraryVersion): """ XMLOutputStream_setLibraryVersion(string libraryVersion) sets the name of the library writing the output Parameter 'libraryVersion' is the version information as string. """ return _libsbml.XMLOutputStream_setLibraryVersion(libraryVersion) class XMLOwningOutputStringStream(_object): """Proxy of C++ XMLOwningOutputStringStream class.""" __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, XMLOwningOutputStringStream, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, XMLOwningOutputStringStream, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(XMLOwningOutputStringStream self, string encoding, bool writeXMLDecl=True, string programName, string programVersion) -> XMLOwningOutputStringStream __init__(XMLOwningOutputStringStream self, string encoding, bool writeXMLDecl=True, string programName) -> XMLOwningOutputStringStream __init__(XMLOwningOutputStringStream self, string encoding, bool writeXMLDecl=True) -> XMLOwningOutputStringStream __init__(XMLOwningOutputStringStream self, string encoding) -> XMLOwningOutputStringStream __init__(XMLOwningOutputStringStream self) -> XMLOwningOutputStringStream Internal implementation method. """ this = _libsbml.new_XMLOwningOutputStringStream(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_XMLOwningOutputStringStream __del__ = lambda self: None XMLOwningOutputStringStream_swigregister = _libsbml.XMLOwningOutputStringStream_swigregister XMLOwningOutputStringStream_swigregister(XMLOwningOutputStringStream) class XMLOwningOutputFileStream(_object): """Proxy of C++ XMLOwningOutputFileStream class.""" __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, XMLOwningOutputFileStream, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, XMLOwningOutputFileStream, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(XMLOwningOutputFileStream self, string filename, string encoding, bool writeXMLDecl=True, string programName, string programVersion) -> XMLOwningOutputFileStream __init__(XMLOwningOutputFileStream self, string filename, string encoding, bool writeXMLDecl=True, string programName) -> XMLOwningOutputFileStream __init__(XMLOwningOutputFileStream self, string filename, string encoding, bool writeXMLDecl=True) -> XMLOwningOutputFileStream __init__(XMLOwningOutputFileStream self, string filename, string encoding) -> XMLOwningOutputFileStream __init__(XMLOwningOutputFileStream self, string filename) -> XMLOwningOutputFileStream Internal implementation method. """ this = _libsbml.new_XMLOwningOutputFileStream(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_XMLOwningOutputFileStream __del__ = lambda self: None XMLOwningOutputFileStream_swigregister = _libsbml.XMLOwningOutputFileStream_swigregister XMLOwningOutputFileStream_swigregister(XMLOwningOutputFileStream) class XMLInputStream(_object): """ An interface to an XML input stream. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. SBML content is serialized using XML; the resulting data can be stored and read to/from a file or data stream. Low-level XML parsers such as Xerces provide facilities to read XML data. To permit the use of different XML parsers (Xerces, Expat or libxml2), libSBML implements an abstraction layer. XMLInputStream and XMLOutputStream are two parts of that abstraction layer. XMLInputStream is an interface to a file or text string containing XML. It wraps the content to be read, as well as the low-level XML parser to be used and an XMLErrorLog to record errors and other issues (if any arise). Internally, the content will be in the form of either a pointer to a file name or a character string; XMLInputStream knows the form of the content and acts appropriately. Other libSBML object classes use XMLInputStream as their interface for all read operations on the XML data. XMLInputStream provides the functionality to extract data in the form of XMLToken objects. It logs any errors encountered while reading. It also keeps track of whether a read operation has failed irrecoverably or determines whether it is safe to continue reading. SBMLNamespaces objects can be associated with an XMLInputStream; this facilitates logging errors related to reading XML attributes and elements that may only be relevant to particular Level and Version combinations of SBML. Note: The convenience of the XMLInputStream and XMLOutputStream abstraction may be useful for developers interested in creating parsers for other XML formats besides SBML. It can provide developers with a layer above more basic XML parsers, as well as some useful programmatic elements such as XMLToken, XMLError, etc. See also XMLOutputStream. """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, XMLInputStream, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, XMLInputStream, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(XMLInputStream self, char const * content, bool isFile=True, string library, XMLErrorLog errorLog=None) -> XMLInputStream __init__(XMLInputStream self, char const * content, bool isFile=True, string library) -> XMLInputStream __init__(XMLInputStream self, char const * content, bool isFile=True) -> XMLInputStream __init__(XMLInputStream self, char const * content) -> XMLInputStream Creates a new XMLInputStream. @param content the source of the stream. @param isFile a boolean flag to indicate whether @p content is a file name. If @c true, @p content is assumed to be the file from which the XML content is to be read. If @c false, @p content is taken to be a string that @em is the content to be read. @param library the name of the parser library to use. @param errorLog the XMLErrorLog object to use. @htmlinclude warn-default-args-in-docs.html """ this = _libsbml.new_XMLInputStream(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_XMLInputStream __del__ = lambda self: None def getEncoding(self): """ getEncoding(XMLInputStream self) -> string Returns the encoding of the XML stream. The encoding is indicated by the xml declaration at the beginning of an XML document or data stream. The form of this declaration is <?xml version='1.0' encoding='UTF-8'?> Note that the SBML specifications require the use of UTF-8 encoding, so for SBML documents, the value returned by this method will always be the string 'UTF-8'. Returns the encoding of the XML stream. See also getVersion(). """ return _libsbml.XMLInputStream_getEncoding(self) def getVersion(self): """ getVersion(XMLInputStream self) -> string Returns the version of the XML stream. The version is indicated by the xml declaration at the beginning of an XML document or data stream. The form of this declaration is <?xml version='1.0' encoding='UTF-8'?> Note that the SBML specifications require the use of version 1.0, so for SBML documents, the value returned by this method will always be the string '1.0'. Returns the version of the XML stream. See also getEncoding(). """ return _libsbml.XMLInputStream_getVersion(self) def getErrorLog(self): """ getErrorLog(XMLInputStream self) -> XMLErrorLog Returns the XMLErrorLog used to log parsing problems. Returns the XMLErrorLog used to log XML parse errors and other validation errors (and messages). """ return _libsbml.XMLInputStream_getErrorLog(self) def isEOF(self): """ isEOF(XMLInputStream self) -> bool Returns 'True' if end of file (stream) has been reached. Returns 'True' if end of file (stream) has been reached, 'False' otherwise. """ return _libsbml.XMLInputStream_isEOF(self) def isError(self): """ isError(XMLInputStream self) -> bool Returns 'True' if a fatal error occurred while reading from this stream. Returns 'True' if a fatal error occurred while reading from this stream. """ return _libsbml.XMLInputStream_isError(self) def isGood(self): """ isGood(XMLInputStream self) -> bool Returns 'True' if the stream is in a good state. The definition of 'good state' is that isEOF() and isError() both return 'False.' Returns 'True' if the stream is in a good state, 'False' otherwise. """ return _libsbml.XMLInputStream_isGood(self) def next(self): """ next(XMLInputStream self) -> XMLToken Returns the next token on this XML input stream. The token is consumed in the process. Returns the next XMLToken, or an EOF token (i.e., XMLToken.isEOF() == true). See also peek(). """ return _libsbml.XMLInputStream_next(self) def peek(self): """ peek(XMLInputStream self) -> XMLToken Returns the next token without consuming it. A subsequent call to either peek() or next() will return the same token. Returns the next XMLToken or EOF (XMLToken.isEOF() == true). See also next(). """ return _libsbml.XMLInputStream_peek(self) def skipPastEnd(self, element): """ skipPastEnd(XMLInputStream self, XMLToken element) Consume zero or more tokens up to and including the corresponding end element or EOF. Parameter 'element' is the element whose end will be sought in the input stream. """ return _libsbml.XMLInputStream_skipPastEnd(self, element) def skipText(self): """ skipText(XMLInputStream self) Consume zero or more tokens up to but not including the next XML element or EOF. """ return _libsbml.XMLInputStream_skipText(self) def setErrorLog(self, log): """ setErrorLog(XMLInputStream self, XMLErrorLog log) -> int Sets the XMLErrorLog this stream will use to log errors. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.XMLInputStream_setErrorLog(self, log) def toString(self): """ toString(XMLInputStream self) -> string Prints a string representation of the underlying token stream. Returns a string representing the underlying XML token stream. Note: This method is intended for debugging purposes. """ return _libsbml.XMLInputStream_toString(self) def getSBMLNamespaces(self): """ getSBMLNamespaces(XMLInputStream self) -> SBMLNamespaces Returns the SBMLNamespaces object attached to this XMLInputStream. Returns the SBMLNamespaces object or 'None' if none has been set. """ return _libsbml.XMLInputStream_getSBMLNamespaces(self) def setSBMLNamespaces(self, sbmlns): """ setSBMLNamespaces(XMLInputStream self, SBMLNamespaces sbmlns) Sets the SBML namespaces associated with this XML input stream. This allows this stream to reference the available SBML namespaces being read. Parameter 'sbmlns' is the list of namespaces to use. """ return _libsbml.XMLInputStream_setSBMLNamespaces(self, sbmlns) def determineNumberChildren(self, *args): """ determineNumberChildren(XMLInputStream self, string elementName) -> unsigned int determineNumberChildren(XMLInputStream self) -> unsigned int Returns the number of child tokens of the given element in this stream. This method allows information from the input stream to be determined without the need to actually read and consume the tokens in the stream. It returns the number of child elements of the element represented by the 'elementName', i.e., the number of child elements encountered before the closing tag for the 'elementName' supplied. If no 'elementName' is supplied or it is an empty string, then as a special case, this method assumes the element is a MathML apply element followed by a function name. Parameter 'elementName' is a string representing the name of the element for which the number of children are to be determined. Returns a long integer giving the number of children of the 'elementName' specified. Note: This method assumes the stream has been read up to and including the element 'elementName'. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.XMLInputStream_determineNumberChildren(self, *args) def determineNumSpecificChildren(self, childName, container): """ determineNumSpecificChildren(XMLInputStream self, string childName, string container) -> unsigned int Returns the number of child tokens of the specified type within a given container element. This method allows information from the input stream to be determined without the need to actually read and consume the tokens in the stream. It returns the number of child elements of the 'childName' element within the element specified by 'container'. In other words, it counts the number of 'childName' elements encountered before the closing tag for the 'container' supplied. Parameter 'childName' is a string representing the name of the child element whose number is to be determined. Parameter 'container' is a string representing the name of the element for which the number of children are to be determined. Returns a long integer giving the number of children of type 'childName' within the 'container' element. Note: This method assumes the stream has been read up to and including the element 'container'. """ return _libsbml.XMLInputStream_determineNumSpecificChildren(self, childName, container) def containsChild(self, childName, container): """ containsChild(XMLInputStream self, string childName, string container) -> bool Predicate returning 'True' if a child token of the specified type occurs within a given container element. This method allows information from the input stream to be determined without the need to actually read and consume the tokens in the stream. It returns 'True' if the 'childName' element occurs at any point within the element specified by 'container'. Parameter 'childName' is a string representing the name of the child element whose presence is to be determined. Parameter 'container' is a string representing the name of the element for which the presence of the child element is to be determined. Returns boolean 'True' if a child of type 'childName' occurs within the 'container' element, 'False' otherwise. Note: This method assumes the stream has been read up to and including the element 'container'. """ return _libsbml.XMLInputStream_containsChild(self, childName, container) XMLInputStream_swigregister = _libsbml.XMLInputStream_swigregister XMLInputStream_swigregister(XMLInputStream) XMLUnknownError = _libsbml.XMLUnknownError XMLOutOfMemory = _libsbml.XMLOutOfMemory XMLFileUnreadable = _libsbml.XMLFileUnreadable XMLFileUnwritable = _libsbml.XMLFileUnwritable XMLFileOperationError = _libsbml.XMLFileOperationError XMLNetworkAccessError = _libsbml.XMLNetworkAccessError InternalXMLParserError = _libsbml.InternalXMLParserError UnrecognizedXMLParserCode = _libsbml.UnrecognizedXMLParserCode XMLTranscoderError = _libsbml.XMLTranscoderError MissingXMLDecl = _libsbml.MissingXMLDecl MissingXMLEncoding = _libsbml.MissingXMLEncoding BadXMLDecl = _libsbml.BadXMLDecl BadXMLDOCTYPE = _libsbml.BadXMLDOCTYPE InvalidCharInXML = _libsbml.InvalidCharInXML BadlyFormedXML = _libsbml.BadlyFormedXML UnclosedXMLToken = _libsbml.UnclosedXMLToken InvalidXMLConstruct = _libsbml.InvalidXMLConstruct XMLTagMismatch = _libsbml.XMLTagMismatch DuplicateXMLAttribute = _libsbml.DuplicateXMLAttribute UndefinedXMLEntity = _libsbml.UndefinedXMLEntity BadProcessingInstruction = _libsbml.BadProcessingInstruction BadXMLPrefix = _libsbml.BadXMLPrefix BadXMLPrefixValue = _libsbml.BadXMLPrefixValue MissingXMLRequiredAttribute = _libsbml.MissingXMLRequiredAttribute XMLAttributeTypeMismatch = _libsbml.XMLAttributeTypeMismatch XMLBadUTF8Content = _libsbml.XMLBadUTF8Content MissingXMLAttributeValue = _libsbml.MissingXMLAttributeValue BadXMLAttributeValue = _libsbml.BadXMLAttributeValue BadXMLAttribute = _libsbml.BadXMLAttribute UnrecognizedXMLElement = _libsbml.UnrecognizedXMLElement BadXMLComment = _libsbml.BadXMLComment BadXMLDeclLocation = _libsbml.BadXMLDeclLocation XMLUnexpectedEOF = _libsbml.XMLUnexpectedEOF BadXMLIDValue = _libsbml.BadXMLIDValue BadXMLIDRef = _libsbml.BadXMLIDRef UninterpretableXMLContent = _libsbml.UninterpretableXMLContent BadXMLDocumentStructure = _libsbml.BadXMLDocumentStructure InvalidAfterXMLContent = _libsbml.InvalidAfterXMLContent XMLExpectedQuotedString = _libsbml.XMLExpectedQuotedString XMLEmptyValueNotPermitted = _libsbml.XMLEmptyValueNotPermitted XMLBadNumber = _libsbml.XMLBadNumber XMLBadColon = _libsbml.XMLBadColon MissingXMLElements = _libsbml.MissingXMLElements XMLContentEmpty = _libsbml.XMLContentEmpty XMLErrorCodesUpperBound = _libsbml.XMLErrorCodesUpperBound LIBSBML_CAT_INTERNAL = _libsbml.LIBSBML_CAT_INTERNAL LIBSBML_CAT_SYSTEM = _libsbml.LIBSBML_CAT_SYSTEM LIBSBML_CAT_XML = _libsbml.LIBSBML_CAT_XML LIBSBML_SEV_INFO = _libsbml.LIBSBML_SEV_INFO LIBSBML_SEV_WARNING = _libsbml.LIBSBML_SEV_WARNING LIBSBML_SEV_ERROR = _libsbml.LIBSBML_SEV_ERROR LIBSBML_SEV_FATAL = _libsbml.LIBSBML_SEV_FATAL LIBSBML_OVERRIDE_DISABLED = _libsbml.LIBSBML_OVERRIDE_DISABLED LIBSBML_OVERRIDE_DONT_LOG = _libsbml.LIBSBML_OVERRIDE_DONT_LOG LIBSBML_OVERRIDE_WARNING = _libsbml.LIBSBML_OVERRIDE_WARNING LIBSBML_OVERRIDE_ERROR = _libsbml.LIBSBML_OVERRIDE_ERROR class XMLError(_object): """ XML-level errors, warnings and other diagnostics. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. LibSBML can be configured to use any of a number of XML parsers; at the time of this writing, libSBML supports Xerces versions 2.4 through 3.1, Expat version 1.95.x and higher, and libxml2 version 2.6.16 and higher. These parsers each report different status codes for the various exceptions that can occur during XML processing. The XMLError object class abstracts away from the particular diagnostics reported by the different parsers and presents a single uniform interface and set of status codes, along with operations for manipulating the error objects. When the libSBML XML parser layer encounters an error in the XML content being processed, or when there is something else wrong (such as an out-of-memory condition), the problems are reported as XMLError objects. Each XMLError object instance has an identification number that identifies the nature of the problem. This error identifier is one of the constants listed in the next section below. Applications can use the error identifiers as a means of recognizing the error encountered and changing their behavior if desired. Integer error codes are useful for software, but not so much for telling humans what happened. For this reason, XMLError also provides two text messages describing the nature of the error. These messages are accessible by means of the methods XMLError.getShortMessage() and XMLError.getMessage(). The method XMLError.getShortMessage() returns a very brief synopsis of the warning or error condition, whereas XMLError.getMessage() returns a longer explanation. These text strings are suitable for displaying to human users. Each XMLError object also contains a category code; its value may be retrieved using the method XMLError.getCategory(). Category values are drawn from a set of constants whose names begin with the characters 'LIBSBML_CAT_,' described below. Categories are used by libSBML to provide more information to calling programs about the nature of a given error. In addition to category codes, each XMLError object also has a severity code; its value may be retrieved using the method XMLError.getSeverity(). Severity code values are drawn from a set of constants whose names begin with the characters 'LIBSBML_SEV_,' described below. Severity levels range from informational (LIBSBML_SEV_INFO) to fatal errors (LIBSBML_SEV_FATAL). Finally, XMLError objects record the line and column near where the problem occurred in the XML content. The values can be retrieved using the methods XMLError.getLine() and XMLError.getColumn(). We say 'near where the problem occurred', because many factors affect how accurate the line/column information ultimately is. For example, sometimes, the underlying XML parsers can only report such information for the parent XML element where an error occurs, and not for the specific point where the problem occurs. In other situations, some parsers report invalid line and/or column numbers altogether. If this occurs, libSBML sets the line and/or column number in the XMLError object to either 0 or the value of the maximum unsigned long integer representable on the platform where libSBML is running. The probability that a true line or column number in an SBML model would equal this value is vanishingly small; thus, if an application encounters these values in an XMLError object, it can assume no valid line/column number could be provided by libSBML in that situation. <center> +-----------------------------+---------------------------------------------------------------+----------+----------+ | Enumerator | Meaning | Category | Severity | +-----------------------------+---------------------------------------------------------------+----------+----------+ | XMLUnknownError | Unrecognized error encountered internally | INTERNAL | FATAL | | XMLOutOfMemory | Out of memory | SYSTEM | FATAL | | XMLFileUnreadable | File unreadable | SYSTEM | ERROR | | XMLFileUnwritable | File unwritable | SYSTEM | ERROR | | XMLFileOperationError | Error encountered while attempting file operation | SYSTEM | ERROR | | XMLNetworkAccessError | Network access error | SYSTEM | ERROR | | InternalXMLParserError | Internal XML parser state error | INTERNAL | FATAL | | UnrecognizedXMLParserCode | XML parser returned an unrecognized error code | INTERNAL | FATAL | | XMLTranscoderError | Character transcoder error | INTERNAL | FATAL | | MissingXMLDecl | Missing XML declaration at beginning of XML input | XML | ERROR | | MissingXMLEncoding | Missing encoding attribute in XML declaration | XML | ERROR | | BadXMLDecl | Invalid or unrecognized XML declaration or XML encoding | XML | ERROR | | BadXMLDOCTYPE | Invalid, malformed or unrecognized XML DOCTYPE declaration | XML | ERROR | | InvalidCharInXML | Invalid character in XML content | XML | ERROR | | BadlyFormedXML | XML content is not well-formed | XML | ERROR | | UnclosedXMLToken | Unclosed XML token | XML | ERROR | | InvalidXMLConstruct | XML construct is invalid or not permitted | XML | ERROR | | XMLTagMismatch | Element tag mismatch or missing tag | XML | ERROR | | DuplicateXMLAttribute | Duplicate XML attribute | XML | ERROR | | UndefinedXMLEntity | Undefined XML entity | XML | ERROR | | BadProcessingInstruction | Invalid, malformed or unrecognized XML processing instruction | XML | ERROR | | BadXMLPrefix | Invalid or undefined XML namespace prefix | XML | ERROR | | BadXMLPrefixValue | Invalid XML namespace prefix value | XML | ERROR | | MissingXMLRequiredAttribute | Missing a required XML attribute | XML | ERROR | | XMLAttributeTypeMismatch | Data type mismatch for the value of an attribute | XML | ERROR | | XMLBadUTF8Content | Invalid UTF8 content | XML | ERROR | | MissingXMLAttributeValue | Missing or improperly formed attribute value | XML | ERROR | | BadXMLAttributeValue | Invalid or unrecognizable attribute value | XML | ERROR | | BadXMLAttribute | Invalid, unrecognized or malformed attribute | XML | ERROR | | UnrecognizedXMLElement | Element either not recognized or not permitted | XML | ERROR | | BadXMLComment | Badly formed XML comment | XML | ERROR | | BadXMLDeclLocation | XML declaration not permitted in this location | XML | ERROR | | XMLUnexpectedEOF | Reached end of input unexpectedly | XML | ERROR | | BadXMLIDValue | Value is invalid for XML ID, or has already been used | XML | ERROR | | BadXMLIDRef | XML ID value was never declared | XML | ERROR | | UninterpretableXMLContent | Unable to interpret content | XML | ERROR | | BadXMLDocumentStructure | Bad XML document structure | XML | ERROR | | InvalidAfterXMLContent | Encountered invalid content after expected content | XML | ERROR | | XMLExpectedQuotedString | Expected to find a quoted string | XML | ERROR | | XMLEmptyValueNotPermitted | An empty value is not permitted in this context | XML | ERROR | | XMLBadNumber | Invalid or unrecognized number | XML | ERROR | | XMLBadColon | Colon characters are invalid in this context | XML | ERROR | | MissingXMLElements | One or more expected elements are missing | XML | ERROR | | XMLContentEmpty | Main XML content is empty | XML | ERROR | +-----------------------------+---------------------------------------------------------------+----------+----------+ </center> <center> +----------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Enumerator | Meaning | +----------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | LIBSBML_CAT_INTERNAL | A problem involving the libSBML software itself or the underlying XML parser. This almost certainly indicates a software defect (i.e., bug) in libSBML. Please report instances of this to the libSBML developers. | | LIBSBML_CAT_SYSTEM | A problem reported by the operating system, such as an inability to read or write a file. This indicates something that is not a program error but is outside of the control of libSBML. | | LIBSBML_CAT_XML | A problem in the XML content itself. This usually arises from malformed XML or the use of constructs not permitted in SBML. | +----------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ </center> <center> +---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | Enumerator | Meaning | +---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | LIBSBML_SEV_INFO | The error is actually informational and not necessarily a serious problem. | | LIBSBML_SEV_WARNING | The error object represents a problem that is not serious enough to necessarily stop the problem, but applications should take note of the problem and evaluate what its implications may be. | | LIBSBML_SEV_ERROR | The error object represents a serious error. The application may continue running but it is unlikely to be able to continue processing the same XML file or data stream. | | LIBSBML_SEV_FATAL | A serious error occurred, such as an out-of-memory condition, and the software should terminate immediately. | +---------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ </center> """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, XMLError, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, XMLError, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(XMLError self, int const errorId=0, string details, unsigned int const line=0, unsigned int const column=0, unsigned int const severity=LIBSBML_SEV_FATAL, unsigned int const category=LIBSBML_CAT_INTERNAL) -> XMLError __init__(XMLError self, int const errorId=0, string details, unsigned int const line=0, unsigned int const column=0, unsigned int const severity=LIBSBML_SEV_FATAL) -> XMLError __init__(XMLError self, int const errorId=0, string details, unsigned int const line=0, unsigned int const column=0) -> XMLError __init__(XMLError self, int const errorId=0, string details, unsigned int const line=0) -> XMLError __init__(XMLError self, int const errorId=0, string details) -> XMLError __init__(XMLError self, int const errorId=0) -> XMLError __init__(XMLError self) -> XMLError __init__(XMLError self, XMLError orig) -> XMLError This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: XMLError(XMLError orig) Copy constructor; creates a copy of this XMLError. 'orig' the XMLError object to copy. ______________________________________________________________________ Method variant with the following signature: XMLError( int errorId = 0 , string details = '' , long line = 0 , long column = 0 , long severity = LIBSBML_SEV_FATAL , long category = LIBSBML_CAT_INTERNAL ) Creates a new XMLError to report that something occurred during XML processing. XMLError objects have identification numbers to indicate the nature of the exception. These numbers are defined as longeger constants in the file 'libsbmlConstants.java'. See the top of this documentation for a table listing the possible values and their meanings. The argument 'errorId' to this constructor can be (but does not have to be) a value from this set of constants. If it is one of the predefined error identifiers, the XMLError class assumes the error is a low-level system or XML layer error and prepends a built-in, predefined error message to any string passed in the argument 'details' to this constructor. In addition, all the predefined error identifiers have associated values for the 'severity' and 'category' codes, and these fields are filled-in as well. If the error identifier 'errorId' is a number greater than 9999, this constructor assumes that the error was generated from another part of the software, and does not do additional filling in of values beyond the defaults in the constructor itself. This allows XMLError to serve as a base class for other errors (and is used in this way elsewhere in libSBML). Callers should fill in all the parameters with suitable values if generating errors with codes greater than 9999 to make maximum use of the XMLError facilities. As mentioned above, there are additional constants defined for standard severity and standard category codes, and every predefined error in libSBML has an associated value for severity and category taken from these predefined sets. These constants have symbol names prefixed with LIBSBML_SEV_ and LIBSBML_CAT_, respectively. If the value of 'errorId' is one of the standard error codes, callers do not need to fill in 'severity' and 'category' in a call to this constructor. Conversely, if 'errorId' is not an existing XML-level error code, callers can use other values for 'severity' and 'category'. Parameter 'errorId' is a long integer, the identification number of the error. Parameter 'details' is a string containing additional details about the error. If the error code in 'errorId' is one that is recognized by XMLError, the given message is appended to a predefined message associated with the given code. If the error code is not recognized, the message is stored as-is as the text of the error. Parameter 'line' is a long integer, the line number at which the error occured. Parameter 'column' is a long integer, the column number at which the error occured. Parameter 'severity' is an integer indicating severity of the error. Parameter 'category' is an integer indicating the category to which the error belongs. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ this = _libsbml.new_XMLError(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_XMLError __del__ = lambda self: None def getErrorId(self): """ getErrorId(XMLError self) -> unsigned int Returns the identifier of this error. Returns the error code for this error. See also getMessage(), getShortMessage(), getCategory(), getSeverity(). """ return _libsbml.XMLError_getErrorId(self) def getMessage(self): """ getMessage(XMLError self) -> string Returns the message text of this error. The message associated with an error object describes the nature of the problem. The message returned by this method is generally longer and clearer than the message returned by XMLError.getShortMessage(), but not in all cases. Callers may use XMLError.getCategory() and XMLError.getSeverity() to obtain additional information about the nature and severity of the problem. Returns the message text. See also getErrorId(), getShortMessage(), getCategory(), getSeverity(). """ return _libsbml.XMLError_getMessage(self) def getShortMessage(self): """ getShortMessage(XMLError self) -> string Returns a brief message for this error. This is an alternative error message that, in general, is as short as the authors could make it. However, brevity is often inversely proportional to clarity, so this short message may not be sufficiently informative to understand the nature of the error. Calling applications may wish to check XMLError.getMessage() in addition or instead. Returns the short error message text. See also getErrorId(), getMessage(), getCategory(), getSeverity(). """ return _libsbml.XMLError_getShortMessage(self) def getLine(self): """ getLine(XMLError self) -> unsigned int Returns the line number in the XML input near where the error, warning or other diagnostic occurred. We say 'near where the problem occurred', because many factors affect how accurate the line/column information ultimately is. For example, sometimes, the underlying XML parsers can only report such information for the parent XML element where an error occurs, and not for the specific point where the problem occurs. In other situations, some parsers report invalid line and/or column numbers altogether. If this occurs, libSBML sets the line and/or column number in the XMLError object to either 0 or the value of the maximum unsigned long integer representable on the platform where libSBML is running. The probability that a true line or column number in an SBML model would equal this value is vanishingly small; thus, if an application encounters these values in an XMLError object, it can assume no valid line/column number could be provided by libSBML in that situation. Returns the line number. See also getColumn(). """ return _libsbml.XMLError_getLine(self) def getColumn(self): """ getColumn(XMLError self) -> unsigned int Returns the column number in the XML input near where the error, warning or other diagnostic occurred. We say 'near where the problem occurred', because many factors affect how accurate the line/column information ultimately is. For example, sometimes, the underlying XML parsers can only report such information for the parent XML element where an error occurs, and not for the specific point where the problem occurs. In other situations, some parsers report invalid line and/or column numbers altogether. If this occurs, libSBML sets the line and/or column number in the XMLError object to either 0 or the value of the maximum unsigned long integer representable on the platform where libSBML is running. The probability that a true line or column number in an SBML model would equal this value is vanishingly small; thus, if an application encounters these values in an XMLError object, it can assume no valid line/column number could be provided by libSBML in that situation. Returns the column number. See also getLine(). """ return _libsbml.XMLError_getColumn(self) def getSeverity(self): """ getSeverity(XMLError self) -> unsigned int Returns the severity of this error. XMLError defines an enumeration of severity codes for the XML layer. Applications that build on XMLError by subclassing it may add their own severity codes with numbers higher than those in the predefined set of severity codes. Returns the severity of this XMLError. See also getSeverityAsString(), getCategory(). """ return _libsbml.XMLError_getSeverity(self) def getSeverityAsString(self): """ getSeverityAsString(XMLError self) -> string Returns a string describing the severity level of this error. XMLError defines an enumeration of severity codes for the XML layer. Applications that build on XMLError by subclassing it may add their own severity codes with numbers higher than those in the predefined set of severity codes. Returns string representing the severity of this XMLError. See also getSeverity(), getCategoryAsString(). """ return _libsbml.XMLError_getSeverityAsString(self) def getCategory(self): """ getCategory(XMLError self) -> unsigned int Returns the category of this error. XMLError defines an enumeration of category codes for the XML layer. Applications that build on XMLError by subclassing it may add their own categories with numbers higher than those in the predefined set of category codes. Categories can be used to partition errors into distinct groups. Among other things, this can be used to prevent id conflicts by uniquely identifying an XMLError by both id and category. Returns the category of this XMLError. See also getSeverity(), getCategoryAsString(). """ return _libsbml.XMLError_getCategory(self) def getCategoryAsString(self): """ getCategoryAsString(XMLError self) -> string Returns a string describing the category of this error. XMLError defines an enumeration of category codes for the XML layer. Applications that build on XMLError by subclassing it may add their own categories with numbers higher than those in the predefined set of category codes. Categories can be used to partition errors into distinct groups. Among other things, this can be used to prevent id conflicts by uniquely identifying an XMLError by both id and category. Returns string representing the category of this XMLError. See also getCategory(), getSeverityAsString(). """ return _libsbml.XMLError_getCategoryAsString(self) def isInfo(self): """ isInfo(XMLError self) -> bool Predicate returning 'True' or 'False' depending on whether this error object is for information purposes only. This is equivalent to obtaining the severity code from an XMLError object (via XMLError.getSeverity()) and then comparing it to the value LIBSBML_SEV_INFO from the set of predefined severity codes. Returns 'True' if this XMLError is for informational purposes only, 'False' otherwise. See also isWarning(), isError(), isFatal(). """ return _libsbml.XMLError_isInfo(self) def isWarning(self): """ isWarning(XMLError self) -> bool Predicate returning 'True' or 'False' depending on whether this error object is a warning. This is equivalent to obtaining the severity code from an XMLError object (via XMLError.getSeverity()) and then comparing it to the value LIBSBML_SEV_WARNING from the set of predefined severity codes. Returns 'True' if this error is a warning, 'False' otherwise. See also isInfo(), isError(), isFatal(). """ return _libsbml.XMLError_isWarning(self) def isError(self): """ isError(XMLError self) -> bool Predicate returning 'True' or 'False' depending on whether this error is a significant error. This is equivalent to obtaining the severity code from an XMLError object (via XMLError.getSeverity()) and then comparing it to the value LIBSBML_SEV_ERROR from the set of predefined severity codes. Returns 'True' if this error is an error, 'False' otherwise. See also isInfo(), isWarning(), isFatal(). """ return _libsbml.XMLError_isError(self) def isFatal(self): """ isFatal(XMLError self) -> bool Predicate returning 'True' or 'False' depending on whether this error is a fatal run-time error. This is equivalent to obtaining the severity code from an XMLError object (via XMLError.getSeverity()) and then comparing it to the value LIBSBML_SEV_FATAL from the set of predefined severity codes. Returns 'True' if this error is a fatal error, 'False' otherwise. See also isInfo(), isWarning(), isError(). """ return _libsbml.XMLError_isFatal(self) def isInternal(self): """ isInternal(XMLError self) -> bool Predicate returning 'True' or 'False' depending on whether this error resulted from an internal program error. This is equivalent to obtaining the category identifier from an XMLError object (via XMLError.getCategory()) and then comparing it to the value LIBSBML_CAT_INTERNAL from the set of predefined category codes. Returns a boolean indicating whether the error is an internal error. See also isSystem(), isXML(). """ return _libsbml.XMLError_isInternal(self) def isSystem(self): """ isSystem(XMLError self) -> bool Predicate returning 'True' or 'False' depending on whether this error was generated by the operating system. This is equivalent to obtaining the category identifier from an XMLError object (via XMLError.getCategory()) and then comparing it to the value LIBSBML_CAT_SYSTEM from the set of predefined category codes. Returns boolean indicating whether the error is a system error. See also isInternal(), isXML(). """ return _libsbml.XMLError_isSystem(self) def isXML(self): """ isXML(XMLError self) -> bool Predicate returning 'True' or 'False' depending on whether this error resulted from a problem in the XML input (e.g., an XML syntax error). This is equivalent to obtaining the category identifier from an XMLError object (via XMLError.getCategory()) and then comparing it to the value LIBSBML_CAT_XML from the set of predefined category codes. Returns a boolean indicating whether the error is an XML catetory error. See also isInternal(), isSystem(). """ return _libsbml.XMLError_isXML(self) def isValid(self): """ isValid(XMLError self) -> bool Predicate returning 'True' or 'False' depending on whether this error resulted from a problem or whether it was logged as an unknown error. This is equivalent to obtaining the error identifier from an XMLError object (via XMLError.getErrorId()) and then comparing it to the value XMLUnknownError or UnknownError from the set of predefined error codes. Returns a boolean indicating whether the error is a valid error ('True)' or whether it is unknown ('False).' """ return _libsbml.XMLError_isValid(self) def setLine(self, line): """ setLine(XMLError self, unsigned int line) -> int Sets the line number where this error occurred. Parameter 'line' is a long integer, the line number to set. Returns integer value indicating success/failure of the function. This particular function only does one thing irrespective of user input or object state, and thus will only return a single value: * LIBSBML_OPERATION_SUCCESS See also setColumn(). """ return _libsbml.XMLError_setLine(self, line) def setColumn(self, column): """ setColumn(XMLError self, unsigned int column) -> int Sets the column number where this error occurred. Parameter 'column' is a long integer, the column number to set. Returns integer value indicating success/failure of the function. This particular function only does one thing irrespective of user input or object state, and thus will only return a single value: * LIBSBML_OPERATION_SUCCESS See also setLine(). """ return _libsbml.XMLError_setColumn(self, column) def getStandardMessage(code): """ getStandardMessage(int const code) -> string Returns a copy of the message string associated with the given predefined XMLError code. Parameter 'code' is the error code whose message is sought; it must be a predefined value from the set of predefined error identifiers. """ return _libsbml.XMLError_getStandardMessage(code) getStandardMessage = staticmethod(getStandardMessage) def getPackage(self): """ getPackage(XMLError self) -> string Returns the SBML Level 3 package extension (if any) that logged this error. Each error logged by an libSBML extension for SBML Level 3 packages includes a record of the package that logged it. The field is a simple text string. If the string is empty or has the value ''core',' then the error came from libSBML core; otherwise, the string will be the short-form name of the package (e.g., ''comp'' for the Hierarchical Model Composition package). Returns a string representing the name of the package that logged this error. If the error did not come from a package extension, the value will be the empty string or ''core'.' """ return _libsbml.XMLError_getPackage(self) def getErrorIdOffset(self): """ getErrorIdOffset(XMLError self) -> unsigned int Returns libSBML's internal numerical offset for the error code associated with this error. In the SBML Level 3 package specifications, package validation rules are identified by 5-digit numbers prefixed with the nickname of the package itself---e.g., "comp-10101", "fbc-20301", etc. Historically, libSBML reported error codes as pure integers, and some application software systems make decisions based on the numerical values of the error codes. To permit these applications to continue to function in this fashion, libSBML internally continues to maintain error identifiers as pure integers. To handle the possibility that errors may come from package extensions, libSBML uses numerical offsets added to the internal error codes. These offsets add two leading digits to the regular 5-digit error codes; for example, "comp" error codes are stored as 1010101, 1020102, etc. The offset in this case is 1000000. Another package will have the offset 2000000, yet another will have 3000000, etc. This method returns the integer offset in this error's error code. Calling applications can get the 5-digit package-specific number for a given error code by subtracting the offset from the value reported by getErrorId(): getErrorId() - getErrorIdOffset() When libSBML produces error messages, it combines the text string returned by getPackage() with the subtracted value of the error code, to produce a text string of the form "comp-10101". See also getErrorId(), getPackage(). """ return _libsbml.XMLError_getErrorIdOffset(self) def __eq__(self, rhs): if ((self is None) and (rhs is None)): return True if ((self is None) or (rhs is None)): return False if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return True return False def __ne__(self, rhs): if ((self is None) and (rhs is None)): return False if ((self is None) or (rhs is None)): return True if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return False return True XMLError_swigregister = _libsbml.XMLError_swigregister XMLError_swigregister(XMLError) def XMLError_getStandardMessage(code): """ XMLError_getStandardMessage(int const code) -> string Returns a copy of the message string associated with the given predefined XMLError code. Parameter 'code' is the error code whose message is sought; it must be a predefined value from the set of predefined error identifiers. """ return _libsbml.XMLError_getStandardMessage(code) class XMLErrorLog(_object): """ Log of diagnostics reported during XML processing. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. The error log is a list. The XML layer of libSBML maintains an error log associated with a given XML document or data stream. When an operation results in an error, or when there is something wrong with the XML content, the problem is reported as an XMLError object stored in the XMLErrorLog list. Potential problems range from low-level issues (such as the inability to open a file) to XML syntax errors (such as mismatched tags or other problems). A typical approach for using this error log is to first use getNumErrors() to inquire how many XMLError object instances it contains, and then to iterate over the list of objects one at a time using getError(long n) . Indexing in the list begins at 0. In normal circumstances, programs using libSBML will actually obtain an SBMLErrorLog rather than an XMLErrorLog. The former is subclassed from XMLErrorLog and simply wraps commands for working with SBMLError objects rather than the low-level XMLError objects. Classes such as SBMLDocument use the higher-level SBMLErrorLog. """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, XMLErrorLog, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, XMLErrorLog, name) __repr__ = _swig_repr def getNumErrors(self): """ getNumErrors(XMLErrorLog self) -> unsigned int Returns the number of errors that have been logged. To retrieve individual errors from the log, callers may use XMLErrorLog.getError() . Returns the number of errors that have been logged. """ return _libsbml.XMLErrorLog_getNumErrors(self) def getError(self, n): """ getError(XMLErrorLog self, unsigned int n) -> XMLError Returns the nth XMLError object in this log. Index 'n' is counted from 0. Callers should first inquire about the number of items in the log by using the method getNumErrors(). Attempts to use an error index number that exceeds the actual number of errors in the log will result in a 'None' being returned. Parameter 'n' is the index number of the error to retrieve (with 0 being the first error). Returns the nth XMLError in this log, or 'None' if 'n' is greater than or equal to getNumErrors(). See also getNumErrors(). """ return _libsbml.XMLErrorLog_getError(self, n) def clearLog(self): """ clearLog(XMLErrorLog self) Deletes all errors from this log. """ return _libsbml.XMLErrorLog_clearLog(self) def __init__(self, *args): """ __init__(XMLErrorLog self) -> XMLErrorLog __init__(XMLErrorLog self, XMLErrorLog other) -> XMLErrorLog @internal """ this = _libsbml.new_XMLErrorLog(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_XMLErrorLog __del__ = lambda self: None def add(self, *args): """ add(XMLErrorLog self, XMLError error) add(XMLErrorLog self, std::vector< XMLError * > const & errors) """ return _libsbml.XMLErrorLog_add(self, *args) def toString(self): """ toString(XMLErrorLog self) -> string Writes all errors contained in this log to a string and returns it. This method uses printErrors() to format the diagnostic messages. Please consult that method for information about the organization of the messages in the string returned by this method. Returns a string containing all logged errors and warnings. See also printErrors(). """ return _libsbml.XMLErrorLog_toString(self) def printErrors(self, *args): """ printErrors(XMLErrorLog self, ostream stream) printErrors(XMLErrorLog self) printErrors(XMLErrorLog self, ostream stream, unsigned int severity) This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: printErrors(std::ostream stream, long severity) Prints the errors or warnings with given severity stored in this error log. This method prints the text to the stream given by the optional parameter 'stream'. If no stream is given, the method prints the output to the standard error stream. The format of the output is: N error(s): line NNN: (id) message If no errors with that severity was found, then no output will be produced. Parameter 'stream' is the ostream or ostringstream object indicating where the output should be printed. Parameter 'severity' is the severity of the errors sought. ______________________________________________________________________ Method variant with the following signature: printErrors(std::ostream stream = std::cerr) Prints all the errors or warnings stored in this error log. This method prints the text to the stream given by the optional parameter 'stream'. If no stream is given, the method prints the output to the standard error stream. The format of the output is: N error(s): line NNN: (id) message If no errors have occurred, i.e., getNumErrors() == 0, then no output will be produced. Parameter 'stream' is the ostream or ostringstream object indicating where the output should be printed. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.XMLErrorLog_printErrors(self, *args) def isSeverityOverridden(self): """ isSeverityOverridden(XMLErrorLog self) -> bool Returns a boolean indicating whether or not the severity has been overridden. The severity override mechanism in XMLErrorLog is intended to help applications handle error conditions in ways that may be more convenient for those applications. It is possible to use the mechanism to override the severity code of errors logged by libSBML, and even to disable error logging completely. An override stays in effect until the override is changed again by the calling application. Returns 'True' if an error severity override has been set, 'False' otherwise. See also getSeverityOverride(), setSeverityOverride(), unsetSeverityOverride(), changeErrorSeverity(). """ return _libsbml.XMLErrorLog_isSeverityOverridden(self) def unsetSeverityOverride(self): """ unsetSeverityOverride(XMLErrorLog self) Usets an existing override. The severity override mechanism in XMLErrorLog is intended to help applications handle error conditions in ways that may be more convenient for those applications. It is possible to use the mechanism to override the severity code of errors logged by libSBML, and even to disable error logging completely. An override stays in effect until the override is changed again by the calling application. See also getSeverityOverride(), setSeverityOverride(), isSeverityOverridden(), changeErrorSeverity(). """ return _libsbml.XMLErrorLog_unsetSeverityOverride(self) def getSeverityOverride(self): """ getSeverityOverride(XMLErrorLog self) -> XMLErrorSeverityOverride_t Returns the current override. The severity override mechanism in XMLErrorLog is intended to help applications handle error conditions in ways that may be more convenient for those applications. It is possible to use the mechanism to override the severity code of errors logged by libSBML, and even to disable error logging completely. An override stays in effect until the override is changed again by the calling application. Returns a severity override code. The possible values are drawn from the set of integer constants whose names begin with the prefix LIBSBML_OVERRIDE_: * LIBSBML_OVERRIDE_DISABLED * LIBSBML_OVERRIDE_DONT_LOG * LIBSBML_OVERRIDE_WARNING See also isSeverityOverridden(), setSeverityOverride(), unsetSeverityOverride(), changeErrorSeverity(). """ return _libsbml.XMLErrorLog_getSeverityOverride(self) def setSeverityOverride(self, severity): """ setSeverityOverride(XMLErrorLog self, XMLErrorSeverityOverride_t severity) Set the severity override. The severity override mechanism in XMLErrorLog is intended to help applications handle error conditions in ways that may be more convenient for those applications. It is possible to use the mechanism to override the severity code of errors logged by libSBML, and even to disable error logging completely. An override stays in effect until the override is changed again by the calling application. Parameter 'severity' is an override code indicating what to do. If the value is LIBSBML_OVERRIDE_DISABLED (the default setting) all errors logged will be given the severity specified in their usual definition. If the value is LIBSBML_OVERRIDE_WARNING, then all errors will be logged as warnings. If the value is LIBSBML_OVERRIDE_DONT_LOG, no error will be logged, regardless of their severity. See also isSeverityOverridden(), getSeverityOverride(), unsetSeverityOverride(), changeErrorSeverity(). """ return _libsbml.XMLErrorLog_setSeverityOverride(self, severity) def changeErrorSeverity(self, *args): """ changeErrorSeverity(XMLErrorLog self, XMLErrorSeverity_t originalSeverity, XMLErrorSeverity_t targetSeverity, string package) changeErrorSeverity(XMLErrorLog self, XMLErrorSeverity_t originalSeverity, XMLErrorSeverity_t targetSeverity) Changes the severity override for errors in the log that have a given severity. This method searches through the list of errors in the log, comparing each one's severity to the value of 'originalSeverity'. For each error encountered with that severity logged by the named 'package', the severity of the error is reset to 'targetSeverity'. The severity override mechanism in XMLErrorLog is intended to help applications handle error conditions in ways that may be more convenient for those applications. It is possible to use the mechanism to override the severity code of errors logged by libSBML, and even to disable error logging completely. An override stays in effect until the override is changed again by the calling application. Parameter 'originalSeverity' is the severity code to match. Parameter 'targetSeverity' is the severity code to use as the new severity. Parameter 'package' is a string, the name of an SBML Level 3 package extension to use to narrow the search for errors. A value of ''all'' signifies to match against errors logged from any package; a value of a package nickname such as ''comp'' signifies to limit consideration to errors from just that package. If no value is provided, ''all'' is the default. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> See also isSeverityOverridden(), getSeverityOverride(), setSeverityOverride(), unsetSeverityOverride(). Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.XMLErrorLog_changeErrorSeverity(self, *args) def contains(self, errorId): """ contains(XMLErrorLog self, unsigned int const errorId) -> bool Returns 'True' if XMLErrorLog contains an errorId Parameter 'errorId' is the error identifier of the error to be found. """ return _libsbml.XMLErrorLog_contains(self, errorId) def __eq__(self, rhs): if ((self is None) and (rhs is None)): return True if ((self is None) or (rhs is None)): return False if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return True return False def __ne__(self, rhs): if ((self is None) and (rhs is None)): return False if ((self is None) or (rhs is None)): return True if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return False return True XMLErrorLog_swigregister = _libsbml.XMLErrorLog_swigregister XMLErrorLog_swigregister(XMLErrorLog) class SBMLErrorLog(XMLErrorLog): """ Log of diagnostics reported during processing. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. The error log is a list. Each SBMLDocument maintains its own SBMLErrorLog. When a libSBML operation on SBML content results in an error, or when there is something worth noting about the SBML content, the issue is reported as an SBMLError object stored in the SBMLErrorLog list. SBMLErrorLog is derived from XMLErrorLog, an object class that serves exactly the same purpose but for the XML parsing layer. XMLErrorLog provides crucial methods such as getNumErrors() for determining how many SBMLError or XMLError objects are in the log. SBMLErrorLog inherits these methods. The general approach to working with SBMLErrorLog in user programs involves first obtaining a pointer to a log from a libSBML object such as SBMLDocument. Callers should then use getNumErrors() to inquire how many objects there are in the list. (The answer may be 0.) If there is at least one SBMLError object in the SBMLErrorLog instance, callers can then iterate over the list using SBMLErrorLog.getError()@if clike @endif, using methods provided by the SBMLError class to find out the error code and associated information such as the error severity, the message, and the line number in the input. If you wish to simply print the error strings for a human to read, an easier and more direct way might be to use SBMLDocument.printErrors(). See also SBMLError, XMLErrorLog, XMLError. """ __swig_setmethods__ = {} for _s in [XMLErrorLog]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLErrorLog, name, value) __swig_getmethods__ = {} for _s in [XMLErrorLog]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, SBMLErrorLog, name) __repr__ = _swig_repr def getError(self, n): """ getError(SBMLErrorLog self, unsigned int n) -> SBMLError Returns the nth SBMLError object in this log. Index 'n' is counted from 0. Callers should first inquire about the number of items in the log by using the getNumErrors() method. Attempts to use an error index number that exceeds the actual number of errors in the log will result in a 'None' being returned. Parameter 'n' is the index number of the error to retrieve (with 0 being the first error). Returns the nth SBMLError in this log, or 'None' if 'n' is greater than or equal to getNumErrors(). See also getNumErrors(). """ return _libsbml.SBMLErrorLog_getError(self, n) def getErrorWithSeverity(self, n, severity): """ getErrorWithSeverity(SBMLErrorLog self, unsigned int n, unsigned int severity) -> SBMLError Returns the nth SBMLError object with given severity in this log. Index 'n' is counted from 0. Callers should first inquire about the number of items in the log by using the getNumFailsWithSeverity() method. Attempts to use an error index number that exceeds the actual number of errors in the log will result in a 'None' being returned. Parameter 'n' is the index number of the error to retrieve (with 0 being the first error). Parameter 'severity' is the severity of the error to retrieve. Returns the nth SBMLError in this log, or 'None' if 'n' is greater than or equal to getNumFailsWithSeverity(). See also getNumFailsWithSeverity(). """ return _libsbml.SBMLErrorLog_getErrorWithSeverity(self, n, severity) def getNumFailsWithSeverity(self, *args): """ getNumFailsWithSeverity(SBMLErrorLog self, unsigned int severity) -> unsigned int getNumFailsWithSeverity(SBMLErrorLog self, unsigned int severity) -> unsigned int Returns the number of errors that have been logged with the given severity code. LibSBML associates severity levels with every SBMLError object to provide an indication of how serious the problem is. Severities range from informational diagnostics to fatal (irrecoverable) errors. Given an SBMLError object instance, a caller can interrogate it for its severity level using methods such as SBMLError.getSeverity(), SBMLError.isFatal(), and so on. The present method encapsulates iteration and interrogation of all objects in an SBMLErrorLog, making it easy to check for the presence of error objects with specific severity levels. Parameter 'severity' is a value from the set of LIBSBML_SEV_ constants defined by the interface class libsbml. Returns a count of the number of errors with the given severity code. See also getNumErrors(). """ return _libsbml.SBMLErrorLog_getNumFailsWithSeverity(self, *args) def __init__(self, *args): """ __init__(SBMLErrorLog self) -> SBMLErrorLog __init__(SBMLErrorLog self, SBMLErrorLog orig) -> SBMLErrorLog @internal """ this = _libsbml.new_SBMLErrorLog(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_SBMLErrorLog __del__ = lambda self: None def logError(self, *args): """ logError(SBMLErrorLog self, unsigned int const errorId=0, unsigned int const level, unsigned int const version, string details, unsigned int const line=0, unsigned int const column=0, unsigned int const severity=LIBSBML_SEV_ERROR, unsigned int const category=LIBSBML_CAT_SBML) logError(SBMLErrorLog self, unsigned int const errorId=0, unsigned int const level, unsigned int const version, string details, unsigned int const line=0, unsigned int const column=0, unsigned int const severity=LIBSBML_SEV_ERROR) logError(SBMLErrorLog self, unsigned int const errorId=0, unsigned int const level, unsigned int const version, string details, unsigned int const line=0, unsigned int const column=0) logError(SBMLErrorLog self, unsigned int const errorId=0, unsigned int const level, unsigned int const version, string details, unsigned int const line=0) logError(SBMLErrorLog self, unsigned int const errorId=0, unsigned int const level, unsigned int const version, string details) logError(SBMLErrorLog self, unsigned int const errorId=0, unsigned int const level, unsigned int const version) logError(SBMLErrorLog self, unsigned int const errorId=0, unsigned int const level) logError(SBMLErrorLog self, unsigned int const errorId=0) logError(SBMLErrorLog self) Internal implementation method. """ return _libsbml.SBMLErrorLog_logError(self, *args) def logPackageError(self, *args): """ logPackageError(SBMLErrorLog self, string package, unsigned int const errorId=0, unsigned int const pkgVersion=1, unsigned int const level, unsigned int const version, string details, unsigned int const line=0, unsigned int const column=0, unsigned int const severity=LIBSBML_SEV_ERROR, unsigned int const category=LIBSBML_CAT_SBML) logPackageError(SBMLErrorLog self, string package, unsigned int const errorId=0, unsigned int const pkgVersion=1, unsigned int const level, unsigned int const version, string details, unsigned int const line=0, unsigned int const column=0, unsigned int const severity=LIBSBML_SEV_ERROR) logPackageError(SBMLErrorLog self, string package, unsigned int const errorId=0, unsigned int const pkgVersion=1, unsigned int const level, unsigned int const version, string details, unsigned int const line=0, unsigned int const column=0) logPackageError(SBMLErrorLog self, string package, unsigned int const errorId=0, unsigned int const pkgVersion=1, unsigned int const level, unsigned int const version, string details, unsigned int const line=0) logPackageError(SBMLErrorLog self, string package, unsigned int const errorId=0, unsigned int const pkgVersion=1, unsigned int const level, unsigned int const version, string details) logPackageError(SBMLErrorLog self, string package, unsigned int const errorId=0, unsigned int const pkgVersion=1, unsigned int const level, unsigned int const version) logPackageError(SBMLErrorLog self, string package, unsigned int const errorId=0, unsigned int const pkgVersion=1, unsigned int const level) logPackageError(SBMLErrorLog self, string package, unsigned int const errorId=0, unsigned int const pkgVersion=1) logPackageError(SBMLErrorLog self, string package, unsigned int const errorId=0) logPackageError(SBMLErrorLog self, string package) logPackageError(SBMLErrorLog self) Internal implementation method. """ return _libsbml.SBMLErrorLog_logPackageError(self, *args) def add(self, error): """add(SBMLErrorLog self, SBMLError error)""" return _libsbml.SBMLErrorLog_add(self, error) def remove(self, errorId): """ remove(SBMLErrorLog self, unsigned int const errorId) Removes an error having errorId from the SBMLError list. Only the first item will be removed if there are multiple errors with the given errorId. Parameter 'errorId' is the error identifier of the error to be removed. """ return _libsbml.SBMLErrorLog_remove(self, errorId) def removeAll(self, errorId): """ removeAll(SBMLErrorLog self, unsigned int const errorId) Removes all errors having errorId from the SBMLError list. Parameter 'errorId' is the error identifier of the error to be removed. """ return _libsbml.SBMLErrorLog_removeAll(self, errorId) def contains(self, errorId): """ contains(SBMLErrorLog self, unsigned int const errorId) -> bool Returns 'True' if SBMLErrorLog contains an errorId Parameter 'errorId' is the error identifier of the error to be found. """ return _libsbml.SBMLErrorLog_contains(self, errorId) SBMLErrorLog_swigregister = _libsbml.SBMLErrorLog_swigregister SBMLErrorLog_swigregister(SBMLErrorLog) UnknownError = _libsbml.UnknownError NotUTF8 = _libsbml.NotUTF8 UnrecognizedElement = _libsbml.UnrecognizedElement NotSchemaConformant = _libsbml.NotSchemaConformant L3NotSchemaConformant = _libsbml.L3NotSchemaConformant InvalidMathElement = _libsbml.InvalidMathElement DisallowedMathMLSymbol = _libsbml.DisallowedMathMLSymbol DisallowedMathMLEncodingUse = _libsbml.DisallowedMathMLEncodingUse DisallowedDefinitionURLUse = _libsbml.DisallowedDefinitionURLUse BadCsymbolDefinitionURLValue = _libsbml.BadCsymbolDefinitionURLValue DisallowedMathTypeAttributeUse = _libsbml.DisallowedMathTypeAttributeUse DisallowedMathTypeAttributeValue = _libsbml.DisallowedMathTypeAttributeValue LambdaOnlyAllowedInFunctionDef = _libsbml.LambdaOnlyAllowedInFunctionDef BooleanOpsNeedBooleanArgs = _libsbml.BooleanOpsNeedBooleanArgs NumericOpsNeedNumericArgs = _libsbml.NumericOpsNeedNumericArgs ArgsToEqNeedSameType = _libsbml.ArgsToEqNeedSameType PiecewiseNeedsConsistentTypes = _libsbml.PiecewiseNeedsConsistentTypes PieceNeedsBoolean = _libsbml.PieceNeedsBoolean ApplyCiMustBeUserFunction = _libsbml.ApplyCiMustBeUserFunction ApplyCiMustBeModelComponent = _libsbml.ApplyCiMustBeModelComponent KineticLawParametersAreLocalOnly = _libsbml.KineticLawParametersAreLocalOnly MathResultMustBeNumeric = _libsbml.MathResultMustBeNumeric OpsNeedCorrectNumberOfArgs = _libsbml.OpsNeedCorrectNumberOfArgs InvalidNoArgsPassedToFunctionDef = _libsbml.InvalidNoArgsPassedToFunctionDef DisallowedMathUnitsUse = _libsbml.DisallowedMathUnitsUse InvalidUnitsValue = _libsbml.InvalidUnitsValue CiCannotReference0DCompartment = _libsbml.CiCannotReference0DCompartment RateOfTargetMustBeCi = _libsbml.RateOfTargetMustBeCi RateOfTargetCannotBeAssigned = _libsbml.RateOfTargetCannotBeAssigned RateOfSpeciesTargetCompartmentNot = _libsbml.RateOfSpeciesTargetCompartmentNot DuplicateComponentId = _libsbml.DuplicateComponentId DuplicateUnitDefinitionId = _libsbml.DuplicateUnitDefinitionId DuplicateLocalParameterId = _libsbml.DuplicateLocalParameterId MultipleAssignmentOrRateRules = _libsbml.MultipleAssignmentOrRateRules MultipleEventAssignmentsForId = _libsbml.MultipleEventAssignmentsForId EventAndAssignmentRuleForId = _libsbml.EventAndAssignmentRuleForId DuplicateMetaId = _libsbml.DuplicateMetaId InvalidSBOTermSyntax = _libsbml.InvalidSBOTermSyntax InvalidMetaidSyntax = _libsbml.InvalidMetaidSyntax InvalidIdSyntax = _libsbml.InvalidIdSyntax InvalidUnitIdSyntax = _libsbml.InvalidUnitIdSyntax InvalidNameSyntax = _libsbml.InvalidNameSyntax DanglingUnitReference = _libsbml.DanglingUnitReference MissingAnnotationNamespace = _libsbml.MissingAnnotationNamespace DuplicateAnnotationNamespaces = _libsbml.DuplicateAnnotationNamespaces SBMLNamespaceInAnnotation = _libsbml.SBMLNamespaceInAnnotation MultipleAnnotations = _libsbml.MultipleAnnotations InconsistentArgUnits = _libsbml.InconsistentArgUnits InconsistentKineticLawUnitsL3 = _libsbml.InconsistentKineticLawUnitsL3 AssignRuleCompartmentMismatch = _libsbml.AssignRuleCompartmentMismatch AssignRuleSpeciesMismatch = _libsbml.AssignRuleSpeciesMismatch AssignRuleParameterMismatch = _libsbml.AssignRuleParameterMismatch AssignRuleStoichiometryMismatch = _libsbml.AssignRuleStoichiometryMismatch InitAssignCompartmenMismatch = _libsbml.InitAssignCompartmenMismatch InitAssignSpeciesMismatch = _libsbml.InitAssignSpeciesMismatch InitAssignParameterMismatch = _libsbml.InitAssignParameterMismatch InitAssignStoichiometryMismatch = _libsbml.InitAssignStoichiometryMismatch RateRuleCompartmentMismatch = _libsbml.RateRuleCompartmentMismatch RateRuleSpeciesMismatch = _libsbml.RateRuleSpeciesMismatch RateRuleParameterMismatch = _libsbml.RateRuleParameterMismatch RateRuleStoichiometryMismatch = _libsbml.RateRuleStoichiometryMismatch KineticLawNotSubstancePerTime = _libsbml.KineticLawNotSubstancePerTime SpeciesInvalidExtentUnits = _libsbml.SpeciesInvalidExtentUnits DelayUnitsNotTime = _libsbml.DelayUnitsNotTime EventAssignCompartmentMismatch = _libsbml.EventAssignCompartmentMismatch EventAssignSpeciesMismatch = _libsbml.EventAssignSpeciesMismatch EventAssignParameterMismatch = _libsbml.EventAssignParameterMismatch EventAssignStoichiometryMismatch = _libsbml.EventAssignStoichiometryMismatch PriorityUnitsNotDimensionless = _libsbml.PriorityUnitsNotDimensionless UpperUnitBound = _libsbml.UpperUnitBound OverdeterminedSystem = _libsbml.OverdeterminedSystem InvalidModelSBOTerm = _libsbml.InvalidModelSBOTerm InvalidFunctionDefSBOTerm = _libsbml.InvalidFunctionDefSBOTerm InvalidParameterSBOTerm = _libsbml.InvalidParameterSBOTerm InvalidInitAssignSBOTerm = _libsbml.InvalidInitAssignSBOTerm InvalidRuleSBOTerm = _libsbml.InvalidRuleSBOTerm InvalidConstraintSBOTerm = _libsbml.InvalidConstraintSBOTerm InvalidReactionSBOTerm = _libsbml.InvalidReactionSBOTerm InvalidSpeciesReferenceSBOTerm = _libsbml.InvalidSpeciesReferenceSBOTerm InvalidKineticLawSBOTerm = _libsbml.InvalidKineticLawSBOTerm InvalidEventSBOTerm = _libsbml.InvalidEventSBOTerm InvalidEventAssignmentSBOTerm = _libsbml.InvalidEventAssignmentSBOTerm InvalidCompartmentSBOTerm = _libsbml.InvalidCompartmentSBOTerm InvalidSpeciesSBOTerm = _libsbml.InvalidSpeciesSBOTerm InvalidCompartmentTypeSBOTerm = _libsbml.InvalidCompartmentTypeSBOTerm InvalidSpeciesTypeSBOTerm = _libsbml.InvalidSpeciesTypeSBOTerm InvalidTriggerSBOTerm = _libsbml.InvalidTriggerSBOTerm InvalidDelaySBOTerm = _libsbml.InvalidDelaySBOTerm InvalidLocalParameterSBOTerm = _libsbml.InvalidLocalParameterSBOTerm InvalidSBMLElementSBOTerm = _libsbml.InvalidSBMLElementSBOTerm NotesNotInXHTMLNamespace = _libsbml.NotesNotInXHTMLNamespace NotesContainsXMLDecl = _libsbml.NotesContainsXMLDecl NotesContainsDOCTYPE = _libsbml.NotesContainsDOCTYPE InvalidNotesContent = _libsbml.InvalidNotesContent OnlyOneNotesElementAllowed = _libsbml.OnlyOneNotesElementAllowed InvalidNamespaceOnSBML = _libsbml.InvalidNamespaceOnSBML MissingOrInconsistentLevel = _libsbml.MissingOrInconsistentLevel MissingOrInconsistentVersion = _libsbml.MissingOrInconsistentVersion PackageNSMustMatch = _libsbml.PackageNSMustMatch LevelPositiveInteger = _libsbml.LevelPositiveInteger VersionPositiveInteger = _libsbml.VersionPositiveInteger AllowedAttributesOnSBML = _libsbml.AllowedAttributesOnSBML L3PackageOnLowerSBML = _libsbml.L3PackageOnLowerSBML MissingModel = _libsbml.MissingModel IncorrectOrderInModel = _libsbml.IncorrectOrderInModel EmptyListElement = _libsbml.EmptyListElement NeedCompartmentIfHaveSpecies = _libsbml.NeedCompartmentIfHaveSpecies OneOfEachListOf = _libsbml.OneOfEachListOf OnlyFuncDefsInListOfFuncDefs = _libsbml.OnlyFuncDefsInListOfFuncDefs OnlyUnitDefsInListOfUnitDefs = _libsbml.OnlyUnitDefsInListOfUnitDefs OnlyCompartmentsInListOfCompartments = _libsbml.OnlyCompartmentsInListOfCompartments OnlySpeciesInListOfSpecies = _libsbml.OnlySpeciesInListOfSpecies OnlyParametersInListOfParameters = _libsbml.OnlyParametersInListOfParameters OnlyInitAssignsInListOfInitAssigns = _libsbml.OnlyInitAssignsInListOfInitAssigns OnlyRulesInListOfRules = _libsbml.OnlyRulesInListOfRules OnlyConstraintsInListOfConstraints = _libsbml.OnlyConstraintsInListOfConstraints OnlyReactionsInListOfReactions = _libsbml.OnlyReactionsInListOfReactions OnlyEventsInListOfEvents = _libsbml.OnlyEventsInListOfEvents L3ConversionFactorOnModel = _libsbml.L3ConversionFactorOnModel L3TimeUnitsOnModel = _libsbml.L3TimeUnitsOnModel L3VolumeUnitsOnModel = _libsbml.L3VolumeUnitsOnModel L3AreaUnitsOnModel = _libsbml.L3AreaUnitsOnModel L3LengthUnitsOnModel = _libsbml.L3LengthUnitsOnModel L3ExtentUnitsOnModel = _libsbml.L3ExtentUnitsOnModel AllowedAttributesOnModel = _libsbml.AllowedAttributesOnModel AllowedAttributesOnListOfFuncs = _libsbml.AllowedAttributesOnListOfFuncs AllowedAttributesOnListOfUnitDefs = _libsbml.AllowedAttributesOnListOfUnitDefs AllowedAttributesOnListOfComps = _libsbml.AllowedAttributesOnListOfComps AllowedAttributesOnListOfSpecies = _libsbml.AllowedAttributesOnListOfSpecies AllowedAttributesOnListOfParams = _libsbml.AllowedAttributesOnListOfParams AllowedAttributesOnListOfInitAssign = _libsbml.AllowedAttributesOnListOfInitAssign AllowedAttributesOnListOfRules = _libsbml.AllowedAttributesOnListOfRules AllowedAttributesOnListOfConstraints = _libsbml.AllowedAttributesOnListOfConstraints AllowedAttributesOnListOfReactions = _libsbml.AllowedAttributesOnListOfReactions AllowedAttributesOnListOfEvents = _libsbml.AllowedAttributesOnListOfEvents L3V2SubstanceUnitsOnModel = _libsbml.L3V2SubstanceUnitsOnModel FunctionDefMathNotLambda = _libsbml.FunctionDefMathNotLambda InvalidApplyCiInLambda = _libsbml.InvalidApplyCiInLambda RecursiveFunctionDefinition = _libsbml.RecursiveFunctionDefinition InvalidCiInLambda = _libsbml.InvalidCiInLambda InvalidFunctionDefReturnType = _libsbml.InvalidFunctionDefReturnType OneMathElementPerFunc = _libsbml.OneMathElementPerFunc AllowedAttributesOnFunc = _libsbml.AllowedAttributesOnFunc InvalidUnitDefId = _libsbml.InvalidUnitDefId InvalidSubstanceRedefinition = _libsbml.InvalidSubstanceRedefinition InvalidLengthRedefinition = _libsbml.InvalidLengthRedefinition InvalidAreaRedefinition = _libsbml.InvalidAreaRedefinition InvalidTimeRedefinition = _libsbml.InvalidTimeRedefinition InvalidVolumeRedefinition = _libsbml.InvalidVolumeRedefinition VolumeLitreDefExponentNotOne = _libsbml.VolumeLitreDefExponentNotOne VolumeMetreDefExponentNot3 = _libsbml.VolumeMetreDefExponentNot3 EmptyListOfUnits = _libsbml.EmptyListOfUnits InvalidUnitKind = _libsbml.InvalidUnitKind OffsetNoLongerValid = _libsbml.OffsetNoLongerValid CelsiusNoLongerValid = _libsbml.CelsiusNoLongerValid EmptyUnitListElement = _libsbml.EmptyUnitListElement OneListOfUnitsPerUnitDef = _libsbml.OneListOfUnitsPerUnitDef OnlyUnitsInListOfUnits = _libsbml.OnlyUnitsInListOfUnits AllowedAttributesOnUnitDefinition = _libsbml.AllowedAttributesOnUnitDefinition AllowedAttributesOnListOfUnits = _libsbml.AllowedAttributesOnListOfUnits AllowedAttributesOnUnit = _libsbml.AllowedAttributesOnUnit ZeroDimensionalCompartmentSize = _libsbml.ZeroDimensionalCompartmentSize ZeroDimensionalCompartmentUnits = _libsbml.ZeroDimensionalCompartmentUnits ZeroDimensionalCompartmentConst = _libsbml.ZeroDimensionalCompartmentConst UndefinedOutsideCompartment = _libsbml.UndefinedOutsideCompartment RecursiveCompartmentContainment = _libsbml.RecursiveCompartmentContainment ZeroDCompartmentContainment = _libsbml.ZeroDCompartmentContainment Invalid1DCompartmentUnits = _libsbml.Invalid1DCompartmentUnits Invalid2DCompartmentUnits = _libsbml.Invalid2DCompartmentUnits Invalid3DCompartmentUnits = _libsbml.Invalid3DCompartmentUnits InvalidCompartmentTypeRef = _libsbml.InvalidCompartmentTypeRef OneDimensionalCompartmentUnits = _libsbml.OneDimensionalCompartmentUnits TwoDimensionalCompartmentUnits = _libsbml.TwoDimensionalCompartmentUnits ThreeDimensionalCompartmentUnits = _libsbml.ThreeDimensionalCompartmentUnits AllowedAttributesOnCompartment = _libsbml.AllowedAttributesOnCompartment NoUnitsOnCompartment = _libsbml.NoUnitsOnCompartment InvalidSpeciesCompartmentRef = _libsbml.InvalidSpeciesCompartmentRef HasOnlySubsNoSpatialUnits = _libsbml.HasOnlySubsNoSpatialUnits NoSpatialUnitsInZeroD = _libsbml.NoSpatialUnitsInZeroD NoConcentrationInZeroD = _libsbml.NoConcentrationInZeroD SpatialUnitsInOneD = _libsbml.SpatialUnitsInOneD SpatialUnitsInTwoD = _libsbml.SpatialUnitsInTwoD SpatialUnitsInThreeD = _libsbml.SpatialUnitsInThreeD InvalidSpeciesSusbstanceUnits = _libsbml.InvalidSpeciesSusbstanceUnits BothAmountAndConcentrationSet = _libsbml.BothAmountAndConcentrationSet NonBoundarySpeciesAssignedAndUsed = _libsbml.NonBoundarySpeciesAssignedAndUsed NonConstantSpeciesUsed = _libsbml.NonConstantSpeciesUsed InvalidSpeciesTypeRef = _libsbml.InvalidSpeciesTypeRef MultSpeciesSameTypeInCompartment = _libsbml.MultSpeciesSameTypeInCompartment MissingSpeciesCompartment = _libsbml.MissingSpeciesCompartment SpatialSizeUnitsRemoved = _libsbml.SpatialSizeUnitsRemoved SubstanceUnitsOnSpecies = _libsbml.SubstanceUnitsOnSpecies ConversionFactorOnSpecies = _libsbml.ConversionFactorOnSpecies AllowedAttributesOnSpecies = _libsbml.AllowedAttributesOnSpecies InvalidParameterUnits = _libsbml.InvalidParameterUnits ParameterUnits = _libsbml.ParameterUnits ConversionFactorMustConstant = _libsbml.ConversionFactorMustConstant AllowedAttributesOnParameter = _libsbml.AllowedAttributesOnParameter InvalidInitAssignSymbol = _libsbml.InvalidInitAssignSymbol MultipleInitAssignments = _libsbml.MultipleInitAssignments InitAssignmentAndRuleForSameId = _libsbml.InitAssignmentAndRuleForSameId OneMathElementPerInitialAssign = _libsbml.OneMathElementPerInitialAssign AllowedAttributesOnInitialAssign = _libsbml.AllowedAttributesOnInitialAssign InitAssignmentCannotRef0DComp = _libsbml.InitAssignmentCannotRef0DComp InvalidAssignRuleVariable = _libsbml.InvalidAssignRuleVariable InvalidRateRuleVariable = _libsbml.InvalidRateRuleVariable AssignmentToConstantEntity = _libsbml.AssignmentToConstantEntity RateRuleForConstantEntity = _libsbml.RateRuleForConstantEntity RepeatedRule10304 = _libsbml.RepeatedRule10304 CircularRuleDependency = _libsbml.CircularRuleDependency OneMathElementPerRule = _libsbml.OneMathElementPerRule AllowedAttributesOnAssignRule = _libsbml.AllowedAttributesOnAssignRule AllowedAttributesOnRateRule = _libsbml.AllowedAttributesOnRateRule AllowedAttributesOnAlgRule = _libsbml.AllowedAttributesOnAlgRule RuleCannotRef0DComp = _libsbml.RuleCannotRef0DComp CircularDependencyRateOf = _libsbml.CircularDependencyRateOf ConstraintMathNotBoolean = _libsbml.ConstraintMathNotBoolean IncorrectOrderInConstraint = _libsbml.IncorrectOrderInConstraint ConstraintNotInXHTMLNamespace = _libsbml.ConstraintNotInXHTMLNamespace ConstraintContainsXMLDecl = _libsbml.ConstraintContainsXMLDecl ConstraintContainsDOCTYPE = _libsbml.ConstraintContainsDOCTYPE InvalidConstraintContent = _libsbml.InvalidConstraintContent OneMathElementPerConstraint = _libsbml.OneMathElementPerConstraint OneMessageElementPerConstraint = _libsbml.OneMessageElementPerConstraint AllowedAttributesOnConstraint = _libsbml.AllowedAttributesOnConstraint NoReactantsOrProducts = _libsbml.NoReactantsOrProducts IncorrectOrderInReaction = _libsbml.IncorrectOrderInReaction EmptyListInReaction = _libsbml.EmptyListInReaction InvalidReactantsProductsList = _libsbml.InvalidReactantsProductsList InvalidModifiersList = _libsbml.InvalidModifiersList OneSubElementPerReaction = _libsbml.OneSubElementPerReaction CompartmentOnReaction = _libsbml.CompartmentOnReaction AllowedAttributesOnReaction = _libsbml.AllowedAttributesOnReaction InvalidSpeciesReference = _libsbml.InvalidSpeciesReference RepeatedRule20611 = _libsbml.RepeatedRule20611 BothStoichiometryAndMath = _libsbml.BothStoichiometryAndMath AllowedAttributesOnSpeciesReference = _libsbml.AllowedAttributesOnSpeciesReference AllowedAttributesOnModifier = _libsbml.AllowedAttributesOnModifier UndeclaredSpeciesRef = _libsbml.UndeclaredSpeciesRef IncorrectOrderInKineticLaw = _libsbml.IncorrectOrderInKineticLaw EmptyListInKineticLaw = _libsbml.EmptyListInKineticLaw NonConstantLocalParameter = _libsbml.NonConstantLocalParameter SubsUnitsNoLongerValid = _libsbml.SubsUnitsNoLongerValid TimeUnitsNoLongerValid = _libsbml.TimeUnitsNoLongerValid OneListOfPerKineticLaw = _libsbml.OneListOfPerKineticLaw OnlyLocalParamsInListOfLocalParams = _libsbml.OnlyLocalParamsInListOfLocalParams AllowedAttributesOnListOfLocalParam = _libsbml.AllowedAttributesOnListOfLocalParam OneMathPerKineticLaw = _libsbml.OneMathPerKineticLaw UndeclaredSpeciesInStoichMath = _libsbml.UndeclaredSpeciesInStoichMath AllowedAttributesOnKineticLaw = _libsbml.AllowedAttributesOnKineticLaw AllowedAttributesOnListOfSpeciesRef = _libsbml.AllowedAttributesOnListOfSpeciesRef AllowedAttributesOnListOfMods = _libsbml.AllowedAttributesOnListOfMods L3V2FastDeprecated = _libsbml.L3V2FastDeprecated AllowedAttributesOnLocalParameter = _libsbml.AllowedAttributesOnLocalParameter LocalParameterShadowsSpecies = _libsbml.LocalParameterShadowsSpecies MissingTriggerInEvent = _libsbml.MissingTriggerInEvent TriggerMathNotBoolean = _libsbml.TriggerMathNotBoolean MissingEventAssignment = _libsbml.MissingEventAssignment TimeUnitsEvent = _libsbml.TimeUnitsEvent IncorrectOrderInEvent = _libsbml.IncorrectOrderInEvent ValuesFromTriggerTimeNeedDelay = _libsbml.ValuesFromTriggerTimeNeedDelay DelayNeedsValuesFromTriggerTime = _libsbml.DelayNeedsValuesFromTriggerTime OneMathPerTrigger = _libsbml.OneMathPerTrigger OneMathPerDelay = _libsbml.OneMathPerDelay InvalidEventAssignmentVariable = _libsbml.InvalidEventAssignmentVariable EventAssignmentForConstantEntity = _libsbml.EventAssignmentForConstantEntity OneMathPerEventAssignment = _libsbml.OneMathPerEventAssignment AllowedAttributesOnEventAssignment = _libsbml.AllowedAttributesOnEventAssignment OnlyOneDelayPerEvent = _libsbml.OnlyOneDelayPerEvent OneListOfEventAssignmentsPerEvent = _libsbml.OneListOfEventAssignmentsPerEvent OnlyEventAssignInListOfEventAssign = _libsbml.OnlyEventAssignInListOfEventAssign AllowedAttributesOnListOfEventAssign = _libsbml.AllowedAttributesOnListOfEventAssign AllowedAttributesOnEvent = _libsbml.AllowedAttributesOnEvent AllowedAttributesOnTrigger = _libsbml.AllowedAttributesOnTrigger AllowedAttributesOnDelay = _libsbml.AllowedAttributesOnDelay PersistentNotBoolean = _libsbml.PersistentNotBoolean InitialValueNotBoolean = _libsbml.InitialValueNotBoolean OnlyOnePriorityPerEvent = _libsbml.OnlyOnePriorityPerEvent OneMathPerPriority = _libsbml.OneMathPerPriority AllowedAttributesOnPriority = _libsbml.AllowedAttributesOnPriority GeneralWarningNotSpecified = _libsbml.GeneralWarningNotSpecified CompartmentShouldHaveSize = _libsbml.CompartmentShouldHaveSize SpeciesShouldHaveValue = _libsbml.SpeciesShouldHaveValue ParameterShouldHaveUnits = _libsbml.ParameterShouldHaveUnits ParameterShouldHaveValue = _libsbml.ParameterShouldHaveValue LocalParameterShadowsId = _libsbml.LocalParameterShadowsId LibSBMLAdditionalCodesLowerBound = _libsbml.LibSBMLAdditionalCodesLowerBound CannotConvertToL1V1 = _libsbml.CannotConvertToL1V1 NoEventsInL1 = _libsbml.NoEventsInL1 NoFunctionDefinitionsInL1 = _libsbml.NoFunctionDefinitionsInL1 NoConstraintsInL1 = _libsbml.NoConstraintsInL1 NoInitialAssignmentsInL1 = _libsbml.NoInitialAssignmentsInL1 NoSpeciesTypesInL1 = _libsbml.NoSpeciesTypesInL1 NoCompartmentTypeInL1 = _libsbml.NoCompartmentTypeInL1 NoNon3DCompartmentsInL1 = _libsbml.NoNon3DCompartmentsInL1 NoFancyStoichiometryMathInL1 = _libsbml.NoFancyStoichiometryMathInL1 NoNonIntegerStoichiometryInL1 = _libsbml.NoNonIntegerStoichiometryInL1 NoUnitMultipliersOrOffsetsInL1 = _libsbml.NoUnitMultipliersOrOffsetsInL1 SpeciesCompartmentRequiredInL1 = _libsbml.SpeciesCompartmentRequiredInL1 NoSpeciesSpatialSizeUnitsInL1 = _libsbml.NoSpeciesSpatialSizeUnitsInL1 NoSBOTermsInL1 = _libsbml.NoSBOTermsInL1 StrictUnitsRequiredInL1 = _libsbml.StrictUnitsRequiredInL1 ConversionFactorNotInL1 = _libsbml.ConversionFactorNotInL1 CompartmentNotOnL1Reaction = _libsbml.CompartmentNotOnL1Reaction ExtentUnitsNotSubstance = _libsbml.ExtentUnitsNotSubstance GlobalUnitsNotDeclared = _libsbml.GlobalUnitsNotDeclared HasOnlySubstanceUnitsNotinL1 = _libsbml.HasOnlySubstanceUnitsNotinL1 AvogadroNotSupported = _libsbml.AvogadroNotSupported NoConstraintsInL2v1 = _libsbml.NoConstraintsInL2v1 NoInitialAssignmentsInL2v1 = _libsbml.NoInitialAssignmentsInL2v1 NoSpeciesTypeInL2v1 = _libsbml.NoSpeciesTypeInL2v1 NoCompartmentTypeInL2v1 = _libsbml.NoCompartmentTypeInL2v1 NoSBOTermsInL2v1 = _libsbml.NoSBOTermsInL2v1 NoIdOnSpeciesReferenceInL2v1 = _libsbml.NoIdOnSpeciesReferenceInL2v1 NoDelayedEventAssignmentInL2v1 = _libsbml.NoDelayedEventAssignmentInL2v1 StrictUnitsRequiredInL2v1 = _libsbml.StrictUnitsRequiredInL2v1 IntegerSpatialDimensions = _libsbml.IntegerSpatialDimensions StoichiometryMathNotYetSupported = _libsbml.StoichiometryMathNotYetSupported PriorityLostFromL3 = _libsbml.PriorityLostFromL3 NonPersistentNotSupported = _libsbml.NonPersistentNotSupported InitialValueFalseEventNotSupported = _libsbml.InitialValueFalseEventNotSupported SBOTermNotUniversalInL2v2 = _libsbml.SBOTermNotUniversalInL2v2 NoUnitOffsetInL2v2 = _libsbml.NoUnitOffsetInL2v2 NoKineticLawTimeUnitsInL2v2 = _libsbml.NoKineticLawTimeUnitsInL2v2 NoKineticLawSubstanceUnitsInL2v2 = _libsbml.NoKineticLawSubstanceUnitsInL2v2 NoDelayedEventAssignmentInL2v2 = _libsbml.NoDelayedEventAssignmentInL2v2 ModelSBOBranchChangedBeyondL2v2 = _libsbml.ModelSBOBranchChangedBeyondL2v2 StrictUnitsRequiredInL2v2 = _libsbml.StrictUnitsRequiredInL2v2 StrictSBORequiredInL2v2 = _libsbml.StrictSBORequiredInL2v2 DuplicateAnnotationInvalidInL2v2 = _libsbml.DuplicateAnnotationInvalidInL2v2 NoUnitOffsetInL2v3 = _libsbml.NoUnitOffsetInL2v3 NoKineticLawTimeUnitsInL2v3 = _libsbml.NoKineticLawTimeUnitsInL2v3 NoKineticLawSubstanceUnitsInL2v3 = _libsbml.NoKineticLawSubstanceUnitsInL2v3 NoSpeciesSpatialSizeUnitsInL2v3 = _libsbml.NoSpeciesSpatialSizeUnitsInL2v3 NoEventTimeUnitsInL2v3 = _libsbml.NoEventTimeUnitsInL2v3 NoDelayedEventAssignmentInL2v3 = _libsbml.NoDelayedEventAssignmentInL2v3 ModelSBOBranchChangedBeyondL2v3 = _libsbml.ModelSBOBranchChangedBeyondL2v3 StrictUnitsRequiredInL2v3 = _libsbml.StrictUnitsRequiredInL2v3 StrictSBORequiredInL2v3 = _libsbml.StrictSBORequiredInL2v3 DuplicateAnnotationInvalidInL2v3 = _libsbml.DuplicateAnnotationInvalidInL2v3 NoUnitOffsetInL2v4 = _libsbml.NoUnitOffsetInL2v4 NoKineticLawTimeUnitsInL2v4 = _libsbml.NoKineticLawTimeUnitsInL2v4 NoKineticLawSubstanceUnitsInL2v4 = _libsbml.NoKineticLawSubstanceUnitsInL2v4 NoSpeciesSpatialSizeUnitsInL2v4 = _libsbml.NoSpeciesSpatialSizeUnitsInL2v4 NoEventTimeUnitsInL2v4 = _libsbml.NoEventTimeUnitsInL2v4 ModelSBOBranchChangedInL2v4 = _libsbml.ModelSBOBranchChangedInL2v4 DuplicateAnnotationInvalidInL2v4 = _libsbml.DuplicateAnnotationInvalidInL2v4 NoSpeciesTypeInL3v1 = _libsbml.NoSpeciesTypeInL3v1 NoCompartmentTypeInL3v1 = _libsbml.NoCompartmentTypeInL3v1 NoUnitOffsetInL3v1 = _libsbml.NoUnitOffsetInL3v1 NoKineticLawTimeUnitsInL3v1 = _libsbml.NoKineticLawTimeUnitsInL3v1 NoKineticLawSubstanceUnitsInL3v1 = _libsbml.NoKineticLawSubstanceUnitsInL3v1 NoSpeciesSpatialSizeUnitsInL3v1 = _libsbml.NoSpeciesSpatialSizeUnitsInL3v1 NoEventTimeUnitsInL3v1 = _libsbml.NoEventTimeUnitsInL3v1 ModelSBOBranchChangedInL3v1 = _libsbml.ModelSBOBranchChangedInL3v1 DuplicateAnnotationInvalidInL3v1 = _libsbml.DuplicateAnnotationInvalidInL3v1 NoCompartmentOutsideInL3v1 = _libsbml.NoCompartmentOutsideInL3v1 NoStoichiometryMathInL3v1 = _libsbml.NoStoichiometryMathInL3v1 DoubleExponentNotSupported = _libsbml.DoubleExponentNotSupported MathMLElementNotSupported = _libsbml.MathMLElementNotSupported EmptyListOfElementNotSupported = _libsbml.EmptyListOfElementNotSupported MissingMathElementNotSupported = _libsbml.MissingMathElementNotSupported MissingTriggerElementNotSupported = _libsbml.MissingTriggerElementNotSupported BooleanNumericDiscrepancy = _libsbml.BooleanNumericDiscrepancy IdNameSBaseInL3V2 = _libsbml.IdNameSBaseInL3V2 MissingParticipantsNotSupported = _libsbml.MissingParticipantsNotSupported ConvertibleMathInitialAssignment = _libsbml.ConvertibleMathInitialAssignment FastReactionsNotSupported = _libsbml.FastReactionsNotSupported SpeciesRefIdInMathMLNotSupported = _libsbml.SpeciesRefIdInMathMLNotSupported InvalidSBMLLevelVersion = _libsbml.InvalidSBMLLevelVersion InvalidPackageLevelVersion = _libsbml.InvalidPackageLevelVersion AnnotationNotesNotAllowedLevel1 = _libsbml.AnnotationNotesNotAllowedLevel1 InvalidRuleOrdering = _libsbml.InvalidRuleOrdering RequiredPackagePresent = _libsbml.RequiredPackagePresent UnrequiredPackagePresent = _libsbml.UnrequiredPackagePresent PackageRequiredShouldBeFalse = _libsbml.PackageRequiredShouldBeFalse SubsUnitsAllowedInKL = _libsbml.SubsUnitsAllowedInKL TimeUnitsAllowedInKL = _libsbml.TimeUnitsAllowedInKL FormulaInLevel1KL = _libsbml.FormulaInLevel1KL L3SubstanceUnitsOnModel = _libsbml.L3SubstanceUnitsOnModel StoichiometryMathMissingMath = _libsbml.StoichiometryMathMissingMath TimeUnitsRemoved = _libsbml.TimeUnitsRemoved BadMathML = _libsbml.BadMathML FailedMathMLReadOfDouble = _libsbml.FailedMathMLReadOfDouble FailedMathMLReadOfInteger = _libsbml.FailedMathMLReadOfInteger FailedMathMLReadOfExponential = _libsbml.FailedMathMLReadOfExponential FailedMathMLReadOfRational = _libsbml.FailedMathMLReadOfRational BadMathMLNodeType = _libsbml.BadMathMLNodeType InvalidMathMLAttribute = _libsbml.InvalidMathMLAttribute NoTimeSymbolInFunctionDef = _libsbml.NoTimeSymbolInFunctionDef NoBodyInFunctionDef = _libsbml.NoBodyInFunctionDef DanglingUnitSIdRef = _libsbml.DanglingUnitSIdRef RDFMissingAboutTag = _libsbml.RDFMissingAboutTag RDFEmptyAboutTag = _libsbml.RDFEmptyAboutTag RDFAboutTagNotMetaid = _libsbml.RDFAboutTagNotMetaid RDFNotCompleteModelHistory = _libsbml.RDFNotCompleteModelHistory RDFNotModelHistory = _libsbml.RDFNotModelHistory AnnotationNotElement = _libsbml.AnnotationNotElement NestedAnnotationNotAllowed = _libsbml.NestedAnnotationNotAllowed InconsistentArgUnitsWarnings = _libsbml.InconsistentArgUnitsWarnings InconsistentPowerUnitsWarnings = _libsbml.InconsistentPowerUnitsWarnings InconsistentExponUnitsWarnings = _libsbml.InconsistentExponUnitsWarnings UndeclaredUnits = _libsbml.UndeclaredUnits UndeclaredTimeUnitsL3 = _libsbml.UndeclaredTimeUnitsL3 UndeclaredExtentUnitsL3 = _libsbml.UndeclaredExtentUnitsL3 UndeclaredObjectUnitsL3 = _libsbml.UndeclaredObjectUnitsL3 CannotVerifyUnitsObjectNoMath = _libsbml.CannotVerifyUnitsObjectNoMath UnrecognisedSBOTerm = _libsbml.UnrecognisedSBOTerm ObseleteSBOTerm = _libsbml.ObseleteSBOTerm IncorrectCompartmentSpatialDimensions = _libsbml.IncorrectCompartmentSpatialDimensions CompartmentTypeNotValidAttribute = _libsbml.CompartmentTypeNotValidAttribute ConstantNotValidAttribute = _libsbml.ConstantNotValidAttribute MetaIdNotValidAttribute = _libsbml.MetaIdNotValidAttribute SBOTermNotValidAttributeBeforeL2V3 = _libsbml.SBOTermNotValidAttributeBeforeL2V3 InvalidL1CompartmentUnits = _libsbml.InvalidL1CompartmentUnits L1V1CompartmentVolumeReqd = _libsbml.L1V1CompartmentVolumeReqd CompartmentTypeNotValidComponent = _libsbml.CompartmentTypeNotValidComponent ConstraintNotValidComponent = _libsbml.ConstraintNotValidComponent EventNotValidComponent = _libsbml.EventNotValidComponent SBOTermNotValidAttributeBeforeL2V2 = _libsbml.SBOTermNotValidAttributeBeforeL2V2 FuncDefNotValidComponent = _libsbml.FuncDefNotValidComponent InitialAssignNotValidComponent = _libsbml.InitialAssignNotValidComponent VariableNotValidAttribute = _libsbml.VariableNotValidAttribute UnitsNotValidAttribute = _libsbml.UnitsNotValidAttribute ConstantSpeciesNotValidAttribute = _libsbml.ConstantSpeciesNotValidAttribute SpatialSizeUnitsNotValidAttribute = _libsbml.SpatialSizeUnitsNotValidAttribute SpeciesTypeNotValidAttribute = _libsbml.SpeciesTypeNotValidAttribute HasOnlySubsUnitsNotValidAttribute = _libsbml.HasOnlySubsUnitsNotValidAttribute IdNotValidAttribute = _libsbml.IdNotValidAttribute NameNotValidAttribute = _libsbml.NameNotValidAttribute SpeciesTypeNotValidComponent = _libsbml.SpeciesTypeNotValidComponent StoichiometryMathNotValidComponent = _libsbml.StoichiometryMathNotValidComponent MultiplierNotValidAttribute = _libsbml.MultiplierNotValidAttribute OffsetNotValidAttribute = _libsbml.OffsetNotValidAttribute L3SpatialDimensionsUnset = _libsbml.L3SpatialDimensionsUnset UnknownCoreAttribute = _libsbml.UnknownCoreAttribute UnknownPackageAttribute = _libsbml.UnknownPackageAttribute PackageConversionNotSupported = _libsbml.PackageConversionNotSupported InvalidTargetLevelVersion = _libsbml.InvalidTargetLevelVersion L3NotSupported = _libsbml.L3NotSupported SBMLCodesUpperBound = _libsbml.SBMLCodesUpperBound LIBSBML_CAT_SBML = _libsbml.LIBSBML_CAT_SBML LIBSBML_CAT_SBML_L1_COMPAT = _libsbml.LIBSBML_CAT_SBML_L1_COMPAT LIBSBML_CAT_SBML_L2V1_COMPAT = _libsbml.LIBSBML_CAT_SBML_L2V1_COMPAT LIBSBML_CAT_SBML_L2V2_COMPAT = _libsbml.LIBSBML_CAT_SBML_L2V2_COMPAT LIBSBML_CAT_GENERAL_CONSISTENCY = _libsbml.LIBSBML_CAT_GENERAL_CONSISTENCY LIBSBML_CAT_IDENTIFIER_CONSISTENCY = _libsbml.LIBSBML_CAT_IDENTIFIER_CONSISTENCY LIBSBML_CAT_UNITS_CONSISTENCY = _libsbml.LIBSBML_CAT_UNITS_CONSISTENCY LIBSBML_CAT_MATHML_CONSISTENCY = _libsbml.LIBSBML_CAT_MATHML_CONSISTENCY LIBSBML_CAT_SBO_CONSISTENCY = _libsbml.LIBSBML_CAT_SBO_CONSISTENCY LIBSBML_CAT_OVERDETERMINED_MODEL = _libsbml.LIBSBML_CAT_OVERDETERMINED_MODEL LIBSBML_CAT_SBML_L2V3_COMPAT = _libsbml.LIBSBML_CAT_SBML_L2V3_COMPAT LIBSBML_CAT_MODELING_PRACTICE = _libsbml.LIBSBML_CAT_MODELING_PRACTICE LIBSBML_CAT_INTERNAL_CONSISTENCY = _libsbml.LIBSBML_CAT_INTERNAL_CONSISTENCY LIBSBML_CAT_SBML_L2V4_COMPAT = _libsbml.LIBSBML_CAT_SBML_L2V4_COMPAT LIBSBML_CAT_SBML_L3V1_COMPAT = _libsbml.LIBSBML_CAT_SBML_L3V1_COMPAT LIBSBML_CAT_SBML_L3V2_COMPAT = _libsbml.LIBSBML_CAT_SBML_L3V2_COMPAT LIBSBML_CAT_SBML_COMPATIBILITY = _libsbml.LIBSBML_CAT_SBML_COMPATIBILITY LIBSBML_SEV_SCHEMA_ERROR = _libsbml.LIBSBML_SEV_SCHEMA_ERROR LIBSBML_SEV_GENERAL_WARNING = _libsbml.LIBSBML_SEV_GENERAL_WARNING LIBSBML_SEV_NOT_APPLICABLE = _libsbml.LIBSBML_SEV_NOT_APPLICABLE class SBMLError(XMLError): """ An error, warning or other diagnostic. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. When a libSBML operation on SBML content results in an error, or when there is something wrong with the SBML content, the problems are reported as SBMLError objects. These are generally stored in an SBMLErrorLog object; this log object, in turn, is kept in the SBMLDocument object containing the SBML content. Applications can obtain the list of logged errors using SBMLDocument.getErrorLog() and then use the methods provided by SBMLErrorLog to access individual SBMLError objects. (Note that despite the word 'error' in the name, SBMLError objects are used to represent not only 'true' errors, but also warnings and some informational diagnostics. The name is a historical hold-over from early versions of libSBML, in which the object really was only used to report errors.) Each SBMLError object instance has an identification number that identifies the nature of the problem. This 'error id' number will be up to five digits long, and it will come from one of two sets of static integer constants defined in the interface class libsbml: either the SBML error identifiers (described below) or the XML error identifiers (described in the documentation for the class XMLError). The former set of constants includes all the SBML validation rule numbers listed in the appendices of the SBML specification documents, as well as some additional libSBML-specific error codes. Error codes are useful mainly for software. For human readers, SBMLError also includes text messages that describe the nature of a given problem. The messages can be accessed using SBMLError.getShortMessage() and SBMLError.getMessage(). The former provides a brief one-line description of the issue, while SBMLError.getMessage() provides a more detailed text, including (if appropriate) references to sections of the SBML specifications where relevant topics are discussed. These text strings are suitable for displaying to human users. An SBMLError object also contains a category code; its value may be retrieved using the method SBMLError.getCategory(). Category values are drawn from a set of static integer constants defined in libsbml and having names beginning with the characters LIBSBML_CAT_. The list of possible codes is described in a separate section below. Categories are used to partition errors into distinct conceptual groups. This is principally used by the libSBML validation system to group classes of validation checks. For example, LIBSBML_CAT_IDENTIFIER_CONSISTENCY is the category for tests that check identifier consistency; LIBSBML_CAT_MATHML_CONSISTENCY is the category for MathML consistency checking; and so on. In addition, SBMLError also has a severity code. Its value may be retrieved using the method SBMLError.getSeverity(). The possible severity values are the same as those reported by XMLError. Severity levels currently range from informational (LIBSBML_SEV_INFO) to fatal errors (LIBSBML_SEV_FATAL). They can be used by an application to evaluate how serious a given problem is. SBMLError also tracks the Level 3 package extension, if any, was responsible for a given warning or error. Each diagnostic code logged by an libSBML extension for SBML Level 3 packages includes a record of the package that logged it. It can be retrieved using SBMLError.getPackage(). The information is a simple text string; the string will be the nickname of the package, such as ''comp'' for the Hierarchical Model Composition package, ''fbc'' for the Flux Balance Constraints package, and so on. If the value returned by SBMLError.getPackage() is an empty string or has the value ''core',' then the error came from libSBML core. Finally, SBMLError records the line and column near where the problem occurred in the SBML content. The values may be retrieved using the methods SBMLError.getLine() and SBMLError.getColumn(). We say 'near', because a lot of factors affect how accurate the line/column information ultimately is. For example, different XML parsers have different conventions for which line and column number they report for a particular problem (which makes a difference when a problem involves an opening XML tag on one line and a closing tag on another line). In some situations, some parsers report invalid line and/or column numbers altogether. If this occurs, libSBML sets the line and/or column number in the SBMLError object to the the value of the maximum unsigned long integer representable on the platform where libSBML is running. (This is equal to the constant named ULONG_MAX in C and C++.) The probability that a true line or column number in an SBML model would equal this value is vanishingly small; thus, if an application encounters these values in an XMLError object, it can assume no valid line/column number could be provided by libSBML in that situation. Error codes associated with SBMLError objects ...................................................................... The error and warning codes returned by libSBML are listed in the table below. The method SBMLError.getErrorId() returns the error code of a given SBMLError object instance. In the libSBML Python language interface, these error identifiers are currently implemented as static integer constants defined in the interface class libsbml. In this table, the right-hand columns titled 'L1V1', 'L1V2', etc. refer to Levels and Versions of the SBML specifications, and the entries in each column refer to whether the severity of the condition in that particular Level+Version of SBML. The codes stand for the following: = Not applicable = Warning = Error = Fatal The text shown in the 'Meaning' is the text returned by the SBMLError.getShortMessage() method on a given SBMLError object. A longer and (hopefully) clearer explanation of the issue is returned by SBMLError.getMessage(). The error codes come from different lists depending on whether they're from libSBML core or from an SBML Level 3 package extension. However, in the language interfaces other than C++, all libSBML error codes are ultimately represented as integer constants rather than separate enumerations lists, and they are all stored in a single interface class. Codes from different libSBML extensions have names that begin with the package's nickname, such as Qual for the Qualitative Models package, Layout for the Layout package, and so on. If the name of a code does not begin with one of the package nicknames (Layout, Fbc, Comp, Qual, etc.), then it is a code from libSBML core. +-------------------------------------------+------------------------------------------------------------------------------------------------------+-------+-------+-------+-------+-------+-------+-------+-------+ | Enumerator | Meaning | L1 V1 | L1 V2 | L2 V1 | L2 V2 | L2 V3 | L2 V4 | L3 V1 | L3 V2 | +-------------------------------------------+------------------------------------------------------------------------------------------------------+-------+-------+-------+-------+-------+-------+-------+-------+ | XMLUnknownError | Unknown error | | | | | | | | | | XMLOutOfMemory | Out of memory | | | | | | | | | | XMLFileUnreadable | File unreadable | | | | | | | | | | XMLFileUnwritable | File unwritable | | | | | | | | | | XMLFileOperationError | File operation error | | | | | | | | | | XMLNetworkAccessError | Network access error | | | | | | | | | | InternalXMLParserError | Internal XML parser error | | | | | | | | | | UnrecognizedXMLParserCode | Unrecognized XML parser code | | | | | | | | | | XMLTranscoderError | Transcoder error | | | | | | | | | | MissingXMLDecl | Missing XML declaration | | | | | | | | | | MissingXMLEncoding | Missing XML encoding attribute | | | | | | | | | | BadXMLDecl | Bad XML declaration | | | | | | | | | | BadXMLDOCTYPE | Bad XML DOCTYPE | | | | | | | | | | InvalidCharInXML | Invalid character | | | | | | | | | | BadlyFormedXML | Badly formed XML | | | | | | | | | | UnclosedXMLToken | Unclosed token | | | | | | | | | | InvalidXMLConstruct | Invalid XML construct | | | | | | | | | | XMLTagMismatch | XML tag mismatch | | | | | | | | | | DuplicateXMLAttribute | Duplicate attribute | | | | | | | | | | UndefinedXMLEntity | Undefined XML entity | | | | | | | | | | BadProcessingInstruction | Bad XML processing instruction | | | | | | | | | | BadXMLPrefix | Bad XML prefix | | | | | | | | | | BadXMLPrefixValue | Bad XML prefix value | | | | | | | | | | MissingXMLRequiredAttribute | Missing required attribute | | | | | | | | | | XMLAttributeTypeMismatch | Attribute type mismatch | | | | | | | | | | XMLBadUTF8Content | Bad UTF8 content | | | | | | | | | | MissingXMLAttributeValue | Missing attribute value | | | | | | | | | | BadXMLAttributeValue | Bad attribute value | | | | | | | | | | BadXMLAttribute | Bad XML attribute | | | | | | | | | | UnrecognizedXMLElement | Unrecognized XML element | | | | | | | | | | BadXMLComment | Bad XML comment | | | | | | | | | | BadXMLDeclLocation | Bad XML declaration location | | | | | | | | | | XMLUnexpectedEOF | Unexpected EOF | | | | | | | | | | BadXMLIDValue | Bad XML ID value | | | | | | | | | | BadXMLIDRef | Bad XML IDREF | | | | | | | | | | UninterpretableXMLContent | Uninterpretable XML content | | | | | | | | | | BadXMLDocumentStructure | Bad XML document structure | | | | | | | | | | InvalidAfterXMLContent | Invalid content after XML content | | | | | | | | | | XMLExpectedQuotedString | Expected quoted string | | | | | | | | | | XMLEmptyValueNotPermitted | Empty value not permitted | | | | | | | | | | XMLBadNumber | Bad number | | | | | | | | | | XMLBadColon | Colon character not permitted | | | | | | | | | | MissingXMLElements | Missing XML elements | | | | | | | | | | XMLContentEmpty | Empty XML content | | | | | | | | | | UnknownError | Encountered unknown internal libSBML error | | | | | | | | | | NotUTF8 | File does not use UTF-8 encoding | | | | | | | | | | UnrecognizedElement | Encountered unrecognized element | | | | | | | | | | NotSchemaConformant | Document does not conform to the SBML XML schema | | | | | | | | | | L3NotSchemaConformant | Document is not well-formed XML | | | | | | | | | | InvalidMathElement | Invalid MathML | | | | | | | | | | DisallowedMathMLSymbol | Disallowed MathML symbol found | | | | | | | | | | DisallowedMathMLEncodingUse | Use of the MathML 'encoding' attribute is not allowed on this element | | | | | | | | | | DisallowedDefinitionURLUse | Use of the MathML 'definitionURL' attribute is not allowed on this element | | | | | | | | | | BadCsymbolDefinitionURLValue | Invalid <csymbol> 'definitionURL' attribute value | | | | | | | | | | DisallowedMathTypeAttributeUse | Use of the MathML 'type' attribute is not allowed on this element | | | | | | | | | | DisallowedMathTypeAttributeValue | Disallowed MathML 'type' attribute value | | | | | | | | | | LambdaOnlyAllowedInFunctionDef | Use of <lambda> not permitted outside of FunctionDefinition objects | | | | | | | | | | BooleanOpsNeedBooleanArgs | Non-Boolean argument given to Boolean operator | | | | | | | | | | NumericOpsNeedNumericArgs | Non-numerical argument given to numerical operator | | | | | | | | | | ArgsToEqNeedSameType | Arguments to <eq> and <neq> must have the same data types | | | | | | | | | | PiecewiseNeedsConsistentTypes | Terms in a <piecewise> expression must have consistent data types | | | | | | | | | | PieceNeedsBoolean | The second argument of a <piece> expression must yield a Boolean value | | | | | | | | | | ApplyCiMustBeUserFunction | A <ci> element in this context must refer to a function definition | | | | | | | | | | ApplyCiMustBeModelComponent | A <ci> element in this context must refer to a model component | | | | | | | | | | KineticLawParametersAreLocalOnly | Cannot use a KineticLaw local parameter outside of its local scope | | | | | | | | | | MathResultMustBeNumeric | A formula's result in this context must be a numerical value | | | | | | | | | | OpsNeedCorrectNumberOfArgs | Incorrect number of arguments given to MathML operator | | | | | | | | | | InvalidNoArgsPassedToFunctionDef | Incorrect number of arguments given to function invocation | | | | | | | | | | DisallowedMathUnitsUse | Attribute 'units' is only permitted on <cn> elements | | | | | | | | | | InvalidUnitsValue | Invalid value given for the 'units' attribute | | | | | | | | | | CiCannotReference0DCompartment | A <ci> element cannot reference a 0D compartment | | | | | | | | | | RateOfTargetMustBeCi | A 'rateOf' <csymbol> must target only a single <ci> element | | | | | | | | | | RateOfTargetCannotBeAssigned | The target of a 'rateOf' <csymbol> cannot be assigned | | | | | | | | | | RateOfSpeciesTargetCompartmentNot | Compartments of non-substance <species> referenced by 'rateOf' must not vary | | | | | | | | | | DuplicateComponentId | Duplicate 'id' attribute value | | | | | | | | | | DuplicateUnitDefinitionId | Duplicate unit definition 'id' attribute value | | | | | | | | | | DuplicateLocalParameterId | Duplicate local parameter 'id' attribute value | | | | | | | | | | MultipleAssignmentOrRateRules | Multiple rules for the same variable are not allowed | | | | | | | | | | MultipleEventAssignmentsForId | Multiple event assignments for the same variable are not allowed | | | | | | | | | | EventAndAssignmentRuleForId | An event assignment and an assignment rule must not have the same value for 'variable' | | | | | | | | | | DuplicateMetaId | Duplicate 'metaid' attribute value | | | | | | | | | | InvalidSBOTermSyntax | Invalid syntax for an 'sboTerm' attribute value | | | | | | | | | | InvalidMetaidSyntax | Invalid syntax for a 'metaid' attribute value | | | | | | | | | | InvalidIdSyntax | Invalid syntax for an 'id' attribute value | | | | | | | | | | InvalidUnitIdSyntax | Invalid syntax for the identifier of a unit | | | | | | | | | | InvalidNameSyntax | Invalid syntax for a 'name' attribute value | | | | | | | | | | DanglingUnitReference | Dangling reference to a unit. | | | | | | | | | | MissingAnnotationNamespace | Missing declaration of the XML namespace for the annotation | | | | | | | | | | DuplicateAnnotationNamespaces | Multiple annotations using the same XML namespace | | | | | | | | | | SBMLNamespaceInAnnotation | The SBML XML namespace cannot be used in an Annotation object | | | | | | | | | | MultipleAnnotations | Only one Annotation object is permitted under a given SBML object | | | | | | | | | | InconsistentArgUnits | The units of the function call's arguments are not consistent with its definition | | | | | | | | | | InconsistentKineticLawUnitsL3 | The kinetic law's units are inconsistent with those of other kinetic laws in the model | | | | | | | | | | AssignRuleCompartmentMismatch | Mismatched units in assignment rule for compartment | | | | | | | | | | AssignRuleSpeciesMismatch | Mismatched units in assignment rule for species | | | | | | | | | | AssignRuleParameterMismatch | Mismatched units in assignment rule for parameter | | | | | | | | | | AssignRuleStoichiometryMismatch | Mismatched units in assignment rule for stoichiometry | | | | | | | | | | InitAssignCompartmenMismatch | Mismatched units in initial assignment to compartment | | | | | | | | | | InitAssignSpeciesMismatch | Mismatched units in initial assignment to species | | | | | | | | | | InitAssignParameterMismatch | Mismatched units in initial assignment to parameter | | | | | | | | | | InitAssignStoichiometryMismatch | Mismatched units in initial assignment to stoichiometry | | | | | | | | | | RateRuleCompartmentMismatch | Mismatched units in rate rule for compartment | | | | | | | | | | RateRuleSpeciesMismatch | Mismatched units in rate rule for species | | | | | | | | | | RateRuleParameterMismatch | Mismatched units in rate rule for parameter | | | | | | | | | | RateRuleStoichiometryMismatch | Mismatched units in rate rule for stoichiometry | | | | | | | | | | KineticLawNotSubstancePerTime | The units of the kinetic law are not 'substance'/'time' | | | | | | | | | | SpeciesInvalidExtentUnits | The species' units are not consistent with units of extent | | | | | | | | | | DelayUnitsNotTime | The units of the delay expression are not units of time | | | | | | | | | | EventAssignCompartmentMismatch | Mismatched units in event assignment for compartment | | | | | | | | | | EventAssignSpeciesMismatch | Mismatched units in event assignment for species | | | | | | | | | | EventAssignParameterMismatch | Mismatched units in event assignment for parameter | | | | | | | | | | EventAssignStoichiometryMismatch | Mismatched units in event assignment for stoichiometry | | | | | | | | | | PriorityUnitsNotDimensionless | The units of a priority expression must be 'dimensionless' | | | | | | | | | | OverdeterminedSystem | The model is overdetermined | | | | | | | | | | InvalidModelSBOTerm | Invalid 'sboTerm' attribute value for a Model object | | | | | | | | | | InvalidFunctionDefSBOTerm | Invalid 'sboTerm' attribute value for a FunctionDefinition object | | | | | | | | | | InvalidParameterSBOTerm | Invalid 'sboTerm' attribute value for a Parameter object | | | | | | | | | | InvalidInitAssignSBOTerm | Invalid 'sboTerm' attribute value for an InitialAssignment object | | | | | | | | | | InvalidRuleSBOTerm | Invalid 'sboTerm' attribute value for a Rule object | | | | | | | | | | InvalidConstraintSBOTerm | Invalid 'sboTerm' attribute value for a Constraint object | | | | | | | | | | InvalidReactionSBOTerm | Invalid 'sboTerm' attribute value for a Reaction object | | | | | | | | | | InvalidSpeciesReferenceSBOTerm | Invalid 'sboTerm' attribute value for a SpeciesReference object | | | | | | | | | | InvalidKineticLawSBOTerm | Invalid 'sboTerm' attribute value for a KineticLaw object | | | | | | | | | | InvalidEventSBOTerm | Invalid 'sboTerm' attribute value for an Event object | | | | | | | | | | InvalidEventAssignmentSBOTerm | Invalid 'sboTerm' attribute value for an EventAssignment object | | | | | | | | | | InvalidCompartmentSBOTerm | Invalid 'sboTerm' attribute value for a Compartment object | | | | | | | | | | InvalidSpeciesSBOTerm | Invalid 'sboTerm' attribute value for a Species object | | | | | | | | | | InvalidCompartmentTypeSBOTerm | Invalid 'sboTerm' attribute value for a CompartmentType object | | | | | | | | | | InvalidSpeciesTypeSBOTerm | Invalid 'sboTerm' attribute value for a SpeciesType object | | | | | | | | | | InvalidTriggerSBOTerm | Invalid 'sboTerm' attribute value for an Event Trigger object | | | | | | | | | | InvalidDelaySBOTerm | Invalid 'sboTerm' attribute value for an Event Delay object | | | | | | | | | | InvalidLocalParameterSBOTerm | Invalid 'sboTerm' attribute value for a LocalParameter object | | | | | | | | | | InvalidSBMLElementSBOTerm | Invalid 'sboTerm' attribute value for the <sbml> element | | | | | | | | | | NotesNotInXHTMLNamespace | Notes must be placed in the XHTML XML namespace | | | | | | | | | | NotesContainsXMLDecl | XML declarations are not permitted in Notes objects | | | | | | | | | | NotesContainsDOCTYPE | XML DOCTYPE elements are not permitted in Notes objects | | | | | | | | | | InvalidNotesContent | Invalid notes content found | | | | | | | | | | OnlyOneNotesElementAllowed | Only one Notes subobject is permitted on a given SBML object | | | | | | | | | | InvalidNamespaceOnSBML | Invalid XML namespace for the SBML container element | | | | | | | | | | MissingOrInconsistentLevel | Missing or inconsistent value for the 'level' attribute | | | | | | | | | | MissingOrInconsistentVersion | Missing or inconsistent value for the 'version' attribute | | | | | | | | | | PackageNSMustMatch | Inconsistent or invalid SBML Level/Version for the package namespace declaration | | | | | | | | | | LevelPositiveInteger | The 'level' attribute must have a positive integer value | | | | | | | | | | VersionPositiveInteger | The 'version' attribute must have a positive integer value | | | | | | | | | | AllowedAttributesOnSBML | Invalid attribute found on the SBML container element | | | | | | | | | | L3PackageOnLowerSBML | An L3 package ns found on the SBML container element | | | | | | | | | | MissingModel | No model definition found | | | | | | | | | | IncorrectOrderInModel | Incorrect ordering of components within the Model object | | | | | | | | | | EmptyListElement | Empty ListOf___ object found | | | | | | | | | | NeedCompartmentIfHaveSpecies | The presence of a species requires a compartment | | | | | | | | | | OneOfEachListOf | Only one of each kind of ListOf___ object is allowed inside a Model object | | | | | | | | | | OnlyFuncDefsInListOfFuncDefs | Only FunctionDefinition, Notes and Annotation objects are allowed in ListOfFunctionDefinitions | | | | | | | | | | OnlyUnitDefsInListOfUnitDefs | Only UnitDefinition, Notes and Annotation objects are allowed in ListOfUnitDefinitions objects | | | | | | | | | | OnlyCompartmentsInListOfCompartments | Only Compartment, Notes and Annotation objects are allowed in ListOfCompartments objects | | | | | | | | | | OnlySpeciesInListOfSpecies | Only Species, Notes and Annotation objects are allowed in ListOfSpecies objects | | | | | | | | | | OnlyParametersInListOfParameters | Only Parameter, Notes and Annotation objects are allowed in ListOfParameters objects | | | | | | | | | | OnlyInitAssignsInListOfInitAssigns | Only InitialAssignment, Notes and Annotation objects are allowed in ListOfInitialAssignments objects | | | | | | | | | | OnlyRulesInListOfRules | Only Rule, Notes and Annotation objects are allowed in ListOfRules objects | | | | | | | | | | OnlyConstraintsInListOfConstraints | Only Constraint, Notes and Annotation objects are allowed in ListOfConstraints objects | | | | | | | | | | OnlyReactionsInListOfReactions | Only Reaction, Notes and Annotation objects are allowed in ListOfReactions objects | | | | | | | | | | OnlyEventsInListOfEvents | Only Event, Notes and Annotation objects are allowed in ListOfEvents objects | | | | | | | | | | L3ConversionFactorOnModel | A 'conversionFactor' attribute value must reference a Parameter object | | | | | | | | | | L3TimeUnitsOnModel | Invalid 'timeUnits' attribute value | | | | | | | | | | L3VolumeUnitsOnModel | Invalid 'volumeUnits' attribute value | | | | | | | | | | L3AreaUnitsOnModel | Invalid 'areaUnits' attribute value | | | | | | | | | | L3LengthUnitsOnModel | Invalid 'lengthUnits' attribute value | | | | | | | | | | L3ExtentUnitsOnModel | Invalid 'extentUnits' attribute value | | | | | | | | | | AllowedAttributesOnModel | Invalid attribute found on the Model object | | | | | | | | | | AllowedAttributesOnListOfFuncs | Invalid attribute found on the ListOfFunctionDefinitions object | | | | | | | | | | AllowedAttributesOnListOfUnitDefs | Invalid attribute found on the ListOfUnitDefinitions object | | | | | | | | | | AllowedAttributesOnListOfComps | Invalid attribute found on the ListOfCompartments object | | | | | | | | | | AllowedAttributesOnListOfSpecies | Invalid attribute found on the ListOfSpecies object | | | | | | | | | | AllowedAttributesOnListOfParams | Invalid attribute found on the ListOfParameters object | | | | | | | | | | AllowedAttributesOnListOfInitAssign | Invalid attribute found on the ListOfInitialAssignments object | | | | | | | | | | AllowedAttributesOnListOfRules | Invalid attribute found on the ListOfRules object | | | | | | | | | | AllowedAttributesOnListOfConstraints | Invalid attribute found on the ListOfConstraints object | | | | | | | | | | AllowedAttributesOnListOfReactions | Invalid attribute found on the ListOfReactions object | | | | | | | | | | AllowedAttributesOnListOfEvents | Invalid attribute found on the ListOfEvents object | | | | | | | | | | L3V2SubstanceUnitsOnModel | Invalid 'substanceUnits' attribute value | | | | | | | | | | FunctionDefMathNotLambda | Invalid expression found in the function definition | | | | | | | | | | InvalidApplyCiInLambda | Invalid forward reference in the MathML <apply><ci>...</ci></apply> expression | | | | | | | | | | RecursiveFunctionDefinition | Recursive function definitions are not permitted | | | | | | | | | | InvalidCiInLambda | Invalid <ci> reference found inside the <lambda> mathematical formula | | | | | | | | | | InvalidFunctionDefReturnType | A function's return type must be either a number or a Boolean | | | | | | | | | | OneMathElementPerFunc | A FunctionDefinition object may contain one <math> element | | | | | | | | | | AllowedAttributesOnFunc | Invalid attribute found on the FunctionDefinition object | | | | | | | | | | InvalidUnitDefId | Invalid 'id' attribute value for a UnitDefinition object | | | | | | | | | | InvalidSubstanceRedefinition | Invalid redefinition of built-in type 'substance' | | | | | | | | | | InvalidLengthRedefinition | Invalid redefinition of built-in type 'length' | | | | | | | | | | InvalidAreaRedefinition | Invalid redefinition of built-in type name 'area' | | | | | | | | | | InvalidTimeRedefinition | Invalid redefinition of built-in type name 'time' | | | | | | | | | | InvalidVolumeRedefinition | Invalid redefinition of built-in type name 'volume' | | | | | | | | | | VolumeLitreDefExponentNotOne | Must use 'exponent'=1 when defining 'volume' in terms of litres | | | | | | | | | | VolumeMetreDefExponentNot3 | Must use 'exponent'=3 when defining 'volume' in terms of metres | | | | | | | | | | EmptyListOfUnits | An empty list of Unit objects is not permitted in a UnitDefinition object | | | | | | | | | | InvalidUnitKind | Invalid value for the 'kind' attribute of a UnitDefinition object | | | | | | | | | | OffsetNoLongerValid | Unit attribute 'offset' is not supported in this Level+Version of SBML | | | | | | | | | | CelsiusNoLongerValid | Unit name 'Celsius' is not defined in this Level+Version of SBML | | | | | | | | | | EmptyUnitListElement | A ListOfUnits object must not be empty | | | | | | | | | | OneListOfUnitsPerUnitDef | At most one ListOfUnits object is allowed inside a UnitDefinition object | | | | | | | | | | OnlyUnitsInListOfUnits | Only Unit, Notes and Annotation objects are allowed in ListOfUnits objects | | | | | | | | | | AllowedAttributesOnUnitDefinition | Invalid attribute found on the UnitDefinition object | | | | | | | | | | AllowedAttributesOnListOfUnits | Invalid attribute found on the ListOfUnits object | | | | | | | | | | AllowedAttributesOnUnit | Invalid attribute found on the Unit object | | | | | | | | | | ZeroDimensionalCompartmentSize | Invalid use of the 'size' attribute for a zero-dimensional compartment | | | | | | | | | | ZeroDimensionalCompartmentUnits | Invalid use of the 'units' attribute for a zero-dimensional compartment | | | | | | | | | | ZeroDimensionalCompartmentConst | Zero-dimensional compartments must be defined to be constant | | | | | | | | | | UndefinedOutsideCompartment | Invalid value for the 'outside' attribute of a Compartment object | | | | | | | | | | RecursiveCompartmentContainment | Recursive nesting of compartments via the 'outside' attribute is not permitted | | | | | | | | | | ZeroDCompartmentContainment | Invalid nesting of zero-dimensional compartments | | | | | | | | | | Invalid1DCompartmentUnits | Invalid value for the 'units' attribute of a one-dimensional compartment | | | | | | | | | | Invalid2DCompartmentUnits | Invalid value for the 'units' attribute of a two-dimensional compartment | | | | | | | | | | Invalid3DCompartmentUnits | Invalid value for the 'units' attribute of a three-dimensional compartment | | | | | | | | | | InvalidCompartmentTypeRef | Invalid value for the 'compartmentType' attribute of a compartment | | | | | | | | | | OneDimensionalCompartmentUnits | No units defined for 1-D compartment | | | | | | | | | | TwoDimensionalCompartmentUnits | No units defined for 2-D compartment | | | | | | | | | | ThreeDimensionalCompartmentUnits | No units defined for 3-D Compartment object | | | | | | | | | | AllowedAttributesOnCompartment | Invalid attribute found on Compartment object | | | | | | | | | | NoUnitsOnCompartment | No units defined for Compartment object | | | | | | | | | | InvalidSpeciesCompartmentRef | Invalid value found for Species 'compartment' attribute | | | | | | | | | | HasOnlySubsNoSpatialUnits | Attribute 'spatialSizeUnits' must not be set if 'hasOnlySubstanceUnits'='true' | | | | | | | | | | NoSpatialUnitsInZeroD | Attribute 'spatialSizeUnits' must not be set if the compartment is zero-dimensional | | | | | | | | | | NoConcentrationInZeroD | Attribute 'initialConcentration' must not be set if the compartment is zero-dimensional | | | | | | | | | | SpatialUnitsInOneD | Invalid value for 'spatialSizeUnits' attribute of a one-dimensional compartment | | | | | | | | | | SpatialUnitsInTwoD | Invalid value for the 'spatialSizeUnits' attribute of a two-dimensional compartment | | | | | | | | | | SpatialUnitsInThreeD | Invalid value for the 'spatialSizeUnits' attribute of a three-dimensional compartment | | | | | | | | | | InvalidSpeciesSusbstanceUnits | Invalid value for a Species 'units' attribute | | | | | | | | | | BothAmountAndConcentrationSet | Cannot set both 'initialConcentration' and 'initialAmount' attributes simultaneously | | | | | | | | | | NonBoundarySpeciesAssignedAndUsed | Cannot use a non-boundary species in both reactions and rules simultaneously | | | | | | | | | | NonConstantSpeciesUsed | Cannot use a constant, non-boundary species as a reactant or product | | | | | | | | | | InvalidSpeciesTypeRef | Invalid value for the 'speciesType' attribute of a species | | | | | | | | | | MultSpeciesSameTypeInCompartment | Cannot have multiple species of the same species type in the same compartment | | | | | | | | | | MissingSpeciesCompartment | Missing value for the 'compartment' attribute | | | | | | | | | | SpatialSizeUnitsRemoved | Attribute 'spatialSizeUnits' is not supported in this Level+Version of SBML | | | | | | | | | | SubstanceUnitsOnSpecies | No substance units defined for the species | | | | | | | | | | ConversionFactorOnSpecies | Invalid value for the 'conversionFactor' attribute | | | | | | | | | | AllowedAttributesOnSpecies | Invalid attribute found on Species object | | | | | | | | | | InvalidParameterUnits | Invalid value for the 'units' attribute of a Parameter object | | | | | | | | | | ParameterUnits | No units defined for the parameter | | | | | | | | | | ConversionFactorMustConstant | A conversion factor must reference a Parameter object declared to be a constant | | | | | | | | | | AllowedAttributesOnParameter | Invalid attribute found on Parameter object | | | | | | | | | | InvalidInitAssignSymbol | Invalid value for the 'symbol' attribute of an InitialAssignment object | | | | | | | | | | MultipleInitAssignments | Multiple initial assignments for the same 'symbol' value are not allowed | | | | | | | | | | InitAssignmentAndRuleForSameId | Cannot set a value using both an initial assignment and an assignment rule simultaneously | | | | | | | | | | OneMathElementPerInitialAssign | An InitialAssignment object may contain one <math> element | | | | | | | | | | AllowedAttributesOnInitialAssign | Invalid attribute found on an InitialAssignment object | | | | | | | | | | InitAssignmentCannotRef0DComp | InitialAssignment cannot reference 0D compartment | | | | | | | | | | InvalidAssignRuleVariable | Invalid value for the 'variable' attribute of an AssignmentRule object | | | | | | | | | | InvalidRateRuleVariable | Invalid value for the 'variable' attribute of a RateRule object | | | | | | | | | | AssignmentToConstantEntity | An assignment rule cannot assign an entity declared to be constant | | | | | | | | | | RateRuleForConstantEntity | A rate rule cannot assign an entity declared to be constant | | | | | | | | | | CircularRuleDependency | Circular dependencies involving rules and reactions are not permitted | | | | | | | | | | OneMathElementPerRule | A rule object may contain one <math> element | | | | | | | | | | AllowedAttributesOnAssignRule | Invalid attribute found on an AssignmentRule object | | | | | | | | | | AllowedAttributesOnRateRule | Invalid attribute found on a RateRule object | | | | | | | | | | AllowedAttributesOnAlgRule | Invalid attribute found on an AlgebraicRule object | | | | | | | | | | RuleCannotRef0DComp | Rule cannot reference 0D compartment | | | | | | | | | | CircularDependencyRateOf | Circular dependencies are not permitted in RateRule and KineticLaw objects | | | | | | | | | | ConstraintMathNotBoolean | A Constraint object's <math> must evaluate to a Boolean value | | | | | | | | | | IncorrectOrderInConstraint | Subobjects inside the Constraint object are not in the prescribed order | | | | | | | | | | ConstraintNotInXHTMLNamespace | A Constraint's Message subobject must be in the XHTML XML namespace | | | | | | | | | | ConstraintContainsXMLDecl | XML declarations are not permitted within Constraint's Message objects | | | | | | | | | | ConstraintContainsDOCTYPE | XML DOCTYPE elements are not permitted within Constraint's Message objects | | | | | | | | | | InvalidConstraintContent | Invalid content for a Constraint object's Message object | | | | | | | | | | OneMathElementPerConstraint | A Constraint object may contain one <math> element | | | | | | | | | | OneMessageElementPerConstraint | A Constraint object can only have one Message subobject | | | | | | | | | | AllowedAttributesOnConstraint | Invalid attribute found on Constraint object | | | | | | | | | | NoReactantsOrProducts | Cannot have a reaction with neither reactants nor products | | | | | | | | | | IncorrectOrderInReaction | Subobjects inside the Reaction object are not in the prescribed order | | | | | | | | | | EmptyListInReaction | Reaction components, if present, cannot be empty | | | | | | | | | | InvalidReactantsProductsList | Invalid object found in the list of reactants or products | | | | | | | | | | InvalidModifiersList | Invalid object found in the list of modifiers | | | | | | | | | | OneSubElementPerReaction | A Reaction object can only contain one of each allowed type of object | | | | | | | | | | CompartmentOnReaction | Invalid value for the Reaction 'compartment' attribute | | | | | | | | | | AllowedAttributesOnReaction | Invalid attribute for a Reaction object | | | | | | | | | | InvalidSpeciesReference | Invalid 'species' attribute value in SpeciesReference object | | | | | | | | | | BothStoichiometryAndMath | The 'stoichiometry' attribute and StoichiometryMath subobject are mutually exclusive | | | | | | | | | | AllowedAttributesOnSpeciesReference | Invalid attribute found on the SpeciesReference object | | | | | | | | | | AllowedAttributesOnModifier | Invalid attribute found on the ModifierSpeciesReference object | | | | | | | | | | UndeclaredSpeciesRef | Unknown species referenced in the kinetic law <math> formula | | | | | | | | | | IncorrectOrderInKineticLaw | Incorrect ordering of components in the KineticLaw object | | | | | | | | | | EmptyListInKineticLaw | The list of parameters, if present, cannot be empty | | | | | | | | | | NonConstantLocalParameter | Parameters local to a KineticLaw object must have a 'constant' attribute value of 'true' | | | | | | | | | | SubsUnitsNoLongerValid | Attribute 'substanceUnits' is not supported in this Level+Version of SBML | | | | | | | | | | TimeUnitsNoLongerValid | Attribute 'timeUnits' is not supported in this Level+Version of SBML | | | | | | | | | | OneListOfPerKineticLaw | Only one ListOfLocalParameters object is permitted within a KineticLaw object | | | | | | | | | | OnlyLocalParamsInListOfLocalParams | Only LocalParameter, Notes and Annotation objects are allowed in ListOfLocalParameter objects | | | | | | | | | | AllowedAttributesOnListOfLocalParam | Invalid attribute found on the ListOfLocalParameters object | | | | | | | | | | OneMathPerKineticLaw | Only one <math> element is allowed in a KineticLaw object | | | | | | | | | | UndeclaredSpeciesInStoichMath | Unknown species referenced in the StoichiometryMath object's <math> formula | | | | | | | | | | AllowedAttributesOnKineticLaw | Invalid attribute found on the KineticLaw object | | | | | | | | | | AllowedAttributesOnListOfSpeciesRef | Invalid attribute found on the ListOfSpeciesReferences object | | | | | | | | | | AllowedAttributesOnListOfMods | Invalid attribute found on the ListOfModifiers object | | | | | | | | | | L3V2FastDeprecated | Fast attribute deprecated | | | | | | | | | | AllowedAttributesOnLocalParameter | Invalid attribute found on the LocalParameter object | | | | | | | | | | LocalParameterShadowsSpecies | Invalid attribute found on the LocalParameter object | | | | | | | | | | MissingTriggerInEvent | The Event object is missing a Trigger subobject | | | | | | | | | | TriggerMathNotBoolean | A Trigger object's <math> expression must evaluate to a Boolean value | | | | | | | | | | MissingEventAssignment | The Event object is missing an EventAssignment subobject | | | | | | | | | | TimeUnitsEvent | Units referenced by 'timeUnits' attribute are not compatible with units of time | | | | | | | | | | IncorrectOrderInEvent | Incorrect ordering of components in Event object | | | | | | | | | | ValuesFromTriggerTimeNeedDelay | Attribute 'useValuesFromTriggerTime'='false', but the Event object does not define a delay | | | | | | | | | | DelayNeedsValuesFromTriggerTime | The use of a Delay object requires the Event attribute 'useValuesFromTriggerTime' | | | | | | | | | | OneMathPerTrigger | A Trigger object may have one <math> element | | | | | | | | | | OneMathPerDelay | A Delay object may have one <math> element | | | | | | | | | | InvalidEventAssignmentVariable | Invalid 'variable' attribute value in Event object | | | | | | | | | | EventAssignmentForConstantEntity | An EventAssignment object cannot assign to a component having attribute 'constant'='true' | | | | | | | | | | OneMathPerEventAssignment | An EventAssignment object may have one <math> element | | | | | | | | | | AllowedAttributesOnEventAssignment | Invalid attribute found on the EventAssignment object | | | | | | | | | | OnlyOneDelayPerEvent | An Event object can only have one Delay subobject | | | | | | | | | | OneListOfEventAssignmentsPerEvent | An Event object can only have one ListOfEventAssignments subobject | | | | | | | | | | OnlyEventAssignInListOfEventAssign | Only EventAssignment, Notes and Annotation objects are allowed in ListOfEventAssignments | | | | | | | | | | AllowedAttributesOnListOfEventAssign | Invalid attribute found on the ListOfEventAssignments object | | | | | | | | | | AllowedAttributesOnEvent | Invalid attribute found on the Event object | | | | | | | | | | AllowedAttributesOnTrigger | Invalid attribute found on the Trigger object | | | | | | | | | | AllowedAttributesOnDelay | Invalid attribute found on the Delay object | | | | | | | | | | PersistentNotBoolean | The Trigger attribute 'persistent' must evaluate to a Boolean value | | | | | | | | | | InitialValueNotBoolean | The Trigger attribute 'initialValue' must evaluate to a Boolean value | | | | | | | | | | OnlyOnePriorityPerEvent | An Event object can only have one Priority subobject | | | | | | | | | | OneMathPerPriority | A Priority object may have one <math> element | | | | | | | | | | AllowedAttributesOnPriority | Invalid attribute found on the Priority object | | | | | | | | | | CompartmentShouldHaveSize | It's best to define a size for every compartment in a model | | | | | | | | | | SpeciesShouldHaveValue | It's best to define an initial amount or initial concentration for every species in a model | | | | | | | | | | ParameterShouldHaveUnits | It's best to declare units for every parameter in a model | | | | | | | | | | ParameterShouldHaveValue | It's best to declare values for every parameter in a model | | | | | | | | | | LocalParameterShadowsId | Local parameters defined within a kinetic law shadow global object symbols | | | | | | | | | | CannotConvertToL1V1 | Cannot convert to SBML Level 1 Version 1 | | | | | | | | | | NoEventsInL1 | SBML Level 1 does not support events | | | | | | | | | | NoFunctionDefinitionsInL1 | SBML Level 1 does not support function definitions | | | | | | | | | | NoConstraintsInL1 | SBML Level 1 does not support constraints | | | | | | | | | | NoInitialAssignmentsInL1 | SBML Level 1 does not support initial assignments | | | | | | | | | | NoSpeciesTypesInL1 | SBML Level 1 does not support species types | | | | | | | | | | NoCompartmentTypeInL1 | SBML Level 1 does not support compartment types | | | | | | | | | | NoNon3DCompartmentsInL1 | SBML Level 1 only supports three-dimensional compartments | | | | | | | | | | NoFancyStoichiometryMathInL1 | SBML Level 1 does not support non-integer nor non-rational stoichiometry formulas | | | | | | | | | | NoNonIntegerStoichiometryInL1 | SBML Level 1 does not support non-integer 'stoichiometry' attribute values | | | | | | | | | | NoUnitMultipliersOrOffsetsInL1 | SBML Level 1 does not support multipliers or offsets in unit definitions | | | | | | | | | | SpeciesCompartmentRequiredInL1 | In SBML Level 1, a value for 'compartment' is mandatory in species definitions | | | | | | | | | | NoSpeciesSpatialSizeUnitsInL1 | SBML Level 1 does not support species 'spatialSizeUnits' settings | | | | | | | | | | NoSBOTermsInL1 | SBML Level 1 does not support the 'sboTerm' attribute | | | | | | | | | | StrictUnitsRequiredInL1 | SBML Level 1 requires strict unit consistency | | | | | | | | | | ConversionFactorNotInL1 | SBML Level 1 does not support the 'conversionFactor' attribute | | | | | | | | | | CompartmentNotOnL1Reaction | SBML Level 1 does not support the 'compartment' attribute on Reaction objects | | | | | | | | | | ExtentUnitsNotSubstance | Units of extent must be compatible with units of substance | | | | | | | | | | GlobalUnitsNotDeclared | Global units must be refer to unit kind or unitDefinition | | | | | | | | | | HasOnlySubstanceUnitsNotinL1 | The concept of hasOnlySubstanceUnits was not available in SBML Level 1 | | | | | | | | | | AvogadroNotSupported | Avogadro not supported in Levels 2 and 1 | | | | | | | | | | NoConstraintsInL2v1 | SBML Level 2 Version 1 does not support Constraint objects | | | | | | | | | | NoInitialAssignmentsInL2v1 | SBML Level 2 Version 1 does not support InitialAssignment objects | | | | | | | | | | NoSpeciesTypeInL2v1 | SBML Level 2 Version 1 does not support SpeciesType objects | | | | | | | | | | NoCompartmentTypeInL2v1 | SBML Level 2 Version 1 does not support CompartmentType objects | | | | | | | | | | NoSBOTermsInL2v1 | SBML Level 2 Version 1 does not support the 'sboTerm' attribute | | | | | | | | | | NoIdOnSpeciesReferenceInL2v1 | SBML Level 2 Version 1 does not support the 'id' attribute on SpeciesReference objects | | | | | | | | | | NoDelayedEventAssignmentInL2v1 | SBML Level 2 Version 1 does not support the 'useValuesFromTriggerTime' attribute | | | | | | | | | | StrictUnitsRequiredInL2v1 | SBML Level 2 Version 1 requires strict unit consistency | | | | | | | | | | IntegerSpatialDimensions | SBML Level 2 Version 1 requires that compartments have spatial dimensions of 0-3 | | | | | | | | | | StoichiometryMathNotYetSupported | Conversion to StoichiometryMath objects not yet supported | | | | | | | | | | PriorityLostFromL3 | SBML Level 2 Version 1 does not support priorities on Event objects | | | | | | | | | | NonPersistentNotSupported | SBML Level 2 Version 1 does not support the 'persistent' attribute on Trigger objects | | | | | | | | | | InitialValueFalseEventNotSupported | SBML Level 2 Version 1 does not support the 'initialValue' attribute on Trigger objects | | | | | | | | | | SBOTermNotUniversalInL2v2 | The 'sboTerm' attribute is invalid for this component in SBML Level 2 Version 2 | | | | | | | | | | NoUnitOffsetInL2v2 | This Level+Version of SBML does not support the 'offset' attribute on Unit objects | | | | | | | | | | NoKineticLawTimeUnitsInL2v2 | This Level+Version of SBML does not support the 'timeUnits' attribute on KineticLaw objects | | | | | | | | | | NoKineticLawSubstanceUnitsInL2v2 | This Level+Version of SBML does not support the 'substanceUnits' attribute on KineticLaw objects | | | | | | | | | | NoDelayedEventAssignmentInL2v2 | This Level+Version of SBML does not support the 'useValuesFromTriggerTime' attribute | | | | | | | | | | ModelSBOBranchChangedBeyondL2v2 | The allowable 'sboTerm' attribute values for Model objects differ for this SBML Level+Version | | | | | | | | | | StrictUnitsRequiredInL2v2 | SBML Level 2 Version 2 requires strict unit consistency | | | | | | | | | | StrictSBORequiredInL2v2 | SBML Level 2 Version 2 requires strict SBO term consistency | | | | | | | | | | DuplicateAnnotationInvalidInL2v2 | Duplicate top-level annotations are invalid in SBML Level 2 Version 2 | | | | | | | | | | NoUnitOffsetInL2v3 | This Level+Version of SBML does not support the 'offset' attribute on Unit objects | | | | | | | | | | NoKineticLawTimeUnitsInL2v3 | This Level+Version of SBML does not support the 'timeUnits' attribute on KineticLaw objects | | | | | | | | | | NoKineticLawSubstanceUnitsInL2v3 | This Level+Version of SBML does not support the 'substanceUnits' attribute on KineticLaw objects | | | | | | | | | | NoSpeciesSpatialSizeUnitsInL2v3 | This Level+Version of SBML does not support the 'spatialSizeUnit' attribute on Species objects | | | | | | | | | | NoEventTimeUnitsInL2v3 | This Level+Version of SBML does not support the 'timeUnits' attribute on Event objects | | | | | | | | | | NoDelayedEventAssignmentInL2v3 | This Level+Version of SBML does not support the 'useValuesFromTriggerTime' attribute | | | | | | | | | | ModelSBOBranchChangedBeyondL2v3 | The allowable 'sboTerm' attribute values for Model objects differ for this SBML Level+Version | | | | | | | | | | StrictUnitsRequiredInL2v3 | SBML Level 2 Version 3 requires strict unit consistency | | | | | | | | | | StrictSBORequiredInL2v3 | SBML Level 2 Version 3 requires strict SBO term consistency | | | | | | | | | | DuplicateAnnotationInvalidInL2v3 | Duplicate top-level annotations are invalid in SBML Level 2 Version 3 | | | | | | | | | | NoUnitOffsetInL2v4 | This Level+Version of SBML does not support the 'offset' attribute on Unit objects | | | | | | | | | | NoKineticLawTimeUnitsInL2v4 | This Level+Version of SBML does not support the 'timeUnits' attribute on KineticLaw objects | | | | | | | | | | NoKineticLawSubstanceUnitsInL2v4 | This Level+Version of SBML does not support the 'substanceUnits' attribute on KineticLaw objects | | | | | | | | | | NoSpeciesSpatialSizeUnitsInL2v4 | This Level+Version of SBML does not support the 'spatialSizeUnit' attribute on Species objects | | | | | | | | | | NoEventTimeUnitsInL2v4 | This Level+Version of SBML does not support the 'timeUnits' attribute on Event objects | | | | | | | | | | ModelSBOBranchChangedInL2v4 | The allowable 'sboTerm' attribute values for Model objects differ for this SBML Level+Version | | | | | | | | | | DuplicateAnnotationInvalidInL2v4 | Duplicate top-level annotations are invalid in SBML Level 2 Version 4 | | | | | | | | | | NoSpeciesTypeInL3v1 | SBML Level 3 Version 1 does not support SpeciesType objects | | | | | | | | | | NoCompartmentTypeInL3v1 | SBML Level 3 Version 1 does not support CompartmentType objects | | | | | | | | | | NoUnitOffsetInL3v1 | This Level+Version of SBML does not support the 'offset' attribute on Unit objects | | | | | | | | | | NoKineticLawTimeUnitsInL3v1 | This Level+Version of SBML does not support the 'timeUnits' attribute on KineticLaw objects | | | | | | | | | | NoKineticLawSubstanceUnitsInL3v1 | This Level+Version of SBML does not support the 'substanceUnits' attribute on KineticLaw objects | | | | | | | | | | NoSpeciesSpatialSizeUnitsInL3v1 | This Level+Version of SBML does not support the 'spatialSizeUnit' attribute on Species objects | | | | | | | | | | NoEventTimeUnitsInL3v1 | This Level+Version of SBML does not support the 'timeUnits' attribute on Event objects | | | | | | | | | | ModelSBOBranchChangedInL3v1 | The allowable 'sboTerm' attribute values for Model objects differ for this SBML Level+Version | | | | | | | | | | DuplicateAnnotationInvalidInL3v1 | Duplicate top-level annotations are invalid in SBML Level 3 Version 1 | | | | | | | | | | NoCompartmentOutsideInL3v1 | This Level+Version of SBML does not support the 'outside' attribute on Compartment objects | | | | | | | | | | NoStoichiometryMathInL3v1 | This Level+Version of SBML does not support the StoichiometryMath object | | | | | | | | | | DoubleExponentNotSupported | Exponent of type double not supported in Levels 2 and 1. | | | | | | | | | | MathMLElementNotSupported | This MathML element is only permitted in L3V2 | | | | | | | | | | EmptyListOfElementNotSupported | Empty 'ListOf' element is only permitted in L3V2 | | | | | | | | | | MissingMathElementNotSupported | Missing <math> element is only permitted in L3V2 | | | | | | | | | | MissingTriggerElementNotSupported | missing <trigger> element is only permitted in L3V2 | | | | | | | | | | BooleanNumericDiscrepancy | Interchange of Boolean and numeric values only permitted in L3V2 | | | | | | | | | | IdNameSBaseInL3V2 | Conversion will lose attributes only available in L3V2 and higher | | | | | | | | | | MissingParticipantsNotSupported | Omission of both <listOfReactants> and <listOfProducts> is only valid in L3V2 | | | | | | | | | | ConvertibleMathInitialAssignment | Some L3V2-specific MathML elements are not permitted in InitialAssignment objects | | | | | | | | | | FastReactionsNotSupported | Conversion of reactions employing the 'fast' attribute is not supported | | | | | | | | | | InvalidSBMLLevelVersion | Unknown Level+Version combination of SBML | | | | | | | | | | AnnotationNotesNotAllowedLevel1 | Annotation objects on the SBML container element are not permitted in SBML Level 1 | | | | | | | | | | InvalidRuleOrdering | Invalid ordering of rules | | | | | | | | | | RequiredPackagePresent | The SBML document requires an SBML Level 3 package unavailable in this software | | | | | | | | | | UnrequiredPackagePresent | The SBML document uses an SBML Level 3 package unavailable in this software | | | | | | | | | | PackageRequiredShouldBeFalse | This package expects required to be false | | | | | | | | | | SubsUnitsAllowedInKL | Disallowed value for attribute 'substanceUnits' on KineticLaw object | | | | | | | | | | TimeUnitsAllowedInKL | Disallowed value for attribute 'timeUnits' on KineticLaw object | | | | | | | | | | FormulaInLevel1KL | Only predefined functions are allowed in SBML Level 1 formulas | | | | | | | | | | L3SubstanceUnitsOnModel | Invalid 'substanceUnits' attribute value | | | | | | | | | | StoichiometryMathMissingMath | The <stoichiometryMath> element must contain a <math> element | | | | | | | | | | TimeUnitsRemoved | This Level+Version of SBML does not support the 'timeUnits' attribute on Event objects | | | | | | | | | | BadMathML | Invalid MathML expression | | | | | | | | | | FailedMathMLReadOfDouble | Missing or invalid floating-point number in MathML expression | | | | | | | | | | FailedMathMLReadOfInteger | Missing or invalid integer in MathML expression | | | | | | | | | | FailedMathMLReadOfExponential | Missing or invalid exponential expression in MathML | | | | | | | | | | FailedMathMLReadOfRational | Missing or invalid rational expression in MathML | | | | | | | | | | BadMathMLNodeType | Invalid MathML element | | | | | | | | | | InvalidMathMLAttribute | Invalid MathML attribute | | | | | | | | | | NoTimeSymbolInFunctionDef | Use of <csymbol> for 'time' not allowed within FunctionDefinition objects | | | | | | | | | | NoBodyInFunctionDef | There must be a <lambda> body within the <math> element of a FunctionDefinition object | | | | | | | | | | DanglingUnitSIdRef | Units must refer to valid unit or unitDefinition | | | | | | | | | | RDFMissingAboutTag | RDF missing the <about> tag | | | | | | | | | | RDFEmptyAboutTag | RDF empty <about> tag | | | | | | | | | | RDFAboutTagNotMetaid | RDF <about> tag is not metaid | | | | | | | | | | RDFNotCompleteModelHistory | RDF does not contain valid ModelHistory | | | | | | | | | | RDFNotModelHistory | RDF does not result in a ModelHistory | | | | | | | | | | AnnotationNotElement | Annotation must contain element | | | | | | | | | | NestedAnnotationNotAllowed | Nested annotations not allowed | | | | | | | | | | UndeclaredUnits | Missing unit declarations on parameters or literal numbers in expression | | | | | | | | | | UndeclaredTimeUnitsL3 | Unable to verify consistency of units: the unit of time has not been declared | | | | | | | | | | UndeclaredExtentUnitsL3 | Unable to verify consistency of units: the units of reaction extent have not been declared | | | | | | | | | | UndeclaredObjectUnitsL3 | Unable to verify consistency of units: encountered a model entity with no declared units | | | | | | | | | | CannotVerifyUnitsObjectNoMath | Unable to verify consistency of units: encountered an object with no <math> element | | | | | | | | | | UnrecognisedSBOTerm | Unrecognized 'sboTerm' attribute value | | | | | | | | | | ObseleteSBOTerm | Obsolete 'sboTerm' attribute value | | | | | | | | | | IncorrectCompartmentSpatialDimensions | In SBML Level 1, only three-dimensional compartments are allowed | | | | | | | | | | CompartmentTypeNotValidAttribute | CompartmentType objects are not available in this Level+Version of SBML | | | | | | | | | | ConstantNotValidAttribute | This Level+Version of SBML does not support the 'constant' attribute on this component | | | | | | | | | | MetaIdNotValidAttribute | Attribute 'metaid' is not available in SBML Level 1 | | | | | | | | | | SBOTermNotValidAttributeBeforeL2V3 | The 'sboTerm' attribute is not available on this component before SBML Level 2 Version 3 | | | | | | | | | | InvalidL1CompartmentUnits | Invalid units for a compartment in SBML Level 1 | | | | | | | | | | L1V1CompartmentVolumeReqd | In SBML Level 1, a compartment's volume must be specified | | | | | | | | | | CompartmentTypeNotValidComponent | CompartmentType objects are not available in this Level+Version of SBML | | | | | | | | | | ConstraintNotValidComponent | Constraint objects are not available in this Level+Version of SBML | | | | | | | | | | EventNotValidComponent | Event objects are not available in this Level+Version of SBML | | | | | | | | | | SBOTermNotValidAttributeBeforeL2V2 | The 'sboTerm' attribute is invalid for this component before Level 2 Version 2 | | | | | | | | | | FuncDefNotValidComponent | FunctionDefinition objects are not available in this Level+Version of SBML | | | | | | | | | | InitialAssignNotValidComponent | InitialAssignment objects are not available in this Level+Version of SBML | | | | | | | | | | VariableNotValidAttribute | Attribute 'variable' is not available on this component in this Level+Version of SBML | | | | | | | | | | UnitsNotValidAttribute | Attribute 'units' is not available on this component in this Level+Version of SBML | | | | | | | | | | ConstantSpeciesNotValidAttribute | Attribute 'constant' is not available on Species objects in SBML Level 1 | | | | | | | | | | SpatialSizeUnitsNotValidAttribute | Attribute 'spatialSizeUnits' is not available on Species objects in SBML Level 1 | | | | | | | | | | SpeciesTypeNotValidAttribute | Attribute 'speciesType' is not available on Species objects in SBML Level 1 | | | | | | | | | | HasOnlySubsUnitsNotValidAttribute | Attribute 'hasOnlySubstanceUnits' is not available on Species objects in SBML Level 1 | | | | | | | | | | IdNotValidAttribute | Attribute 'id' is not available on SpeciesReference objects in SBML Level 1 | | | | | | | | | | NameNotValidAttribute | Attribute 'name' is not available on SpeciesReference objects in SBML Level 1 | | | | | | | | | | SpeciesTypeNotValidComponent | The SpeciesType object is not supported in SBML Level 1 | | | | | | | | | | StoichiometryMathNotValidComponent | The StoichiometryMath object is not supported in SBML Level 1 | | | | | | | | | | MultiplierNotValidAttribute | Attribute 'multiplier' on Unit objects is not supported in SBML Level 1 | | | | | | | | | | OffsetNotValidAttribute | Attribute 'offset' on Unit objects is only available in SBML Level 2 Version 1 | | | | | | | | | | L3SpatialDimensionsUnset | No value given for 'spatialDimensions' attribute; assuming a value of 3 | | | | | | | | | | PackageConversionNotSupported | Conversion of SBML Level 3 package constructs is not yet supported | | | | | | | | | | InvalidTargetLevelVersion | The requested SBML Level/Version combination is not known to exist | | | | | | | | | | L3NotSupported | SBML Level 3 is not yet supported | | | | | | | | | | CompUnknown | | | | | | | | | | | CompNSUndeclared | The comp ns is not correctly declared | | | | | | | | | | CompElementNotInNs | Element not in comp namespace | | | | | | | | | | CompDuplicateComponentId | Duplicate 'id' attribute value | | | | | | | | | | CompUniqueModelIds | Model and ExternalModelDefinitions must have unique ids | | | | | | | | | | CompUniquePortIds | Ports must have unique ids | | | | | | | | | | CompInvalidSIdSyntax | Invalid SId syntax | | | | | | | | | | CompInvalidSubmodelRefSyntax | Invalid submodelRef syntax | | | | | | | | | | CompInvalidDeletionSyntax | Invalid deletion syntax | | | | | | | | | | CompInvalidConversionFactorSyntax | Invalid conversionFactor syntax | | | | | | | | | | CompInvalidNameSyntax | Invalid name syntax | | | | | | | | | | CompReplacedUnitsShouldMatch | Units of replaced elements should match replacement units. | | | | | | | | | | CompOneListOfReplacedElements | Only one <listOfReplacedElements> allowed. | | | | | | | | | | CompLOReplaceElementsAllowedElements | Allowed children of <listOfReplacedElements> | | | | | | | | | | CompLOReplacedElementsAllowedAttribs | Allowed <listOfReplacedElements> attributes | | | | | | | | | | CompEmptyLOReplacedElements | <listOfReplacedElements> must not be empty | | | | | | | | | | CompOneReplacedByElement | Only one <replacedBy> object allowed. | | | | | | | | | | CompAttributeRequiredMissing | Required comp:required attribute on <sbml> | | | | | | | | | | CompAttributeRequiredMustBeBoolean | The comp:required attribute must be Boolean | | | | | | | | | | CompRequiredTrueIfElementsRemain | The comp:required attribute must be 'true' if math changes | | | | | | | | | | CompRequiredFalseIfAllElementsReplaced | The comp:required attribute must be 'false' if math does not change | | | | | | | | | | CompOneListOfModelDefinitions | Only one <listOfModelDefinitions> allowed. | | | | | | | | | | CompEmptyLOModelDefs | <listOfModelDefinitions> and <listOfExternalModelDefinitions> must not be empty | | | | | | | | | | CompLOModelDefsAllowedElements | Only <modelDefinitions> in <listOfModelDefinitions> | | | | | | | | | | CompLOExtModelDefsAllowedElements | Only <externalModelDefinitions> in <listOfExternalModelDefinitions> | | | | | | | | | | CompLOModelDefsAllowedAttributes | Allowed <listOfModelDefinitions> attributes | | | | | | | | | | CompLOExtModDefsAllowedAttributes | Allowed <listOfExternalModelDefinitions> attributes | | | | | | | | | | CompOneListOfExtModelDefinitions | Only one <listOfExternalModelDefinitions> allowed. | | | | | | | | | | CompAttributeRequiredMustBeTrue | The comp:required attribute must be 'true' | | | | | | | | | | CompExtModDefAllowedCoreAttributes | Allowed <externalModelDefinitions> core attributes | | | | | | | | | | CompExtModDefAllowedElements | Allowed <externalModelDefinitions> elements | | | | | | | | | | CompExtModDefAllowedAttributes | Allowed <externalModelDefinitions> attributes | | | | | | | | | | CompReferenceMustBeL3 | External models must be L3 | | | | | | | | | | CompModReferenceMustIdOfModel | 'modelRef' must be the 'id' of a model in the 'source' document | | | | | | | | | | CompExtModMd5DoesNotMatch | MD5 checksum does not match the 'source' document | | | | | | | | | | CompInvalidSourceSyntax | The 'comp:source' attribute must be of type 'anyURI' | | | | | | | | | | CompInvalidModelRefSyntax | The 'comp:modelRef' attribute must have the syntax of 'SId' | | | | | | | | | | CompInvalidMD5Syntax | The 'comp:md5' attribute must have the syntax of 'string' | | | | | | | | | | CompCircularExternalModelReference | Circular reference in <externalModelDefinition> | | | | | | | | | | CompOneListOfOnModel | Only one <listOfSubmodels> and one <listOfPorts> allowed | | | | | | | | | | CompNoEmptyListOfOnModel | No empty listOf elements allowed | | | | | | | | | | CompLOSubmodelsAllowedElements | Allowed elements on <listOfSubmodels> | | | | | | | | | | CompLOPortsAllowedElements | Allowed elements on <listOfPorts> | | | | | | | | | | CompLOSubmodelsAllowedAttributes | Allowed attributes on <listOfSubmodels> | | | | | | | | | | CompLOPortsAllowedAttributes | Allowed attributes on <listOfPorts> | | | | | | | | | | CompSubmodelAllowedCoreAttributes | Allowed core attributes on <submodel> | | | | | | | | | | CompSubmodelAllowedElements | Allowed elements on <submodel> | | | | | | | | | | CompOneListOfDeletionOnSubmodel | Only one <listOfDeletions> on a <submodel> allowed | | | | | | | | | | CompSubmodelNoEmptyLODeletions | No empty listOfDeletions elements allowed | | | | | | | | | | CompLODeletionsAllowedElements | Allowed elements on <listOfDeletions> | | | | | | | | | | CompLODeletionAllowedAttributes | Allowed <listOfDeletions> attributes | | | | | | | | | | CompSubmodelAllowedAttributes | Allowed <submodel> attributes | | | | | | | | | | CompModReferenceSyntax | 'comp:modelRef' must conform to SId syntax | | | | | | | | | | CompInvalidTimeConvFactorSyntax | 'comp:timeConversionFactor' must conform to SId syntax | | | | | | | | | | CompInvalidExtentConvFactorSyntax | 'comp:extentConversionFactor' must conform to SId syntax | | | | | | | | | | CompSubmodelMustReferenceModel | The 'comp:modelRef' attribute must reference a model | | | | | | | | | | CompSubmodelCannotReferenceSelf | The 'comp:modelRef' attribute cannot reference own model | | | | | | | | | | CompModCannotCircularlyReferenceSelf | <model> may not reference <submodel> that references itself. | | | | | | | | | | CompTimeConversionMustBeParameter | The 'comp:timeConversionFactor' must reference a parameter | | | | | | | | | | CompExtentConversionMustBeParameter | The 'comp:extentConversionFactor' must reference a parameter | | | | | | | | | | CompPortRefMustReferencePort | The 'comp:portRef' attribute must be the 'id' of a <port> | | | | | | | | | | CompIdRefMustReferenceObject | The 'comp:idRef' attribute must be the 'id' of a model element | | | | | | | | | | CompUnitRefMustReferenceUnitDef | The 'comp:unitRef' attribute must be the 'id' of a UnitDefinition | | | | | | | | | | CompMetaIdRefMustReferenceObject | The 'comp:metaIdRef' attribute must be the 'metaid' of an object | | | | | | | | | | CompParentOfSBRefChildMustBeSubmodel | If <sBaseRef> has a child <sBaseRef> its parent must be a <submodel> | | | | | | | | | | CompInvalidPortRefSyntax | The 'comp:portRef' attribute must have the syntax of an SBML SId | | | | | | | | | | CompInvalidIdRefSyntax | The 'comp:idRef' attribute must have the syntax of an SBML SId | | | | | | | | | | CompInvalidUnitRefSyntax | The 'comp:unitRef' attribute must have the syntax of an SBML SId | | | | | | | | | | CompInvalidMetaIdRefSyntax | The 'comp:metaIdRef' attribute must have the syntax of an XML ID | | | | | | | | | | CompOneSBaseRefOnly | Only one <sbaseRef> | | | | | | | | | | CompDeprecatedSBaseRefSpelling | The spelling 'sbaseRef' is deprecated | | | | | | | | | | CompSBaseRefMustReferenceObject | An SBaseRef must reference an object. | | | | | | | | | | CompSBaseRefMustReferenceOnlyOneObject | An SBaseRef must reference only one other object. | | | | | | | | | | CompNoMultipleReferences | Objects may not be referenced by mutiple SBaseRef constructs. | | | | | | | | | | CompPortMustReferenceObject | Port must reference an object | | | | | | | | | | CompPortMustReferenceOnlyOneObject | Port must reference only one other object. | | | | | | | | | | CompPortAllowedAttributes | Allowed attributes on a Port | | | | | | | | | | CompPortReferencesUnique | Port definitions must be unique. | | | | | | | | | | CompDeletionMustReferenceObject | Deletion must reference an object | | | | | | | | | | CompDeletionMustReferOnlyOneObject | Deletion must reference only one other object. | | | | | | | | | | CompDeletionAllowedAttributes | Allowed attributes on a Deletion | | | | | | | | | | CompReplacedElementMustRefObject | ReplacedElement must reference an object | | | | | | | | | | CompReplacedElementMustRefOnlyOne | ReplacedElement must reference only one other object. | | | | | | | | | | CompReplacedElementAllowedAttributes | Allowed attributes on <replacedElement> | | | | | | | | | | CompReplacedElementSubModelRef | The 'comp:submodelRef' attribute must point to a <submodel> | | | | | | | | | | CompReplacedElementDeletionRef | The 'comp:deletion' attribute must point to a <deletion> | | | | | | | | | | CompReplacedElementConvFactorRef | The 'comp:conversionFactor attribute must point to a <parameter> | | | | | | | | | | CompReplacedElementSameReference | No <replacedElement> refer to same object | | | | | | | | | | CompReplacedElementNoDelAndConvFact | No <replacedElement> with deletion and conversionfactor | | | | | | | | | | CompReplacedByMustRefObject | ReplacedBy must reference an object | | | | | | | | | | CompReplacedByMustRefOnlyOne | ReplacedBy must reference only one other object. | | | | | | | | | | CompReplacedByAllowedAttributes | Allowed attributes on <replacedBy> | | | | | | | | | | CompReplacedBySubModelRef | The 'comp:submodelRef' attribute must point to a <submodel> | | | | | | | | | | CompMustReplaceSameClass | Replaced classes must match. | | | | | | | | | | CompMustReplaceIDs | Replaced IDs must be replaced with IDs. | | | | | | | | | | CompMustReplaceMetaIDs | Replaced metaids must be replaced with metaids. | | | | | | | | | | CompMustReplacePackageIDs | Replaced package IDs must be replaced with package IDs. | | | | | | | | | | CompUnresolvedReference | Unresolved reference. | | | | | | | | | | CompNoModelInReference | No model in referenced document. | | | | | | | | | | CompExtModDefBad | Referenced <externalModelDefinition> unresolvable. | | | | | | | | | | CompModelFlatteningFailed | Model failed to flatten. | | | | | | | | | | CompFlatModelNotValid | Flat model not valid. | | | | | | | | | | CompLineNumbersUnreliable | Line numbers unreliable. | | | | | | | | | | CompFlatteningNotRecognisedReqd | Flattening not implemented for required package. | | | | | | | | | | CompFlatteningNotRecognisedNotReqd | Flattening not implemented for unrequired package. | | | | | | | | | | CompFlatteningNotImplementedNotReqd | Flattening not implemented for unrequired package. | | | | | | | | | | CompFlatteningNotImplementedReqd | Flattening not implemented for required package. | | | | | | | | | | CompFlatteningWarning | Flattening reference may come from package. | | | | | | | | | | CompDeprecatedDeleteFunction | The performDeletions functions is deprecated. | | | | | | | | | | CompDeprecatedReplaceFunction | The performReplacementsAndConversions fuctions is deprecated. | | | | | | | | | | CompDeletedReplacement | Element deleted before a subelement could be replaced. | | | | | | | | | | CompIdRefMayReferenceUnknownPackage | The 'comp:idRef' attribute must be the 'id' of a model element | | | | | | | | | | CompMetaIdRefMayReferenceUnknownPkg | The 'comp:metaIdRef' attribute must be the 'metaid' of a model element | | | | | | | | | | FbcUnknown | | | | | | | | | | | FbcNSUndeclared | The fbc ns is not correctly declared | | | | | | | | | | FbcElementNotInNs | Element not in fbc namespace | | | | | | | | | | FbcDuplicateComponentId | Duplicate 'id' attribute value | | | | | | | | | | FbcSBMLSIdSyntax | Invalid 'id' attribute | | | | | | | | | | FbcAttributeRequiredMissing | Required fbc:required attribute on <sbml> | | | | | | | | | | FbcAttributeRequiredMustBeBoolean | The fbc:required attribute must be Boolean | | | | | | | | | | FbcRequiredFalse | The fbc:required attribute must be 'false' | | | | | | | | | | FbcOnlyOneEachListOf | One of each list of allowed | | | | | | | | | | FbcNoEmptyListOfs | ListOf elements cannot be empty | | | | | | | | | | FbcLOFluxBoundsAllowedElements | Allowed elements on ListOfFluxBounds | | | | | | | | | | FbcLOObjectivesAllowedElements | Allowed elements on ListOfObjectives | | | | | | | | | | FbcLOFluxBoundsAllowedAttributes | Allowed attributes on ListOfFluxBounds | | | | | | | | | | FbcLOObjectivesAllowedAttributes | Allowed attributes on ListOfObjectives | | | | | | | | | | FbcActiveObjectiveSyntax | Type of activeObjective attribute | | | | | | | | | | FbcActiveObjectiveRefersObjective | ActiveObjective must reference Objective | | | | | | | | | | FbcModelMustHaveStrict | 'Strict' attribute required on <model> | | | | | | | | | | FbcModelStrictMustBeBoolean | 'Strict' attribute must be Boolean | | | | | | | | | | FbcLOGeneProductsAllowedElements | Allowed elements on ListOfGeneProducts | | | | | | | | | | FbcLOGeneProductsAllowedAttributes | Allowed attributes on ListOfGeneProducts | | | | | | | | | | FbcSpeciesAllowedL3Attributes | Species allowed attributes | | | | | | | | | | FbcSpeciesChargeMustBeInteger | Charge must be integer | | | | | | | | | | FbcSpeciesFormulaMustBeString | Chemical formula must be string | | | | | | | | | | FbcFluxBoundAllowedL3Attributes | <fluxBound> may only have 'metaId' and 'sboTerm' from L3 namespace | | | | | | | | | | FbcFluxBoundAllowedElements | <fluxBound> may only have <notes> and <annotations> from L3 Core | | | | | | | | | | FbcFluxBoundRequiredAttributes | Invalid attribute found on <fluxBound> object | | | | | | | | | | FbcFluxBoundRectionMustBeSIdRef | Datatype for 'fbc:reaction' must be SIdRef | | | | | | | | | | FbcFluxBoundNameMustBeString | The attribute 'fbc:name' must be of the data type string | | | | | | | | | | FbcFluxBoundOperationMustBeEnum | The attribute 'fbc:operation' must be of data type FbcOperation | | | | | | | | | | FbcFluxBoundValueMustBeDouble | The attribute 'fbc:value' must be of the data type double | | | | | | | | | | FbcFluxBoundReactionMustExist | 'fbc:reaction' must refer to valid reaction | | | | | | | | | | FbcFluxBoundsForReactionConflict | Conflicting set of FluxBounds for a reaction | | | | | | | | | | FbcObjectiveAllowedL3Attributes | <objective> may only have 'metaId' and 'sboTerm' from L3 namespace | | | | | | | | | | FbcObjectiveAllowedElements | <objective> may only have <notes> and <annotations> from L3 Core | | | | | | | | | | FbcObjectiveRequiredAttributes | Invalid attribute found on <objective> object | | | | | | | | | | FbcObjectiveNameMustBeString | The attribute 'fbc:name' must be of the data type string | | | | | | | | | | FbcObjectiveTypeMustBeEnum | The attribute 'fbc:type' must be of data type FbcType. | | | | | | | | | | FbcObjectiveOneListOfObjectives | An <objective> must have one <listOfFluxObjectives>. | | | | | | | | | | FbcObjectiveLOFluxObjMustNotBeEmpty | <listOfFluxObjectives> subobject must not be empty | | | | | | | | | | FbcObjectiveLOFluxObjOnlyFluxObj | Invalid element found in <listOfFluxObjectives> | | | | | | | | | | FbcObjectiveLOFluxObjAllowedAttribs | <listOfFluxObjectives> may only have 'metaId' and 'sboTerm' from L3 core | | | | | | | | | | FbcFluxObjectAllowedL3Attributes | <fluxObjective> may only have 'metaId' and 'sboTerm' from L3 namespace | | | | | | | | | | FbcFluxObjectAllowedElements | <fluxObjective> may only have <notes> and <annotations> from L3 Core | | | | | | | | | | FbcFluxObjectRequiredAttributes | Invalid attribute found on <fluxObjective> object | | | | | | | | | | FbcFluxObjectNameMustBeString | The attribute 'fbc:name' must be of the data type string | | | | | | | | | | FbcFluxObjectReactionMustBeSIdRef | Datatype for 'fbc:reaction' must be SIdRef | | | | | | | | | | FbcFluxObjectReactionMustExist | 'fbc:reaction' must refer to valid reaction | | | | | | | | | | FbcFluxObjectCoefficientMustBeDouble | The attribute 'fbc:coefficient' must be of the data type double | | | | | | | | | | FbcFluxObjectCoefficientWhenStrict | The 'fbc:coefficient' must be declared when strict | | | | | | | | | | FbcReactionOnlyOneGeneProdAss | One GeneProductAssociation in a Reaction | | | | | | | | | | FbcReactionAllowedAttributes | Fbc attributes on a Reaction | | | | | | | | | | FbcReactionLwrBoundSIdRef | LowerBound must be SIdRef | | | | | | | | | | FbcReactionUpBoundSIdRef | UpperBound must be SIdRef | | | | | | | | | | FbcReactionLwrBoundRefExists | LowerBound must point to Parameter | | | | | | | | | | FbcReactionUpBoundRefExists | UpperBound must point to Parameter | | | | | | | | | | FbcReactionMustHaveBoundsStrict | Reaction must have bounds when strict | | | | | | | | | | FbcReactionConstantBoundsStrict | Reaction bounds constant when strict | | | | | | | | | | FbcReactionBoundsMustHaveValuesStrict | Reaction bounds must have values when strict | | | | | | | | | | FbcReactionBoundsNotAssignedStrict | Reaction bounds not assigned when strict | | | | | | | | | | FbcReactionLwrBoundNotInfStrict | LowerBound cannot be INF when strict | | | | | | | | | | FbcReactionUpBoundNotNegInfStrict | UpperBound cannot be -INF when strict | | | | | | | | | | FbcReactionLwrLessThanUpStrict | LowerBound less than upperBound when strict | | | | | | | | | | FbcSpeciesReferenceConstantStrict | SpeciesReferences must be constant when strict | | | | | | | | | | FbcSpeciesRefsStoichMustBeRealStrict | Stoichiometry of SpeciesReferences must be real valued when strict | | | | | | | | | | FbcSpeciesRefNotAssignedStrict | SpeciesReference not target of InitialAssignment when strict | | | | | | | | | | FbcGeneProdAssocAllowedCoreAttribs | Allowed core attributes on <GeneProductAssociation> | | | | | | | | | | FbcGeneProdAssocAllowedCoreElements | Allowed core elements on <GeneProductAssociation> | | | | | | | | | | FbcGeneProdAssocAllowedAttribs | Allowed fbc attributes on <GeneProductAssociation> | | | | | | | | | | FbcGeneProdAssocIdSyntax | 'fbc:id' must have SId syntax | | | | | | | | | | FbcGeneProdAssocContainsOneElement | <GeneProductAssociation> must contain one concrete object | | | | | | | | | | FbcGeneProdAssocNameMustBeString | 'fbc:name' must be string | | | | | | | | | | FbcGeneProdRefAllowedCoreAttribs | Allowed core attributes on <GeneProductRef> | | | | | | | | | | FbcGeneProdRefAllowedCoreElements | Allowed core elements on <GeneProductRef> | | | | | | | | | | FbcGeneProdRefAllowedAttribs | Allowed fbc attributes on <GeneProductRef> | | | | | | | | | | FbcGeneProdRefGeneProductSIdRef | 'fbc:geneProduct' must be SIdRef | | | | | | | | | | FbcGeneProdRefGeneProductExists | 'fbc:geneProduct' must point to existing <GeneProduct> | | | | | | | | | | FbcAndAllowedCoreAttributes | Allowed core attributes on <And> | | | | | | | | | | FbcAndAllowedCoreElements | Allowed core attributes on <And> | | | | | | | | | | FbcAndTwoChildren | <And> must have at least two child elements | | | | | | | | | | FbcOrAllowedCoreAttributes | Allowed core attributes on <Or> | | | | | | | | | | FbcOrAllowedCoreElements | Allowed core elements on <Or> | | | | | | | | | | FbcOrTwoChildren | <Or> must have at least two child elements | | | | | | | | | | FbcGeneProductAllowedCoreAttributes | Allowed core attributes on <GeneProduct> | | | | | | | | | | FbcGeneProductAllowedCoreElements | Allowed core elements on <GeneProduct> | | | | | | | | | | FbcGeneProductAllowedAttributes | Allowed fbc attributes on <GeneProduct> | | | | | | | | | | FbcGeneProductLabelMustBeString | 'fbc:label' must be string | | | | | | | | | | FbcGeneProductLabelMustBeUnique | 'fbc:label' must be unique | | | | | | | | | | FbcGeneProductNameMustBeString | 'fbc:name' must be string | | | | | | | | | | FbcGeneProductAssocSpeciesMustExist | 'fbc:associatedSpecies' must point to existing <species> | | | | | | | | | | QualUnknown | | | | | | | | | | | QualNSUndeclared | The qual ns is not correctly declared | | | | | | | | | | QualElementNotInNs | Element not in qual namespace | | | | | | | | | | QualFunctionTermBool | FunctionTerm should return Boolean | | | | | | | | | | QualMathCSymbolDisallowed | CSymbol time or delay not allowed | | | | | | | | | | QualDuplicateComponentId | Duplicate 'id' attribute value | | | | | | | | | | QualAttributeRequiredMissing | Required qual:required attribute on <sbml> | | | | | | | | | | QualAttributeRequiredMustBeBoolean | The qual:required attribute must be Boolean | | | | | | | | | | QualRequiredTrueIfTransitions | The qual:required attribute must be 'true' if math changes | | | | | | | | | | QualOneListOfTransOrQS | Only one <listOfTransitions> or <listOfQualitativeSpeciesgt; allowed. | | | | | | | | | | QualEmptyLONotAllowed | Empty <listOfTransitions> or <listOfQualitativeSpeciesgt; not allowed. | | | | | | | | | | QualLOTransitiondAllowedElements | Elements allowed on <listOfTransitions>. | | | | | | | | | | QualLOQualSpeciesAllowedElements | Elements allowed on <listOfTransitions>. | | | | | | | | | | QualLOQualSpeciesAllowedAttributes | Attributes allowed on <listOfQualitativeSpeciesgt;. | | | | | | | | | | QualLOTransitionsAllowedAttributes | Attributes allowed on <listOfTransitions>. | | | | | | | | | | QualQualSpeciesAllowedCoreAttributes | Core attributes allowed on <qualitativeSpeciesgt;. | | | | | | | | | | QualQualSpeciesAllowedElements | Elements allowed on <qualitativeSpeciesgt;. | | | | | | | | | | QualQualSpeciesAllowedAttributes | Attributes allowed on <qualitativeSpeciesgt;. | | | | | | | | | | QualConstantMustBeBool | Attribute 'constant' on <qualitativeSpeciesgt; must be Boolean. | | | | | | | | | | QualNameMustBeString | Attribute 'name' on <qualitativeSpeciesgt; must be string. | | | | | | | | | | QualInitialLevelMustBeInt | Attribute 'initialLevel' on <qualitativeSpeciesgt; must be integer. | | | | | | | | | | QualMaxLevelMustBeInt | Attribute 'maxLevel' on <qualitativeSpeciesgt; must be integer. | | | | | | | | | | QualCompartmentMustReferExisting | Attribute 'compartment' on <qualitativeSpeciesgt; must reference compartment. | | | | | | | | | | QualInitialLevelCannotExceedMax | Attribute 'initialLevel' on <qualitativeSpeciesgt; cannot exceed maxLevel. | | | | | | | | | | QualConstantQSCannotBeOutput | Constant <qualitativeSpeciesgt; cannot be an Output. | | | | | | | | | | QualQSAssignedOnlyOnce | A <qualitativeSpeciesgt; can only be assigned once. | | | | | | | | | | QualInitalLevelNotNegative | Attribute 'initialLevel' on <qualitativeSpeciesgt; cannot be negative. | | | | | | | | | | QualMaxLevelNotNegative | Attribute 'maxLevel' on <qualitativeSpeciesgt; cannot be negative. | | | | | | | | | | QualTransitionAllowedCoreAttributes | Core attributes allowed on <transition>. | | | | | | | | | | QualTransitionAllowedElements | Elements allowed on <transition>. | | | | | | | | | | QualTransitionAllowedAttributes | Attributes allowed on <transition>. | | | | | | | | | | QualTransitionNameMustBeString | Attribute 'name' on <transition> must be string. | | | | | | | | | | QualTransitionLOElements | ListOf elements on <transition>. | | | | | | | | | | QualTransitionEmptyLOElements | ListOf elements on <transition> not empty. | | | | | | | | | | QualTransitionLOInputElements | Elements on <listOfInputs>. | | | | | | | | | | QualTransitionLOOutputElements | Elements on <listOfOutputs>. | | | | | | | | | | QualTransitionLOFuncTermElements | Elements on <listOfFunctionTerms>. | | | | | | | | | | QualTransitionLOInputAttributes | Attributes allowed on <listOfInputs>. | | | | | | | | | | QualTransitionLOOutputAttributes | Attributes allowed on <listOfOutputs>. | | | | | | | | | | QualTransitionLOFuncTermAttributes | Attributes allowed on <listOfFunctionTerms>. | | | | | | | | | | QualTransitionLOFuncTermExceedMax | <listOfFunctionTerms> cannot make qualitativeSpecies exceed maxLevel. | | | | | | | | | | QualTransitionLOFuncTermNegative | <listOfFunctionTerms> cannot make qualitativeSpecies negative. | | | | | | | | | | QualInputAllowedCoreAttributes | Core attributes allowed on <input>. | | | | | | | | | | QualInputAllowedElements | Elements allowed on <input>. | | | | | | | | | | QualInputAllowedAttributes | Attributes allowed on <input>. | | | | | | | | | | QualInputNameMustBeString | Attribute 'name' on <input> must be string. | | | | | | | | | | QualInputSignMustBeSignEnum | Attribute 'sign' on <input> must be enum. | | | | | | | | | | QualInputTransEffectMustBeInputEffect | Attribute 'transitionEffect' on <input> must be enum. | | | | | | | | | | QualInputThreshMustBeInteger | Attribute 'thresholdLevel' on <input> must be non negative integer. | | | | | | | | | | QualInputQSMustBeExistingQS | Attribute 'qualitativeSpecies' on <input> must refer to existing | | | | | | | | | | QualInputConstantCannotBeConsumed | Constant <input> cannot be consumed. | | | | | | | | | | QualInputThreshMustBeNonNegative | Attribute 'thresholdLevel' on <input> must be non negative integer. | | | | | | | | | | QualOutputAllowedCoreAttributes | Core attributes allowed on <output>. | | | | | | | | | | QualOutputAllowedElements | Elements allowed on <output>. | | | | | | | | | | QualOutputAllowedAttributes | Attributes allowed on <output>. | | | | | | | | | | QualOutputNameMustBeString | Attribute 'name' on <output> must be string. | | | | | | | | | | QualOutputTransEffectMustBeOutput | Attribute 'transitionEffect' on <output> must be enum. | | | | | | | | | | QualOutputLevelMustBeInteger | Attribute 'outputLevel' on <output> must be non negative integer. | | | | | | | | | | QualOutputQSMustBeExistingQS | Attribute 'qualitativeSpecies' on <output> must refer to existing | | | | | | | | | | QualOutputConstantMustBeFalse | Constant 'qualitativeSpecies' cannot be <output> | | | | | | | | | | QualOutputProductionMustHaveLevel | <output> being produced must have level | | | | | | | | | | QualOutputLevelMustBeNonNegative | Attribute 'outputLevel' on <output> must be non negative integer. | | | | | | | | | | QualDefaultTermAllowedCoreAttributes | Core attributes allowed on <defaultTerm>. | | | | | | | | | | QualDefaultTermAllowedElements | Elements allowed on <defaultTerm>. | | | | | | | | | | QualDefaultTermAllowedAttributes | Attributes allowed on <defaultTerm>. | | | | | | | | | | QualDefaultTermResultMustBeInteger | Attribute 'resultLevel' on <defaultTerm> must be non negative integer. | | | | | | | | | | QualDefaultTermResultMustBeNonNeg | Attribute 'resultLevel' on <defaultTerm> must be non negative integer. | | | | | | | | | | QualFuncTermAllowedCoreAttributes | Core attributes allowed on <functionTerm>. | | | | | | | | | | QualFuncTermAllowedElements | Elements allowed on <functionTerm>. | | | | | | | | | | QualFuncTermAllowedAttributes | Attributes allowed on <functionTerm>. | | | | | | | | | | QualFuncTermOnlyOneMath | Only one <math> on <functionTerm>. | | | | | | | | | | QualFuncTermResultMustBeInteger | Attribute 'resultLevel' on <functionTerm> must be non negative integer. | | | | | | | | | | QualFuncTermResultMustBeNonNeg | Attribute 'resultLevel' on <functionTerm> must be non negative integer. | | | | | | | | | | GroupsUnknown | | | | | | | | | | | GroupsNSUndeclared | The Groups namespace is not correctly declared. | | | | | | | | | | GroupsElementNotInNs | Element not in Groups namespace | | | | | | | | | | GroupsDuplicateComponentId | Duplicate 'id' attribute value | | | | | | | | | | GroupsIdSyntaxRule | Invalid SId syntax | | | | | | | | | | GroupsAttributeRequiredMissing | Required groups:required attribute on <sbml> | | | | | | | | | | GroupsAttributeRequiredMustBeBoolean | The groups:required attribute must be Boolean | | | | | | | | | | GroupsAttributeRequiredMustHaveValue | The groups:required attribute must be 'false' | | | | | | | | | | GroupsModelAllowedElements | Elements allowed on <model>. | | | | | | | | | | GroupsModelEmptyLOElements | No Empty ListOf elements allowed on <Modelgt;. | | | | | | | | | | GroupsModelLOGroupsAllowedCoreElements | Core elements allowed on <model>. | | | | | | | | | | GroupsModelLOGroupsAllowedCoreAttributes | Core attributes allowed on <model>. | | | | | | | | | | GroupsGroupAllowedCoreAttributes | Core attributes allowed on <group>. | | | | | | | | | | GroupsGroupAllowedCoreElements | Core elements allowed on <group>. | | | | | | | | | | GroupsGroupAllowedAttributes | Attributes allowed on <group>. | | | | | | | | | | GroupsGroupAllowedElements | Elements allowed on <group>. | | | | | | | | | | GroupsGroupKindMustBeGroupKindEnum | Kind attribute must be GroupKind. | | | | | | | | | | GroupsGroupNameMustBeString | Name attribute must be String. | | | | | | | | | | GroupsGroupEmptyLOElements | No Empty ListOf elements allowed on <group>. | | | | | | | | | | GroupsGroupLOMembersAllowedCoreElements | Core elements allowed on <listOfMembers>. | | | | | | | | | | GroupsGroupLOMembersAllowedCoreAttributes | Core attributes allowed on <listOfMembers>. | | | | | | | | | | GroupsGroupLOMembersAllowedAttributes | Attributes allowed on <listOfMembers>. | | | | | | | | | | GroupsLOMembersNameMustBeString | Name attribute must be String. | | | | | | | | | | GroupsLOMembersConsistentReferences | Consistent references by multiple <member> objects. | | | | | | | | | | GroupsNotCircularReferences | Circular references by multiple <member> objects. | | | | | | | | | | GroupsMemberAllowedCoreAttributes | Core attributes allowed on <member>. | | | | | | | | | | GroupsMemberAllowedCoreElements | Core elements allowed on <member>. | | | | | | | | | | GroupsMemberAllowedAttributes | Attributes allowed on <member>. | | | | | | | | | | GroupsMemberNameMustBeString | Name attribute must be String. | | | | | | | | | | GroupsMemberIdRefMustBeSBase | Attribute 'idRef' must point to SBase object. | | | | | | | | | | GroupsMemberMetaIdRefMustBeSBase | Attribute 'metaIdRef' must point to SBase object. | | | | | | | | | | GroupsMemberIdRefMustBeSId | Attribute 'idRef' must be type 'SId'. | | | | | | | | | | GroupsMemberMetaIdRefMustBeID | Attribute 'metaIdRef' must be type 'ID'. | | | | | | | | | | LayoutUnknownError | | | | | | | | | | | LayoutNSUndeclared | The layout ns is not correctly declared | | | | | | | | | | LayoutElementNotInNs | Element not in layout namespace | | | | | | | | | | LayoutDuplicateComponentId | Duplicate 'id' attribute value | | | | | | | | | | LayoutSIdSyntax | 'id' attribute incorrect syntax | | | | | | | | | | LayoutXsiTypeAllowedLocations | 'xsi:type' allowed locations | | | | | | | | | | LayoutXsiTypeSyntax | 'xsi:type' attribute incorrect syntax | | | | | | | | | | LayoutAttributeRequiredMissing | Required layout:required attribute on <sbml> | | | | | | | | | | LayoutAttributeRequiredMustBeBoolean | The layout:required attribute must be Boolean | | | | | | | | | | LayoutRequiredFalse | The layout:required attribute must be 'false' | | | | | | | | | | LayoutOnlyOneLOLayouts | Only one listOfLayouts on <model> | | | | | | | | | | LayoutLOLayoutsNotEmpty | ListOf elements cannot be empty | | | | | | | | | | LayoutLOLayoutsAllowedElements | Allowed elements on ListOfLayouts | | | | | | | | | | LayoutLOLayoutsAllowedAttributes | Allowed attributes on ListOfLayouts | | | | | | | | | | LayoutLayoutAllowedElements | Allowed elements on Layout | | | | | | | | | | LayoutLayoutAllowedCoreAttributes | Allowed core attributes on Layout | | | | | | | | | | LayoutOnlyOneEachListOf | Only one each listOf on <layout> | | | | | | | | | | LayoutNoEmptyListOfs | ListOf elements cannot be empty | | | | | | | | | | LayoutLayoutAllowedAttributes | <layout> must have 'id' and may have 'name' | | | | | | | | | | LayoutLayoutNameMustBeString | 'name' must be string | | | | | | | | | | LayoutLOCompGlyphAllowedAttributes | Attributes allowed on <listOfCompartmentGlyphs>. | | | | | | | | | | LayoutLOCompGlyphAllowedElements | Elements allowed on <listOfCompartmentGlyphs>. | | | | | | | | | | LayoutLOSpeciesGlyphAllowedAttributes | Attributes allowed on <listOfSpeciesGlyphs>. | | | | | | | | | | LayoutLOSpeciesGlyphAllowedElements | Elements allowed on <listOfSpeciesGlyphs>. | | | | | | | | | | LayoutLORnGlyphAllowedAttributes | Attributes allowed on <listOfReactionGlyphs>. | | | | | | | | | | LayoutLORnGlyphAllowedElements | Elements allowed on <listOfReactionGlyphs>. | | | | | | | | | | LayoutLOAddGOAllowedAttribut | Attributes allowed on <listOfAdditionalGraphicalObjectGlyphs>. | | | | | | | | | | LayoutLOAddGOAllowedElements | Elements allowed on <listOfAdditionalGraphicalObjectGlyphs>. | | | | | | | | | | LayoutLayoutMustHaveDimensions | Layout must have <dimensions>. | | | | | | | | | | LayoutLOTextGlyphAllowedAttributes | Attributes allowed on <listOfTextGlyphs>. | | | | | | | | | | LayoutLOTextGlyphAllowedElements | Elements allowed on <listOfTextGlyphs>. | | | | | | | | | | LayoutGOAllowedCoreElements | Core elements allowed on <graphicalObject>. | | | | | | | | | | LayoutGOAllowedCoreAttributes | Core attributes allowed on <graphicalObject>. | | | | | | | | | | LayoutGOAllowedElements | Layout elements allowed on <graphicalObject>. | | | | | | | | | | LayoutGOAllowedAttributes | Layout attributes allowed on <graphicalObject>. | | | | | | | | | | LayoutGOMetaIdRefMustBeIDREF | Layout 'metaidRef' must be IDREF. | | | | | | | | | | LayoutGOMetaIdRefMustReferenceObject | Layout 'metaidRef' must reference existing object. | | | | | | | | | | LayoutGOMustContainBoundingBox | A <graphicalObject> must contain a <boundingBox>. | | | | | | | | | | LayoutCGAllowedCoreElements | Core elements allowed on <compartmentGlyph>. | | | | | | | | | | LayoutCGAllowedCoreAttributes | Core attributes allowed on <compartmentGlyph>. | | | | | | | | | | LayoutCGAllowedElements | Layout elements allowed on <compartmentGlyph>. | | | | | | | | | | LayoutCGAllowedAttributes | Layout attributes allowed on <compartmentGlyph>. | | | | | | | | | | LayoutCGMetaIdRefMustBeIDREF | Layout 'metaidRef' must be IDREF. | | | | | | | | | | LayoutCGMetaIdRefMustReferenceObject | Layout 'metaidRef' must reference existing object. | | | | | | | | | | LayoutCGCompartmentSyntax | CompartmentGlyph 'compartment' must have SIdRef syntax. | | | | | | | | | | LayoutCGCompartmentMustRefComp | CompartmentGlyph compartment must reference existing compartment. | | | | | | | | | | LayoutCGNoDuplicateReferences | CompartmentGlyph cannot reference two objects. | | | | | | | | | | LayoutCGOrderMustBeDouble | CompartmentGlyph order must be double. | | | | | | | | | | LayoutSGAllowedCoreElements | Core elements allowed on <speciesGlyph>. | | | | | | | | | | LayoutSGAllowedCoreAttributes | Core attributes allowed on <speciesGlyph>. | | | | | | | | | | LayoutSGAllowedElements | Layout elements allowed on <speciesGlyph>. | | | | | | | | | | LayoutSGAllowedAttributes | Layout attributes allowed on <speciesGlyph>. | | | | | | | | | | LayoutSGMetaIdRefMustBeIDREF | Layout 'metaidRef' must be IDREF. | | | | | | | | | | LayoutSGMetaIdRefMustReferenceObject | Layout 'metaidRef' must reference existing object. | | | | | | | | | | LayoutSGSpeciesSyntax | SpeciesGlyph 'species' must have SIdRef syntax. | | | | | | | | | | LayoutSGSpeciesMustRefSpecies | SpeciesGlyph species must reference existing species. | | | | | | | | | | LayoutSGNoDuplicateReferences | SpeciesGlyph cannot reference two objects. | | | | | | | | | | LayoutRGAllowedCoreElements | Core elements allowed on <reactionGlyph>. | | | | | | | | | | LayoutRGAllowedCoreAttributes | Core attributes allowed on <reactionGlyph>. | | | | | | | | | | LayoutRGAllowedElements | Layout elements allowed on <reactionGlyph>. | | | | | | | | | | LayoutRGAllowedAttributes | Layout attributes allowed on <reactionGlyph>. | | | | | | | | | | LayoutRGMetaIdRefMustBeIDREF | Layout 'metaidRef' must be IDREF. | | | | | | | | | | LayoutRGMetaIdRefMustReferenceObject | Layout 'metaidRef' must reference existing object. | | | | | | | | | | LayoutRGReactionSyntax | ReactionGlyph 'reaction' must have SIdRef syntax. | | | | | | | | | | LayoutRGReactionMustRefReaction | ReactionGlyph reaction must reference existing reaction. | | | | | | | | | | LayoutRGNoDuplicateReferences | ReactionGlyph cannot reference two objects. | | | | | | | | | | LayoutLOSpeciesRefGlyphAllowedElements | Allowed elements on ListOfSpeciesReferenceGlyphs | | | | | | | | | | LayoutLOSpeciesRefGlyphAllowedAttribs | Allowed attributes on ListOfSpeciesReferenceGlyphs | | | | | | | | | | LayoutLOSpeciesRefGlyphNotEmpty | ListOfSpeciesReferenceGlyphs not empty | | | | | | | | | | LayoutGGAllowedCoreElements | Core elements allowed on <generalGlyph>. | | | | | | | | | | LayoutGGAllowedCoreAttributes | Core attributes allowed on <generalGlyph>. | | | | | | | | | | LayoutGGAllowedElements | Layout elements allowed on <generalGlyph>. | | | | | | | | | | LayoutGGAllowedAttributes | Layout attributes allowed on <generalGlyph>. | | | | | | | | | | LayoutGGMetaIdRefMustBeIDREF | Layout 'metaidRef' must be IDREF. | | | | | | | | | | LayoutGGMetaIdRefMustReferenceObject | Layout 'metaidRef' must reference existing object. | | | | | | | | | | LayoutGGReferenceSyntax | GeneralGlyph 'reference' must have SIdRef syntax. | | | | | | | | | | LayoutGGReferenceMustRefObject | GeneralGlyph 'reference' must reference existing element. | | | | | | | | | | LayoutGGNoDuplicateReferences | GeneralGlyph cannot reference two objects. | | | | | | | | | | LayoutLOReferenceGlyphAllowedElements | Allowed elements on ListOfReferenceGlyphs | | | | | | | | | | LayoutLOReferenceGlyphAllowedAttribs | Allowed attributes on ListOfReferenceGlyphs | | | | | | | | | | LayoutLOSubGlyphAllowedElements | | | | | | | | | | | LayoutLOSubGlyphAllowedAttribs | Allowed attributes on ListOfSubGlyphs | | | | | | | | | | LayoutTGAllowedCoreElements | Core elements allowed on <textGlyph>. | | | | | | | | | | LayoutTGAllowedCoreAttributes | Core attributes allowed on <textGlyph>. | | | | | | | | | | LayoutTGAllowedElements | Layout elements allowed on <textGlyph>. | | | | | | | | | | LayoutTGAllowedAttributes | Layout attributes allowed on <textGlyph>. | | | | | | | | | | LayoutTGMetaIdRefMustBeIDREF | Layout 'metaidRef' must be IDREF. | | | | | | | | | | LayoutTGMetaIdRefMustReferenceObject | Layout 'metaidRef' must reference existing object. | | | | | | | | | | LayoutTGOriginOfTextSyntax | TextGlyph 'originOfText' must have SIdRef syntax. | | | | | | | | | | LayoutTGOriginOfTextMustRefObject | TextGlyph 'originOfText' must reference existing element. | | | | | | | | | | LayoutTGNoDuplicateReferences | TextGlyph cannot reference two objects. | | | | | | | | | | LayoutTGGraphicalObjectSyntax | TextGlyph 'graphicalObject' must have SIdRef syntax. | | | | | | | | | | LayoutTGGraphicalObjectMustRefObject | TextGlyph 'graphicalObject' must reference existing element. | | | | | | | | | | LayoutTGTextMustBeString | TextGlyph 'text' must be string. | | | | | | | | | | LayoutSRGAllowedCoreElements | Core elements allowed on <speciesReferenceGlyph>. | | | | | | | | | | LayoutSRGAllowedCoreAttributes | Core attributes allowed on <speciesReferenceGlyph>. | | | | | | | | | | LayoutSRGAllowedElements | Layout elements allowed on <speciesReferenceGlyph>. | | | | | | | | | | LayoutSRGAllowedAttributes | Layout attributes allowed on <speciesReferenceGlyph>. | | | | | | | | | | LayoutSRGMetaIdRefMustBeIDREF | Layout 'metaidRef' must be IDREF. | | | | | | | | | | LayoutSRGMetaIdRefMustReferenceObject | Layout 'metaidRef' must reference existing object. | | | | | | | | | | LayoutSRGSpeciesReferenceSyntax | SpeciesReferenceGlyph 'speciesReference' must have SIdRef syntax. | | | | | | | | | | LayoutSRGSpeciesRefMustRefObject | SpeciesReferenceGlyph 'speciesReference' must reference existing element. | | | | | | | | | | LayoutSRGNoDuplicateReferences | SpeciesReferenceGlyph cannot reference two objects. | | | | | | | | | | LayoutSRGSpeciesGlyphSyntax | SpeciesReferenceGlyph 'speciesGlyph' must have SIdRef syntax. | | | | | | | | | | LayoutSRGSpeciesGlyphMustRefObject | SpeciesReferenceGlyph 'speciesGlyph' must reference existing element. | | | | | | | | | | LayoutSRGRoleSyntax | SpeciesReferenceGlyph 'role' must be string from enumeration. | | | | | | | | | | LayoutREFGAllowedCoreElements | Core elements allowed on <referenceGlyph>. | | | | | | | | | | LayoutREFGAllowedCoreAttributes | Core attributes allowed on <referenceGlyph>. | | | | | | | | | | LayoutREFGAllowedElements | Layout elements allowed on <referenceGlyph>. | | | | | | | | | | LayoutREFGAllowedAttributes | Layout attributes allowed on <referenceGlyph>. | | | | | | | | | | LayoutREFGMetaIdRefMustBeIDREF | Layout 'metaidRef' must be IDREF. | | | | | | | | | | LayoutREFGMetaIdRefMustReferenceObject | Layout 'metaidRef' must reference existing object. | | | | | | | | | | LayoutREFGReferenceSyntax | ReferenceGlyph 'reference' must have SIdRef syntax. | | | | | | | | | | LayoutREFGReferenceMustRefObject | ReferenceGlyph 'reference' must reference existing element. | | | | | | | | | | LayoutREFGNoDuplicateReferences | ReferenceGlyph cannot reference two objects. | | | | | | | | | | LayoutREFGGlyphSyntax | ReferenceGlyph 'glyph' must have SIdRef syntax. | | | | | | | | | | LayoutREFGGlyphMustRefObject | ReferenceGlyph 'glyph' must reference existing element. | | | | | | | | | | LayoutREFGRoleSyntax | ReferenceGlyph 'role' must be string. | | | | | | | | | | LayoutPointAllowedCoreElements | Core elements allowed on <pointgt;. | | | | | | | | | | LayoutPointAllowedCoreAttributes | Core attributes allowed on <pointgt;. | | | | | | | | | | LayoutPointAllowedAttributes | Layout attributes allowed on <pointgt;. | | | | | | | | | | LayoutPointAttributesMustBeDouble | Layout 'x', 'y' and 'z' must be double. | | | | | | | | | | LayoutBBoxAllowedCoreElements | Core elements allowed on <boundingBox>. | | | | | | | | | | LayoutBBoxAllowedCoreAttributes | Core attributes allowed on <boundingBox>. | | | | | | | | | | LayoutBBoxAllowedElements | Layout elements allowed on <boundingBox>. | | | | | | | | | | LayoutBBoxAllowedAttributes | Layout attributes allowed on <boundingBox>. | | | | | | | | | | LayoutBBoxConsistent3DDefinition | Layout consistent dimensions on a <boundingBox> | | | | | | | | | | LayoutCurveAllowedCoreElements | Core elements allowed on <curve>. | | | | | | | | | | LayoutCurveAllowedCoreAttributes | Core attributes allowed on <curve>. | | | | | | | | | | LayoutCurveAllowedElements | Layout elements allowed on <curve>. | | | | | | | | | | LayoutCurveAllowedAttributes | Layout attributes allowed on <curve>. | | | | | | | | | | LayoutLOCurveSegsAllowedAttributes | Allowed attributes on ListOfCurveSegments | | | | | | | | | | LayoutLOCurveSegsAllowedElements | Allowed elements on ListOfCurveSegments | | | | | | | | | | LayoutLOCurveSegsNotEmpty | No empty ListOfCurveSegments | | | | | | | | | | LayoutLSegAllowedCoreElements | Core elements allowed on <lineSegment>. | | | | | | | | | | LayoutLSegAllowedCoreAttributes | Core attributes allowed on <lineSegment>. | | | | | | | | | | LayoutLSegAllowedElements | Layout elements allowed on <lineSegment>. | | | | | | | | | | LayoutLSegAllowedAttributes | Layout attributes allowed on <lineSegment>. | | | | | | | | | | LayoutCBezAllowedCoreElements | Core elements allowed on <cubicBezier>. | | | | | | | | | | LayoutCBezAllowedCoreAttributes | Core attributes allowed on <cubicBezier>. | | | | | | | | | | LayoutCBezAllowedElements | Layout elements allowed on <cubicBezier>. | | | | | | | | | | LayoutCBezAllowedAttributes | Layout attributes allowed on <cubicBezier>. | | | | | | | | | | LayoutDimsAllowedCoreElements | Core elements allowed on <dimensions>. | | | | | | | | | | LayoutDimsAllowedCoreAttributes | Core attributes allowed on <dimensions>. | | | | | | | | | | LayoutDimsAllowedAttributes | Layout attributes allowed on <dimensions>. | | | | | | | | | | LayoutDimsAttributesMustBeDouble | Layout 'width', 'height' and 'depth' must be double. | | | | | | | | | +-------------------------------------------+------------------------------------------------------------------------------------------------------+-------+-------+-------+-------+-------+-------+-------+-------+ Category codes associated with SBMLError objects ...................................................................... As discussed above, each SBMLError object contains a value for a category identifier, describing the type of issue that the SBMLError object represents. The category can be retrieved from an SBMLError object using the method SBMLError.getCategory(). The following table lists each possible value and a brief description of its meaning. As is the case with the error codes, in the libSBML Python language interface, the category identifiers are currently implemented as static integer constants defined in the interface class libsbml. The following table lists each possible value and a brief description of its meaning. <center> LIBSBML_CAT_SBML General error not falling into another category below. LIBSBML_CAT_SBML_L1_COMPAT Category of errors that can only occur during attempted translation from one Level/Version of SBML to another. This particular category applies to errors encountered while trying to convert a model from SBML Level 2 to SBML Level 1. LIBSBML_CAT_SBML_L2V1_COMPAT Category of errors that can only occur during attempted translation from one Level/Version of SBML to another. This particular category applies to errors encountered while trying to convert a model to SBML Level 2 Version 1. LIBSBML_CAT_SBML_L2V2_COMPAT Category of errors that can only occur during attempted translation from one Level/Version of SBML to another. This particular category applies to errors encountered while trying to convert a model to SBML Level 2 Version 2. LIBSBML_CAT_GENERAL_CONSISTENCY Category of errors that can occur while validating general SBML constructs. 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. LIBSBML_CAT_IDENTIFIER_CONSISTENCY Category of errors that can occur while validating symbol identifiers in a model. 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. LIBSBML_CAT_UNITS_CONSISTENCY Category of errors that can occur while validating the units of measurement on 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. LIBSBML_CAT_MATHML_CONSISTENCY Category of errors that can occur while validating MathML formulas in a model. 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. LIBSBML_CAT_SBO_CONSISTENCY Category of errors that can occur while validating SBO identifiers in a 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. LIBSBML_CAT_OVERDETERMINED_MODEL Error in the system of equations in the model: the system is overdetermined, therefore violating a tenet of proper SBML. With respect to the SBML specification, this is validation rule #10601 in the SBML Level 2 Versions 2-4 and Level 3 Versions 1-2 specifications. LIBSBML_CAT_SBML_L2V3_COMPAT Category of errors that can only occur during attempted translation from one Level/Version of SBML to another. This particular category applies to errors encountered while trying to convert a model to SBML Level 2 Version 3. LIBSBML_CAT_MODELING_PRACTICE Category of warnings about recommended good practices involving SBML and computational modeling. (These are tests performed by libSBML and do not have equivalent SBML validation rules.) LIBSBML_CAT_INTERNAL_CONSISTENCY Category of errors that can occur while validating libSBML's internal representation of SBML constructs. (These are tests performed by libSBML and do not have equivalent SBML validation rules.) LIBSBML_CAT_SBML_L2V4_COMPAT Category of errors that can only occur during attempted translation from one Level/Version of SBML to another. This particular category applies to errors encountered while trying to convert a model to SBML Level 2 Version 4. LIBSBML_CAT_SBML_L3V1_COMPAT Category of errors that can only occur during attempted translation from one Level/Version of SBML to another. This particular category applies to errors encountered while trying to convert a model to SBML Level 3 Version 1. </center> <a class='anchor' name='SBMLErrorSeverity_t'>Severity codes associated with SBMLError objects ...................................................................... In libSBML version 5.17.2 there are no additional severity codes beyond those defined by XMLError. They are implemented as static integer constants defined in the interface class libsbml, and have names beginning with LIBSBML_SEV_. """ __swig_setmethods__ = {} for _s in [XMLError]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLError, name, value) __swig_getmethods__ = {} for _s in [XMLError]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, SBMLError, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(SBMLError self, unsigned int const errorId=0, unsigned int const level, unsigned int const version, string details, unsigned int const line=0, unsigned int const column=0, unsigned int const severity=LIBSBML_SEV_ERROR, unsigned int const category=LIBSBML_CAT_SBML, string package, unsigned int const pkgVersion=1) -> SBMLError __init__(SBMLError self, unsigned int const errorId=0, unsigned int const level, unsigned int const version, string details, unsigned int const line=0, unsigned int const column=0, unsigned int const severity=LIBSBML_SEV_ERROR, unsigned int const category=LIBSBML_CAT_SBML, string package) -> SBMLError __init__(SBMLError self, unsigned int const errorId=0, unsigned int const level, unsigned int const version, string details, unsigned int const line=0, unsigned int const column=0, unsigned int const severity=LIBSBML_SEV_ERROR, unsigned int const category=LIBSBML_CAT_SBML) -> SBMLError __init__(SBMLError self, unsigned int const errorId=0, unsigned int const level, unsigned int const version, string details, unsigned int const line=0, unsigned int const column=0, unsigned int const severity=LIBSBML_SEV_ERROR) -> SBMLError __init__(SBMLError self, unsigned int const errorId=0, unsigned int const level, unsigned int const version, string details, unsigned int const line=0, unsigned int const column=0) -> SBMLError __init__(SBMLError self, unsigned int const errorId=0, unsigned int const level, unsigned int const version, string details, unsigned int const line=0) -> SBMLError __init__(SBMLError self, unsigned int const errorId=0, unsigned int const level, unsigned int const version, string details) -> SBMLError __init__(SBMLError self, unsigned int const errorId=0, unsigned int const level, unsigned int const version) -> SBMLError __init__(SBMLError self, unsigned int const errorId=0, unsigned int const level) -> SBMLError __init__(SBMLError self, unsigned int const errorId=0) -> SBMLError __init__(SBMLError self) -> SBMLError __init__(SBMLError self, SBMLError orig) -> SBMLError This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: SBMLError(SBMLError orig) Copy constructor; creates a copy of this SBMLError. Parameter 'orig' is the instance to copy. ______________________________________________________________________ Method variant with the following signature: SBMLError( long errorId = 0 , long level = SBML_DEFAULT_LEVEL , long version = SBML_DEFAULT_VERSION , string details = '' , long line = 0 , long column = 0 , long severity = LIBSBML_SEV_ERROR , long category = LIBSBML_CAT_SBML , string package = 'core' , long pkgVersion = 1 ) Creates a new SBMLError to report that something occurred during SBML processing. When a libSBML operation on SBML content results in a warning, error or other diagnostic, the issue is reported as an SBMLError object. SBMLError objects have identification numbers to indicate the nature of the exception. These numbers are defined as longeger constants in the interface class libsbml. See the top of this documentation page for a table listing the possible values and their meanings. The argument 'errorId' to this constructor can be (but does not have to be) a value from this set of constants. If it is one of the predefined error identifiers, the SBMLError class assumes the error is a low-level system or SBML layer error and prepends a built-in, predefined error message to any string passed in the argument 'details' to this constructor. In addition, all the predefined error identifiers have associated values for the 'severity' and 'category' codes, and these fields are filled-in using the libSBML defaults for each different error identifier. If the error identifier 'errorId' is a number greater than 99999, the SBMLError class assumes the error was generated from another part of the software and does not do additional filling in of values beyond the default in the constructor itself. This allows SBMLError to serve as a base class for other errors, such as for user-defined validation rules (see Validator). Callers should fill in all the parameters with suitable values if generating errors with codes greater than 99999 to make maximum use of the SBMLError facilities. As mentioned above, there are additional constants defined for standard severity and standard category codes, and every predefined error in libSBML has an associated value for severity and category taken from these predefined sets. These constants have symbol names prefixed with LIBSBML_SEV_ and LIBSBML_CAT_, respectively. If the value of 'errorId' is one of the standard error codes, callers do not need to fill in 'severity' and 'category' in a call to this constructor. Conversely, if 'errorId' is not an existing SBML-level error code, callers can use other values for 'severity' and 'category'. Please see the top of the documentation for SBMLError for a longer discussion of the possible error codes, their meanings, and their applicability to different combinations of Level+Version of SBML. Parameter 'errorId' is a long integer, the identification number of the error. Parameter 'level' is the SBML Level of the SBML model. Parameter 'version' is the SBML Version within the Level of the SBML model. Parameter 'details' is a string containing additional details about the error. If the error code in 'errorId' is one that is recognized by SBMLError, the given message is appended to a predefined message associated with the given code. If the error code is not recognized, the message is stored as-is as the text of the error. Parameter 'line' is a long integer, the line number at which the error occured. Parameter 'column' is a long integer, the column number at which the error occured. Parameter 'severity' is an integer indicating severity of the error. Parameter 'category' is an integer indicating the category to which the error belongs. Parameter 'package' is the SBML Level package involved. Parameter 'pkgVersion' is the version of the 'package'. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ this = _libsbml.new_SBMLError(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_SBMLError __del__ = lambda self: None SBMLError_swigregister = _libsbml.SBMLError_swigregister SBMLError_swigregister(SBMLError) MODEL_QUALIFIER = _libsbml.MODEL_QUALIFIER BIOLOGICAL_QUALIFIER = _libsbml.BIOLOGICAL_QUALIFIER UNKNOWN_QUALIFIER = _libsbml.UNKNOWN_QUALIFIER BQM_IS = _libsbml.BQM_IS BQM_IS_DESCRIBED_BY = _libsbml.BQM_IS_DESCRIBED_BY BQM_IS_DERIVED_FROM = _libsbml.BQM_IS_DERIVED_FROM BQM_IS_INSTANCE_OF = _libsbml.BQM_IS_INSTANCE_OF BQM_HAS_INSTANCE = _libsbml.BQM_HAS_INSTANCE BQM_UNKNOWN = _libsbml.BQM_UNKNOWN BQB_IS = _libsbml.BQB_IS BQB_HAS_PART = _libsbml.BQB_HAS_PART BQB_IS_PART_OF = _libsbml.BQB_IS_PART_OF BQB_IS_VERSION_OF = _libsbml.BQB_IS_VERSION_OF BQB_HAS_VERSION = _libsbml.BQB_HAS_VERSION BQB_IS_HOMOLOG_TO = _libsbml.BQB_IS_HOMOLOG_TO BQB_IS_DESCRIBED_BY = _libsbml.BQB_IS_DESCRIBED_BY BQB_IS_ENCODED_BY = _libsbml.BQB_IS_ENCODED_BY BQB_ENCODES = _libsbml.BQB_ENCODES BQB_OCCURS_IN = _libsbml.BQB_OCCURS_IN BQB_HAS_PROPERTY = _libsbml.BQB_HAS_PROPERTY BQB_IS_PROPERTY_OF = _libsbml.BQB_IS_PROPERTY_OF BQB_HAS_TAXON = _libsbml.BQB_HAS_TAXON BQB_UNKNOWN = _libsbml.BQB_UNKNOWN class CVTerm(_object): """ A MIRIAM-compliant controlled vocabulary term. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. The SBML Level 2 and Level 3 specifications define a simple format for annotating models when (a) referring to controlled vocabulary terms and database identifiers that define and describe biological and biochemical entities, and (b) describing the creator of a model and the model's modification history. This SBML format is a concrete syntax that conforms to the guidelines of MIRIAM ('Minimum Information Requested in the Annotation of biochemical Models', Nature Biotechnology, vol. 23, no. 12, Dec. 2005). The format uses a subset of W3C RDF (Resource Description Format). In order to help application developers work with annotations in this format, libSBML provides several helper classes that provide higher-level interfaces to the data elements; these classes include CVTerm, ModelCreator, ModelHistory, RDFAnnotationParser, and Date. Components of an SBML annotation ====================================================================== The SBML annotation format consists of RDF-based content placed inside an <annotation> element attached to an SBML component such as Species, Compartment, etc. A small change was introduced in SBML Level 2 Version 5 and SBML Level 3 Version 2 to permit nested annotations: lower Versions of the SBML specifications did not explicitly allow this. We first describe the different parts of SBML annotations in XML form for SBML Level 2 below Version 5 and SBML Level 3 below Version 2: <SBML_ELEMENT +++ metaid="meta id" +++> +++ <annotation> +++ <rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#' xmlns:dcterm='http://purl.org/dc/terms/' xmlns:vcard='http://www.w3.org/2001/vcard-rdf/3.0#' xmlns:bqbiol='http://biomodels.net/biology-qualifiers/' xmlns:bqmodel='http://biomodels.net/model-qualifiers/' > <rdf:Description rdf:about="#meta id"> HISTORY <RELATION_ELEMENT> <rdf:Bag> <rdf:li rdf:resource="URI" /> ... </rdf:Bag> </RELATION_ELEMENT> ... </rdf:Description> +++ </rdf:RDF> +++ </annotation> +++ </SBML_ELEMENT> In the template above, the placeholder SBML_ELEMENT stands for the XML tag name of an SBML model component (e.g., model, reaction, etc.) and the placeholder meta id stands for the element's meta identifier, which is a field available on all SBML components derived from the SBase base object class. The dotted portions are optional, the symbol +++ is a placeholder for either no content or valid XML content that is not defined by this annotation scheme, and the ellipses ... are placeholders for zero or more elements of the same form as the immediately preceding element. The optional content HISTORY is a creation and modification history; in libSBML, this is stored using ModelHistory objects. The placeholder RELATION_ELEMENT refers to a BioModels.net qualifier element name. This is an element in either the XML namespace 'http://biomodels.net/model-qualifiers' (for model qualifiers) or 'http://biomodels.net/biology-qualifiers' (for biological qualifier). Note that these namespace URIs are only labels, and not actual Web locations, which means you cannot visit an address such as 'http://biomodels.net/model-qualifiers' in your browser or try to have your application access it. The URI is a required data value that uniquely identifies a resource and data within that resource to which the annotation refers. Again, being URIs, these do not refer to physical Web locations; nevertheless, applications will often want a means of finding the resource to which a given URI refers. Providing the facilities for this task is the purpose of MIRIAM Resources, described in detail online at http://biomodels.net/miriam) and also in the paper 'MIRIAM Resources: tools to generate and resolve robust cross-references in Systems Biology', BMC Systems Biology, 58(1), 2007. Finally, the following is the same template as above, but this time showing the nested content permitted by the most recent SBML specifications (SBML Level 2 Version 5 and Level 3 Version 2): <SBML_ELEMENT +++ metaid="meta id" +++> +++ <annotation> +++ <rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#' xmlns:dcterm='http://purl.org/dc/terms/' xmlns:vcard='http://www.w3.org/2001/vcard-rdf/3.0#' xmlns:bqbiol='http://biomodels.net/biology-qualifiers/' xmlns:bqmodel='http://biomodels.net/model-qualifiers/' > <rdf:Description rdf:about="#meta id"> HISTORY <RELATION_ELEMENT> <rdf:Bag> <rdf:li rdf:resource="URI" /> NESTED_CONTENT ... </rdf:Bag> </RELATION_ELEMENT> ... </rdf:Description> +++ </rdf:RDF> +++ </annotation> +++ </SBML_ELEMENT> The placeholder NESTED_CONTENT refers to other optional RDF elements such as 'bqbiol:isDescribedBy' that describe a clarification or another annotation about the RELATION_ELEMENT in which it appears. Nested content allows one to, for example, describe protein modifications on species, or to add evidence codes for an annotation. Nested content relates to its containing RELATION_ELEMENT, not the other way around. It qualifies it, but does not change its meaning. As such, ignoring a NESTED_CONTENT does not affect the information provided by the containing RELATION_ELEMENT. For more information about SBML annotations in general, please refer to Section 6 in the SBML Level 2 (Versions 2-4) or Level 3 specification documents. The parts of a CVTerm ====================================================================== Annotations that refer to controlled vocabularies are managed in libSBML using CVTerm objects. The relation-resource pairs discussed in the previous section are the 'controlled vocabulary' terms that CVTerm is designed to store and manipulate. A set of RDF-based annotations attached to a given SBML <annotation> element are read by RDFAnnotationParser and converted into a list of these CVTerm objects. Each CVTerm object instance stores the following components of an annotation: * The qualifier, which can be a BioModels.net 'biological qualifier', a BioModels.net 'model qualifier', or an unknown qualifier (as far as the CVTerm class is concerned). Qualifiers are used in MIRIAM to indicate the nature of the relationship between the object being annotated and the resource. In CVTerm, the qualifiers can be manipulated using the methods CVTerm.getQualifierType(), CVTerm.setQualifierType(), and related methods. * The resource, represented by a URI (which, we must remind developers, is not the same as a URL). In the CVTerm class, the resource component can be manipulated using the methods CVTerm.addResource() and CVTerm.removeResource(). Note that a CVTerm contains a single qualifier, but possibly more than one resource. This corresponds to the possibility of an annotation that points to multiple resources, all of which are qualified by the same BioModels.net qualifier. The CVTerm object class supports this by supporting a list of resources. Detailed explanations of the qualifiers defined by BioModels.net can be found at http://co.mbine.org/standards/qualifiers. """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, CVTerm, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, CVTerm, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_CVTerm __del__ = lambda self: None def __init__(self, *args): """ __init__(CVTerm self, QualifierType_t type=UNKNOWN_QUALIFIER) -> CVTerm __init__(CVTerm self) -> CVTerm __init__(CVTerm self, XMLNode node) -> CVTerm __init__(CVTerm self, CVTerm orig) -> CVTerm This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: CVTerm(CVTerm orig) Copy constructor; creates a copy of a CVTerm object. Parameter 'orig' is the CVTerm instance to copy. ______________________________________________________________________ Method variant with the following signature: CVTerm( XMLNode node) Creates a new CVTerm from the given XMLNode. The SBML Level 2 and Level 3 specifications define a simple format for annotating models when (a) referring to controlled vocabulary terms and database identifiers that define and describe biological and other entities, and (b) describing the creator of a model and the model's modification history. The annotation content is stored in <annotation> elements attached to individual SBML elements. The format for storing the content inside SBML <annotation> elements is a subset of W3C RDF (Resource Description Format) expressed in XML. The CVTerm class provides a programming interface for working directly with controlled vocabulary term ('CV term') objects without having to deal directly with the XML form. When libSBML reads in an SBML model containing RDF annotations, it parses those annotations into a list of CVTerm objects, and when writing a model, it parses the CVTerm objects back into the appropriate SBML <annotation> structure. This method creates a CVTerm object from the given XMLNode object 'node'. XMLNode is libSBML's representation of a node in an XML tree of elements, and each such element can be placed in a namespace. This constructor looks for the element to be in the XML namespaces 'http://biomodels.net/model-qualifiers' (for model qualifiers) and 'http://biomodels.net/biology-qualifiers' (for biological qualifier), and if they are, creates CVTerm objects for the result. Parameter 'node' is an XMLNode representing a CVTerm. Note: This method assumes that the given XMLNode object 'node' is of the correct structural form. ______________________________________________________________________ Method variant with the following signature: CVTerm(QualifierType_t type = UNKNOWN_QUALIFIER) Creates an empty CVTerm, optionally with the given qualifier 'type' . The SBML Level 2 and Level 3 specifications define a simple format for annotating models when (a) referring to controlled vocabulary terms and database identifiers that define and describe biological and other entities, and (b) describing the creator of a model and the model's modification history. The annotation content is stored in <annotation> elements attached to individual SBML elements. The format for storing the content inside SBML <annotation> elements is a subset of W3C RDF (Resource Description Format) expressed in XML. The CVTerm class provides a programming interface for working directly with controlled vocabulary term ('CV term') objects without having to deal directly with the XML form. When libSBML reads in an SBML model containing RDF annotations, it parses those annotations into a list of CVTerm objects, and when writing a model, it parses the CVTerm objects back into the appropriate SBML <annotation> structure. This method creates an empty CVTerm object. The possible qualifier types usable as values of 'type' are MODEL_QUALIFIER and BIOLOGICAL_QUALIFIER. If an explicit value for 'type' is not given, this method defaults to using UNKNOWN_QUALIFIER. The qualifier type can be set later using the CVTerm.setQualifierType() method. Different BioModels.net qualifier elements encode different types of relationships. Please refer to the SBML specification or the BioModels.net qualifiers web page for an explanation of the meaning of these different qualifiers. Parameter 'type' is a qualifier type. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ this = _libsbml.new_CVTerm(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(CVTerm self) -> CVTerm Creates and returns a deep copy of this CVTerm object. Returns the (deep) copy of this CVTerm object. """ return _libsbml.CVTerm_clone(self) def getQualifierType(self, *args): """ getQualifierType(CVTerm self) -> QualifierType_t getQualifierType(CVTerm self) -> QualifierType_t Returns the qualifier type of this CVTerm object. The RDF element used in the SBML format for referring to external entities is <rdf:Description>, with a <rdf:Bag> element inside of it containing one or more <rdf:li> elements. The following template illustrates the structure: <rdf:Description rdf:about="#meta id"> HISTORY <RELATION_ELEMENT> <rdf:Bag> <rdf:li rdf:resource="resource URI" /> ... </rdf:Bag> </RELATION_ELEMENT> ... </rdf:Description> In the template above, the placeholder meta id stands for the element's meta identifier, which is a field available on all SBML components derived from the SBase base object class. The dotted portions are optional, and the ellipses ... are placeholders for zero or more elements of the same form as the immediately preceding element. The placeholder RELATION_ELEMENT refers to a BioModels.net qualifier element name. This is an element in either the XML namespace 'http://biomodels.net/model-qualifiers' (for model qualifiers) or 'http://biomodels.net/biology-qualifiers' (for biological qualifier). The present method returns a code identifying which one of these two relationship namespaces is being used; any other qualifier in libSBML is considered unknown (as far as the CVTerm class is concerned). Consequently, this method will return one of the following values: * MODEL_QUALIFIER * BIOLOGICAL_QUALIFIER * UNKNOWN_QUALIFIER The specific relationship of this CVTerm to the enclosing SBML object can be determined using the CVTerm methods such as CVTerm.getModelQualifierType() and CVTerm.getBiologicalQualifierType(). Callers will typically want to use the present method to find out which one of the other two methods to call to find out the specific relationship. Returns the qualifier type of this object or UNKNOWN_QUALIFIER (the default). See also getResources(), getModelQualifierType(), getBiologicalQualifierType(). """ return _libsbml.CVTerm_getQualifierType(self, *args) def getModelQualifierType(self, *args): """ getModelQualifierType(CVTerm self) -> ModelQualifierType_t getModelQualifierType(CVTerm self) -> ModelQualifierType_t Returns the model qualifier type of this CVTerm object. The RDF element used in the SBML format for referring to external entities is <rdf:Description>, with a <rdf:Bag> element inside of it containing one or more <rdf:li> elements. The following template illustrates the structure: <rdf:Description rdf:about="#meta id"> HISTORY <RELATION_ELEMENT> <rdf:Bag> <rdf:li rdf:resource="resource URI" /> ... </rdf:Bag> </RELATION_ELEMENT> ... </rdf:Description> In the template above, the placeholder meta id stands for the element's meta identifier, which is a field available on all SBML components derived from the SBase base object class. The dotted portions are optional, and the ellipses ... are placeholders for zero or more elements of the same form as the immediately preceding element. The placeholder RELATION_ELEMENT refers to a BioModels.net qualifier element name. This is an element in either the XML namespace 'http://biomodels.net/model-qualifiers' (for model qualifiers) or 'http://biomodels.net/biology-qualifiers' (for biological qualifier). Callers will typically use CVTerm.getQualifierType() to find out the type of qualifier relevant to this particular CVTerm object, then if it is a model qualifier, use the present method to determine the specific qualifier. Annotations with model qualifiers express a relationship between an annotation resource and the modeling concept represented by a given object in the model. The diagram below illustrates the relationship in this case: +---------------------+ qualifier +---------------------+ | model element +------------------>| annotation | +----------+----------+ +---------------------+ | | | represents | represents v v +---------------------+ relationship +---------------------+ | modelling object A +------------------>| modelling object B | +---------------------+ +---------------------+ The set of known model qualifiers is, at the time of this libSBML release, the following: * BQM_IS * BQM_IS_DESCRIBED_BY * BQM_IS_DERIVED_FROM * BQM_IS_INSTANCE_OF * BQM_HAS_INSTANCE Any other BioModels.net qualifier found in the model is considered unknown by libSBML and reported as BQM_UNKNOWN. Returns the model qualifier type of this object or BQM_UNKNOWN (the default). """ return _libsbml.CVTerm_getModelQualifierType(self, *args) def getBiologicalQualifierType(self, *args): """ getBiologicalQualifierType(CVTerm self) -> BiolQualifierType_t getBiologicalQualifierType(CVTerm self) -> BiolQualifierType_t Returns the biological qualifier type of this CVTerm object. The RDF element used in the SBML format for referring to external entities is <rdf:Description>, with a <rdf:Bag> element inside of it containing one or more <rdf:li> elements. The following template illustrates the structure: <rdf:Description rdf:about="#meta id"> HISTORY <RELATION_ELEMENT> <rdf:Bag> <rdf:li rdf:resource="resource URI" /> ... </rdf:Bag> </RELATION_ELEMENT> ... </rdf:Description> In the template above, the placeholder meta id stands for the element's meta identifier, which is a field available on all SBML components derived from the SBase base object class. The dotted portions are optional, and the ellipses ... are placeholders for zero or more elements of the same form as the immediately preceding element. The placeholder RELATION_ELEMENT refers to a BioModels.net qualifier element name. This is an element in either the XML namespace 'http://biomodels.net/model-qualifiers' (for model qualifiers) or 'http://biomodels.net/biology-qualifiers' (for biological qualifier). Callers will typically use CVTerm.getQualifierType() to find out the type of qualifier relevant to this particular CVTerm object, then if it is a biological qualifier, use the present method to determine the specific qualifier. Annotations with biological qualifiers express a relationship between an annotation resource and the biological concept represented by a given object in the model. The diagram below illustrates the relationship in this case: +---------------------+ qualifier +---------------------+ | model element +------------------>| annotation | +----------+----------+ +---------------------+ | | | represents | represents v v +---------------------+ relationship +---------------------+ | biological entity A +------------------>| biological entity B | +---------------------+ +---------------------+ The set of known biological qualifiers is, at the time of this libSBML release, the following: * BQB_IS * BQB_HAS_PART * BQB_IS_PART_OF * BQB_IS_VERSION_OF * BQB_HAS_VERSION * BQB_IS_HOMOLOG_TO * BQB_IS_DESCRIBED_BY * BQB_IS_ENCODED_BY * BQB_ENCODES * BQB_OCCURS_IN * BQB_HAS_PROPERTY * BQB_IS_PROPERTY_OF * BQB_HAS_TAXON Any other BioModels.net qualifier found in the model is considered unknown by libSBML and reported as BQB_UNKNOWN. Returns the biology qualifier type of this object or BQB_UNKNOWN (the default). """ return _libsbml.CVTerm_getBiologicalQualifierType(self, *args) def getResources(self, *args): """ getResources(CVTerm self) -> XMLAttributes getResources(CVTerm self) -> XMLAttributes Returns the resource references for this CVTerm object. The RDF element used in the SBML format for referring to external entities is <rdf:Description>, with a <rdf:Bag> element inside of it containing one or more <rdf:li> elements. The following template illustrates the structure: <rdf:Description rdf:about="#meta id"> HISTORY <RELATION_ELEMENT> <rdf:Bag> <rdf:li rdf:resource="resource URI" /> ... </rdf:Bag> </RELATION_ELEMENT> ... </rdf:Description> In the template above, the placeholder meta id stands for the element's meta identifier, which is a field available on all SBML components derived from the SBase base object class. The dotted portions are optional, and the ellipses ... are placeholders for zero or more elements of the same form as the immediately preceding element. The resource URI values shown in the template above are stored internally in CVTerm objects using an XMLAttributes object. Each attribute stored inside the XMLAttributes will have the same name (specifically, "rdf:resource") but a different value, and the value will be a resource URI shown in the XML template above. A valid CVTerm entity must always have at least one resource and a value for the relationship qualifier. Returns the XMLAttributes that store the resources of this CVTerm. See also getQualifierType(), addResource(), getResourceURI(). """ return _libsbml.CVTerm_getResources(self, *args) def getNumResources(self, *args): """ getNumResources(CVTerm self) -> unsigned int getNumResources(CVTerm self) -> unsigned int Returns the number of resources for this CVTerm object. The RDF element used in the SBML format for referring to external entities is <rdf:Description>, with a <rdf:Bag> element inside of it containing one or more <rdf:li> elements. The following template illustrates the structure: <rdf:Description rdf:about="#meta id"> HISTORY <RELATION_ELEMENT> <rdf:Bag> <rdf:li rdf:resource="resource URI" /> ... </rdf:Bag> </RELATION_ELEMENT> ... </rdf:Description> In the template above, the placeholder meta id stands for the element's meta identifier, which is a field available on all SBML components derived from the SBase base object class. The dotted portions are optional, and the ellipses ... are placeholders for zero or more elements of the same form as the immediately preceding element. The fragment above illustrates that there can be more than one resource referenced by a given relationship annotation (i.e., the resource URI values associated with a particular RELATION_ELEMENT). The present method returns a count of the resources stored in this CVTerm object. Returns the number of resources in the set of XMLAttributes of this CVTerm. See also getResources(), getResourceURI(). """ return _libsbml.CVTerm_getNumResources(self, *args) def getResourceURI(self, *args): """ getResourceURI(CVTerm self, unsigned int n) -> string getResourceURI(CVTerm self, unsigned int n) -> string Returns the value of the nth resource for this CVTerm object. The RDF element used in the SBML format for referring to external entities is <rdf:Description>, with a <rdf:Bag> element inside of it containing one or more <rdf:li> elements. The following template illustrates the structure: <rdf:Description rdf:about="#meta id"> HISTORY <RELATION_ELEMENT> <rdf:Bag> <rdf:li rdf:resource="resource URI" /> ... </rdf:Bag> </RELATION_ELEMENT> ... </rdf:Description> In the template above, the placeholder meta id stands for the element's meta identifier, which is a field available on all SBML components derived from the SBase base object class. The dotted portions are optional, and the ellipses ... are placeholders for zero or more elements of the same form as the immediately preceding element. The fragment above illustrates that there can be more than one resource referenced by a given relationship annotation (i.e., the resource URI values associated with a particular RELATION_ELEMENT). LibSBML stores all resource URIs in a single CVTerm object for a given relationship. Callers can use CVTerm.getNumResources() to find out how many resources are stored in this CVTerm object, then call this method to retrieve the nth resource URI. Parameter 'n' is the index of the resource to query. Returns string representing the value of the nth resource in the set of XMLAttributes of this CVTerm. See also getNumResources(), getQualifierType(). """ return _libsbml.CVTerm_getResourceURI(self, *args) def setQualifierType(self, type): """ setQualifierType(CVTerm self, QualifierType_t type) -> int Sets the qualifier code of this CVTerm object. Parameter 'type' is the qualifier type. Returns integer value indicating success/failure of the function. This particular function only does one thing irrespective of user input or object state, and thus will only return a single value: * LIBSBML_OPERATION_SUCCESS See also getQualifierType(). """ return _libsbml.CVTerm_setQualifierType(self, type) def setModelQualifierType(self, *args): """ setModelQualifierType(CVTerm self, ModelQualifierType_t type) -> int setModelQualifierType(CVTerm self, string qualifier) -> int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: setModelQualifierType(string qualifier) Sets the model qualifier type value of this CVTerm object. Parameter 'qualifier' is the string representing a model qualifier. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE Note: If the Qualifier Type of this object is not MODEL_QUALIFIER, then the model qualifier type will default to BQM_UNKNOWN. See also getQualifierType(), setQualifierType(). ______________________________________________________________________ Method variant with the following signature: setModelQualifierType(ModelQualifierType_t type) Sets the model qualifier type of this CVTerm object. Parameter 'type' is the model qualifier type. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE Note: If the qualifier type of this object is not MODEL_QUALIFIER, then the then the model qualifier type will default to BQM_UNKNOWN. See also getQualifierType(), setQualifierType(). """ return _libsbml.CVTerm_setModelQualifierType(self, *args) def setBiologicalQualifierType(self, *args): """ setBiologicalQualifierType(CVTerm self, BiolQualifierType_t type) -> int setBiologicalQualifierType(CVTerm self, string qualifier) -> int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: setBiologicalQualifierType(string qualifier) Sets the biology qualifier type code of this CVTerm object. Parameter 'qualifier' is the string representing a biology qualifier. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE Note: If the Qualifier Type of this object is not BIOLOGICAL_QUALIFIER, then the biology qualifier type code will default to BQB_UNKNOWN. See also getQualifierType(), setQualifierType(). ______________________________________________________________________ Method variant with the following signature: setBiologicalQualifierType(BiolQualifierType_t type) Sets the biology qualifier type of this CVTerm object. Parameter 'type' is the biology qualifier type. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE Note: If the Qualifier Type of this object is not BIOLOGICAL_QUALIFIER, then the biology qualifier type will default to BQB_UNKNOWN. See also getQualifierType(), setQualifierType(). """ return _libsbml.CVTerm_setBiologicalQualifierType(self, *args) def addResource(self, resource): """ addResource(CVTerm self, string resource) -> int Adds a resource reference to this CVTerm object. The SBML Level 2 and Level 3 specifications define a simple format for annotating models when (a) referring to controlled vocabulary terms and database identifiers that define and describe biological and other entities, and (b) describing the creator of a model and the model's modification history. The annotation content is stored in <annotation> elements attached to individual SBML elements. The format for storing the content inside SBML <annotation> elements is a subset of W3C RDF (Resource Description Format) expressed in XML. The CVTerm class provides a programming interface for working directly with controlled vocabulary term ('CV term') objects without having to deal directly with the XML form. When libSBML reads in an SBML model containing RDF annotations, it parses those annotations into a list of CVTerm objects, and when writing a model, it parses the CVTerm objects back into the appropriate SBML <annotation> structure. The specific RDF element used in this SBML format for referring to external entities is <rdf:Description>, with a <rdf:Bag> element containing one or more <rdf:li> elements. Each such element refers to a data item in an external resource; the resource and data item are together identified uniquely using a URI. The following template illustrates the structure: <rdf:Description rdf:about="#meta id"> HISTORY <RELATION_ELEMENT> <rdf:Bag> <rdf:li rdf:resource="resource URI" /> ... </rdf:Bag> </RELATION_ELEMENT> ... </rdf:Description> In the template above, the placeholder meta id stands for the element's meta identifier, which is a field available on all SBML components derived from the SBase base object class. The dotted portions are optional, and the ellipses ... are placeholders for zero or more elements of the same form as the immediately preceding element. The placeholder RELATION_ELEMENT refers to a BioModels.net qualifier element name. This is an element in either the XML namespace 'http://biomodels.net/model-qualifiers' (for model qualifiers) or 'http://biomodels.net/biology-qualifiers' (for biological qualifier). The resource URI is a required data value that uniquely identifies a resource and data within that resource to which the annotation refers. The present method allows callers to add a reference to a resource URI with the same relationship to the enclosing SBML object. (In other words, the argument to this method is a resource URI as shown in the XML fragment above.) Resources are stored in this CVTerm object within an XMLAttributes object. The relationship of this CVTerm to the enclosing SBML object can be determined using the CVTerm methods such as CVTerm.getModelQualifierType() and CVTerm.getBiologicalQualifierType(). Parameter 'resource' is a string representing the URI of the resource and data item being referenced; e.g., 'http://www.geneontology.org/#GO:0005892'. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also getResources(), removeResource(), getQualifierType(), getModelQualifierType(), getBiologicalQualifierType(). """ return _libsbml.CVTerm_addResource(self, resource) def removeResource(self, resource): """ removeResource(CVTerm self, string resource) -> int Removes a resource URI from the set of resources stored in this CVTerm object. Parameter 'resource' is a string representing the resource URI to remove; e.g., 'http://www.geneontology.org/#GO:0005892'. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INDEX_EXCEEDS_SIZE * LIBSBML_INVALID_ATTRIBUTE_VALUE See also addResource(). """ return _libsbml.CVTerm_removeResource(self, resource) def hasBeenModified(self): """ hasBeenModified(CVTerm self) -> bool Internal implementation method. """ return _libsbml.CVTerm_hasBeenModified(self) def resetModifiedFlags(self): """ resetModifiedFlags(CVTerm self) Internal implementation method. """ return _libsbml.CVTerm_resetModifiedFlags(self) def hasRequiredAttributes(self, *args): """ hasRequiredAttributes(CVTerm self) -> bool hasRequiredAttributes(CVTerm self) -> bool Predicate returning 'True' if all the required elements for this CVTerm object have been set. Note: The required attributes for a CVTerm are: * a qualifier type, which can be either a model qualifier or a biological qualifier * at least one resource """ return _libsbml.CVTerm_hasRequiredAttributes(self, *args) def getNumNestedCVTerms(self): """ getNumNestedCVTerms(CVTerm self) -> unsigned int Returns the number of CVTerm objects nested within this CVTerm object. Returns the number of CVTerms nested within this CVTerm object. Note: this does not recurse through potentially nested CVTerm objects within a given nested CVTerm. It returns the number of terms immediately nested within this CVTerm. """ return _libsbml.CVTerm_getNumNestedCVTerms(self) def getNestedCVTerm(self, *args): """ getNestedCVTerm(CVTerm self, unsigned int n) -> CVTerm getNestedCVTerm(CVTerm self, unsigned int n) -> CVTerm Returns the nth CVTerm in the list of CVTerms of this CVTerm object. Parameter 'n' is long the index of the CVTerm to retrieve. Returns the nth CVTerm in the list of CVTerms for this CVTerm object or 'None' if no such object exists. """ return _libsbml.CVTerm_getNestedCVTerm(self, *args) def getListNestedCVTerms(self, *args): """ getListNestedCVTerms(CVTerm self) -> List getListNestedCVTerms(CVTerm self) -> List const * Returns a list of CVTerm objects contained within this CVTerm object. Returns the list of CVTerms for this CVTerm object. """ return _libsbml.CVTerm_getListNestedCVTerms(self, *args) def addNestedCVTerm(self, term): """ addNestedCVTerm(CVTerm self, CVTerm term) -> int Adds a copy of the given CVTerm object to the list of nested CVTerm objects within this CVTerm object. Parameter 'term' is the CVTerm to assign. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_INVALID_OBJECT """ return _libsbml.CVTerm_addNestedCVTerm(self, term) def removeNestedCVTerm(self, n): """ removeNestedCVTerm(CVTerm self, unsigned int n) -> CVTerm Removes the nth CVTerm in the list of CVTerms of this CVTerm object and returns a pointer to it. Parameter 'n' is long the index of the CVTerm to retrieve. Returns a pointer to the nth CVTerm in the list of CVTerms for this CVTerm object. """ return _libsbml.CVTerm_removeNestedCVTerm(self, n) __metaclass__ = AutoProperty def __eq__(self, rhs): if ((self is None) and (rhs is None)): return True if ((self is None) or (rhs is None)): return False if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return True return False def __ne__(self, rhs): if ((self is None) and (rhs is None)): return False if ((self is None) or (rhs is None)): return True if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return False return True CVTerm_swigregister = _libsbml.CVTerm_swigregister CVTerm_swigregister(CVTerm) def ModelQualifierType_toString(type): """ ModelQualifierType_toString(ModelQualifierType_t type) -> char const * This method takes a model qualifier type code and returns a string representing the code. This method takes a model qualifier type as argument and returns a string name corresponding to that code. For example, passing it the qualifier BQM_IS_DESCRIBED_BY will return the string 'isDescribedBy'. Parameter 'type' is the value to translate. The value should be a libSBML constant whose name begins with 'BQM_,' such as (for example) BQM_IS. Returns a human readable qualifier name for the given qualifier type. Note: The caller does not own the returned string and is therefore not allowed to modify it. """ return _libsbml.ModelQualifierType_toString(type) def BiolQualifierType_toString(type): """ BiolQualifierType_toString(BiolQualifierType_t type) -> char const * This method takes a biol qualifier type code and returns a string representing the code. This method takes a biol qualifier type as argument and returns a string name corresponding to that code. For example, passing it the qualifier BQB_HAS_VERSION will return the string 'hasVersion'. Parameter 'type' is the value to translate. The value should be a constant whose name begins with 'BQB_,' such as (for example) BQB_IS. Returns a human readable qualifier name for the given type. Note: The caller does not own the returned string and is therefore not allowed to modify it. """ return _libsbml.BiolQualifierType_toString(type) def ModelQualifierType_fromString(s): """ ModelQualifierType_fromString(char const * s) -> ModelQualifierType_t This method takes a string and returns a model qualifier representing the string. This method takes a string as argument and returns a model qualifier type corresponding to that string. For example, passing it the string 'isDescribedBy' will return the qualifier BQM_IS_DESCRIBED_BY. Parameter 's' is the string to translate to a libSBML constant value representing a model qualifier. Returns a libSBML qualifier enumeration value for the given human readable qualifier name. """ return _libsbml.ModelQualifierType_fromString(s) def BiolQualifierType_fromString(s): """ BiolQualifierType_fromString(char const * s) -> BiolQualifierType_t This method takes a string and returns a biol qualifier representing the string. This method takes a string as argument and returns a biol qualifier type corresponding to that string. For example, passing it the string 'hasVersion' will return the qualifier BQB_HAS_VERSION. Parameter 's' is the string to translate to a libSBML constant value representing a biological qualifier. Returns a libSBML qualifier enumeration value for the given human readable qualifier name. """ return _libsbml.BiolQualifierType_fromString(s) class Date(_object): """ A MIRIAM-compliant date representation. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. A Date object stores a reasonably complete representation of date and time. Its purpose is to serve as a way to store dates to be read and written in the W3C date format used in RDF Dublin Core annotations within SBML. The W3C date format is a restricted form of ISO 8601, the international standard for the representation of dates and times. A time and date value in this W3C format takes the form YYYY-MM- DDThh:mm:ssXHH:ZZ (e.g., 1997-07-16T19:20:30+01:00) where XHH:ZZ is the time zone offset. The libSBML Date object contains the following fields to represent these values: * year: a long integer representing the year. This should be a four-digit number such as '2011.' * month: a long integer representing the month, with a range of values of 1-12. The value '1' represents January, and so on. * day: a long integer representing the day of the month, with a range of values of 1-31. * hour: a long integer representing the hour on a 24-hour clock, with a range of values of 0-23. * minute: a long integer representing the minute, with a range of 0-59. * second: a long integer representing the second, with a range of 0-59. * sign: a long integer representing the sign of the offset ('0' signifying '+' and '1' signifying '-).' See the paragraph below for further explanations. * hours offset: a long integer representing the time zone's hour offset from GMT, with a range of 0-12. * minute offset: a long integer representing the time zone's minute offset from GMT, with a range of 0-59. To illustrate the time zone offset, a value of -05:00 would correspond to USA Eastern Standard Time. In the Date object, this would require a value of '1' for the sign field, '5' for the hour offset and '0' for the minutes offset. In the restricted RDF annotations used in SBML, described in Section 6 of the SBML Level 2 and Level 3 specification documents, date/time stamps can be used to indicate the time of creation and modification of a model. The following SBML model fragment illustrates this: <model metaid='_180340' id='GMO' name='Goldbeter1991_MinMitOscil'> <annotation> <rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#' xmlns:dc='http://purl.org/dc/elements/1.1/' xmlns:dcterms='http://purl.org/dc/terms/' xmlns:vCard='http://www.w3.org/2001/vcard-rdf/3.0#' > <rdf:Description rdf:about='#_180340'> <dc:creator> <rdf:Bag> <rdf:li rdf:parseType='Resource'> <vCard:N rdf:parseType='Resource'> <vCard:Family>Shapiro</vCard:Family> <vCard:Given>Bruce</vCard:Given> </vCard:N> <vCard:EMAIL>bshapiro@jpl.nasa.gov</vCard:EMAIL> <vCard:ORG rdf:parseType='Resource'> <vCard:Orgname>NASA Jet Propulsion Laboratory</vCard:Orgname> </vCard:ORG> </rdf:li> </rdf:Bag> </dc:creator> <dcterms:created rdf:parseType='Resource'> <dcterms:W3CDTF>2005-02-06T23:39:40+00:00</dcterms:W3CDTF> </dcterms:created> <dcterms:modified rdf:parseType='Resource'> <dcterms:W3CDTF>2005-09-13T13:24:56+00:00</dcterms:W3CDTF> </dcterms:modified> </rdf:Description> </rdf:RDF> </annotation> </model> """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, Date, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, Date, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_Date __del__ = lambda self: None def __init__(self, *args): """ __init__(Date self, unsigned int year=2000, unsigned int month=1, unsigned int day=1, unsigned int hour=0, unsigned int minute=0, unsigned int second=0, unsigned int sign=0, unsigned int hoursOffset=0, unsigned int minutesOffset=0) -> Date __init__(Date self, unsigned int year=2000, unsigned int month=1, unsigned int day=1, unsigned int hour=0, unsigned int minute=0, unsigned int second=0, unsigned int sign=0, unsigned int hoursOffset=0) -> Date __init__(Date self, unsigned int year=2000, unsigned int month=1, unsigned int day=1, unsigned int hour=0, unsigned int minute=0, unsigned int second=0, unsigned int sign=0) -> Date __init__(Date self, unsigned int year=2000, unsigned int month=1, unsigned int day=1, unsigned int hour=0, unsigned int minute=0, unsigned int second=0) -> Date __init__(Date self, unsigned int year=2000, unsigned int month=1, unsigned int day=1, unsigned int hour=0, unsigned int minute=0) -> Date __init__(Date self, unsigned int year=2000, unsigned int month=1, unsigned int day=1, unsigned int hour=0) -> Date __init__(Date self, unsigned int year=2000, unsigned int month=1, unsigned int day=1) -> Date __init__(Date self, unsigned int year=2000, unsigned int month=1) -> Date __init__(Date self, unsigned int year=2000) -> Date __init__(Date self) -> Date __init__(Date self, string date) -> Date __init__(Date self, Date orig) -> Date This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: Date(string date) Creates a Date object from a string expressing a date and time value. This constructor expects its argument to be in the W3C date format with time zone offset, used in RDF Dublin Core annotations within SBML. The date format expresses a date and time value as a string of the form YYYY-MM-DDThh:mm:ssXHH:ZZ, where * YYYY is a four-digit integer representing the year. This should be a four-digit number such as '2011.' * MM is a two-digit integer representing the month, with a range of values of 01-12. The value '1' represents January, and so on. * DD is a two-digit integer representing the day of the month, with a range of values of 01-31. * T is the literal character 'T.' * hh is a two-digit integer representing the hour on a 24-hour clock, with a range of values of 00-23. * mm is a two-digit integer representing the minute, with a range of 00-59. * ss is a two-digit integer representing the second, with a range of 0-59. * X is the the sign of the time zone offset, either '+' or -. * HH is a two-digit integer representing the hour of the time zone offset, with a range of 00-23. * ZZ is a two-digit integer representing the minutes of the time zone offset, with a range of 00-59. In the string format above, it is important not to forget the literal character 'T' in the string. Here is an example date/time string: 1997-07-16T19:20:30+01:00, which would represent July 16, 1997, at 19:20:30 in Central European Time (which is UTC +1:00). If this constructor is given a 'None' argument or a string of length zero, it constructs a Date object with the value of January 1, 2000, at time 00:00 UTC. Otherwise, the argument must be in the complete format described above, or unpredictable results will happen. Parameter 'date' is a string representing the date. ______________________________________________________________________ Method variant with the following signature: Date(long year = 2000, long month = 1, long day = 1, long hour = 0, long minute = 0, long second = 0, long sign = 0, long hoursOffset = 0, long minutesOffset = 0) Creates a time and date representation for use in model annotations and elsewhere. The following is the complete set of possible arguments to this constructor, with default values as indicated: Parameter 'year' is a long integereger representing the year. This should be a four-digit number such as '2011.' (Default value used if this argument is not given: '2000.)' Parameter 'month' is a long integereger representing the month, with a range of values of 1-12. The value '1' represents January, and so on. (Default value used if this argument is not given: '1.)' Parameter 'day' is a long integereger representing the day of the month, with a range of values of 1-31. (Default value used if this argument is not given: '1.)' Parameter 'hour' is a long integereger representing the hour on a 24-hour clock, with a range of values of 0-23. (Default value used if this argument is not given: '0.)' Parameter 'minute' is a long integereger representing the minute, with a range of 0-59. (Default value used if this argument is not given: '0.)' Parameter 'second' is a long integereger representing the second, with a range of 0-59. (Default value used if this argument is not given: '0.)' Parameter 'sign' is a long integereger representing the sign of the offset ('0' signifying '+' and '1' signifying '-).' See the paragraph below for further explanations. (Default value used if this argument is not given: '0.)' Parameter 'hoursOffset' is a long integereger representing the time zone's hour offset from GMT. (Default value used if this argument is not given: '0.)' Parameter 'minutesOffset' is a long integereger representing the time zone's minute offset from GMT. (Default value used if this argument is not given: '0.)' To illustrate the time zone offset, a value of -05:00 would correspond to USA Eastern Standard Time. In the Date object, this would require a value of '1' for the sign field, '5' for the hour offset and '0' for the minutes offset. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. ______________________________________________________________________ Method variant with the following signature: Date(Date orig) Copy constructor; creates a copy of this Date. Parameter 'orig' is the object to copy. """ this = _libsbml.new_Date(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(Date self) -> Date Creates and returns a deep copy of this Date object. Returns the (deep) copy of this Date object. """ return _libsbml.Date_clone(self) def getYear(self): """ getYear(Date self) -> unsigned int Returns the year from this Date. Returns the year from this Date. """ return _libsbml.Date_getYear(self) def getMonth(self): """ getMonth(Date self) -> unsigned int Returns the month from this Date. Returns the month from this Date. """ return _libsbml.Date_getMonth(self) def getDay(self): """ getDay(Date self) -> unsigned int Returns the day from this Date. Returns the day from this Date. """ return _libsbml.Date_getDay(self) def getHour(self): """ getHour(Date self) -> unsigned int Returns the hour from this Date. Returns the hour from this Date. """ return _libsbml.Date_getHour(self) def getMinute(self): """ getMinute(Date self) -> unsigned int Returns the minute from this Date. Returns the minute from this Date. """ return _libsbml.Date_getMinute(self) def getSecond(self): """ getSecond(Date self) -> unsigned int Returns the seconds from this Date. Returns the seconds from this Date. """ return _libsbml.Date_getSecond(self) def getSignOffset(self): """ getSignOffset(Date self) -> unsigned int Returns the sign of the time zone offset from this Date. Returns the sign of the offset from this Date. """ return _libsbml.Date_getSignOffset(self) def getHoursOffset(self): """ getHoursOffset(Date self) -> unsigned int Returns the hours of the time zone offset from this Date. Returns the hours of the offset from this Date. """ return _libsbml.Date_getHoursOffset(self) def getMinutesOffset(self): """ getMinutesOffset(Date self) -> unsigned int Returns the minutes of the time zone offset from this Date. Returns the minutes of the offset from this Date. """ return _libsbml.Date_getMinutesOffset(self) def getDateAsString(self): """ getDateAsString(Date self) -> string Returns the current Date value in text-string form. The string returned will be in the W3C date format with time zone offset, used in RDF Dublin Core annotations within SBML. The date format expresses a date and time value as a string of the form YYYY-MM-DDThh:mm:ssXHH:ZZ, where * YYYY is a four-digit integer representing the year. This should be a four-digit number such as '2011.' * MM is a two-digit integer representing the month, with a range of values of 01-12. The value '1' represents January, and so on. * DD is a two-digit integer representing the day of the month, with a range of values of 01-31. * T is the literal character 'T.' * hh is a two-digit integer representing the hour on a 24-hour clock, with a range of values of 00-23. * mm is a two-digit integer representing the minute, with a range of 00-59. * ss is a two-digit integer representing the second, with a range of 0-59. * X is the the sign of the time zone offset, either '+' or -. * HH is a two-digit integer representing the hour of the time zone offset, with a range of 00-23. * ZZ is a two-digit integer representing the minutes of the time zone offset, with a range of 00-59. In the string format above, it is important not to forget the literal character 'T' in the string. Here is an example date/time string: 1997-07-16T19:20:30+01:00, which would represent July 16, 1997, at 19:20:30 in Central European Time (which is UTC +1:00). Returns the date as a string. """ return _libsbml.Date_getDateAsString(self) def setYear(self, year): """ setYear(Date self, unsigned int year) -> int Sets the value of the year of this Date object. The value given as argument must be between 1000 and 9999 inclusive. (In the millennium during which this libSBML documentation is being written, a typical value is '2011,' but we hope that SBML will continue to be used for a long time.) Parameter 'year' is a long integer representing the year. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.Date_setYear(self, year) def setMonth(self, month): """ setMonth(Date self, unsigned int month) -> int Sets the value of the month of this Date object. Parameter 'month' is a long integer representing the month; it must be in the range 1-12 or an error will be signaled. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.Date_setMonth(self, month) def setDay(self, day): """ setDay(Date self, unsigned int day) -> int Sets the value of the day of this Date object. Parameter 'day' is a long integer representing the day; it must be in the range 0-31 or an error will be signaled. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.Date_setDay(self, day) def setHour(self, hour): """ setHour(Date self, unsigned int hour) -> int Sets the value of the hour of this Date object. Parameter 'hour' is a long integer representing the hour to set; it must be in the range 0-23 or an error will be signaled. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.Date_setHour(self, hour) def setMinute(self, minute): """ setMinute(Date self, unsigned int minute) -> int Sets the value of the minute of this Date object. Parameter 'minute' is a long integer representing the minute to set; it must be in the range 0-59 or an error will be signaled. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.Date_setMinute(self, minute) def setSecond(self, second): """ setSecond(Date self, unsigned int second) -> int Sets the value of the second of the Date object. Parameter 'second' is a long integer representing the seconds; it must be in the range 0-59 or an error will be signaled. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.Date_setSecond(self, second) def setSignOffset(self, sign): """ setSignOffset(Date self, unsigned int sign) -> int Sets the value of the sign of the time zone offset of this Date object. The only permissible values are '0' and '1.' Parameter 'sign' is a long integer representing the sign of the offset, with '0' signifying '+' and '1' signifying '-.' Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.Date_setSignOffset(self, sign) def setHoursOffset(self, hoursOffset): """ setHoursOffset(Date self, unsigned int hoursOffset) -> int Sets the value of this Date object's time zone hour offset. Parameter 'hoursOffset' is a long integer representing the hours of the offset; it must be in the range 0-12 or an error will be signaled. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.Date_setHoursOffset(self, hoursOffset) def setMinutesOffset(self, minutesOffset): """ setMinutesOffset(Date self, unsigned int minutesOffset) -> int Sets the value of this Date object's time zone minutes offset. Parameter 'minutesOffset' is a long integer representing the minutes of the offset; it must be in the range 0-59 or an error will be signaled. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.Date_setMinutesOffset(self, minutesOffset) def setDateAsString(self, date): """ setDateAsString(Date self, string date) -> int Sets the value of this Date object using a date and time value expressed as a text string. This method expects its argument to be in the W3C date format with time zone offset, used in RDF Dublin Core annotations within SBML. The date format expresses a date and time value as a string of the form YYYY-MM-DDThh:mm:ssXHH:ZZ, where * YYYY is a four-digit integer representing the year. This should be a four-digit number such as '2011.' * MM is a two-digit integer representing the month, with a range of values of 01-12. The value '1' represents January, and so on. * DD is a two-digit integer representing the day of the month, with a range of values of 01-31. * T is the literal character 'T.' * hh is a two-digit integer representing the hour on a 24-hour clock, with a range of values of 00-23. * mm is a two-digit integer representing the minute, with a range of 00-59. * ss is a two-digit integer representing the second, with a range of 0-59. * X is the the sign of the time zone offset, either '+' or -. * HH is a two-digit integer representing the hour of the time zone offset, with a range of 00-23. * ZZ is a two-digit integer representing the minutes of the time zone offset, with a range of 00-59. In the string format above, it is important not to forget the literal character 'T' in the string. Here is an example date/time string: 1997-07-16T19:20:30+01:00, which would represent July 16, 1997, at 19:20:30 in Central European Time (which is UTC +1:00). If this method is given a 'None' argument or a string of length zero, it constructs a Date object with the value of January 1, 2000, at time 00:00 UTC. Otherwise, the argument must be in the complete format described above, or unpredictable results will happen. Parameter 'date' is a string representing the date. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.Date_setDateAsString(self, date) def representsValidDate(self): """ representsValidDate(Date self) -> bool Returns 'True' or 'False' depending on whether this date object represents a valid date and time value. This method verifies that the date/time value stored in this object is well-formed and represents plausible values. A time and date value in the W3C format takes the form YYYY-MM-DDThh:mm:ssXHH:ZZ (e.g., 1997-07-16T19:20:30+01:00) where XHH:ZZ is the time zone offset. This method checks such things as whether the value of the month number is less than or equal to 12, whether the value of the minutes number is less than or equal to 59, whether a time zone offset is set, etc. Returns 'True' if the date is valid, 'False' otherwise. """ return _libsbml.Date_representsValidDate(self) def hasBeenModified(self): """ hasBeenModified(Date self) -> bool Internal implementation method. """ return _libsbml.Date_hasBeenModified(self) def resetModifiedFlags(self): """ resetModifiedFlags(Date self) Internal implementation method. """ return _libsbml.Date_resetModifiedFlags(self) __metaclass__ = AutoProperty def __eq__(self, rhs): if ((self is None) and (rhs is None)): return True if ((self is None) or (rhs is None)): return False if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return True return False def __ne__(self, rhs): if ((self is None) and (rhs is None)): return False if ((self is None) or (rhs is None)): return True if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return False return True Date_swigregister = _libsbml.Date_swigregister Date_swigregister(Date) class ModelCreator(_object): """ MIRIAM-compliant data about a model's creator. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. The SBML specification beginning with Level 2 Version 2 defines a standard approach to recording model history and model creator information in a form that complies with MIRIAM ('Minimum Information Requested in the Annotation of biochemical Models', Nature Biotechnology, vol. 23, no. 12, Dec. 2005). For the model creator, this form involves the use of parts of the vCard representation. LibSBML provides the ModelCreator class as a convenience high-level interface for working with model creator data. Objects of class ModelCreator can be used to store and carry around creator data within a program, and the various methods in this object class let callers manipulate the different parts of the model creator representation. The different parts of a model creator definition ====================================================================== The ModelCreator class mirrors the structure of the MIRIAM model creator annotations in SBML. The following template illustrates these different fields when they are written in XML form: <vCard:N rdf:parseType='Resource'> <vCard:Family>family name</vCard:Family> <vCard:Given>given name</vCard:Given> </vCard:N> ... <vCard:EMAIL>email address</vCard:EMAIL> ... <vCard:ORG rdf:parseType='Resource'> <vCard:Orgname>organization</vCard:Orgname> </vCard:ORG> Each of the separate data values family name, given name, email address, and organization can be set and retrieved via corresponding methods in the ModelCreator class. These methods are documented in more detail below. """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, ModelCreator, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, ModelCreator, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_ModelCreator __del__ = lambda self: None def __init__(self, *args): """ __init__(ModelCreator self) -> ModelCreator __init__(ModelCreator self, XMLNode creator) -> ModelCreator __init__(ModelCreator self, ModelCreator orig) -> ModelCreator This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: ModelCreator( XMLNode creator) Creates a new ModelCreator from an XMLNode. Parameter 'creator' is the XMLNode from which to create the ModelCreator. ______________________________________________________________________ Method variant with the following signature: ModelCreator() Creates a new ModelCreator object. ______________________________________________________________________ Method variant with the following signature: ModelCreator(ModelCreator orig) Copy constructor; creates a copy of the ModelCreator. Parameter 'orig' is the object to copy. """ this = _libsbml.new_ModelCreator(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(ModelCreator self) -> ModelCreator Creates and returns a deep copy of this ModelCreator object. Returns the (deep) copy of this ModelCreator object. """ return _libsbml.ModelCreator_clone(self) def getFamilyName(self): """ getFamilyName(ModelCreator self) -> string Returns the 'family name' stored in this ModelCreator object. Returns the 'family name' portion of the ModelCreator object. """ return _libsbml.ModelCreator_getFamilyName(self) def getGivenName(self): """ getGivenName(ModelCreator self) -> string Returns the 'given name' stored in this ModelCreator object. Returns the 'given name' portion of the ModelCreator object. """ return _libsbml.ModelCreator_getGivenName(self) def getEmail(self): """ getEmail(ModelCreator self) -> string Returns the 'email' stored in this ModelCreator object. Returns email from the ModelCreator. """ return _libsbml.ModelCreator_getEmail(self) def getOrganization(self): """ getOrganization(ModelCreator self) -> string Returns the 'organization' stored in this ModelCreator object. Returns organization from the ModelCreator. """ return _libsbml.ModelCreator_getOrganization(self) def getOrganisation(self): """ getOrganisation(ModelCreator self) -> string (Alternate spelling) Returns the 'organization' stored in this ModelCreator object. Note: This function is an alias of getOrganization(). Returns organization from the ModelCreator. See also getOrganization(). """ return _libsbml.ModelCreator_getOrganisation(self) def getName(self): """ getName(ModelCreator self) -> string Returns the 'fn' stored in this ModelCreator object when using vCard4. Returns the 'fn' portion of the ModelCreator object. """ return _libsbml.ModelCreator_getName(self) def isSetFamilyName(self): """ isSetFamilyName(ModelCreator self) -> bool Predicate returning 'True' or 'False' depending on whether this ModelCreator's 'family name' part is set. Returns 'True' if the familyName of this ModelCreator is set, 'False' otherwise. """ return _libsbml.ModelCreator_isSetFamilyName(self) def isSetGivenName(self): """ isSetGivenName(ModelCreator self) -> bool Predicate returning 'True' or 'False' depending on whether this ModelCreator's 'given name' part is set. Returns 'True' if the givenName of this ModelCreator is set, 'False' otherwise. """ return _libsbml.ModelCreator_isSetGivenName(self) def isSetEmail(self): """ isSetEmail(ModelCreator self) -> bool Predicate returning 'True' or 'False' depending on whether this ModelCreator's 'email' part is set. Returns 'True' if the email of this ModelCreator is set, 'False' otherwise. """ return _libsbml.ModelCreator_isSetEmail(self) def isSetOrganization(self): """ isSetOrganization(ModelCreator self) -> bool Predicate returning 'True' or 'False' depending on whether this ModelCreator's 'organization' part is set. Returns 'True' if the organization of this ModelCreator is set, 'False' otherwise. """ return _libsbml.ModelCreator_isSetOrganization(self) def isSetOrganisation(self): """ isSetOrganisation(ModelCreator self) -> bool (Alternate spelling) Predicate returning 'True' or 'False' depending on whether this ModelCreator's 'organization' part is set. Note: This function is an alias of isSetOrganization(). Returns 'True' if the organization of this ModelCreator is set, 'False' otherwise. See also isSetOrganization(). """ return _libsbml.ModelCreator_isSetOrganisation(self) def isSetName(self): """ isSetName(ModelCreator self) -> bool Predicate returning 'True' or 'False' depending on whether this ModelCreator's 'fn' part is set (when using vCard4). Returns 'True' if the fn of this ModelCreator is set, 'False' otherwise. """ return _libsbml.ModelCreator_isSetName(self) def setFamilyName(self, familyName): """ setFamilyName(ModelCreator self, string familyName) -> int Sets the 'family name' portion of this ModelCreator object. Parameter 'familyName' is a string representing the familyName of the ModelCreator. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.ModelCreator_setFamilyName(self, familyName) def setGivenName(self, givenName): """ setGivenName(ModelCreator self, string givenName) -> int Sets the 'given name' portion of this ModelCreator object. Parameter 'givenName' is a string representing the givenName of the ModelCreator. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.ModelCreator_setGivenName(self, givenName) def setEmail(self, email): """ setEmail(ModelCreator self, string email) -> int Sets the 'email' portion of this ModelCreator object. Parameter 'email' is a string representing the email of the ModelCreator. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.ModelCreator_setEmail(self, email) def setOrganization(self, organization): """ setOrganization(ModelCreator self, string organization) -> int Sets the 'organization' portion of this ModelCreator object. Parameter 'organization' is a string representing the organization of the ModelCreator. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.ModelCreator_setOrganization(self, organization) def setOrganisation(self, organization): """ setOrganisation(ModelCreator self, string organization) -> int (Alternate spelling) Sets the 'organization' portion of this ModelCreator object. Parameter 'organization' is a string representing the organization of the ModelCreator. Note: This function is an alias of setOrganization(string organization). Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE See also setOrganization(). """ return _libsbml.ModelCreator_setOrganisation(self, organization) def setName(self, name): """ setName(ModelCreator self, string name) -> int Sets the 'fn' portion of this ModelCreator object (when using vCard4). Parameter 'name' is a string representing the fn of the ModelCreator. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.ModelCreator_setName(self, name) def unsetFamilyName(self): """ unsetFamilyName(ModelCreator self) -> int Unsets the 'family name' portion of this ModelCreator object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.ModelCreator_unsetFamilyName(self) def unsetGivenName(self): """ unsetGivenName(ModelCreator self) -> int Unsets the 'given name' portion of this ModelCreator object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.ModelCreator_unsetGivenName(self) def unsetEmail(self): """ unsetEmail(ModelCreator self) -> int Unsets the 'email' portion of this ModelCreator object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.ModelCreator_unsetEmail(self) def unsetOrganization(self): """ unsetOrganization(ModelCreator self) -> int Unsets the 'organization' portion of this ModelCreator object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.ModelCreator_unsetOrganization(self) def unsetOrganisation(self): """ unsetOrganisation(ModelCreator self) -> int (Alternate spelling) Unsets the 'organization' portion of this ModelCreator object. Note: This function is an alias of unsetOrganization(). Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also unsetOrganization(). """ return _libsbml.ModelCreator_unsetOrganisation(self) def unsetName(self): """ unsetName(ModelCreator self) -> int Unsets the 'fn' portion of this ModelCreator object (when using vCard4). Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.ModelCreator_unsetName(self) def hasRequiredAttributes(self): """ hasRequiredAttributes(ModelCreator self) -> bool Predicate returning 'True' if all the required elements for this ModelCreator object have been set. The only required elements for a ModelCreator object are the 'family name' and 'given name'. Returns a boolean value indicating whether all the required elements for this object have been defined. """ return _libsbml.ModelCreator_hasRequiredAttributes(self) def hasBeenModified(self): """ hasBeenModified(ModelCreator self) -> bool Internal implementation method. """ return _libsbml.ModelCreator_hasBeenModified(self) def resetModifiedFlags(self): """ resetModifiedFlags(ModelCreator self) Internal implementation method. """ return _libsbml.ModelCreator_resetModifiedFlags(self) def usingFNVcard4(self): """ usingFNVcard4(ModelCreator self) -> bool Internal implementation method. """ return _libsbml.ModelCreator_usingFNVcard4(self) def usingSingleName(self): """ usingSingleName(ModelCreator self) -> bool Internal implementation method. """ return _libsbml.ModelCreator_usingSingleName(self) def setUseSingleName(self, flag): """ setUseSingleName(ModelCreator self, bool flag) Internal implementation method. """ return _libsbml.ModelCreator_setUseSingleName(self, flag) __metaclass__ = AutoProperty def __eq__(self, rhs): if ((self is None) and (rhs is None)): return True if ((self is None) or (rhs is None)): return False if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return True return False def __ne__(self, rhs): if ((self is None) and (rhs is None)): return False if ((self is None) or (rhs is None)): return True if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return False return True ModelCreator_swigregister = _libsbml.ModelCreator_swigregister ModelCreator_swigregister(ModelCreator) class ModelHistory(_object): """ MIRIAM-compliant data about a model's history. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. The SBML specification beginning with Level 2 Version 2 defines a standard approach to recording optional model history and model creator information in a form that complies with MIRIAM ('Minimum Information Requested in the Annotation of biochemical Models', Nature Biotechnology, vol. 23, no. 12, Dec. 2005). LibSBML provides the ModelHistory class as a convenient high-level interface for working with model history data. Model histories in SBML consist of one or more model creators, a single date of creation, and one or more modification dates. The overall XML form of this data takes the following form: <dc:creator> <rdf:Bag> <rdf:li rdf:parseType='Resource'> +++ <vCard:N rdf:parseType='Resource'> <vCard:Family>family name</vCard:Family> <vCard:Given>given name</vCard:Given> </vCard:N> +++ <vCard:EMAIL><span style='background-color: #bbb'>email address</vCard:EMAIL></span> +++ <vCard:ORG rdf:parseType='Resource'> <vCard:Orgname><span style='background-color: #bbb'>organization name</vCard:Orgname></span> </vCard:ORG> +++ </rdf:li> ... </rdf:Bag> </dc:creator> <dcterms:created rdf:parseType='Resource'> <dcterms:W3CDTF>creation date</dcterms:W3CDTF> </dcterms:created> <dcterms:modified rdf:parseType='Resource'> <dcterms:W3CDTF>modification date</dcterms:W3CDTF> </dcterms:modified> ... In the template above, the underlined portions are optional, the symbol +++ is a placeholder for either no content or valid XML content that is not defined by the annotation scheme, and the ellipses ... are placeholders for zero or more elements of the same form as the immediately preceding element. The various placeholders for content, namely family name, given name, email address, organization, creation date, and modification date are data that can be filled in using the various methods on the ModelHistory class described below. See also ModelCreator, Date. """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, ModelHistory, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, ModelHistory, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_ModelHistory __del__ = lambda self: None def __init__(self, *args): """ __init__(ModelHistory self) -> ModelHistory __init__(ModelHistory self, ModelHistory orig) -> ModelHistory This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: ModelHistory(ModelHistory orig) Copy constructor; creates a copy of this ModelHistory object. Parameter 'orig' is the object to copy. ______________________________________________________________________ Method variant with the following signature: ModelHistory() Creates a new ModelHistory object. """ this = _libsbml.new_ModelHistory(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(ModelHistory self) -> ModelHistory Creates and returns a deep copy of this ModelHistory object. Returns the (deep) copy of this ModelHistory object. """ return _libsbml.ModelHistory_clone(self) def getCreatedDate(self): """ getCreatedDate(ModelHistory self) -> Date Returns the 'creation date' portion of this ModelHistory object. Returns a Date object representing the creation date stored in this ModelHistory object. """ return _libsbml.ModelHistory_getCreatedDate(self) def isSetCreatedDate(self): """ isSetCreatedDate(ModelHistory self) -> bool Predicate returning 'True' or 'False' depending on whether this ModelHistory's 'creation date' is set. Returns 'True' if the creation date value of this ModelHistory is set, 'False' otherwise. """ return _libsbml.ModelHistory_isSetCreatedDate(self) def isSetModifiedDate(self): """ isSetModifiedDate(ModelHistory self) -> bool Predicate returning 'True' or 'False' depending on whether this ModelHistory's 'modified date' is set. Returns 'True' if the modification date value of this ModelHistory object is set, 'False' otherwise. """ return _libsbml.ModelHistory_isSetModifiedDate(self) def setCreatedDate(self, date): """ setCreatedDate(ModelHistory self, Date date) -> int Sets the creation date of this ModelHistory object. Parameter 'date' is a Date object representing the date to which the 'created date' portion of this ModelHistory should be set. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT """ return _libsbml.ModelHistory_setCreatedDate(self, date) def setModifiedDate(self, date): """ setModifiedDate(ModelHistory self, Date date) -> int Sets the modification date of this ModelHistory object. Parameter 'date' is a Date object representing the date to which the 'modified date' portion of this ModelHistory should be set. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_INVALID_OBJECT """ return _libsbml.ModelHistory_setModifiedDate(self, date) def addModifiedDate(self, date): """ addModifiedDate(ModelHistory self, Date date) -> int Adds a copy of a Date object to the list of 'modified date' values stored in this ModelHistory object. In the MIRIAM format for annotations, there can be multiple modification dates. The libSBML ModelHistory class supports this by storing a list of 'modified date' values. Parameter 'date' is a Date object representing the 'modified date' that should be added to this ModelHistory object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED * LIBSBML_INVALID_OBJECT """ return _libsbml.ModelHistory_addModifiedDate(self, date) def getListModifiedDates(self): """ getListModifiedDates(self) -> DateList Get the List of Date objects in this ModelHistory. Returns the DateList for this ModelHistory. """ return _libsbml.ModelHistory_getListModifiedDates(self) def getModifiedDate(self, *args): """ getModifiedDate(ModelHistory self) -> Date getModifiedDate(ModelHistory self, unsigned int n) -> Date This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getModifiedDate() Returns the 'modified date' portion of this ModelHistory object. Note that in the MIRIAM format for annotations, there can be multiple modification dates. The libSBML ModelHistory class supports this by storing a list of 'modified date' values. If this ModelHistory object contains more than one 'modified date' value in the list, this method will return the first one in the list. Returns a Date object representing the date of modification stored in this ModelHistory object. ______________________________________________________________________ Method variant with the following signature: getModifiedDate(long n) Get the nth Date object in the list of 'modified date' values stored in this ModelHistory object. In the MIRIAM format for annotations, there can be multiple modification dates. The libSBML ModelHistory class supports this by storing a list of 'modified date' values. Returns the nth Date in the list of ModifiedDates of this ModelHistory or 'None' if no such object exists. """ return _libsbml.ModelHistory_getModifiedDate(self, *args) def getNumModifiedDates(self): """ getNumModifiedDates(ModelHistory self) -> unsigned int Get the number of Date objects in this ModelHistory object's list of 'modified dates'. In the MIRIAM format for annotations, there can be multiple modification dates. The libSBML ModelHistory class supports this by storing a list of 'modified date' values. Returns the number of ModifiedDates in this ModelHistory. """ return _libsbml.ModelHistory_getNumModifiedDates(self) def addCreator(self, mc): """ addCreator(ModelHistory self, ModelCreator mc) -> int Adds a copy of a ModelCreator object to the list of 'model creator' values stored in this ModelHistory object. In the MIRIAM format for annotations, there can be multiple model creators. The libSBML ModelHistory class supports this by storing a list of 'model creator' values. Parameter 'mc' is the ModelCreator to add. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_OBJECT * LIBSBML_OPERATION_FAILED """ return _libsbml.ModelHistory_addCreator(self, mc) def getListCreators(self): """ getListCreators(self) -> ModelCreatorList Get the List of ModelCreator objects in this ModelHistory. Returns the ModelCreatorList for this ModelHistory. """ return _libsbml.ModelHistory_getListCreators(self) def getCreator(self, n): """ getCreator(ModelHistory self, unsigned int n) -> ModelCreator Get the nth ModelCreator object stored in this ModelHistory object. In the MIRIAM format for annotations, there can be multiple model creators. The libSBML ModelHistory class supports this by storing a list of 'model creator' values. Returns the nth ModelCreator object or 'None' if no such object exists. """ return _libsbml.ModelHistory_getCreator(self, n) def getNumCreators(self): """ getNumCreators(ModelHistory self) -> unsigned int Get the number of ModelCreator objects stored in this ModelHistory object. In the MIRIAM format for annotations, there can be multiple model creators. The libSBML ModelHistory class supports this by storing a list of 'model creator' values. Returns the number of ModelCreators objects. """ return _libsbml.ModelHistory_getNumCreators(self) def hasRequiredAttributes(self): """ hasRequiredAttributes(ModelHistory self) -> bool Predicate returning 'True' if all the required elements for this ModelHistory object have been set. The required elements for a ModelHistory object are 'created name', 'modified date', and at least one 'model creator'. Returns a boolean value indicating whether all the required elements for this object have been defined. """ return _libsbml.ModelHistory_hasRequiredAttributes(self) def hasBeenModified(self): """ hasBeenModified(ModelHistory self) -> bool Internal implementation method. """ return _libsbml.ModelHistory_hasBeenModified(self) def resetModifiedFlags(self): """ resetModifiedFlags(ModelHistory self) Internal implementation method. """ return _libsbml.ModelHistory_resetModifiedFlags(self) __metaclass__ = AutoProperty def __eq__(self, rhs): if ((self is None) and (rhs is None)): return True if ((self is None) or (rhs is None)): return False if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return True return False def __ne__(self, rhs): if ((self is None) and (rhs is None)): return False if ((self is None) or (rhs is None)): return True if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return False return True ModelHistory_swigregister = _libsbml.ModelHistory_swigregister ModelHistory_swigregister(ModelHistory) class RDFAnnotationParser(_object): """ MIRIAM-compliant RDF annotation reader/writer. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. RDFAnnotationParser is a libSBML construct used as part of the libSBML support for annotations conforming to the guidelines specified by MIRIAM ('Minimum Information Requested in the Annotation of biochemical Models', Nature Biotechnology, vol. 23, no. 12, Dec. 2005). Section 6 of the SBML Level 2 and Level 3 specification documents defines a recommended way of encoding MIRIAM information using a subset of RDF (Resource Description Format). The general scheme is as follows. A set of RDF-based annotations attached to a given SBML <annotation> element are read by RDFAnnotationParser and converted into a list of CVTerm objects. There are different versions of the main method, and RDFAnnotationParser.parseRDFAnnotation(), used depending on whether the annotation in question concerns the MIRIAM model history or other MIRIAM resource annotations. A special object class, ModelHistory, is used to make it easier to manipulate model history annotations. All of the methods on RDFAnnotationParser are static; the class exists only to encapsulate the annotation and CVTerm parsing and manipulation functionality. """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, RDFAnnotationParser, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, RDFAnnotationParser, name) __repr__ = _swig_repr def createAnnotation(): """ createAnnotation() -> XMLNode Creates a blank annotation and returns its root XMLNode object. This creates a completely empty SBML <annotation> element. It is not attached to any SBML element. An example of how this might be used is illustrated in the following code fragment. In this example, suppose that 'content' is an XMLNode object previously created, containing MIRIAM-style annotations, and that 'sbmlObject' is an SBML object derived from SBase (e.g., a Model, or a Species, or a Compartment, etc.). Then: RDF = RDFAnnotationParser.createRDFAnnotation() # Create XML structure. success = RDF.addChild(...content...) # Put some content into it. ... # Check return code value. annot = RDFAnnotationParser.createAnnotation() # Create <annotation>. success = annot.addChild(RDF) # Put the annotation into it. ... # Check return code value. success = sbmlObject.setAnnotation(annot) # Set object's annotation. ... # Check return code value. The SBML specification contains more information about the format of annotations. We urge readers to consult Section 6 of the SBML Level 2 (Versions 2-4) and SBML Level 3 specification documents. Returns a pointer to an XMLNode for the annotation. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also RDFAnnotationParser.createRDFAnnotation() . """ return _libsbml.RDFAnnotationParser_createAnnotation() createAnnotation = staticmethod(createAnnotation) def createRDFAnnotation(level=3, version=1): """ createRDFAnnotation(unsigned int level=3, unsigned int version=1) -> XMLNode createRDFAnnotation(unsigned int level=3) -> XMLNode createRDFAnnotation() -> XMLNode Creates a blank RDF element suitable for use in SBML annotations. The annotation created by this method has namespace declarations for all the relevant XML namespaces used in RDF annotations and also has an empty RDF element. The result is the following XML: <rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#' xmlns:dc='http://purl.org/dc/elements/1.1/' xmlns:dcterms='http://purl.org/dc/terms/' xmlns:vCard='http://www.w3.org/2001/vcard-rdf/3.0#' xmlns:bqbiol='http://biomodels.net/biology-qualifiers/' xmlns:bqmodel='http://biomodels.net/model-qualifiers/' > </rdf:RDF> Note that this does not create the containing SBML <annotation> element; the method RDFAnnotationParser.createAnnotation() is available for creating the container. Returns a pointer to an XMLNode. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also RDFAnnotationParser.createAnnotation() . Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.RDFAnnotationParser_createRDFAnnotation(level, version) createRDFAnnotation = staticmethod(createRDFAnnotation) def createCVTerms(obj): """ createCVTerms(SBase obj) -> XMLNode Takes a list of CVTerm objects and creates a the RDF 'Description' element. This essentially takes the given SBML object, reads out the CVTerm objects attached to it, creates an RDF 'Description' element to hold the terms, and adds each term with appropriate qualifiers. Parameter 'obj' is the SBML object to start from. Returns the XMLNode tree corresponding to the Description element of an RDF annotation. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.RDFAnnotationParser_createCVTerms(obj) createCVTerms = staticmethod(createCVTerms) def parseCVTerms(obj): """ parseCVTerms(SBase obj) -> XMLNode Takes a list of CVTerm objects and creates a complete SBML annotation around it. This essentially takes the given SBML object, reads out the CVTerm objects attached to it, calls RDFAnnotationParser.createRDFAnnotation() to create an RDF annotation to hold the terms, and finally calls RDFAnnotationParser.createAnnotation() to wrap the result as an SBML <annotation> element. Parameter 'obj' is the SBML object to start from. Returns the XMLNode tree corresponding to the annotation. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.RDFAnnotationParser_parseCVTerms(obj) parseCVTerms = staticmethod(parseCVTerms) def parseModelHistory(obj): """ parseModelHistory(SBase obj) -> XMLNode Reads the model history and cvTerms stored in 'obj' and creates the XML structure for an SBML annotation representing that metadata if there is a model history stored in 'obj'. Parameter 'obj' is any SBase object. Returns the XMLNode corresponding to an annotation containing MIRIAM- compliant model history and CV term information in RDF format. Note: If the object does not have a history element stored then 'None' is returned even if CVTerms are present. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.RDFAnnotationParser_parseModelHistory(obj) parseModelHistory = staticmethod(parseModelHistory) def parseOnlyModelHistory(obj): """ parseOnlyModelHistory(SBase obj) -> XMLNode Reads the model history stored in 'obj' and creates the XML structure for an SBML annotation representing that history. Parameter 'obj' is any SBase object. Returns the XMLNode corresponding to an annotation containing MIRIAM- compliant model history information in RDF format. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.RDFAnnotationParser_parseOnlyModelHistory(obj) parseOnlyModelHistory = staticmethod(parseOnlyModelHistory) def deleteRDFAnnotation(annotation): """ deleteRDFAnnotation(XMLNode annotation) -> XMLNode Deletes any SBML MIRIAM RDF annotation found in the given XMLNode tree and returns any remaining annotation content. The name of the XMLNode given as parameter 'annotation' must be 'annotation', or else this method returns 'None.' The method will walk down the XML structure looking for elements that are in the RDF XML namespace, and remove them if they conform to the syntax of a History or CVTerm element. Parameter 'annotation' is the XMLNode tree within which the RDF annotation is to be found and deleted. Returns the XMLNode structure that is left after RDF annotations are deleted. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.RDFAnnotationParser_deleteRDFAnnotation(annotation) deleteRDFAnnotation = staticmethod(deleteRDFAnnotation) def deleteRDFHistoryAnnotation(annotation): """ deleteRDFHistoryAnnotation(XMLNode annotation) -> XMLNode Deletes any SBML MIRIAM RDF 'History' annotation found in the given XMLNode tree and returns any remaining annotation content. The name of the XMLNode given as parameter 'annotation' must be 'annotation', or else this method returns 'None.' The method will walk down the XML structure looking for elements that are in the RDF XML namespace, and remove any that conform to the syntax of a History element. Parameter 'annotation' is the XMLNode tree within which the RDF annotation is to be found and deleted. Returns the XMLNode structure that is left after RDF annotations are deleted. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.RDFAnnotationParser_deleteRDFHistoryAnnotation(annotation) deleteRDFHistoryAnnotation = staticmethod(deleteRDFHistoryAnnotation) def deleteRDFCVTermAnnotation(annotation): """ deleteRDFCVTermAnnotation(XMLNode annotation) -> XMLNode Deletes any SBML MIRIAM RDF 'CVTerm' annotation found in the given XMLNode tree and returns any remaining annotation content. The name of the XMLNode given as parameter 'annotation' must be 'annotation', or else this method returns 'None.' The method will walk down the XML structure looking for elements that are in the RDF XML namespace, and remove any that conform to the syntax of a CVTerm element. Parameter 'annotation' is the XMLNode tree within which the RDF annotation is to be found and deleted. Returns the XMLNode structure that is left after RDF annotations are deleted. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.RDFAnnotationParser_deleteRDFCVTermAnnotation(annotation) deleteRDFCVTermAnnotation = staticmethod(deleteRDFCVTermAnnotation) def parseRDFAnnotation(*args): """ parseRDFAnnotation(XMLNode annotation, char const * metaId=None, XMLInputStream stream=None) -> ModelHistory parseRDFAnnotation(XMLNode annotation, char const * metaId=None) -> ModelHistory parseRDFAnnotation(XMLNode annotation) -> ModelHistory parseRDFAnnotation(XMLNode annotation, CVTermList CVTerms) parseRDFAnnotation(XMLNode annotation, CVTermList CVTerms, char const * metaId=None, XMLInputStream stream=None) parseRDFAnnotation(XMLNode annotation, CVTermList CVTerms, char const * metaId=None) Parses an annotation (given as an XMLNode tree) into a list of CVTerm objects. This is used to take an annotation that has been read into an SBML model, identify the RDF elements within it, and create a list of corresponding CVTerm (controlled vocabulary term) objects. @param annotation XMLNode containing the annotation. @param CVTerms list of CVTerm objects to be created. @param metaId optional metaId, if set only the RDF annotation for this metaId will be returned. @param stream optional XMLInputStream that facilitates error logging. @copydetails doc_note_static_methods @htmlinclude warn-default-args-in-docs.html """ return _libsbml.RDFAnnotationParser_parseRDFAnnotation(*args) parseRDFAnnotation = staticmethod(parseRDFAnnotation) def __init__(self): """ __init__(RDFAnnotationParser self) -> RDFAnnotationParser @internal """ this = _libsbml.new_RDFAnnotationParser() try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_RDFAnnotationParser __del__ = lambda self: None RDFAnnotationParser_swigregister = _libsbml.RDFAnnotationParser_swigregister RDFAnnotationParser_swigregister(RDFAnnotationParser) def RDFAnnotationParser_createAnnotation(): """ RDFAnnotationParser_createAnnotation() -> XMLNode Creates a blank annotation and returns its root XMLNode object. This creates a completely empty SBML <annotation> element. It is not attached to any SBML element. An example of how this might be used is illustrated in the following code fragment. In this example, suppose that 'content' is an XMLNode object previously created, containing MIRIAM-style annotations, and that 'sbmlObject' is an SBML object derived from SBase (e.g., a Model, or a Species, or a Compartment, etc.). Then: RDF = RDFAnnotationParser.createRDFAnnotation() # Create XML structure. success = RDF.addChild(...content...) # Put some content into it. ... # Check return code value. annot = RDFAnnotationParser.createAnnotation() # Create <annotation>. success = annot.addChild(RDF) # Put the annotation into it. ... # Check return code value. success = sbmlObject.setAnnotation(annot) # Set object's annotation. ... # Check return code value. The SBML specification contains more information about the format of annotations. We urge readers to consult Section 6 of the SBML Level 2 (Versions 2-4) and SBML Level 3 specification documents. Returns a pointer to an XMLNode for the annotation. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also RDFAnnotationParser.createRDFAnnotation() . """ return _libsbml.RDFAnnotationParser_createAnnotation() def RDFAnnotationParser_createRDFAnnotation(level=3, version=1): """ createRDFAnnotation(unsigned int level=3, unsigned int version=1) -> XMLNode createRDFAnnotation(unsigned int level=3) -> XMLNode RDFAnnotationParser_createRDFAnnotation() -> XMLNode Creates a blank RDF element suitable for use in SBML annotations. The annotation created by this method has namespace declarations for all the relevant XML namespaces used in RDF annotations and also has an empty RDF element. The result is the following XML: <rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#' xmlns:dc='http://purl.org/dc/elements/1.1/' xmlns:dcterms='http://purl.org/dc/terms/' xmlns:vCard='http://www.w3.org/2001/vcard-rdf/3.0#' xmlns:bqbiol='http://biomodels.net/biology-qualifiers/' xmlns:bqmodel='http://biomodels.net/model-qualifiers/' > </rdf:RDF> Note that this does not create the containing SBML <annotation> element; the method RDFAnnotationParser.createAnnotation() is available for creating the container. Returns a pointer to an XMLNode. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. See also RDFAnnotationParser.createAnnotation() . Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.RDFAnnotationParser_createRDFAnnotation(level, version) def RDFAnnotationParser_createCVTerms(obj): """ RDFAnnotationParser_createCVTerms(SBase obj) -> XMLNode Takes a list of CVTerm objects and creates a the RDF 'Description' element. This essentially takes the given SBML object, reads out the CVTerm objects attached to it, creates an RDF 'Description' element to hold the terms, and adds each term with appropriate qualifiers. Parameter 'obj' is the SBML object to start from. Returns the XMLNode tree corresponding to the Description element of an RDF annotation. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.RDFAnnotationParser_createCVTerms(obj) def RDFAnnotationParser_parseCVTerms(obj): """ RDFAnnotationParser_parseCVTerms(SBase obj) -> XMLNode Takes a list of CVTerm objects and creates a complete SBML annotation around it. This essentially takes the given SBML object, reads out the CVTerm objects attached to it, calls RDFAnnotationParser.createRDFAnnotation() to create an RDF annotation to hold the terms, and finally calls RDFAnnotationParser.createAnnotation() to wrap the result as an SBML <annotation> element. Parameter 'obj' is the SBML object to start from. Returns the XMLNode tree corresponding to the annotation. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.RDFAnnotationParser_parseCVTerms(obj) def RDFAnnotationParser_parseModelHistory(obj): """ RDFAnnotationParser_parseModelHistory(SBase obj) -> XMLNode Reads the model history and cvTerms stored in 'obj' and creates the XML structure for an SBML annotation representing that metadata if there is a model history stored in 'obj'. Parameter 'obj' is any SBase object. Returns the XMLNode corresponding to an annotation containing MIRIAM- compliant model history and CV term information in RDF format. Note: If the object does not have a history element stored then 'None' is returned even if CVTerms are present. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.RDFAnnotationParser_parseModelHistory(obj) def RDFAnnotationParser_parseOnlyModelHistory(obj): """ RDFAnnotationParser_parseOnlyModelHistory(SBase obj) -> XMLNode Reads the model history stored in 'obj' and creates the XML structure for an SBML annotation representing that history. Parameter 'obj' is any SBase object. Returns the XMLNode corresponding to an annotation containing MIRIAM- compliant model history information in RDF format. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.RDFAnnotationParser_parseOnlyModelHistory(obj) def RDFAnnotationParser_deleteRDFAnnotation(annotation): """ RDFAnnotationParser_deleteRDFAnnotation(XMLNode annotation) -> XMLNode Deletes any SBML MIRIAM RDF annotation found in the given XMLNode tree and returns any remaining annotation content. The name of the XMLNode given as parameter 'annotation' must be 'annotation', or else this method returns 'None.' The method will walk down the XML structure looking for elements that are in the RDF XML namespace, and remove them if they conform to the syntax of a History or CVTerm element. Parameter 'annotation' is the XMLNode tree within which the RDF annotation is to be found and deleted. Returns the XMLNode structure that is left after RDF annotations are deleted. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.RDFAnnotationParser_deleteRDFAnnotation(annotation) def RDFAnnotationParser_deleteRDFHistoryAnnotation(annotation): """ RDFAnnotationParser_deleteRDFHistoryAnnotation(XMLNode annotation) -> XMLNode Deletes any SBML MIRIAM RDF 'History' annotation found in the given XMLNode tree and returns any remaining annotation content. The name of the XMLNode given as parameter 'annotation' must be 'annotation', or else this method returns 'None.' The method will walk down the XML structure looking for elements that are in the RDF XML namespace, and remove any that conform to the syntax of a History element. Parameter 'annotation' is the XMLNode tree within which the RDF annotation is to be found and deleted. Returns the XMLNode structure that is left after RDF annotations are deleted. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.RDFAnnotationParser_deleteRDFHistoryAnnotation(annotation) def RDFAnnotationParser_deleteRDFCVTermAnnotation(annotation): """ RDFAnnotationParser_deleteRDFCVTermAnnotation(XMLNode annotation) -> XMLNode Deletes any SBML MIRIAM RDF 'CVTerm' annotation found in the given XMLNode tree and returns any remaining annotation content. The name of the XMLNode given as parameter 'annotation' must be 'annotation', or else this method returns 'None.' The method will walk down the XML structure looking for elements that are in the RDF XML namespace, and remove any that conform to the syntax of a CVTerm element. Parameter 'annotation' is the XMLNode tree within which the RDF annotation is to be found and deleted. Returns the XMLNode structure that is left after RDF annotations are deleted. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.RDFAnnotationParser_deleteRDFCVTermAnnotation(annotation) def RDFAnnotationParser_parseRDFAnnotation(*args): """ parseRDFAnnotation(XMLNode annotation, char const * metaId=None, XMLInputStream stream=None) -> ModelHistory parseRDFAnnotation(XMLNode annotation, char const * metaId=None) -> ModelHistory parseRDFAnnotation(XMLNode annotation) -> ModelHistory parseRDFAnnotation(XMLNode annotation, CVTermList CVTerms) parseRDFAnnotation(XMLNode annotation, CVTermList CVTerms, char const * metaId=None, XMLInputStream stream=None) RDFAnnotationParser_parseRDFAnnotation(XMLNode annotation, CVTermList CVTerms, char const * metaId=None) Parses an annotation (given as an XMLNode tree) into a list of CVTerm objects. This is used to take an annotation that has been read into an SBML model, identify the RDF elements within it, and create a list of corresponding CVTerm (controlled vocabulary term) objects. @param annotation XMLNode containing the annotation. @param CVTerms list of CVTerm objects to be created. @param metaId optional metaId, if set only the RDF annotation for this metaId will be returned. @param stream optional XMLInputStream that facilitates error logging. @copydetails doc_note_static_methods @htmlinclude warn-default-args-in-docs.html """ return _libsbml.RDFAnnotationParser_parseRDFAnnotation(*args) class ISBMLExtensionNamespaces(SBMLNamespaces): """ Internal implementation method. """ __swig_setmethods__ = {} for _s in [SBMLNamespaces]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, ISBMLExtensionNamespaces, name, value) __swig_getmethods__ = {} for _s in [SBMLNamespaces]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, ISBMLExtensionNamespaces, name) def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_ISBMLExtensionNamespaces __del__ = lambda self: None def getURI(self): """ getURI(ISBMLExtensionNamespaces self) -> string Returns a string representing the SBML XML namespace of this object. Returns a string representing the SBML namespace that reflects the SBML Level and Version of this object. """ return _libsbml.ISBMLExtensionNamespaces_getURI(self) def getPackageVersion(self): """getPackageVersion(ISBMLExtensionNamespaces self) -> unsigned int""" return _libsbml.ISBMLExtensionNamespaces_getPackageVersion(self) def getPackageName(self): """ getPackageName(ISBMLExtensionNamespaces self) -> string Returns the name of the main package for this namespace. Returns the name of the main package for this namespace. 'core' will be returned if this namespace is defined in the SBML core. """ return _libsbml.ISBMLExtensionNamespaces_getPackageName(self) def setPackageVersion(self, pkgVersion): """setPackageVersion(ISBMLExtensionNamespaces self, unsigned int pkgVersion)""" return _libsbml.ISBMLExtensionNamespaces_setPackageVersion(self, pkgVersion) ISBMLExtensionNamespaces_swigregister = _libsbml.ISBMLExtensionNamespaces_swigregister ISBMLExtensionNamespaces_swigregister(ISBMLExtensionNamespaces) class SBaseExtensionPoint(_object): """ Internal implementation method. """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, SBaseExtensionPoint, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, SBaseExtensionPoint, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_SBaseExtensionPoint __del__ = lambda self: None def __init__(self, *args): """ __init__(SBaseExtensionPoint self, string pkgName, int typeCode) -> SBaseExtensionPoint __init__(SBaseExtensionPoint self, string pkgName, int typeCode, string elementName, bool elementOnly=False) -> SBaseExtensionPoint __init__(SBaseExtensionPoint self, string pkgName, int typeCode, string elementName) -> SBaseExtensionPoint __init__(SBaseExtensionPoint self, SBaseExtensionPoint rhs) -> SBaseExtensionPoint This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: SBaseExtensionPoint(string pkgName, int typeCode, string elementName, bool elementOnly = false) Constructor for SBaseExtensionPoint. The use of SBaseExtensionPoint is relatively straightforward. The class needs to be used for each extended SBML object implemented using SBMLDocumentPlugin or SBasePlugin. Doing so requires knowing just two things: * The short-form name of the parent package being extended. The parent package is often simply core SBML, identified in libSBML by the nickname 'core', but a SBML Level 3 package could conceivably extend another Level 3 package and the mechanism supports this. * The libSBML type code assigned to the object being extended. For example, if an extension of Model is implemented, the relevant type code is SBML_MODEL, found in #SBMLTypeCode_t. Parameter 'pkgName' is the short-form name of the parent package where that this package extension is extending. Parameter 'typeCode' is the type code of the object being extended. Parameter 'elementName' is element name for the target element, in case multiple elements match the same type code (as will be the case for ListOf classes). Parameter 'elementOnly' is flag to be used during the registration of the package, when set then the plugin is only applied to elements whose elementName match. Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. ______________________________________________________________________ Method variant with the following signature: SBaseExtensionPoint( SBaseExtensionPoint rhs) Copy constructor. This creates a copy of an SBaseExtensionPoint instance. Parameter 'rhs' is the object to copy. ______________________________________________________________________ Method variant with the following signature: SBaseExtensionPoint(string pkgName, int typeCode) Constructor for SBaseExtensionPoint. The use of SBaseExtensionPoint is relatively straightforward. The class needs to be used for each extended SBML object implemented using SBMLDocumentPlugin or SBasePlugin. Doing so requires knowing just two things: * The short-form name of the parent package being extended. The parent package is often simply core SBML, identified in libSBML by the nickname 'core', but a SBML Level 3 package could conceivably extend another Level 3 package and the mechanism supports this. * The libSBML type code assigned to the object being extended. For example, if an extension of Model is implemented, the relevant type code is SBML_MODEL, found in #SBMLTypeCode_t. Parameter 'pkgName' is the short-form name of the parent package where that this package extension is extending. Parameter 'typeCode' is the type code of the object being extended. """ this = _libsbml.new_SBaseExtensionPoint(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(SBaseExtensionPoint self) -> SBaseExtensionPoint Creates and returns a deep copy of this SBaseExtensionPoint object. Returns the (deep) copy of this SBaseExtensionPoint object. """ return _libsbml.SBaseExtensionPoint_clone(self) def getPackageName(self): """ getPackageName(SBaseExtensionPoint self) -> string Returns the package name of this extension point. """ return _libsbml.SBaseExtensionPoint_getPackageName(self) def getTypeCode(self): """ getTypeCode(SBaseExtensionPoint self) -> int Returns the libSBML type code of this extension point. """ return _libsbml.SBaseExtensionPoint_getTypeCode(self) def getElementName(self): """ getElementName(SBaseExtensionPoint self) -> string the target element name """ return _libsbml.SBaseExtensionPoint_getElementName(self) def isElementOnly(self): """ isElementOnly(SBaseExtensionPoint self) -> bool """ return _libsbml.SBaseExtensionPoint_isElementOnly(self) SBaseExtensionPoint_swigregister = _libsbml.SBaseExtensionPoint_swigregister SBaseExtensionPoint_swigregister(SBaseExtensionPoint) class SBasePlugin(_object): """ Base class for extending SBML objects in packages. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. The SBasePlugin class is libSBML's base class for extensions of core SBML component objects. SBasePlugin defines basic virtual methods for reading/writing/checking additional attributes and/or subobjects; these methods should be overridden by subclasses to implement the necessary features of an extended SBML object. Basic principles of SBML package extensions in libSBML ====================================================================== SBML Level 3's package structure permits modular extensions to the core SBML format. In libSBML, support for SBML Level 3 packages is provided through optional package extensions that can be plugged into libSBML at the time it is built/compiled. Users of libSBML can thus choose which extensions are enabled in their software applications. LibSBML defines a number of classes that developers of package extensions can use to implement support for an SBML Level 3 package. These classes make it easier to extend libSBML objects with new attributes and/or subobjects as needed by a particular Level 3 package. Three overall categories of classes make up libSBML's facilities for implementing package extensions. There are (1) classes that serve as base classes meant to be subclassed, (2) template classes meant to be instantiated rather than subclassed, and (3) support classes that provide utility features. A given package implementation for libSBML will take the form of code using these and other libSBML classes, placed in a subdirectory of src/sbml/packages/. The basic libSBML distribution includes a number of package extensions implementing support for officially-endorsed SBML Level 3 packages; among these are Flux Balance Constraints ('fbc'), Hierarchical Model Composition ('comp'), Layout ('layout'), and Qualitative Models ('qual'). They can serve as working examples for developers working to implement other packages. Extensions in libSBML can currently only be implemented in C++ or C; there is no mechanism to implement them first in languages such as Java or Python. However, once implemented in C++ or C, language interfaces can be generated semi-automatically using the framework in place in libSBML. (The approach is based on using SWIG and facilities in libSBML's build system.) """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, SBasePlugin, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, SBasePlugin, name) def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_SBasePlugin __del__ = lambda self: None def getElementNamespace(self): """ getElementNamespace(SBasePlugin self) -> string Returns the namespace URI of the package to which this plugin object belongs. Returns the XML namespace URI of the SBML Level 3 package implemented by this libSBML package extension. """ return _libsbml.SBasePlugin_getElementNamespace(self) def getPrefix(self): """ getPrefix(SBasePlugin self) -> string Returns the XML namespace prefix of the package to which this plugin object belongs. Returns the XML namespace prefix of the SBML Level 3 package implemented by this libSBML package extension. """ return _libsbml.SBasePlugin_getPrefix(self) def getPackageName(self): """ getPackageName(SBasePlugin self) -> string Returns the short-form name of the package to which this plugin object belongs. Returns the short-form package name (or nickname) of the SBML package implemented by this package extension. """ return _libsbml.SBasePlugin_getPackageName(self) def clone(self): """ clone(SBasePlugin self) -> SBasePlugin Creates and returns a deep copy of this SBasePlugin object. Returns the (deep) copy of this SBasePlugin object. """ return _libsbml.SBasePlugin_clone(self) def getElementBySId(self, id): """ getElementBySId(SBasePlugin self, string id) -> SBase Return the first child object found with a given identifier. This method searches all the subobjects under this one, compares their identifiers to 'id', and returns the first one that machines. Normally, SId type identifier values are unique across a model in SBML. However, in some circumstances they may not be, such as if a model is invalid because of multiple objects having the same identifier. Parameter 'id' is string representing the identifier of the object to find. Returns pointer to the first object with the given 'id'. """ return _libsbml.SBasePlugin_getElementBySId(self, id) def getElementByMetaId(self, metaid): """ getElementByMetaId(SBasePlugin self, string metaid) -> SBase Return the first child object found with a given meta identifier. This method searches all the subobjects under this one, compares their meta identifiers to 'metaid', and returns the first one that machines. Parameter 'metaid' is string, the metaid of the object to find. Returns pointer to the first object found with the given 'metaid'. """ return _libsbml.SBasePlugin_getElementByMetaId(self, metaid) def connectToParent(self, sbase): """ connectToParent(SBasePlugin self, SBase sbase) Internal implementation method. """ return _libsbml.SBasePlugin_connectToParent(self, sbase) def enablePackageInternal(self, pkgURI, pkgPrefix, flag): """ enablePackageInternal(SBasePlugin self, string pkgURI, string pkgPrefix, bool flag) Internal implementation method. """ return _libsbml.SBasePlugin_enablePackageInternal(self, pkgURI, pkgPrefix, flag) def stripPackage(self, pkgPrefix, flag): """ stripPackage(SBasePlugin self, string pkgPrefix, bool flag) -> bool Internal implementation method. """ return _libsbml.SBasePlugin_stripPackage(self, pkgPrefix, flag) def getSBMLDocument(self, *args): """ getSBMLDocument(SBasePlugin self) -> SBMLDocument getSBMLDocument(SBasePlugin self) -> SBMLDocument Returns the SBMLDocument object containing this object instance. LibSBML uses the class SBMLDocument as a top-level container for storing SBML content and data associated with it (such as warnings and error messages). An SBML model in libSBML is contained inside an SBMLDocument object. SBMLDocument corresponds roughly to the class SBML defined in the SBML Level 3 and Level 2 specifications, but it does not have a direct correspondence in SBML Level 1. (But, it is created by libSBML no matter whether the model is Level 1, Level 2 or Level 3.) This method allows the caller to obtain the SBMLDocument for the current object. Returns the parent SBMLDocument object of this plugin object. See also getParentSBMLObject(). """ return _libsbml.SBasePlugin_getSBMLDocument(self, *args) def getURI(self): """ getURI(SBasePlugin self) -> string Returns the XML namespace URI for the package to which this object belongs. In the XML representation of an SBML document, XML namespaces are used to identify the origin of each XML construct used. XML namespaces are identified by their unique resource identifiers (URIs). The core SBML specifications stipulate the namespaces that must be used for core SBML constructs; for example, all XML elements that belong to SBML Level 3 Version 1 Core must be placed in the XML namespace identified by the URI 'http://www.sbml.org/sbml/level3/version1/core'. Individual SBML Level 3 packages define their own XML namespaces; for example, all elements belonging to the SBML Level 3 Layout Version 1 package must be placed in the XML namespace 'http://www.sbml.org/sbml/level3/version1/layout/version1/'. This method first looks into the SBMLNamespaces object possessed by the parent SBMLDocument object of the current object. If this cannot be found, this method returns the result of getElementNamespace(). Returns a string, the URI of the XML namespace to which this object belongs. See also getPackageName(), getElementNamespace(), getSBMLDocument(). """ return _libsbml.SBasePlugin_getURI(self) def getParentSBMLObject(self, *args): """ getParentSBMLObject(SBasePlugin self) -> SBase getParentSBMLObject(SBasePlugin self) -> SBase Returns the parent object to which this plugin object is connected. Returns the parent object of this object. """ return _libsbml.SBasePlugin_getParentSBMLObject(self, *args) def setElementNamespace(self, uri): """ setElementNamespace(SBasePlugin self, string uri) -> int Sets the XML namespace to which this object belongs. In the XML representation of an SBML document, XML namespaces are used to identify the origin of each XML construct used. XML namespaces are identified by their unique resource identifiers (URIs). The core SBML specifications stipulate the namespaces that must be used for core SBML constructs; for example, all XML elements that belong to SBML Level 3 Version 1 Core must be placed in the XML namespace identified by the URI 'http://www.sbml.org/sbml/level3/version1/core'. Individual SBML Level 3 packages define their own XML namespaces; for example, all elements belonging to the SBML Level 3 Layout Version 1 package must be placed in the XML namespace 'http://www.sbml.org/sbml/level3/version1/layout/version1/'. Parameter 'uri' is the URI to assign to this object. Returns integer value indicating success/failure of the function. This particular function only does one thing irrespective of user input or object state, and thus will only return a single value: * LIBSBML_OPERATION_SUCCESS See also getElementNamespace(). """ return _libsbml.SBasePlugin_setElementNamespace(self, uri) def getLevel(self): """ getLevel(SBasePlugin self) -> unsigned int Returns the SBML Level of the package extension of this plugin object. Returns the SBML Level. See also getVersion(). """ return _libsbml.SBasePlugin_getLevel(self) def getVersion(self): """ getVersion(SBasePlugin self) -> unsigned int Returns the Version within the SBML Level of the package extension of this plugin object. Returns the SBML Version. See also getLevel(). """ return _libsbml.SBasePlugin_getVersion(self) def getPackageVersion(self): """ getPackageVersion(SBasePlugin self) -> unsigned int Returns the package version of the package extension of this plugin object. Returns the package version of the package extension of this plugin object. See also getLevel(), getVersion(). """ return _libsbml.SBasePlugin_getPackageVersion(self) def replaceSIDWithFunction(self, id, function): """ replaceSIDWithFunction(SBasePlugin self, string id, ASTNode function) Internal implementation method. """ return _libsbml.SBasePlugin_replaceSIDWithFunction(self, id, function) def divideAssignmentsToSIdByFunction(self, id, function): """ divideAssignmentsToSIdByFunction(SBasePlugin self, string id, ASTNode function) Internal implementation method. """ return _libsbml.SBasePlugin_divideAssignmentsToSIdByFunction(self, id, function) def multiplyAssignmentsToSIdByFunction(self, id, function): """ multiplyAssignmentsToSIdByFunction(SBasePlugin self, string id, ASTNode function) Internal implementation method. """ return _libsbml.SBasePlugin_multiplyAssignmentsToSIdByFunction(self, id, function) def hasIdentifierBeginningWith(self, prefix): """ hasIdentifierBeginningWith(SBasePlugin self, string prefix) -> bool Internal implementation method. """ return _libsbml.SBasePlugin_hasIdentifierBeginningWith(self, prefix) def prependStringToAllIdentifiers(self, prefix): """ prependStringToAllIdentifiers(SBasePlugin self, string prefix) -> int Internal implementation method. """ return _libsbml.SBasePlugin_prependStringToAllIdentifiers(self, prefix) def renameSIdRefs(self, oldid, newid): """ renameSIdRefs(SBasePlugin self, string oldid, string newid) Replaces all uses of a given 'SIdRef' type attribute value with another value. In SBML, object identifiers are of a data type called SId. In SBML Level 3, an explicit data type called SIdRef was introduced for attribute values that refer to SId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to an identifier', but the effective data type was the same as SIdRef in Level 3. These and other methods of libSBML refer to the type SIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all attributes and (if appropriate) mathematical formulas in MathML content, comparing the referenced identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.SBasePlugin_renameSIdRefs(self, oldid, newid) def renameMetaIdRefs(self, oldid, newid): """ renameMetaIdRefs(SBasePlugin self, string oldid, string newid) Replaces all uses of a given meta identifier attribute value with another value. In SBML, object 'meta' identifiers are of the XML data type ID; the SBML object attribute itself is typically named metaid. All attributes that hold values referring to values of type ID are of the XML data type IDREF. They are also sometimes informally referred to as 'metaid refs', in analogy to the SBML-defined type SIdRef. This method works by looking at all meta-identifier attribute values, comparing the identifiers to the value of 'oldid'. If any matches are found, the matching identifiers are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.SBasePlugin_renameMetaIdRefs(self, oldid, newid) def renameUnitSIdRefs(self, oldid, newid): """ renameUnitSIdRefs(SBasePlugin self, string oldid, string newid) Replaces all uses of a given 'UnitSIdRef' type attribute value with another value. In SBML, unit definitions have identifiers of type UnitSId. In SBML Level 3, an explicit data type called UnitSIdRef was introduced for attribute values that refer to UnitSId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as 'referring to a unit identifier', but the effective data type was the same as UnitSIdRef in Level 3. These and other methods of libSBML refer to the type UnitSIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type. This method works by looking at all unit identifier attribute values (including, if appropriate, inside mathematical formulas), comparing the referenced unit identifiers to the value of 'oldid'. If any matches are found, the matching values are replaced with 'newid'. The method does not descend into child elements. Parameter 'oldid' is the old identifier. Parameter 'newid' is the new identifier. """ return _libsbml.SBasePlugin_renameUnitSIdRefs(self, oldid, newid) def transformIdentifiers(self, sidTransformer): """ transformIdentifiers(SBasePlugin self, IdentifierTransformer sidTransformer) -> int Internal implementation method. """ return _libsbml.SBasePlugin_transformIdentifiers(self, sidTransformer) def getLine(self): """ getLine(SBasePlugin self) -> unsigned int Internal implementation method. """ return _libsbml.SBasePlugin_getLine(self) def getColumn(self): """ getColumn(SBasePlugin self) -> unsigned int Internal implementation method. """ return _libsbml.SBasePlugin_getColumn(self) def getSBMLNamespaces(self): """ getSBMLNamespaces(SBasePlugin self) -> SBMLNamespaces Internal implementation method. """ return _libsbml.SBasePlugin_getSBMLNamespaces(self) def logUnknownElement(self, element, sbmlLevel, sbmlVersion, pkgVersion): """ logUnknownElement(SBasePlugin self, string element, unsigned int const sbmlLevel, unsigned int const sbmlVersion, unsigned int const pkgVersion) Internal implementation method. """ return _libsbml.SBasePlugin_logUnknownElement(self, element, sbmlLevel, sbmlVersion, pkgVersion) def isValidTypeForList(self, item): """ isValidTypeForList(SBasePlugin self, SBase item) -> bool """ return _libsbml.SBasePlugin_isValidTypeForList(self, item) def getSBMLExtension(self): """ getSBMLExtension(SBasePlugin self) -> SBMLExtension Internal implementation method. """ return _libsbml.SBasePlugin_getSBMLExtension(self) def updateSBMLNamespace(self, package, level, version): """ updateSBMLNamespace(SBasePlugin self, string package, unsigned int level, unsigned int version) Internal implementation method. """ return _libsbml.SBasePlugin_updateSBMLNamespace(self, package, level, version) __metaclass__ = AutoProperty def __eq__(self, rhs): if ((self is None) and (rhs is None)): return True if ((self is None) or (rhs is None)): return False if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return True return False def __ne__(self, rhs): if ((self is None) and (rhs is None)): return False if ((self is None) or (rhs is None)): return True if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return False return True def getListOfAllElements(self, *args): """ getListOfAllElements(self) -> SBaseList Get the List of SBase objects in this plugin. Returns the SBaseList of all element for this plugin. """ return _libsbml.SBasePlugin_getListOfAllElements(self, *args) SBasePlugin_swigregister = _libsbml.SBasePlugin_swigregister SBasePlugin_swigregister(SBasePlugin) class SBMLDocumentPlugin(SBasePlugin): """ Base class for extending SBMLDocument in packages. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. The SBMLDocumentPlugin class is a specialization of SBasePlugin designed specifically for extending SBMLDocument. All package extensions must extend SBMLDocument to implement support for SBML Level 3 packages; these extensions can be subclasses of this class or from a derived class of this class. All packages must additionally define a required flag named required, which indicates whether that package's constructs can be used to change the core mathematics of the <model> child of the <sbml> element. If they can, this attribute must be set 'True,' and if they cannot, this attribute must be set 'False.' Basic principles of SBML package extensions in libSBML ====================================================================== SBML Level 3's package structure permits modular extensions to the core SBML format. In libSBML, support for SBML Level 3 packages is provided through optional package extensions that can be plugged into libSBML at the time it is built/compiled. Users of libSBML can thus choose which extensions are enabled in their software applications. LibSBML defines a number of classes that developers of package extensions can use to implement support for an SBML Level 3 package. These classes make it easier to extend libSBML objects with new attributes and/or subobjects as needed by a particular Level 3 package. Three overall categories of classes make up libSBML's facilities for implementing package extensions. There are (1) classes that serve as base classes meant to be subclassed, (2) template classes meant to be instantiated rather than subclassed, and (3) support classes that provide utility features. A given package implementation for libSBML will take the form of code using these and other libSBML classes, placed in a subdirectory of src/sbml/packages/. The basic libSBML distribution includes a number of package extensions implementing support for officially-endorsed SBML Level 3 packages; among these are Flux Balance Constraints ('fbc'), Hierarchical Model Composition ('comp'), Layout ('layout'), and Qualitative Models ('qual'). They can serve as working examples for developers working to implement other packages. Extensions in libSBML can currently only be implemented in C++ or C; there is no mechanism to implement them first in languages such as Java or Python. However, once implemented in C++ or C, language interfaces can be generated semi-automatically using the framework in place in libSBML. (The approach is based on using SWIG and facilities in libSBML's build system.) """ __swig_setmethods__ = {} for _s in [SBasePlugin]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLDocumentPlugin, name, value) __swig_getmethods__ = {} for _s in [SBasePlugin]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, SBMLDocumentPlugin, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(SBMLDocumentPlugin self, string uri, string prefix, SBMLNamespaces sbmlns) -> SBMLDocumentPlugin __init__(SBMLDocumentPlugin self, SBMLDocumentPlugin orig) -> SBMLDocumentPlugin This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: SBMLDocumentPlugin(string &uri, string &prefix, SBMLNamespaces sbmlns) Creates a new SBMLDocumentPlugin object using the given parameters. In the XML representation of an SBML document, XML namespaces are used to identify the origin of each XML construct used. XML namespaces are identified by their unique resource identifiers (URIs). The core SBML specifications stipulate the namespaces that must be used for core SBML constructs; for example, all XML elements that belong to SBML Level 3 Version 1 Core must be placed in the XML namespace identified by the URI 'http://www.sbml.org/sbml/level3/version1/core'. Individual SBML Level 3 packages define their own XML namespaces; for example, all elements belonging to the SBML Level 3 Layout Version 1 package must be placed in the XML namespace 'http://www.sbml.org/sbml/level3/version1/layout/version1/'. The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments. Parameter 'uri' is the URI of the SBML Level 3 package implemented by this libSBML package extension. Parameter 'prefix' is the XML namespace prefix being used for the package. Parameter 'sbmlns' is the SBMLNamespaces object for the package. ______________________________________________________________________ Method variant with the following signature: SBMLDocumentPlugin(SBMLDocumentPlugin orig) Copy constructor. This creates a copy of this object. Parameter 'orig' is the SBMLDocumentPlugin instance to copy. """ this = _libsbml.new_SBMLDocumentPlugin(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_SBMLDocumentPlugin __del__ = lambda self: None def clone(self): """ clone(SBMLDocumentPlugin self) -> SBMLDocumentPlugin Creates and returns a deep copy of this SBMLDocumentPlugin object. Returns the (deep) copy of this SBMLDocumentPlugin object. """ return _libsbml.SBMLDocumentPlugin_clone(self) def setRequired(self, value): """ setRequired(SBMLDocumentPlugin self, bool value) -> int Sets the SBML 'required' attribute value. SBML Level 3 requires that every package defines an attribute named 'required' on the root <sbml> element in an SBML file or data stream. The attribute, being in the namespace of the Level 3 package in question, must be prefixed by the XML namespace prefix associated with the package. The value of the 'required' attribute indicates whether constructs in that package may change the mathematical interpretation of constructs defined in SBML Level 3 Core. A 'required' value of 'True' indicates that the package may do so. The value of the attribute is set by the Level 3 package specification, and does not depend on the actual presence or absence of particular package constructs in a given SBML document: in other words, if the package specification defines any construct that can change the model's meaning, the value of the 'required' attribute must always be set to 'True' in any SBML document that uses the package. The XML namespace declaration for an SBML Level 3 package is an indication that a model makes use of features defined by that package, while the 'required' attribute indicates whether the features may be ignored without compromising the mathematical meaning of the model. Both are necessary for a complete reference to an SBML Level 3 package. Parameter 'value' is the value to be assigned to the 'required' attribute. The 'required' attribute takes a Boolean value, either 'True' or 'False.' Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE See also getRequired(), isSetRequired(), unsetRequired(). """ return _libsbml.SBMLDocumentPlugin_setRequired(self, value) def getRequired(self): """ getRequired(SBMLDocumentPlugin self) -> bool Returns the value of the 'required' attribute. SBML Level 3 requires that every package defines an attribute named 'required' on the root <sbml> element in an SBML file or data stream. The attribute, being in the namespace of the Level 3 package in question, must be prefixed by the XML namespace prefix associated with the package. The value of the 'required' attribute indicates whether constructs in that package may change the mathematical interpretation of constructs defined in SBML Level 3 Core. A 'required' value of 'True' indicates that the package may do so. The value of the attribute is set by the Level 3 package specification, and does not depend on the actual presence or absence of particular package constructs in a given SBML document: in other words, if the package specification defines any construct that can change the model's meaning, the value of the 'required' attribute must always be set to 'True' in any SBML document that uses the package. The XML namespace declaration for an SBML Level 3 package is an indication that a model makes use of features defined by that package, while the 'required' attribute indicates whether the features may be ignored without compromising the mathematical meaning of the model. Both are necessary for a complete reference to an SBML Level 3 package. Returns the bool value of 'required' attribute for the SBML package. See also setRequired(), isSetRequired(), unsetRequired(). """ return _libsbml.SBMLDocumentPlugin_getRequired(self) def isSetRequired(self): """ isSetRequired(SBMLDocumentPlugin self) -> bool Returns the value of the 'required' attribute. SBML Level 3 requires that every package defines an attribute named 'required' on the root <sbml> element in an SBML file or data stream. The attribute, being in the namespace of the Level 3 package in question, must be prefixed by the XML namespace prefix associated with the package. The value of the 'required' attribute indicates whether constructs in that package may change the mathematical interpretation of constructs defined in SBML Level 3 Core. A 'required' value of 'True' indicates that the package may do so. The value of the attribute is set by the Level 3 package specification, and does not depend on the actual presence or absence of particular package constructs in a given SBML document: in other words, if the package specification defines any construct that can change the model's meaning, the value of the 'required' attribute must always be set to 'True' in any SBML document that uses the package. The XML namespace declaration for an SBML Level 3 package is an indication that a model makes use of features defined by that package, while the 'required' attribute indicates whether the features may be ignored without compromising the mathematical meaning of the model. Both are necessary for a complete reference to an SBML Level 3 package. Returns 'True' if the 'required' attribute of this SBMLDocument has been set to 'True,' 'False' otherwise. """ return _libsbml.SBMLDocumentPlugin_isSetRequired(self) def unsetRequired(self): """ unsetRequired(SBMLDocumentPlugin self) -> int Unsets the value of the 'required' attribute of this SBMLDocumentPlugin. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS """ return _libsbml.SBMLDocumentPlugin_unsetRequired(self) def isCompFlatteningImplemented(self): """ isCompFlatteningImplemented(SBMLDocumentPlugin self) -> bool Internal implementation method. """ return _libsbml.SBMLDocumentPlugin_isCompFlatteningImplemented(self) def checkConsistency(self): """ checkConsistency(SBMLDocumentPlugin self) -> unsigned int Internal implementation method. """ return _libsbml.SBMLDocumentPlugin_checkConsistency(self) SBMLDocumentPlugin_swigregister = _libsbml.SBMLDocumentPlugin_swigregister SBMLDocumentPlugin_swigregister(SBMLDocumentPlugin) class SBMLExtension(_object): """ Base class for SBML Level 3 package plug-ins. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. The SBMLExtension class is a component of the libSBML package extension mechanism. It is an abstract class that is extended by each package extension implementation. Basic principles of SBML package extensions in libSBML ====================================================================== SBML Level 3's package structure permits modular extensions to the core SBML format. In libSBML, support for SBML Level 3 packages is provided through optional package extensions that can be plugged into libSBML at the time it is built/compiled. Users of libSBML can thus choose which extensions are enabled in their software applications. LibSBML defines a number of classes that developers of package extensions can use to implement support for an SBML Level 3 package. These classes make it easier to extend libSBML objects with new attributes and/or subobjects as needed by a particular Level 3 package. Three overall categories of classes make up libSBML's facilities for implementing package extensions. There are (1) classes that serve as base classes meant to be subclassed, (2) template classes meant to be instantiated rather than subclassed, and (3) support classes that provide utility features. A given package implementation for libSBML will take the form of code using these and other libSBML classes, placed in a subdirectory of src/sbml/packages/. The basic libSBML distribution includes a number of package extensions implementing support for officially-endorsed SBML Level 3 packages; among these are Flux Balance Constraints ('fbc'), Hierarchical Model Composition ('comp'), Layout ('layout'), and Qualitative Models ('qual'). They can serve as working examples for developers working to implement other packages. Extensions in libSBML can currently only be implemented in C++ or C; there is no mechanism to implement them first in languages such as Java or Python. However, once implemented in C++ or C, language interfaces can be generated semi-automatically using the framework in place in libSBML. (The approach is based on using SWIG and facilities in libSBML's build system.) Special handling for SBML Level 2 ====================================================================== Due to the historical background of the SBML Layout package, libSBML implements special behavior for that package: it always creates a Layout plugin object for any SBML Level 2 document it reads in, regardless of whether that document actually uses Layout constructs. This is unlike the case for SBML Level 3 documents that use Layout; for them, libSBML will not create a plugin object unless the document actually declares the use of the Layout package (via the usual Level 3 namespace declaration for Level 3 packages). This has the following consequence. If an application queries for the presence of Layout in an SBML Level 2 document by testing only for the existence of the plugin object, it will always get a positive result; in other words, the presence of a Layout extension object is not an indication of whether a read-in Level 2 document does or does not use SBML Layout. Instead, callers have to query explicitly for the existence of layout information. An example of such a query is the following code: # Assume 'doc' below is an SBMLDocument object. m = doc.getModel() if m != None: layoutPlugin = m.getPlugin('layout') if layoutPlugin != None: numLayouts = layoutPlugin.getNumLayouts() # If numLayouts is greater than zero, then the model uses Layout. The special, always-available Level 2 Layout behavior was motivated by a desire to support legacy applications. In SBML Level 3, the Layout package uses the normal SBML Level 3 scheme of requiring declarations on the SBML document element. This means that upon reading a model, libSBML knows right away whether it contains layout information. In SBML Level 2, there is no top-level declaration because layout is stored as annotations in the body of the model. Detecting the presence of layout information when reading a Level 2 model requires parsing the annotations. For efficiency reasons, libSBML normally does not parse annotations automatically when reading a model. However, applications that predated the introduction of Level 3 Layout and the updated version of libSBML never had to do anything special to enable parsing layout; the facilities were always available for every Level 2 model as long as libSBML was compiled with Layout support. To avoid burdening developers of legacy applications with the need to modify their software, libSBML provides backward compatibility by always preloading the Layout package extension when reading Level 2 models. The same applies to the creation of Level 2 models: with the plugin-oriented libSBML, applications normally would have to take deliberate steps to activate package code, instantiate objects, manage namespaces, and so on. LibSBML again loads the Layout package plugin automatically when creating a Level 2 model, thereby making the APIs available to legacy applications without further work on their part. """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLExtension, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, SBMLExtension, name) def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_SBMLExtension __del__ = lambda self: None def getNumOfSBasePlugins(self): """ getNumOfSBasePlugins(SBMLExtension self) -> int Returns the number of SBasePluginCreatorBase objects stored in this object. Returns the total number of SBasePluginCreatorBase objects stored in this SBMLExtension-derived object. """ return _libsbml.SBMLExtension_getNumOfSBasePlugins(self) def getNumOfSupportedPackageURI(self): """ getNumOfSupportedPackageURI(SBMLExtension self) -> unsigned int Returns the number of supported package namespace URIs. Returns the number of supported package XML namespace URIs of this package extension. """ return _libsbml.SBMLExtension_getNumOfSupportedPackageURI(self) def isSupported(self, uri): """ isSupported(SBMLExtension self, string uri) -> bool Returns 'True' if the given XML namespace URI is supported by this package extension. Returns 'True' if the given XML namespace URI (equivalent to a package version) is supported by this package extension, 'False' otherwise. """ return _libsbml.SBMLExtension_isSupported(self, uri) def getSupportedPackageURI(self, n): """ getSupportedPackageURI(SBMLExtension self, unsigned int n) -> string Returns the nth XML namespace URI. Parameter 'n' is the index number of the namespace URI being sought. Returns a string representing the XML namespace URI understood to be supported by this package. An empty string will be returned if there is no nth URI. """ return _libsbml.SBMLExtension_getSupportedPackageURI(self, n) def clone(self): """ clone(SBMLExtension self) -> SBMLExtension Creates and returns a deep copy of this SBMLExtension object. Returns a (deep) copy of this SBMLExtension object. Note: This is a method that package extension implementations must override. See the libSBML documentation on extending libSBML to support SBML packages for more information on this topic. """ return _libsbml.SBMLExtension_clone(self) def getName(self): """ getName(SBMLExtension self) -> string Returns the nickname of this package. This returns the short-form name of an SBML Level 3 package implemented by a given SBMLExtension-derived class. Examples of such names are 'layout', 'fbc', etc. Returns a string, the nickname of SBML package. Note: This is a method that package extension implementations must override. See the libSBML documentation on extending libSBML to support SBML packages for more information on this topic. """ return _libsbml.SBMLExtension_getName(self) def getURI(self, sbmlLevel, sbmlVersion, pkgVersion): """ getURI(SBMLExtension self, unsigned int sbmlLevel, unsigned int sbmlVersion, unsigned int pkgVersion) -> string Returns the XML namespace URI for a given Level and Version. Parameter 'sbmlLevel' is the SBML Level. Parameter 'sbmlVersion' is the SBML Version. Parameter 'pkgVersion' is the version of the package. Returns a string, the XML namespace URI for the package for the given SBML Level, SBML Version, and package version. Note: This is a method that package extension implementations must override. See the libSBML documentation on extending libSBML to support SBML packages for more information on this topic. """ return _libsbml.SBMLExtension_getURI(self, sbmlLevel, sbmlVersion, pkgVersion) def getLevel(self, uri): """ getLevel(SBMLExtension self, string uri) -> unsigned int Returns the SBML Level associated with the given XML namespace URI. Parameter 'uri' is the string of URI that represents a version of the package. Returns the SBML Level associated with the given URI of this package. Note: This is a method that package extension implementations must override. See the libSBML documentation on extending libSBML to support SBML packages for more information on this topic. """ return _libsbml.SBMLExtension_getLevel(self, uri) def getVersion(self, uri): """ getVersion(SBMLExtension self, string uri) -> unsigned int Returns the SBML Version associated with the given XML namespace URI. Parameter 'uri' is the string of URI that represents a version of the package. Returns the SBML Version associated with the given URI of this package. Note: This is a method that package extension implementations must override. See the libSBML documentation on extending libSBML to support SBML packages for more information on this topic. """ return _libsbml.SBMLExtension_getVersion(self, uri) def getPackageVersion(self, uri): """ getPackageVersion(SBMLExtension self, string uri) -> unsigned int Returns the package version associated with the given XML namespace URI. Parameter 'uri' is the string of URI that represents a version of this package. Returns the package version associated with the given URI of this package. Note: This is a method that package extension implementations must override. See the libSBML documentation on extending libSBML to support SBML packages for more information on this topic. """ return _libsbml.SBMLExtension_getPackageVersion(self, uri) def getStringFromTypeCode(self, typeCode): """ getStringFromTypeCode(SBMLExtension self, int typeCode) -> char const * Returns a string representation of a type code. This method takes a numerical type code 'typeCode' for a component object implemented by this package extension, and returns a string representing that type code. Parameter 'typeCode' is the type code to turn into a string. Returns the string representation of 'typeCode'. Note: This is a method that package extension implementations must override. See the libSBML documentation on extending libSBML to support SBML packages for more information on this topic. """ return _libsbml.SBMLExtension_getStringFromTypeCode(self, typeCode) def getSBMLExtensionNamespaces(self, uri): """ getSBMLExtensionNamespaces(SBMLExtension self, string uri) -> SBMLNamespaces Returns a specialized SBMLNamespaces object corresponding to a given namespace URI. LibSBML package extensions each define a subclass of SBMLNamespaces. The present method returns the appropriate object corresponding to the given XML namespace URI in argument 'uri'. Parameter 'uri' is the namespace URI that represents one of versions of the package implemented in this extension. Returns an SBMLNamespaces object, or 'None' if the given 'uri' is not defined in the corresponding package. Note: This is a method that package extension implementations must override. See the libSBML documentation on extending libSBML to support SBML packages for more information on this topic. """ return _libsbml.SBMLExtension_getSBMLExtensionNamespaces(self, uri) def setEnabled(self, isEnabled): """ setEnabled(SBMLExtension self, bool isEnabled) -> bool Enable or disable this package. Parameter 'isEnabled' is flag indicating whether to enable (if 'True)' or disable ('False)' this package extension. Returns 'True' if this call succeeded; 'False' otherwise. """ return _libsbml.SBMLExtension_setEnabled(self, isEnabled) def isEnabled(self): """ isEnabled(SBMLExtension self) -> bool Returns 'True' if this package is enabled. Returns 'True' if this package is enabled, 'False' otherwise. """ return _libsbml.SBMLExtension_isEnabled(self) def removeL2Namespaces(self, xmlns): """ removeL2Namespaces(SBMLExtension self, XMLNamespaces xmlns) Internal implementation method. """ return _libsbml.SBMLExtension_removeL2Namespaces(self, xmlns) def addL2Namespaces(self, xmlns): """ addL2Namespaces(SBMLExtension self, XMLNamespaces xmlns) Internal implementation method. """ return _libsbml.SBMLExtension_addL2Namespaces(self, xmlns) def enableL2NamespaceForDocument(self, doc): """ enableL2NamespaceForDocument(SBMLExtension self, SBMLDocument doc) Internal implementation method. """ return _libsbml.SBMLExtension_enableL2NamespaceForDocument(self, doc) def isInUse(self, doc): """ isInUse(SBMLExtension self, SBMLDocument doc) -> bool Indicates whether this extension is being used by the given SBMLDocument. The default implementation returns 'True.' This means that when a document had this extension enabled, it will not be possible to convert it to SBML Level 2 as we cannot make sure that the extension can be converted. Parameter 'doc' is the SBML document to test. Returns a boolean indicating whether the extension is actually being used by the document. """ return _libsbml.SBMLExtension_isInUse(self, doc) def hasMutiplePackageVersions(self): """ hasMutiplePackageVersions(SBMLExtension self) -> bool Internal implementation method. """ return _libsbml.SBMLExtension_hasMutiplePackageVersions(self) def getErrorTableIndex(self, errorId): """ getErrorTableIndex(SBMLExtension self, unsigned int errorId) -> unsigned int Internal implementation method. """ return _libsbml.SBMLExtension_getErrorTableIndex(self, errorId) def getErrorIdOffset(self): """ getErrorIdOffset(SBMLExtension self) -> unsigned int Internal implementation method. """ return _libsbml.SBMLExtension_getErrorIdOffset(self) def getSeverity(self, index, pkgVersion): """ getSeverity(SBMLExtension self, unsigned int index, unsigned int pkgVersion) -> unsigned int Internal implementation method. """ return _libsbml.SBMLExtension_getSeverity(self, index, pkgVersion) def getCategory(self, index): """ getCategory(SBMLExtension self, unsigned int index) -> unsigned int Internal implementation method. """ return _libsbml.SBMLExtension_getCategory(self, index) def getMessage(self, index, pkgVersion, details): """ getMessage(SBMLExtension self, unsigned int index, unsigned int pkgVersion, string details) -> string Internal implementation method. """ return _libsbml.SBMLExtension_getMessage(self, index, pkgVersion, details) def getShortMessage(self, index): """ getShortMessage(SBMLExtension self, unsigned int index) -> string Internal implementation method. """ return _libsbml.SBMLExtension_getShortMessage(self, index) def __eq__(self, rhs): if ((self is None) and (rhs is None)): return True if ((self is None) or (rhs is None)): return False if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return True return False def __ne__(self, rhs): if ((self is None) and (rhs is None)): return False if ((self is None) or (rhs is None)): return True if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return False return True SBMLExtension_swigregister = _libsbml.SBMLExtension_swigregister SBMLExtension_swigregister(SBMLExtension) class SBMLExtensionException(_object): """ Exception used by package extensions This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. Certain situations can result in an exception being thrown by libSBML package extensions. A prominent example involves the constructor for SBMLNamespaces (and its subclasses), which will throw SBMLExtensionException if the arguments it is given refer to an unknown SBML Level 3 package. The situation can arise for legitimate SBML files if the necessary package extension has not been registered with a given copy of libSBML. See also SBMLNamespaces. """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLExtensionException, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, SBMLExtensionException, name) __repr__ = _swig_repr def __init__(self, errmsg): """ __init__(SBMLExtensionException self, string errmsg) -> SBMLExtensionException Creates a new SBMLExtensionException object with a given message. Parameter 'errmsg' is a string, the text of the error message to store with this exception. """ this = _libsbml.new_SBMLExtensionException(errmsg) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_SBMLExtensionException __del__ = lambda self: None SBMLExtensionException_swigregister = _libsbml.SBMLExtensionException_swigregister SBMLExtensionException_swigregister(SBMLExtensionException) class SBMLExtensionRegistry(_object): """ Registry where package extensions are registered. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. This class provides a central registry of all extensions known to libSBML. Each package extension must be registered with the registry. The registry class is accessed by various classes to retrieve information about known package extensions and to create additional attributes and/or elements by factory objects of the package extensions. The package extension registry is implemented as a singleton instance of SBMLExtensionRegistry. The class provides only utility functionality; implementations of SBML packages do not need to implement any subclasses or methods of this class. SBMLExtensionRegistry is useful for its facilities to query the known packages, and to enable or disable packages selectively. """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, SBMLExtensionRegistry, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, SBMLExtensionRegistry, name) def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") __repr__ = _swig_repr def getInstance(): """ getInstance() -> SBMLExtensionRegistry Returns a singleton instance of the registry. Callers need to obtain a copy of the package extension registry before they can invoke its methods. The registry is implemented as a singleton, and this is the method callers can use to get a copy of it. Returns the instance of the SBMLExtensionRegistry object. """ return _libsbml.SBMLExtensionRegistry_getInstance() getInstance = staticmethod(getInstance) def addExtension(self, ext): """ addExtension(SBMLExtensionRegistry self, SBMLExtension ext) -> int Add the given SBMLExtension object to this SBMLExtensionRegistry. Parameter 'ext' is the SBMLExtension object to be added. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_PKG_CONFLICT * LIBSBML_INVALID_ATTRIBUTE_VALUE """ return _libsbml.SBMLExtensionRegistry_addExtension(self, ext) def getExtension(self, package): """ getExtension(SBMLExtensionRegistry self, string package) -> SBMLExtension Returns an SBMLExtension object with the given package URI or package name. Parameter 'package' is a string representing the URI or name of the SBML package whose package extension is being sought. Returns a clone of the SBMLExtension object with the given package URI or name. Note: The caller is responsible for freeing the object returned. Since the object is a clone, freeing it will not result in the deletion of the original package extension object. """ return _libsbml.SBMLExtensionRegistry_getExtension(self, package) def removeL2Namespaces(self, xmlns): """ removeL2Namespaces(SBMLExtensionRegistry self, XMLNamespaces xmlns) Removes SBML Level 2 namespaces from the namespace list. Parameter 'xmlns' is an XMLNamespaces object listing one or more namespaces to be removed. """ return _libsbml.SBMLExtensionRegistry_removeL2Namespaces(self, xmlns) def addL2Namespaces(self, xmlns): """ addL2Namespaces(SBMLExtensionRegistry self, XMLNamespaces xmlns) Adds SBML Level 2 namespaces to the namespace list. Parameter 'xmlns' is an XMLNamespaces object providing one or more namespaces to be added. """ return _libsbml.SBMLExtensionRegistry_addL2Namespaces(self, xmlns) def enableL2NamespaceForDocument(self, doc): """ enableL2NamespaceForDocument(SBMLExtensionRegistry self, SBMLDocument doc) Enables package extensions that support serialization to SBML annotations. SBML Level 2 does not have a package mechanism in the way that SBML Level 3 does. However, SBML annotations can be used to store SBML constructs. In fact, a widely-used approach to developing SBML Level 3 packages involves first using them as annotations. Parameter 'doc' is the SBMLDocument object for which this should be enabled. """ return _libsbml.SBMLExtensionRegistry_enableL2NamespaceForDocument(self, doc) def disableUnusedPackages(self, doc): """ disableUnusedPackages(SBMLExtensionRegistry self, SBMLDocument doc) Disables unused packages. This method walks through all extensions in the list of plugins of the given SBML document 'doc', and disables all that are not being used. Parameter 'doc' is the SBMLDocument object whose unused package extensions should be disabled. """ return _libsbml.SBMLExtensionRegistry_disableUnusedPackages(self, doc) def disablePackage(package): """ disablePackage(string package) Disables the package with the given URI or name. Parameter 'package' is a string representing the URI or name of the SBML package whose package extension is to be disabled. """ return _libsbml.SBMLExtensionRegistry_disablePackage(package) disablePackage = staticmethod(disablePackage) def isPackageEnabled(package): """ isPackageEnabled(string package) -> bool Returns 'True' if the named package is enabled. Parameter 'package' is the name or URI of a package to test. Returns 'True' if the package is enabled, 'False' otherwise. """ return _libsbml.SBMLExtensionRegistry_isPackageEnabled(package) isPackageEnabled = staticmethod(isPackageEnabled) def enablePackage(package): """ enablePackage(string package) Enables the package with the given URI / name. Parameter 'package' is the name or URI of a package to enable. """ return _libsbml.SBMLExtensionRegistry_enablePackage(package) enablePackage = staticmethod(enablePackage) def getNumExtension(self, extPoint): """ getNumExtension(SBMLExtensionRegistry self, SBaseExtensionPoint extPoint) -> unsigned int Returns the number of extensions that have a given extension point. Parameter 'extPoint' is the SBaseExtensionPoint object. Returns the number of SBMLExtension-derived objects with the given extension point. """ return _libsbml.SBMLExtensionRegistry_getNumExtension(self, extPoint) def setEnabled(self, uri, isEnabled): """ setEnabled(SBMLExtensionRegistry self, string uri, bool isEnabled) -> bool Enables or disable the package with the given URI. Parameter 'uri' is the URI of the target package. Parameter 'isEnabled' is 'True' to enable the package, 'False' to disable. Returns 'False' if 'isEnabled' is 'False' or the given package is not registered, otherwise this method returns 'True.' """ return _libsbml.SBMLExtensionRegistry_setEnabled(self, uri, isEnabled) def isEnabled(self, uri): """ isEnabled(SBMLExtensionRegistry self, string uri) -> bool Returns 'True' if the given extension is enabled. Parameter 'uri' is the URI of the target package. Returns 'False' if the given package is disabled or not registered, 'True' otherwise. """ return _libsbml.SBMLExtensionRegistry_isEnabled(self, uri) def isRegistered(self, uri): """ isRegistered(SBMLExtensionRegistry self, string uri) -> bool Returns 'True' if a package extension is registered for the corresponding package URI. Parameter 'uri' is the URI of the target package. Returns 'True' if the package with the given URI is registered, otherwise returns 'False.' """ return _libsbml.SBMLExtensionRegistry_isRegistered(self, uri) def getAllRegisteredPackageNames(): """ getAllRegisteredPackageNames() -> std::vector< std::string > Returns a list of registered packages. This method returns a vector of strings containing the nicknames of the SBML packages for which package extensions are registered with this copy of libSBML. The vector will contain string objects. Returns a vector of strings of the registered package names. """ return _libsbml.SBMLExtensionRegistry_getAllRegisteredPackageNames() getAllRegisteredPackageNames = staticmethod(getAllRegisteredPackageNames) def getNumRegisteredPackages(): """ getNumRegisteredPackages() -> unsigned int Returns the number of registered packages. Returns a count of the registered package extensions. """ return _libsbml.SBMLExtensionRegistry_getNumRegisteredPackages() getNumRegisteredPackages = staticmethod(getNumRegisteredPackages) def getRegisteredPackageName(index): """ getRegisteredPackageName(unsigned int index) -> string Returns the nth registered package. Parameter 'index' is zero-based index of the package name to return. Returns the package name with the given index, or 'None' if none such exists. See also getNumRegisteredPackages(). """ return _libsbml.SBMLExtensionRegistry_getRegisteredPackageName(index) getRegisteredPackageName = staticmethod(getRegisteredPackageName) def getASTPlugins(self): """ getASTPlugins(SBMLExtensionRegistry self) -> std::vector< ASTBasePlugin * > """ return _libsbml.SBMLExtensionRegistry_getASTPlugins(self) def getNumASTPlugins(self): """ getNumASTPlugins(SBMLExtensionRegistry self) -> unsigned int """ return _libsbml.SBMLExtensionRegistry_getNumASTPlugins(self) def getASTPlugin(self, i): """ getASTPlugin(SBMLExtensionRegistry self, unsigned int i) -> ASTBasePlugin """ return _libsbml.SBMLExtensionRegistry_getASTPlugin(self, i) SBMLExtensionRegistry_swigregister = _libsbml.SBMLExtensionRegistry_swigregister SBMLExtensionRegistry_swigregister(SBMLExtensionRegistry) def SBMLExtensionRegistry_getInstance(): """ SBMLExtensionRegistry_getInstance() -> SBMLExtensionRegistry Returns a singleton instance of the registry. Callers need to obtain a copy of the package extension registry before they can invoke its methods. The registry is implemented as a singleton, and this is the method callers can use to get a copy of it. Returns the instance of the SBMLExtensionRegistry object. """ return _libsbml.SBMLExtensionRegistry_getInstance() def SBMLExtensionRegistry_disablePackage(package): """ SBMLExtensionRegistry_disablePackage(string package) Disables the package with the given URI or name. Parameter 'package' is a string representing the URI or name of the SBML package whose package extension is to be disabled. """ return _libsbml.SBMLExtensionRegistry_disablePackage(package) def SBMLExtensionRegistry_isPackageEnabled(package): """ SBMLExtensionRegistry_isPackageEnabled(string package) -> bool Returns 'True' if the named package is enabled. Parameter 'package' is the name or URI of a package to test. Returns 'True' if the package is enabled, 'False' otherwise. """ return _libsbml.SBMLExtensionRegistry_isPackageEnabled(package) def SBMLExtensionRegistry_enablePackage(package): """ SBMLExtensionRegistry_enablePackage(string package) Enables the package with the given URI / name. Parameter 'package' is the name or URI of a package to enable. """ return _libsbml.SBMLExtensionRegistry_enablePackage(package) def SBMLExtensionRegistry_getAllRegisteredPackageNames(): """ SBMLExtensionRegistry_getAllRegisteredPackageNames() -> std::vector< std::string > Returns a list of registered packages. This method returns a vector of strings containing the nicknames of the SBML packages for which package extensions are registered with this copy of libSBML. The vector will contain string objects. Returns a vector of strings of the registered package names. """ return _libsbml.SBMLExtensionRegistry_getAllRegisteredPackageNames() def SBMLExtensionRegistry_getNumRegisteredPackages(): """ SBMLExtensionRegistry_getNumRegisteredPackages() -> unsigned int Returns the number of registered packages. Returns a count of the registered package extensions. """ return _libsbml.SBMLExtensionRegistry_getNumRegisteredPackages() def SBMLExtensionRegistry_getRegisteredPackageName(index): """ SBMLExtensionRegistry_getRegisteredPackageName(unsigned int index) -> string Returns the nth registered package. Parameter 'index' is zero-based index of the package name to return. Returns the package name with the given index, or 'None' if none such exists. See also getNumRegisteredPackages(). """ return _libsbml.SBMLExtensionRegistry_getRegisteredPackageName(index) EM_L3V2 = _libsbml.EM_L3V2 EM_DISTRIB = _libsbml.EM_DISTRIB EM_ARRAYS = _libsbml.EM_ARRAYS EM_UNKNOWN = _libsbml.EM_UNKNOWN ALLOWED_CHILDREN_ANY = _libsbml.ALLOWED_CHILDREN_ANY ALLOWED_CHILDREN_ATLEAST = _libsbml.ALLOWED_CHILDREN_ATLEAST ALLOWED_CHILDREN_EXACTLY = _libsbml.ALLOWED_CHILDREN_EXACTLY ALLOWED_CHILDREN_UNKNOWN = _libsbml.ALLOWED_CHILDREN_UNKNOWN AST_PLUS = _libsbml.AST_PLUS AST_MINUS = _libsbml.AST_MINUS AST_TIMES = _libsbml.AST_TIMES AST_DIVIDE = _libsbml.AST_DIVIDE AST_POWER = _libsbml.AST_POWER AST_INTEGER = _libsbml.AST_INTEGER AST_REAL = _libsbml.AST_REAL AST_REAL_E = _libsbml.AST_REAL_E AST_RATIONAL = _libsbml.AST_RATIONAL AST_NAME = _libsbml.AST_NAME AST_NAME_AVOGADRO = _libsbml.AST_NAME_AVOGADRO AST_NAME_TIME = _libsbml.AST_NAME_TIME AST_CONSTANT_E = _libsbml.AST_CONSTANT_E AST_CONSTANT_FALSE = _libsbml.AST_CONSTANT_FALSE AST_CONSTANT_PI = _libsbml.AST_CONSTANT_PI AST_CONSTANT_TRUE = _libsbml.AST_CONSTANT_TRUE AST_LAMBDA = _libsbml.AST_LAMBDA AST_FUNCTION = _libsbml.AST_FUNCTION AST_FUNCTION_ABS = _libsbml.AST_FUNCTION_ABS AST_FUNCTION_ARCCOS = _libsbml.AST_FUNCTION_ARCCOS AST_FUNCTION_ARCCOSH = _libsbml.AST_FUNCTION_ARCCOSH AST_FUNCTION_ARCCOT = _libsbml.AST_FUNCTION_ARCCOT AST_FUNCTION_ARCCOTH = _libsbml.AST_FUNCTION_ARCCOTH AST_FUNCTION_ARCCSC = _libsbml.AST_FUNCTION_ARCCSC AST_FUNCTION_ARCCSCH = _libsbml.AST_FUNCTION_ARCCSCH AST_FUNCTION_ARCSEC = _libsbml.AST_FUNCTION_ARCSEC AST_FUNCTION_ARCSECH = _libsbml.AST_FUNCTION_ARCSECH AST_FUNCTION_ARCSIN = _libsbml.AST_FUNCTION_ARCSIN AST_FUNCTION_ARCSINH = _libsbml.AST_FUNCTION_ARCSINH AST_FUNCTION_ARCTAN = _libsbml.AST_FUNCTION_ARCTAN AST_FUNCTION_ARCTANH = _libsbml.AST_FUNCTION_ARCTANH AST_FUNCTION_CEILING = _libsbml.AST_FUNCTION_CEILING AST_FUNCTION_COS = _libsbml.AST_FUNCTION_COS AST_FUNCTION_COSH = _libsbml.AST_FUNCTION_COSH AST_FUNCTION_COT = _libsbml.AST_FUNCTION_COT AST_FUNCTION_COTH = _libsbml.AST_FUNCTION_COTH AST_FUNCTION_CSC = _libsbml.AST_FUNCTION_CSC AST_FUNCTION_CSCH = _libsbml.AST_FUNCTION_CSCH AST_FUNCTION_DELAY = _libsbml.AST_FUNCTION_DELAY AST_FUNCTION_EXP = _libsbml.AST_FUNCTION_EXP AST_FUNCTION_FACTORIAL = _libsbml.AST_FUNCTION_FACTORIAL AST_FUNCTION_FLOOR = _libsbml.AST_FUNCTION_FLOOR AST_FUNCTION_LN = _libsbml.AST_FUNCTION_LN AST_FUNCTION_LOG = _libsbml.AST_FUNCTION_LOG AST_FUNCTION_PIECEWISE = _libsbml.AST_FUNCTION_PIECEWISE AST_FUNCTION_POWER = _libsbml.AST_FUNCTION_POWER AST_FUNCTION_ROOT = _libsbml.AST_FUNCTION_ROOT AST_FUNCTION_SEC = _libsbml.AST_FUNCTION_SEC AST_FUNCTION_SECH = _libsbml.AST_FUNCTION_SECH AST_FUNCTION_SIN = _libsbml.AST_FUNCTION_SIN AST_FUNCTION_SINH = _libsbml.AST_FUNCTION_SINH AST_FUNCTION_TAN = _libsbml.AST_FUNCTION_TAN AST_FUNCTION_TANH = _libsbml.AST_FUNCTION_TANH AST_LOGICAL_AND = _libsbml.AST_LOGICAL_AND AST_LOGICAL_NOT = _libsbml.AST_LOGICAL_NOT AST_LOGICAL_OR = _libsbml.AST_LOGICAL_OR AST_LOGICAL_XOR = _libsbml.AST_LOGICAL_XOR AST_RELATIONAL_EQ = _libsbml.AST_RELATIONAL_EQ AST_RELATIONAL_GEQ = _libsbml.AST_RELATIONAL_GEQ AST_RELATIONAL_GT = _libsbml.AST_RELATIONAL_GT AST_RELATIONAL_LEQ = _libsbml.AST_RELATIONAL_LEQ AST_RELATIONAL_LT = _libsbml.AST_RELATIONAL_LT AST_RELATIONAL_NEQ = _libsbml.AST_RELATIONAL_NEQ AST_END_OF_CORE = _libsbml.AST_END_OF_CORE AST_FUNCTION_MAX = _libsbml.AST_FUNCTION_MAX AST_FUNCTION_MIN = _libsbml.AST_FUNCTION_MIN AST_FUNCTION_QUOTIENT = _libsbml.AST_FUNCTION_QUOTIENT AST_FUNCTION_RATE_OF = _libsbml.AST_FUNCTION_RATE_OF AST_FUNCTION_REM = _libsbml.AST_FUNCTION_REM AST_LOGICAL_IMPLIES = _libsbml.AST_LOGICAL_IMPLIES AST_CSYMBOL_FUNCTION = _libsbml.AST_CSYMBOL_FUNCTION AST_DISTRIB_FUNCTION_NORMAL = _libsbml.AST_DISTRIB_FUNCTION_NORMAL AST_DISTRIB_FUNCTION_UNIFORM = _libsbml.AST_DISTRIB_FUNCTION_UNIFORM AST_DISTRIB_FUNCTION_BERNOULLI = _libsbml.AST_DISTRIB_FUNCTION_BERNOULLI AST_DISTRIB_FUNCTION_BINOMIAL = _libsbml.AST_DISTRIB_FUNCTION_BINOMIAL AST_DISTRIB_FUNCTION_CAUCHY = _libsbml.AST_DISTRIB_FUNCTION_CAUCHY AST_DISTRIB_FUNCTION_CHISQUARE = _libsbml.AST_DISTRIB_FUNCTION_CHISQUARE AST_DISTRIB_FUNCTION_EXPONENTIAL = _libsbml.AST_DISTRIB_FUNCTION_EXPONENTIAL AST_DISTRIB_FUNCTION_GAMMA = _libsbml.AST_DISTRIB_FUNCTION_GAMMA AST_DISTRIB_FUNCTION_LAPLACE = _libsbml.AST_DISTRIB_FUNCTION_LAPLACE AST_DISTRIB_FUNCTION_LOGNORMAL = _libsbml.AST_DISTRIB_FUNCTION_LOGNORMAL AST_DISTRIB_FUNCTION_POISSON = _libsbml.AST_DISTRIB_FUNCTION_POISSON AST_DISTRIB_FUNCTION_RAYLEIGH = _libsbml.AST_DISTRIB_FUNCTION_RAYLEIGH AST_LINEAR_ALGEBRA_VECTOR = _libsbml.AST_LINEAR_ALGEBRA_VECTOR AST_LINEAR_ALGEBRA_SELECTOR = _libsbml.AST_LINEAR_ALGEBRA_SELECTOR AST_LINEAR_ALGEBRA_MATRIX = _libsbml.AST_LINEAR_ALGEBRA_MATRIX AST_LINEAR_ALGEBRA_MATRIXROW = _libsbml.AST_LINEAR_ALGEBRA_MATRIXROW AST_LINEAR_ALGEBRA_DETERMINANT = _libsbml.AST_LINEAR_ALGEBRA_DETERMINANT AST_LINEAR_ALGEBRA_TRANSPOSE = _libsbml.AST_LINEAR_ALGEBRA_TRANSPOSE AST_LINEAR_ALGEBRA_VECTOR_PRODUCT = _libsbml.AST_LINEAR_ALGEBRA_VECTOR_PRODUCT AST_LINEAR_ALGEBRA_SCALAR_PRODUCT = _libsbml.AST_LINEAR_ALGEBRA_SCALAR_PRODUCT AST_LINEAR_ALGEBRA_OUTER_PRODUCT = _libsbml.AST_LINEAR_ALGEBRA_OUTER_PRODUCT AST_LOGICAL_EXISTS = _libsbml.AST_LOGICAL_EXISTS AST_LOGICAL_FORALL = _libsbml.AST_LOGICAL_FORALL AST_STATISTICS_MEAN = _libsbml.AST_STATISTICS_MEAN AST_STATISTICS_MEDIAN = _libsbml.AST_STATISTICS_MEDIAN AST_STATISTICS_MODE = _libsbml.AST_STATISTICS_MODE AST_STATISTICS_MOMENT = _libsbml.AST_STATISTICS_MOMENT AST_SERIES_PRODUCT = _libsbml.AST_SERIES_PRODUCT AST_STATISTICS_SDEV = _libsbml.AST_STATISTICS_SDEV AST_SERIES_SUM = _libsbml.AST_SERIES_SUM AST_STATISTICS_VARIANCE = _libsbml.AST_STATISTICS_VARIANCE AST_UNKNOWN = _libsbml.AST_UNKNOWN class ASTNode(_object): """ Abstract Syntax Tree (AST) representation of a mathematical expression. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. Abstract Syntax Trees (ASTs) are a simple kind of data structure used in libSBML for storing mathematical expressions. The ASTNode is the cornerstone of libSBML's AST representation. An AST 'node' represents the most basic, indivisible part of a mathematical formula and come in many types. For instance, there are node types to represent numbers (with subtypes to distinguish integer, real, and rational numbers), names (e.g., constants or variables), simple mathematical operators, logical or relational operators and functions. LibSBML ASTs provide a canonical, in-memory representation for all mathematical formulas regardless of their original format (which might be MathML or might be text strings). An AST node in libSBML is a recursive tree structure; each node has a type, a pointer to a value, and a list of children nodes. Each ASTNode node may have none, one, two, or more children depending on its type. There are node types to represent numbers (with subtypes to distinguish integer, real, and rational numbers), names (e.g., constants or variables), simple mathematical operators, logical or relational operators and functions. The following diagram illustrates an example of how the mathematical expression '1 + 2' is represented as an AST with one plus node having two integer children nodes for the numbers 1 and 2. The figure also shows the corresponding MathML representation: +-------+-----------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------+ | Infix | AST | MathML | +-------+-----------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------+ | 1 + 2 | <object type="image/svg+xml" data="simple-ast.svg" class="centered" width="140px"></object> | <math xmlns="http://www.w3.org/1998/Math/MathML"> <apply> <plus/> <cn type="integer"> 1 </cn> <cn type="integer"> 2 </cn> </apply> </math> | +-------+-----------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------+ The following are other noteworthy points about the AST representation in libSBML: * A numerical value represented in MathML as a real number with an exponent is preserved as such in the AST node representation, even if the number could be stored in a 'float' data type. This is done so that when an SBML model is read in and then written out again, the amount of change introduced by libSBML to the SBML during the round- trip activity is minimized. * Rational numbers are represented in an AST node using separate numerator and denominator values. These can be retrieved using the methods ASTNode.getNumerator() and ASTNode.getDenominator(). * The children of an ASTNode are other ASTNode objects. The list of children is empty for nodes that are leaf elements, such as numbers. For nodes that are actually roots of expression subtrees, the list of children points to the parsed objects that make up the rest of the expression. For many applications, the details of ASTs are irrelevant because libSBML provides text-string based translation functions such as formulaToL3String() and parseL3Formula(). If you find the complexity of using the AST representation of expressions too high for your purposes, perhaps the string-based functions will be more suitable. The set of possible ASTNode types ...................................................................... Every ASTNode has an associated type code to indicate whether, for example, it holds a number or stands for an arithmetic operator. The type is recorded as a value drawn from a set of static integer constants defined in the class 'libsbml'. Their names begin with the characters 'AST_.' The list of possible types is quite long, because it covers all the mathematical functions that are permitted in SBML. The values are shown in the following table: AST_CONSTANT_E AST_FUNCTION_CSC AST_LOGICAL_AND AST_CONSTANT_FALSE AST_FUNCTION_CSCH AST_LOGICAL_IMPLIES^2 AST_CONSTANT_PI AST_FUNCTION_DELAY AST_LOGICAL_NOT AST_CONSTANT_TRUE AST_FUNCTION_EXP AST_LOGICAL_OR AST_DIVIDE AST_FUNCTION_FACTORIAL AST_LOGICAL_XOR AST_FUNCTION AST_FUNCTION_FLOOR AST_MINUS AST_FUNCTION_ABS AST_FUNCTION_LN AST_NAME AST_FUNCTION_ARCCOS AST_FUNCTION_LOG AST_NAME_AVOGADRO^1 AST_FUNCTION_ARCCOSH AST_FUNCTION_MAX^2 AST_NAME_TIME AST_FUNCTION_ARCCOT AST_FUNCTION_MIN^2 AST_FUNCTION_ARCCOTH AST_FUNCTION_PIECEWISE AST_PLUS AST_FUNCTION_ARCCSC AST_FUNCTION_POWER AST_POWER AST_FUNCTION_ARCCSCH AST_FUNCTION_QUOTIENT^2 AST_RATIONAL AST_FUNCTION_ARCSEC AST_FUNCTION_RATE_OF^2 AST_REAL AST_FUNCTION_ARCSECH AST_FUNCTION_REM^2 AST_REAL_E AST_FUNCTION_ARCSIN AST_FUNCTION_ROOT AST_RELATIONAL_EQ AST_FUNCTION_ARCSINH AST_FUNCTION_SEC AST_RELATIONAL_GEQ AST_FUNCTION_ARCTAN AST_FUNCTION_SECH AST_RELATIONAL_GT AST_FUNCTION_ARCTANH AST_FUNCTION_SIN AST_RELATIONAL_LEQ AST_FUNCTION_CEILING AST_FUNCTION_SINH AST_RELATIONAL_LT AST_FUNCTION_COS AST_FUNCTION_TAN AST_RELATIONAL_NEQ AST_FUNCTION_COSH AST_FUNCTION_TANH AST_TIMES AST_FUNCTION_COT AST_INTEGER AST_UNKNOWN AST_FUNCTION_COTH AST_LAMBDA ^1 (Level 3 only)<br/> ^2 (Level 3 Version 2+ only) The types have the following meanings: * If the node is basic mathematical operator (e.g., ''+'),' then the node's type will be AST_PLUS, AST_MINUS, AST_TIMES, AST_DIVIDE, or AST_POWER, as appropriate. * If the node is a predefined function or operator from SBML Level 1 (in the string-based formula syntax used in Level 1) or SBML Level 2 and 3 (in the subset of MathML used in SBML Levels 2 and 3), then the node's type will be either AST_FUNCTION_X, AST_LOGICAL_X, or AST_RELATIONAL_X, as appropriate. (Examples: AST_FUNCTION_LOG, AST_RELATIONAL_LEQ.) * If the node refers to a user-defined function, the node's type will be AST_FUNCTION (because it holds the name of the function). * If the node is a lambda expression, its type will be AST_LAMBDA. * If the node is a predefined constant (''ExponentialE',' ''Pi',' ''True'' or ''False'),' then the node's type will be AST_CONSTANT_E, AST_CONSTANT_PI, AST_CONSTANT_TRUE, or AST_CONSTANT_FALSE. * (Levels 2 and 3 only) If the node is the special MathML csymbol 'time,' the value of the node will be AST_NAME_TIME. (Note, however, that the MathML csymbol 'delay' is translated into a node of type AST_FUNCTION_DELAY. The difference is due to the fact that 'time' is a single variable, whereas 'delay' is actually a function taking arguments.) * (Level 3 only) If the node is the special MathML csymbol 'avogadro,' the value of the node will be AST_NAME_AVOGADRO. * (Level 3 Version 2+ only) If the node is the special MathML csymbol 'rateOf,' the value of the node will be AST_FUNCTION_RATE_OF. * (Level 3 Version 2+ only) If the node is a MathML operator that originates in a package, it is included in the ASTNodeType_t list, but may not be legally used in an SBML document that does not include that package. This includes the node types from the 'Distributions' package (AST_DISTRIB_FUNCTION_NORMAL, AST_DISTRIB_FUNCTION_UNIFORM, etc.), and elements from MathML that were not included in core. * If the node contains a numerical value, its type will be AST_INTEGER, AST_REAL, AST_REAL_E, or AST_RATIONAL, as appropriate. Converting between ASTs and text strings ...................................................................... The text-string form of mathematical formulas produced by libsbml.formulaToString() and read by libsbml.parseFormula() and libsbml.parseL3Formula() are in a simple C-inspired infix notation. A formula in this text-string form can be handed to a program that understands SBML mathematical expressions, or used as part of a translation system. The libSBML distribution comes with an example program in the ''examples'' subdirectory called 'translateMath' that implements an interactive command-line demonstration of translating infix formulas into MathML and vice-versa. The formula strings may contain operators, function calls, symbols, and white space characters. The allowable white space characters are tab and space. The following are illustrative examples of formulas expressed in the syntax: 0.10 * k4^2 (vm * s1)/(km + s1) The following table shows the precedence rules in this syntax. In the Class column, operand implies the construct is an operand, prefix implies the operation is applied to the following arguments, unary implies there is one argument, and binary implies there are two arguments. The values in the Precedence column show how the order of different types of operation are determined. For example, the expression a * b + c is evaluated as (a * b) + c because the * operator has higher precedence. The Associates column shows how the order of similar precedence operations is determined; for example, a - b + c is evaluated as (a - b) + c because the + and - operators are left-associative. The precedence and associativity rules are taken from the C programming language, except for the symbol ^, which is used in C for a different purpose. (Exponentiation can be invoked using either ^ or the function 'power.)' +--------------+---------------------+---------+------------+------------+ | Token | Operation | Class | Precedence | Associates | +--------------+---------------------+---------+------------+------------+ | name | symbol reference | operand | 6 | n/a | | (expression) | expression grouping | operand | 6 | n/a | | f(...) | function call | prefix | 6 | left | | - | negation | unary | 5 | right | | ^ | power | binary | 4 | left | | * | multiplication | binary | 3 | left | | / | divison | binary | 3 | left | | + | addition | binary | 2 | left | | - | subtraction | binary | 2 | left | | , | argument delimiter | binary | 1 | left | +--------------+---------------------+---------+------------+------------+ A program parsing a formula in an SBML model should assume that names appearing in the formula are the identifiers of Species, Parameter, Compartment, FunctionDefinition, Reaction (in SBML Levels 2 and 3), or SpeciesReference (in SBML Level 3 only) objects defined in a model. When a function call is involved, the syntax consists of a function identifier, followed by optional white space, followed by an opening parenthesis, followed by a sequence of zero or more arguments separated by commas (with each comma optionally preceded and/or followed by zero or more white space characters), followed by a closing parenthesis. There is an almost one-to-one mapping between the list of predefined functions available, and those defined in MathML. All of the MathML functions are recognized; this set is larger than the functions defined in SBML Level 1. In the subset of functions that overlap between MathML and SBML Level 1, there exist a few differences. The following table summarizes the differences between the predefined functions in SBML Level 1 and the MathML equivalents in SBML Levels 2 and 3: +-------------------------------+-------------------------------------------+ | Text string formula functions | MathML equivalents in SBML Levels 2 and 3 | +-------------------------------+-------------------------------------------+ | acos | arccos | | asin | arcsin | | atan | arctan | | ceil | ceiling | | log | ln | | log10(x) | log(x) or log(10, x) | | pow(x, y) | power(x, y) | | sqr(x) | power(x, 2) | | sqrt(x) | root(x) or root(2, x) | +-------------------------------+-------------------------------------------+ @copydetails doc_warning_L1_math_string_syntax See also libsbml.parseL3Formula(), libsbml.parseFormula(). """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, ASTNode, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, ASTNode, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(ASTNode self, ASTNodeType_t type=AST_UNKNOWN) -> ASTNode __init__(ASTNode self) -> ASTNode __init__(ASTNode self, ASTNode orig) -> ASTNode This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: ASTNode(ASTNode orig) Copy constructor; creates a deep copy of the given ASTNode. Parameter 'orig' is the ASTNode to be copied. ______________________________________________________________________ Method variant with the following signature: ASTNode(Token_t *token) Creates a new ASTNode from the given Token. The resulting ASTNode will contain the same data as the Token. Parameter 'token' is the Token to add. ______________________________________________________________________ Method variant with the following signature: ASTNode(ASTNodeType_t type = AST_UNKNOWN) Creates and returns a new ASTNode. Unless the argument 'type' is given, the returned node will by default have a type of AST_UNKNOWN. If the type isn't supplied when caling this constructor, the caller should set the node type to something else as soon as possible using ASTNode.setType(). Parameter 'type' is an optional type code indicating the type of node to create. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ this = _libsbml.new_ASTNode(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_ASTNode __del__ = lambda self: None def freeName(self): """ freeName(ASTNode self) -> int Frees the name of this ASTNode and sets it to 'None.' This operation is only applicable to ASTNode objects corresponding to operators, numbers, or AST_UNKNOWN. This method has no effect on other types of nodes. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE """ return _libsbml.ASTNode_freeName(self) def canonicalize(self): """ canonicalize(ASTNode self) -> bool Converts this ASTNode to a canonical form and returns 'True' if successful, 'False' otherwise. The rules determining the canonical form conversion are as follows: * If the node type is AST_NAME and the node name matches ''ExponentialE',' ''Pi',' ''True'' or ''False'' the node type is converted to the corresponding AST_CONSTANT_X type. * If the node type is an AST_FUNCTION and the node name matches an SBML (MathML) function name, logical operator name, or relational operator name, the node is converted to the corresponding AST_FUNCTION_X or AST_LOGICAL_X type. SBML Level 1 function names are searched first; thus, for example, canonicalizing 'log' will result in a node type of AST_FUNCTION_LN. (See the SBML Level 1 Version 2 Specification, Appendix C.) Sometimes, canonicalization of a node results in a structural conversion of the node as a result of adding a child. For example, a node with the SBML Level 1 function name 'sqr' and a single child node (the argument) will be transformed to a node of type AST_FUNCTION_POWER with two children. The first child will remain unchanged, but the second child will be an ASTNode of type AST_INTEGER and a value of 2. The function names that result in structural changes are: 'log10,' 'sqr,' and 'sqrt.' """ return _libsbml.ASTNode_canonicalize(self) def addChild(self, disownedChild, inRead=False): """ addChild(ASTNode self, ASTNode disownedChild, bool inRead=False) -> int addChild(ASTNode self, ASTNode disownedChild) -> int Adds the given node as a child of this ASTNode. Child nodes are added in-order, from left to right. Parameter 'disownedChild' is the ASTNode instance to add Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED WARNING: Explicitly adding, removing or replacing children of an ASTNode object may change the structure of the mathematical formula it represents, and may even render the representation invalid. Callers need to be careful to use this method in the context of other operations to create complete and correct formulas. The method ASTNode.isWellFormedASTNode() may also be useful for checking the results of node modifications. See also prependChild(), replaceChild(), insertChild(), removeChild(), isWellFormedASTNode(). Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.ASTNode_addChild(self, disownedChild, inRead) def prependChild(self, disownedChild): """ prependChild(ASTNode self, ASTNode disownedChild) -> int Adds the given node as a child of this ASTNode. This method adds child nodes from right to left. Parameter 'disownedChild' is the ASTNode instance to add Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED WARNING: Explicitly adding, removing or replacing children of an ASTNode object may change the structure of the mathematical formula it represents, and may even render the representation invalid. Callers need to be careful to use this method in the context of other operations to create complete and correct formulas. The method ASTNode.isWellFormedASTNode() may also be useful for checking the results of node modifications. See also addChild(), replaceChild(), insertChild(), removeChild(). """ return _libsbml.ASTNode_prependChild(self, disownedChild) def removeChild(self, n): """ removeChild(ASTNode self, unsigned int n) -> int Removes the nth child of this ASTNode object. Parameter 'n' is long the index of the child to remove Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INDEX_EXCEEDS_SIZE WARNING: Explicitly adding, removing or replacing children of an ASTNode object may change the structure of the mathematical formula it represents, and may even render the representation invalid. Callers need to be careful to use this method in the context of other operations to create complete and correct formulas. The method ASTNode.isWellFormedASTNode() may also be useful for checking the results of node modifications. See also addChild(), prependChild(), replaceChild(), insertChild(). """ return _libsbml.ASTNode_removeChild(self, n) def replaceChild(self, n, disownedChild, delreplaced=False): """ replaceChild(ASTNode self, unsigned int n, ASTNode disownedChild, bool delreplaced=False) -> int replaceChild(ASTNode self, unsigned int n, ASTNode disownedChild) -> int Replaces and optionally deletes the nth child of this ASTNode with the given ASTNode. Parameter 'n' is long the index of the child to replace Parameter 'disownedChild' is ASTNode to replace the nth child Parameter 'delreplaced' is boolean indicating whether to delete the replaced child. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INDEX_EXCEEDS_SIZE * LIBSBML_INVALID_OBJECT WARNING: Explicitly adding, removing or replacing children of an ASTNode object may change the structure of the mathematical formula it represents, and may even render the representation invalid. Callers need to be careful to use this method in the context of other operations to create complete and correct formulas. The method ASTNode.isWellFormedASTNode() may also be useful for checking the results of node modifications. See also addChild(), prependChild(), insertChild(), removeChild(). """ return _libsbml.ASTNode_replaceChild(self, n, disownedChild, delreplaced) def insertChild(self, n, disownedChild): """ insertChild(ASTNode self, unsigned int n, ASTNode disownedChild) -> int Inserts the given ASTNode at point n in the list of children of this ASTNode. Parameter 'n' is long the index of the ASTNode being added Parameter 'disownedChild' is ASTNode to insert as the nth child Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INDEX_EXCEEDS_SIZE * LIBSBML_INVALID_OBJECT WARNING: Explicitly adding, removing or replacing children of an ASTNode object may change the structure of the mathematical formula it represents, and may even render the representation invalid. Callers need to be careful to use this method in the context of other operations to create complete and correct formulas. The method ASTNode.isWellFormedASTNode() may also be useful for checking the results of node modifications. See also addChild(), prependChild(), replaceChild(), removeChild(). """ return _libsbml.ASTNode_insertChild(self, n, disownedChild) def deepCopy(self): """ deepCopy(ASTNode self) -> ASTNode Creates a recursive copy of this node and all its children. Returns a copy of this ASTNode and all its children. The caller owns the returned ASTNode and is responsible for deleting it. """ return _libsbml.ASTNode_deepCopy(self) def getChild(self, n): """ getChild(ASTNode self, unsigned int n) -> ASTNode Gets a child of this node according to its index number. Parameter 'n' is the index of the child to get Returns the nth child of this ASTNode or 'None' if this node has no nth child (n > ASTNode.getNumChildren() - 1). See also getNumChildren(), getLeftChild(), getRightChild(). """ return _libsbml.ASTNode_getChild(self, n) def getLeftChild(self): """ getLeftChild(ASTNode self) -> ASTNode Gets the left child of this node. Returns the left child of this ASTNode. This is equivalent to calling ASTNode.getChild() with an argument of '0.' See also getNumChildren(), getChild(), getRightChild(). """ return _libsbml.ASTNode_getLeftChild(self) def getRightChild(self): """ getRightChild(ASTNode self) -> ASTNode Gets the right child of this node. Returns the right child of this ASTNode, or 'None' if this node has no right child. If ASTNode.getNumChildren() > 1, then this is equivalent to: getChild( getNumChildren() - 1 ); See also getNumChildren(), getLeftChild(), getChild(). """ return _libsbml.ASTNode_getRightChild(self) def getNumChildren(self): """ getNumChildren(ASTNode self) -> unsigned int Gets the number of children that this node has. Returns the number of children of this ASTNode, or 0 is this node has no children. """ return _libsbml.ASTNode_getNumChildren(self) def addSemanticsAnnotation(self, disownedAnnotation): """ addSemanticsAnnotation(ASTNode self, XMLNode disownedAnnotation) -> int Adds the given XMLNode as a semantic annotation of this ASTNode. The <semantics> element is a MathML 2.0 construct that can be used to associate additional information with a MathML construct. The construct can be used to decorate a MathML expressions with a sequence of one or more <annotation> or <annotation-xml> elements. Each such element contains a pair of items; the first is a symbol that acts as an attribute or key, and the second is the value associated with the attribute or key. Please refer to the MathML 2.0 documentation, particularly the Section 5.2, Semantic Annotations for more information about these constructs. Parameter 'disownedAnnotation' is the annotation to add. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED Note: Although SBML permits the semantic annotation construct in MathML expressions, the truth is that this construct has so far (at this time of this writing, which is early 2011) seen very little use in SBML software. The full implications of using semantic annotations are still poorly understood. If you wish to use this construct, we urge you to discuss possible uses and applications on the SBML discussion lists, particularly sbml-discuss@caltech.edu and/or sbml- interoperability@caltech.edu. """ return _libsbml.ASTNode_addSemanticsAnnotation(self, disownedAnnotation) def getNumSemanticsAnnotations(self): """ getNumSemanticsAnnotations(ASTNode self) -> unsigned int Gets the number of semantic annotation elements inside this node. The <semantics> element is a MathML 2.0 construct that can be used to associate additional information with a MathML construct. The construct can be used to decorate a MathML expressions with a sequence of one or more <annotation> or <annotation-xml> elements. Each such element contains a pair of items; the first is a symbol that acts as an attribute or key, and the second is the value associated with the attribute or key. Please refer to the MathML 2.0 documentation, particularly the Section 5.2, Semantic Annotations for more information about these constructs. Returns the number of annotations of this ASTNode. See also ASTNode.addSemanticsAnnotation(). """ return _libsbml.ASTNode_getNumSemanticsAnnotations(self) def getSemanticsAnnotation(self, n): """ getSemanticsAnnotation(ASTNode self, unsigned int n) -> XMLNode Gets the nth semantic annotation of this node. The <semantics> element is a MathML 2.0 construct that can be used to associate additional information with a MathML construct. The construct can be used to decorate a MathML expressions with a sequence of one or more <annotation> or <annotation-xml> elements. Each such element contains a pair of items; the first is a symbol that acts as an attribute or key, and the second is the value associated with the attribute or key. Please refer to the MathML 2.0 documentation, particularly the Section 5.2, Semantic Annotations for more information about these constructs. Returns the nth annotation of this ASTNode, or 'None' if this node has no nth annotation (n > ASTNode.getNumSemanticsAnnotations() - 1). See also ASTNode.addSemanticsAnnotation(). """ return _libsbml.ASTNode_getSemanticsAnnotation(self, n) def getCharacter(self): """ getCharacter(ASTNode self) -> char Gets the value of this node as a single character. This function should be called only when ASTNode.getType() returns AST_PLUS, AST_MINUS, AST_TIMES, AST_DIVIDE or AST_POWER. Returns the value of this ASTNode as a single character """ return _libsbml.ASTNode_getCharacter(self) def getId(self): """ getId(ASTNode self) -> string Gets the id of this ASTNode. Returns the MathML id of this ASTNode. """ return _libsbml.ASTNode_getId(self) def getClass(self): """ getClass(ASTNode self) -> string Gets the class of this ASTNode. Returns the MathML class of this ASTNode. """ return _libsbml.ASTNode_getClass(self) def getStyle(self): """ getStyle(ASTNode self) -> string Gets the style of this ASTNode. Returns the MathML style of this ASTNode. """ return _libsbml.ASTNode_getStyle(self) def getInteger(self): """ getInteger(ASTNode self) -> long Gets the value of this node as an integer. This function should be called only when ASTNode.getType() == AST_INTEGER. Returns the value of this ASTNode as a (long) integer. """ return _libsbml.ASTNode_getInteger(self) def getName(self): """ getName(ASTNode self) -> char const * Gets the value of this node as a string. This function may be called on nodes that (1) are not operators, i.e., nodes for which ASTNode.isOperator() returns 'False,' and (2) are not numbers, i.e., ASTNode.isNumber() returns 'False.' Returns the value of this ASTNode as a string. """ return _libsbml.ASTNode_getName(self) def getOperatorName(self): """ getOperatorName(ASTNode self) -> char const * Gets the value of this operator node as a string. This function may be called on nodes that are operators, i.e., nodes for which ASTNode.isOperator() returns 'True.' Returns the name of this operator ASTNode as a string (or None if not an operator). """ return _libsbml.ASTNode_getOperatorName(self) def getNumerator(self): """ getNumerator(ASTNode self) -> long Gets the value of the numerator of this node. This function should be called only when ASTNode.getType() == AST_RATIONAL. Returns the value of the numerator of this ASTNode. """ return _libsbml.ASTNode_getNumerator(self) def getDenominator(self): """ getDenominator(ASTNode self) -> long Gets the value of the denominator of this node. This function should be called only when ASTNode.getType() == AST_RATIONAL. Returns the value of the denominator of this ASTNode. """ return _libsbml.ASTNode_getDenominator(self) def getReal(self): """ getReal(ASTNode self) -> double Gets the real-numbered value of this node. This function should be called only when ASTNode.isReal() == true. This function performs the necessary arithmetic if the node type is AST_REAL_E (mantissa * 10^exponent) or AST_RATIONAL (numerator / denominator). Returns the value of this ASTNode as a real (double). """ return _libsbml.ASTNode_getReal(self) def getMantissa(self): """ getMantissa(ASTNode self) -> double Gets the mantissa value of this node. This function should be called only when ASTNode.getType() returns AST_REAL_E or AST_REAL. If ASTNode.getType() returns AST_REAL, this method is identical to ASTNode.getReal(). Returns the value of the mantissa of this ASTNode. """ return _libsbml.ASTNode_getMantissa(self) def getExponent(self): """ getExponent(ASTNode self) -> long Gets the exponent value of this ASTNode. This function should be called only when ASTNode.getType() returns AST_REAL_E or AST_REAL. Returns the value of the exponent of this ASTNode. """ return _libsbml.ASTNode_getExponent(self) def getValue(self): """ getValue(ASTNode self) -> double Returns the numerical value of this ASTNode. Returns the numerical value of this ASTNode, or 'NaN' if this is not a type of node that has a numerical value. Note: This function will return a numerical value (as a double) for any ASTNode_t that represents a number, a constant such as AST_CONSTANT_PI, AST_CONSTANT_E, or AST_NAME_AVOGADRO, or '1' for nodes of type AST_CONSTANT_TRUE and '0' for nodes of type AST_CONSTANT_FALSE. It does not evaluate the node in any way so, for example, it will not return the value of a named ASTNode_t or attempt to evaluate a function. This includes a node representing 'time' i.e. nodes of type AST_NAME_TIME. """ return _libsbml.ASTNode_getValue(self) def getPrecedence(self): """ getPrecedence(ASTNode self) -> int Gets the precedence of this node in the infix math syntax of SBML Level 1. For more information about the infix syntax, see the discussion about text string formulas at the top of the documentation for ASTNode. Returns an integer indicating the precedence of this ASTNode """ return _libsbml.ASTNode_getPrecedence(self) def getType(self): """ getType(ASTNode self) -> ASTNodeType_t Gets the type of this ASTNode. The value returned is one of the enumeration values such as AST_LAMBDA, AST_PLUS, etc. Returns the type of this ASTNode. """ return _libsbml.ASTNode_getType(self) def getUnits(self): """ getUnits(ASTNode self) -> string Gets the units of this ASTNode. SBML Level 3 Version 1 introduced the ability to include an attribute sbml:units on MathML cn elements appearing in SBML mathematical formulas. The value of this attribute can be used to indicate the unit of measurement to be associated with the number in the content of the cn element. The value of this attribute must be the identifier of a unit of measurement defined by SBML or the enclosing Model. Here, the sbml portion is an XML namespace prefix that must be associated with the SBML namespace for SBML Level 3. The following example illustrates how this attribute can be used to define a number with value 10 and unit of measurement second: <math xmlns="http://www.w3.org/1998/Math/MathML" xmlns:sbml="http://www.sbml.org/sbml/level3/version1/core"> <cn type="integer" sbml:units="second"> 10 </cn> </math> Returns the units of this ASTNode. Note: The sbml:units attribute is only available in SBML Level 3. It may not be used in Levels 1-2 of SBML. See also libsbml.parseL3Formula(). """ return _libsbml.ASTNode_getUnits(self) def isAvogadro(self): """ isAvogadro(ASTNode self) -> bool Returns 'True' (non-zero) if this node is the special symbol 'avogadro.' The predicate returns 'False' (zero) otherwise. Returns 'True' if this ASTNode is the special symbol avogadro. See also libsbml.parseL3Formula(). """ return _libsbml.ASTNode_isAvogadro(self) def isBoolean(self): """ isBoolean(ASTNode self) -> bool Returns 'True' (non-zero) if this node has a boolean type (a logical operator, a relational operator, or the constants 'True' or 'False).' Returns true if this ASTNode is a boolean, false otherwise. """ return _libsbml.ASTNode_isBoolean(self) def returnsBoolean(self, model=None): """ returnsBoolean(ASTNode self, Model model=None) -> bool returnsBoolean(ASTNode self) -> bool Returns 'True' (non-zero) if this node returns a boolean type or 'False' (zero) otherwise. This function looks at the whole ASTNode rather than just the top level of the ASTNode. Thus it will consider return values from piecewise statements. In addition, if this ASTNode uses a function call, the return value of the functionDefinition will be determined. Note that this is only possible where the ASTNode can trace its parent Model, that is, the ASTNode must represent the math element of some SBML object that has already been added to an instance of an SBMLDocument. See also isBoolean(). Returns true if this ASTNode returns a boolean, false otherwise. """ return _libsbml.ASTNode_returnsBoolean(self, model) def isConstant(self): """ isConstant(ASTNode self) -> bool Returns 'True' (non-zero) if this node represents a MathML constant (e.g., 'True,' 'Pi).' Returns 'True' if this ASTNode is a MathML constant, 'False' otherwise. Note: this function will also return 'True' for AST_NAME_AVOGADRO in SBML Level 3. """ return _libsbml.ASTNode_isConstant(self) def isCiNumber(self): """ isCiNumber(ASTNode self) -> bool Returns 'True' (non-zero) if this node represents a MathML ci element representing a value not a function (e.g., 'True,' 'Pi).' Returns 'True' if this ASTNode is a MathML ci element, 'False' otherwise. """ return _libsbml.ASTNode_isCiNumber(self) def isConstantNumber(self): """ isConstantNumber(ASTNode self) -> bool Returns 'True' (non-zero) if this node represents a MathML constant with numeric value(e.g., 'Pi).' Returns 'True' if this ASTNode is a MathML constant, 'False' otherwise. Note: this function will also return 'True' for AST_NAME_AVOGADRO in SBML Level 3. """ return _libsbml.ASTNode_isConstantNumber(self) def isCSymbolFunction(self): """ isCSymbolFunction(ASTNode self) -> bool Returns 'True' (non-zero) if this node represents a MathML csymbol representing a function. Returns 'True' if this ASTNode is a MathML csymbol function, 'False' otherwise. """ return _libsbml.ASTNode_isCSymbolFunction(self) def isFunction(self): """ isFunction(ASTNode self) -> bool Returns 'True' (non-zero) if this node represents a MathML function (e.g., abs()), or an SBML Level 1 function, or a user-defined function. Returns 'True' if this ASTNode is a function, 'False' otherwise. """ return _libsbml.ASTNode_isFunction(self) def isInfinity(self): """ isInfinity(ASTNode self) -> bool Returns 'True' (non-zero) if this node represents the special IEEE 754 value infinity, 'False' (zero) otherwise. Returns 'True' if this ASTNode is the special IEEE 754 value infinity, 'False' otherwise. """ return _libsbml.ASTNode_isInfinity(self) def isInteger(self): """ isInteger(ASTNode self) -> bool Returns 'True' (non-zero) if this node contains an integer value, 'False' (zero) otherwise. Returns 'True' if this ASTNode is of type AST_INTEGER, 'False' otherwise. """ return _libsbml.ASTNode_isInteger(self) def isLambda(self): """ isLambda(ASTNode self) -> bool Returns 'True' (non-zero) if this node is a MathML <lambda>, 'False' (zero) otherwise. Returns 'True' if this ASTNode is of type AST_LAMBDA, 'False' otherwise. """ return _libsbml.ASTNode_isLambda(self) def isLog10(self): """ isLog10(ASTNode self) -> bool Returns 'True' (non-zero) if this node represents a 'log10' function, 'False' (zero) otherwise. More precisely, this predicate returns 'True' if the node type is AST_FUNCTION_LOG with two children, the first of which is an AST_INTEGER equal to 10. Returns 'True' if the given ASTNode represents a log10() function, 'False' otherwise. See also libsbml.parseL3Formula(). """ return _libsbml.ASTNode_isLog10(self) def isLogical(self): """ isLogical(ASTNode self) -> bool Returns 'True' (non-zero) if this node is a MathML logical operator (i.e., 'and,' 'or,' 'not,' 'xor).' Returns 'True' if this ASTNode is a MathML logical operator """ return _libsbml.ASTNode_isLogical(self) def isName(self): """ isName(ASTNode self) -> bool Returns 'True' (non-zero) if this node is a user-defined variable name in SBML L1, L2 (MathML), or the special symbols 'time' or 'avogadro.' The predicate returns 'False' (zero) otherwise. Returns 'True' if this ASTNode is a user-defined variable name in SBML L1, L2 (MathML) or the special symbols delay or time. """ return _libsbml.ASTNode_isName(self) def isNaN(self): """ isNaN(ASTNode self) -> bool Returns 'True' (non-zero) if this node represents the special IEEE 754 value 'not a number' (NaN), 'False' (zero) otherwise. Returns 'True' if this ASTNode is the special IEEE 754 NaN. """ return _libsbml.ASTNode_isNaN(self) def isNegInfinity(self): """ isNegInfinity(ASTNode self) -> bool Returns 'True' (non-zero) if this node represents the special IEEE 754 value 'negative infinity', 'False' (zero) otherwise. Returns 'True' if this ASTNode is the special IEEE 754 value negative infinity, 'False' otherwise. """ return _libsbml.ASTNode_isNegInfinity(self) def isNumber(self): """ isNumber(ASTNode self) -> bool Returns 'True' (non-zero) if this node contains a number, 'False' (zero) otherwise. This is functionally equivalent to the following code: isInteger() || isReal() Returns 'True' if this ASTNode is a number, 'False' otherwise. """ return _libsbml.ASTNode_isNumber(self) def isOperator(self): """ isOperator(ASTNode self) -> bool Returns 'True' (non-zero) if this node is a mathematical operator, meaning, +, -, *, / or ^ (power). Returns 'True' if this ASTNode is an operator. """ return _libsbml.ASTNode_isOperator(self) def isPiecewise(self): """ isPiecewise(ASTNode self) -> bool Returns 'True' (non-zero) if this node is the MathML <piecewise> construct, 'False' (zero) otherwise. Returns 'True' if this ASTNode is a MathML 'piecewise' function """ return _libsbml.ASTNode_isPiecewise(self) def isRational(self): """ isRational(ASTNode self) -> bool Returns 'True' (non-zero) if this node represents a rational number, 'False' (zero) otherwise. Returns 'True' if this ASTNode is of type AST_RATIONAL. """ return _libsbml.ASTNode_isRational(self) def isReal(self): """ isReal(ASTNode self) -> bool Returns 'True' (non-zero) if this node can represent a real number, 'False' (zero) otherwise. More precisely, this node must be of one of the following types: AST_REAL, AST_REAL_E or AST_RATIONAL. Returns 'True' if the value of this ASTNode can represented as a real number, 'False' otherwise. """ return _libsbml.ASTNode_isReal(self) def isRelational(self): """ isRelational(ASTNode self) -> bool Returns 'True' (non-zero) if this node is a MathML relational operator, meaning ==, >=, >, <, and !=. Returns 'True' if this ASTNode is a MathML relational operator, 'False' otherwise """ return _libsbml.ASTNode_isRelational(self) def isSqrt(self): """ isSqrt(ASTNode self) -> bool Returns 'True' (non-zero) if this node represents a square root function, 'False' (zero) otherwise. More precisely, the node type must be AST_FUNCTION_ROOT with two children, the first of which is an AST_INTEGER node having value equal to 2. Returns 'True' if the given ASTNode represents a sqrt() function, 'False' otherwise. """ return _libsbml.ASTNode_isSqrt(self) def isUMinus(self): """ isUMinus(ASTNode self) -> bool Returns 'True' (non-zero) if this node is a unary minus operator, 'False' (zero) otherwise. A node is defined as a unary minus node if it is of type AST_MINUS and has exactly one child. For numbers, unary minus nodes can be 'collapsed' by negating the number. In fact, libsbml.parseFormula() does this during its parsing process, and libsbml.parseL3Formula() has a configuration option that allows this behavior to be turned on or off. However, unary minus nodes for symbols (AST_NAME) cannot be 'collapsed', so this predicate function is necessary. Returns 'True' if this ASTNode is a unary minus, 'False' otherwise. See also libsbml.parseL3Formula(). """ return _libsbml.ASTNode_isUMinus(self) def isUPlus(self): """ isUPlus(ASTNode self) -> bool Returns 'True' (non-zero) if this node is a unary plus operator, 'False' (zero) otherwise. A node is defined as a unary minus node if it is of type AST_MINUS and has exactly one child. Returns 'True' if this ASTNode is a unary plus, 'False' otherwise. """ return _libsbml.ASTNode_isUPlus(self) def isUserFunction(self): """ isUserFunction(ASTNode self) -> bool Returns 'True' (non-zero) if this node represents a MathML user- defined function. Returns 'True' if this ASTNode is a user-defined function, 'False' otherwise. """ return _libsbml.ASTNode_isUserFunction(self) def hasTypeAndNumChildren(self, type, numchildren): """ hasTypeAndNumChildren(ASTNode self, ASTNodeType_t type, unsigned int numchildren) -> int Returns 'True' if this node is of type Parameter 'type' is and has Parameter 'numchildren' is number of children. Designed for use in cases where it is useful to discover if the node is a unary not or unary minus, or a times node with no children, etc. Returns 'True' if this ASTNode is has the specified type and number of children, 'False' otherwise. """ return _libsbml.ASTNode_hasTypeAndNumChildren(self, type, numchildren) def isUnknown(self): """ isUnknown(ASTNode self) -> bool Returns 'True' (non-zero) if this node has an unknown type. 'Unknown' nodes have the type AST_UNKNOWN. Nodes with unknown types will not appear in an ASTNode tree returned by libSBML based upon valid SBML input; the only situation in which a node with type AST_UNKNOWN may appear is immediately after having create a new, untyped node using the ASTNode constructor. Callers creating nodes should endeavor to set the type to a valid node type as soon as possible after creating new nodes. Returns 'True' if this ASTNode is of type AST_UNKNOWN, 'False' otherwise. """ return _libsbml.ASTNode_isUnknown(self) def isSetId(self): """ isSetId(ASTNode self) -> bool Returns 'True' (non-zero) if this node has a value for the MathML attribute 'id'. Returns true if this ASTNode has an attribute id, false otherwise. """ return _libsbml.ASTNode_isSetId(self) def isSetClass(self): """ isSetClass(ASTNode self) -> bool Returns 'True' (non-zero) if this node has a value for the MathML attribute 'class'. Returns true if this ASTNode has an attribute class, false otherwise. """ return _libsbml.ASTNode_isSetClass(self) def isSetStyle(self): """ isSetStyle(ASTNode self) -> bool Returns 'True' (non-zero) if this node has a value for the MathML attribute 'style'. Returns true if this ASTNode has an attribute style, false otherwise. """ return _libsbml.ASTNode_isSetStyle(self) def isSetUnits(self): """ isSetUnits(ASTNode self) -> bool Returns 'True' (non-zero) if this node has the attribute sbml:units. SBML Level 3 Version 1 introduced the ability to include an attribute sbml:units on MathML cn elements appearing in SBML mathematical formulas. The value of this attribute can be used to indicate the unit of measurement to be associated with the number in the content of the cn element. The value of this attribute must be the identifier of a unit of measurement defined by SBML or the enclosing Model. Here, the sbml portion is an XML namespace prefix that must be associated with the SBML namespace for SBML Level 3. The following example illustrates how this attribute can be used to define a number with value 10 and unit of measurement second: <math xmlns="http://www.w3.org/1998/Math/MathML" xmlns:sbml="http://www.sbml.org/sbml/level3/version1/core"> <cn type="integer" sbml:units="second"> 10 </cn> </math> Returns 'True' if this ASTNode has units associated with it, 'False' otherwise. Note: The sbml:units attribute is only available in SBML Level 3. It may not be used in Levels 1-2 of SBML. """ return _libsbml.ASTNode_isSetUnits(self) def hasUnits(self): """ hasUnits(ASTNode self) -> bool Returns 'True' (non-zero) if this node or any of its children nodes have the attribute sbml:units. SBML Level 3 Version 1 introduced the ability to include an attribute sbml:units on MathML cn elements appearing in SBML mathematical formulas. The value of this attribute can be used to indicate the unit of measurement to be associated with the number in the content of the cn element. The value of this attribute must be the identifier of a unit of measurement defined by SBML or the enclosing Model. Here, the sbml portion is an XML namespace prefix that must be associated with the SBML namespace for SBML Level 3. The following example illustrates how this attribute can be used to define a number with value 10 and unit of measurement second: <math xmlns="http://www.w3.org/1998/Math/MathML" xmlns:sbml="http://www.sbml.org/sbml/level3/version1/core"> <cn type="integer" sbml:units="second"> 10 </cn> </math> Returns 'True' if this ASTNode or its children has units associated with it, 'False' otherwise. Note: The sbml:units attribute is only available in SBML Level 3. It may not be used in Levels 1-2 of SBML. """ return _libsbml.ASTNode_hasUnits(self) def setCharacter(self, value): """ setCharacter(ASTNode self, char value) -> int Sets the value of this ASTNode to the given character. If character is one of '+,' '-,' *, / or '^,' the node type will be set accordingly. For all other characters, the node type will be set to AST_UNKNOWN. Parameter 'value' is the character value to which the node's value should be set. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS """ return _libsbml.ASTNode_setCharacter(self, value) def setId(self, id): """ setId(ASTNode self, string id) -> int Sets the MathML id of this ASTNode to id. Parameter 'id' is 'string' representing the identifier. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS """ return _libsbml.ASTNode_setId(self, id) def setClass(self, className): """ setClass(ASTNode self, string className) -> int Sets the MathML class of this ASTNode to className. Parameter 'className' is 'string' representing the MathML class for this node. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS """ return _libsbml.ASTNode_setClass(self, className) def setStyle(self, style): """ setStyle(ASTNode self, string style) -> int Sets the MathML style of this ASTNode to style. Parameter 'style' is 'string' representing the identifier. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS """ return _libsbml.ASTNode_setStyle(self, style) def setName(self, name): """ setName(ASTNode self, char const * name) -> int Sets the value of this ASTNode to the given name. As a side-effect, this ASTNode object's type will be reset to AST_NAME if (and only if) the ASTNode was previously an operator ( ASTNode.isOperator() == true), number ( ASTNode.isNumber() == true), or unknown. This allows names to be set for AST_FUNCTION nodes and the like. Parameter 'name' is the string containing the name to which this node's value should be set Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS """ return _libsbml.ASTNode_setName(self, name) def setValue(self, *args): """ setValue(ASTNode self, long value) -> int setValue(ASTNode self, long numerator, long denominator) -> int setValue(ASTNode self, double value) -> int setValue(ASTNode self, double mantissa, long exponent) -> int This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: setValue(long numerator, long denominator) Sets the value of this ASTNode to the given rational in two parts: the numerator and denominator. The node type is set to AST_RATIONAL. Parameter 'numerator' is the numerator value of the rational Parameter 'denominator' is the denominator value of the rational Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS ______________________________________________________________________ Method variant with the following signature: setValue(double mantissa, long exponent) Sets the value of this ASTNode to the given real ('float)' in two parts: the mantissa and the exponent. The node type is set to AST_REAL_E. Parameter 'mantissa' is the mantissa of this node's real-numbered value Parameter 'exponent' is the exponent of this node's real- numbered value Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS ______________________________________________________________________ Method variant with the following signature: setValue(int value) Sets the value of this ASTNode to the given integer and sets the node type to AST_INTEGER. Parameter 'value' is the integer to which this node's value should be set Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS ______________________________________________________________________ Method variant with the following signature: setValue(double value) Sets the value of this ASTNode to the given real ('float)' and sets the node type to AST_REAL. This is functionally equivalent to: setValue(value, 0); Parameter 'value' is the 'float' format number to which this node's value should be set Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS ______________________________________________________________________ Method variant with the following signature: setValue(long value) Sets the value of this ASTNode to the given ('long)' integer and sets the node type to AST_INTEGER. Parameter 'value' is the integer to which this node's value should be set Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS """ return _libsbml.ASTNode_setValue(self, *args) def setType(self, type): """ setType(ASTNode self, ASTNodeType_t type) -> int Sets the type of this ASTNode to the given type code. Parameter 'type' is the type to which this node should be set Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_INVALID_ATTRIBUTE_VALUE Note: A side-effect of doing this is that any numerical values previously stored in this node are reset to zero. """ return _libsbml.ASTNode_setType(self, type) def setUnits(self, units): """ setUnits(ASTNode self, string units) -> int Sets the units of this ASTNode to units. The units will be set only if this ASTNode object represents a MathML <cn> element, i.e., represents a number. Callers may use ASTNode.isNumber() to inquire whether the node is of that type. SBML Level 3 Version 1 introduced the ability to include an attribute sbml:units on MathML cn elements appearing in SBML mathematical formulas. The value of this attribute can be used to indicate the unit of measurement to be associated with the number in the content of the cn element. The value of this attribute must be the identifier of a unit of measurement defined by SBML or the enclosing Model. Here, the sbml portion is an XML namespace prefix that must be associated with the SBML namespace for SBML Level 3. The following example illustrates how this attribute can be used to define a number with value 10 and unit of measurement second: <math xmlns="http://www.w3.org/1998/Math/MathML" xmlns:sbml="http://www.sbml.org/sbml/level3/version1/core"> <cn type="integer" sbml:units="second"> 10 </cn> </math> Parameter 'units' is 'string' representing the unit identifier. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE * LIBSBML_INVALID_ATTRIBUTE_VALUE Note: The sbml:units attribute is only available in SBML Level 3. It may not be used in Levels 1-2 of SBML. """ return _libsbml.ASTNode_setUnits(self, units) def swapChildren(self, that): """ swapChildren(ASTNode self, ASTNode that) -> int Swaps the children of this ASTNode object with the children of the given ASTNode object. Parameter 'that' is the other node whose children should be used to replace this node's children Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.ASTNode_swapChildren(self, that) def renameSIdRefs(self, oldid, newid): """ renameSIdRefs(ASTNode self, string oldid, string newid) Renames all the SIdRef attributes on this node and any child node """ return _libsbml.ASTNode_renameSIdRefs(self, oldid, newid) def renameUnitSIdRefs(self, oldid, newid): """ renameUnitSIdRefs(ASTNode self, string oldid, string newid) Renames all the UnitSIdRef attributes on this node and any child node. (The only place UnitSIDRefs appear in MathML <cn> elements.) """ return _libsbml.ASTNode_renameUnitSIdRefs(self, oldid, newid) def replaceIDWithFunction(self, id, function): """ replaceIDWithFunction(ASTNode self, string id, ASTNode function) Internal implementation method. """ return _libsbml.ASTNode_replaceIDWithFunction(self, id, function) def multiplyTimeBy(self, function): """ multiplyTimeBy(ASTNode self, ASTNode function) Internal implementation method. """ return _libsbml.ASTNode_multiplyTimeBy(self, function) def unsetUnits(self): """ unsetUnits(ASTNode self) -> int Unsets the units of this ASTNode. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_UNEXPECTED_ATTRIBUTE * LIBSBML_OPERATION_FAILED """ return _libsbml.ASTNode_unsetUnits(self) def unsetId(self): """ unsetId(ASTNode self) -> int Unsets the MathML id of this ASTNode. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.ASTNode_unsetId(self) def unsetClass(self): """ unsetClass(ASTNode self) -> int Unsets the MathML class of this ASTNode. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.ASTNode_unsetClass(self) def unsetStyle(self): """ unsetStyle(ASTNode self) -> int Unsets the MathML style of this ASTNode. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.ASTNode_unsetStyle(self) def setDefinitionURL(self, *args): """ setDefinitionURL(ASTNode self, XMLAttributes url) -> int setDefinitionURL(ASTNode self, string url) -> int """ return _libsbml.ASTNode_setDefinitionURL(self, *args) def getDefinitionURL(self): """ getDefinitionURL(ASTNode self) -> XMLAttributes Gets the MathML 'definitionURL' attribute value. Returns the value of the 'definitionURL' attribute, in the form of a libSBML XMLAttributes object. """ return _libsbml.ASTNode_getDefinitionURL(self) def replaceArgument(self, bvar, arg): """ replaceArgument(ASTNode self, string bvar, ASTNode arg) Replaces occurences of a given name within this ASTNode with the name/value/formula represented by 'arg'. For example, if the formula in this ASTNode is x + y, then the <bvar> is 'x' and 'arg' is an ASTNode representing the real value '3.' This method substitutes '3' for 'x' within this ASTNode object. Parameter 'bvar' is a string representing the variable name to be substituted Parameter 'arg' is an ASTNode representing the name/value/formula to substitute """ return _libsbml.ASTNode_replaceArgument(self, bvar, arg) def getParentSBMLObject(self): """ getParentSBMLObject(ASTNode self) -> SBase Returns the parent SBML object. Returns the parent SBML object of this ASTNode. """ return _libsbml.ASTNode_getParentSBMLObject(self) def unsetParentSBMLObject(self): """ unsetParentSBMLObject(ASTNode self) -> int Unsets the parent SBML object. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED See also isSetParentSBMLObject(), getParentSBMLObject(). """ return _libsbml.ASTNode_unsetParentSBMLObject(self) def isSetParentSBMLObject(self): """ isSetParentSBMLObject(ASTNode self) -> bool Returns 'True' if this node has a value for the parent SBML object. Returns true if this ASTNode has an parent SBML object set, 'False' otherwise. See also getParentSBMLObject(). """ return _libsbml.ASTNode_isSetParentSBMLObject(self) def reduceToBinary(self): """ reduceToBinary(ASTNode self) Reduces this ASTNode to a binary tree. Example: if this ASTNode is and(x, y, z), then the formula of the reduced node is and(and(x, y), z). The operation replaces the formula stored in the current ASTNode object. """ return _libsbml.ASTNode_reduceToBinary(self) def unsetUserData(self): """ unsetUserData(ASTNode self) -> int Unsets the user data of this node. The user data can be used by the application developer to attach custom information to the node. In case of a deep copy, this attribute will passed as it is. The attribute will be never interpreted by this class. Returns integer value indicating success/failure of the function. The possible values returned by this function are: * LIBSBML_OPERATION_SUCCESS * LIBSBML_OPERATION_FAILED """ return _libsbml.ASTNode_unsetUserData(self) def isSetUserData(self): """ isSetUserData(ASTNode self) -> bool Returns 'True' if this node has a user data object. Returns true if this ASTNode has a user data object set, 'False' otherwise. """ return _libsbml.ASTNode_isSetUserData(self) def isWellFormedASTNode(self): """ isWellFormedASTNode(ASTNode self) -> bool Returns 'True' or 'False' depending on whether this ASTNode is well- formed. Note: An ASTNode may be well-formed, with each node and its children having the appropriate number of children for the given type, but may still be invalid in the context of its use within an SBML model. Returns 'True' if this ASTNode is well-formed, 'False' otherwise. See also hasCorrectNumberArguments(). """ return _libsbml.ASTNode_isWellFormedASTNode(self) def hasCorrectNumberArguments(self): """ hasCorrectNumberArguments(ASTNode self) -> bool Returns 'True' or 'False' depending on whether this ASTNode has the correct number of children for its type. For example, an ASTNode with type AST_PLUS expects 2 child nodes. Note: This function performs a check on the top-level node only. Child nodes are not checked. Returns 'True' if this ASTNode has the appropriate number of children for its type, 'False' otherwise. See also isWellFormedASTNode(). """ return _libsbml.ASTNode_hasCorrectNumberArguments(self) def getDefinitionURLString(self): """ getDefinitionURLString(ASTNode self) -> string Returns the MathML 'definitionURL' attribute value as a string. Returns the value of the 'definitionURL' attribute, as a string. See also getDefinitionURL(), setDefinitionURL(), setDefinitionURL(). """ return _libsbml.ASTNode_getDefinitionURLString(self) def representsBvar(self): """ representsBvar(ASTNode self) -> bool Internal implementation method. """ return _libsbml.ASTNode_representsBvar(self) def isBvar(self): """ isBvar(ASTNode self) -> bool Internal implementation method. """ return _libsbml.ASTNode_isBvar(self) def setBvar(self): """ setBvar(ASTNode self) Internal implementation method. """ return _libsbml.ASTNode_setBvar(self) def usesL3V2MathConstructs(self): """ usesL3V2MathConstructs(ASTNode self) -> bool Internal implementation method. """ return _libsbml.ASTNode_usesL3V2MathConstructs(self) def usesRateOf(self): """ usesRateOf(ASTNode self) -> bool Internal implementation method. """ return _libsbml.ASTNode_usesRateOf(self) def isQualifier(self): """ isQualifier(ASTNode self) -> bool Internal implementation method. """ return _libsbml.ASTNode_isQualifier(self) def isSemantics(self): """ isSemantics(ASTNode self) -> bool Internal implementation method. """ return _libsbml.ASTNode_isSemantics(self) def getNumBvars(self): """ getNumBvars(ASTNode self) -> unsigned int Internal implementation method. """ return _libsbml.ASTNode_getNumBvars(self) def addPlugin(self, plugin): """ addPlugin(ASTNode self, ASTBasePlugin plugin) Internal implementation method. """ return _libsbml.ASTNode_addPlugin(self, plugin) def loadASTPlugins(self, sbmlns): """ loadASTPlugins(ASTNode self, SBMLNamespaces sbmlns) Internal implementation method. """ return _libsbml.ASTNode_loadASTPlugins(self, sbmlns) def loadASTPlugin(self, pkgName): """ loadASTPlugin(ASTNode self, string pkgName) Internal implementation method. """ return _libsbml.ASTNode_loadASTPlugin(self, pkgName) def getASTPlugin(self, *args): """ getASTPlugin(ASTNode self, SBMLNamespaces sbmlns) -> ASTBasePlugin getASTPlugin(ASTNode self, ASTNodeType_t type) -> ASTBasePlugin getASTPlugin(ASTNode self, string name, bool isCsymbol=False) -> ASTBasePlugin getASTPlugin(ASTNode self, string name) -> ASTBasePlugin getASTPlugin(ASTNode self, SBMLNamespaces sbmlns) -> ASTBasePlugin getASTPlugin(ASTNode self, ASTNodeType_t type) -> ASTBasePlugin getASTPlugin(ASTNode self, string name, bool isCsymbol=False) -> ASTBasePlugin getASTPlugin(ASTNode self, string name) -> ASTBasePlugin This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: getASTPlugin(SBMLNamespaces sbmlns) ______________________________________________________________________ Method variant with the following signature: getASTPlugin(string name, bool isCsymbol = false) Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. ______________________________________________________________________ Method variant with the following signature: getASTPlugin(ASTNodeType_t type) """ return _libsbml.ASTNode_getASTPlugin(self, *args) def getPlugin(self, *args): """ getPlugin(ASTNode self, string package) -> ASTBasePlugin getPlugin(ASTNode self, string package) -> ASTBasePlugin getPlugin(ASTNode self, unsigned int n) -> ASTBasePlugin getPlugin(ASTNode self, unsigned int n) -> ASTBasePlugin """ return _libsbml.ASTNode_getPlugin(self, *args) def getNumPlugins(self): """ getNumPlugins(ASTNode self) -> unsigned int Internal implementation method. """ return _libsbml.ASTNode_getNumPlugins(self) def __eq__(self, rhs): if ((self is None) and (rhs is None)): return True if ((self is None) or (rhs is None)): return False if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return True return False def __ne__(self, rhs): if ((self is None) and (rhs is None)): return False if ((self is None) or (rhs is None)): return True if (hasattr(self, 'this') and hasattr(rhs, 'this')): if (self.this == rhs.this): return False return True def getListOfNodes(self): """ getListOfNodes(ASTNode self) -> ASTNodeList Returns a list of nodes. Unlike the equivalent method in the libSBML C/C++ interface, this method does not offer the ability to pass a predicate as an argument. The method always returns the list of all ASTNode objects. @return the ASTNodeList of nodes. @warning The list returned is owned by the caller and should be deleted after the caller is done using it. The ASTNode objects in the list; however, are <strong>not</strong> owned by the caller (as they still belong to the tree itself), and therefore should not be deleted. """ return _libsbml.ASTNode_getListOfNodes(self) ASTNode_swigregister = _libsbml.ASTNode_swigregister ASTNode_swigregister(ASTNode) def readMathMLFromString(xml): """ readMathMLFromString(char const * xml) -> ASTNode Reads the MathML from the given XML string, constructs a corresponding abstract syntax tree, and returns a pointer to the root of the tree. Parameter 'xml' is a string containing a full MathML expression Returns the root of an AST corresponding to the given mathematical expression, otherwise 'None' is returned if the given string is 'None' or invalid. """ return _libsbml.readMathMLFromString(xml) def readMathMLFromStringWithNamespaces(xml, xmlns): """ readMathMLFromStringWithNamespaces(char const * xml, XMLNamespaces xmlns) -> ASTNode Reads the MathML from the given XML string, constructs a corresponding abstract syntax tree, and returns a pointer to the root of the tree. Parameter 'xml' is a string containing a full MathML expression Parameter 'xmlns' is an XMLNamespaces object containing namespaces that are considered active during the read. (For example, an SBML Level 3 package namespace.) Returns the root of an AST corresponding to the given mathematical expression, otherwise 'None' is returned if the given string is 'None' or invalid. """ return _libsbml.readMathMLFromStringWithNamespaces(xml, xmlns) def writeMathMLToString(node): """ writeMathMLToString(ASTNode node) -> char * Writes the given ASTNode (and its children) to a string as MathML, and returns the string. Parameter 'node' is the root of an AST to write out to the stream. Returns a string containing the written-out MathML representation of the given AST. Note: The string is owned by the caller and should be freed (with free()) when no longer needed. 'None' is returned if the given argument is 'None.' """ return _libsbml.writeMathMLToString(node) def writeMathMLWithNamespaceToString(node, sbmlns): """ writeMathMLWithNamespaceToString(ASTNode node, SBMLNamespaces sbmlns) -> char * Writes the given AST node (and its children) to a string as MathML, and returns the string. Parameter 'node' is the root of an AST to write out to the stream. Parameter 'sbmlns' is the SBML namespace to be used Returns a string containing the written-out MathML representation of the given AST. Note: The string is owned by the caller and should be freed (with free()) when no longer needed. 'None' is returned if the given argument is 'None.' """ return _libsbml.writeMathMLWithNamespaceToString(node, sbmlns) def parseFormula(formula): """ parseFormula(char const * formula) -> ASTNode Parses the given SBML formula and returns a representation of it as an Abstract Syntax Tree (AST). The text-string form of mathematical formulas produced by formulaToString() and read by parseFormula() use a simple C-inspired infix notation taken from SBML Level 1. A formula in this text-string form therefore can be handed to a program that understands SBML Level 1 mathematical expressions, or used as part of a formula translation system. The syntax is described in detail in the documentation for ASTNode. The following are illustrative examples of formulas expressed using this syntax: 0.10 * k4^2 (vm * s1)/(km + s1) Note that this facility is provided as a convenience by libSBML---the MathML standard does not actually define a 'string-form' equivalent to MathML expression trees, so the choice of formula syntax is somewhat arbitrary. The approach taken by libSBML is to use the syntax defined by SBML Level 1 (which in fact used a text-string representation of formulas and not MathML). This formula syntax is based mostly on C programming syntax, and may contain operators, function calls, symbols, and white space characters. The following table provides the precedence rules for the different entities that may appear in formula strings. +--------------+---------------------+---------+------------+------------+ | Token | Operation | Class | Precedence | Associates | +--------------+---------------------+---------+------------+------------+ | name | symbol reference | operand | 6 | n/a | | (expression) | expression grouping | operand | 6 | n/a | | f(...) | function call | prefix | 6 | left | | - | negation | unary | 5 | right | | ^ | power | binary | 4 | left | | * | multiplication | binary | 3 | left | | / | divison | binary | 3 | left | | + | addition | binary | 2 | left | | - | subtraction | binary | 2 | left | | , | argument delimiter | binary | 1 | left | +--------------+---------------------+---------+------------+------------+ In the table above, operand implies the construct is an operand, prefix implies the operation is applied to the following arguments, unary implies there is one argument, and binary implies there are two arguments. The values in the Precedence column show how the order of different types of operation are determined. For example, the expression a * b + c is evaluated as (a * b) + c because the '*' operator has higher precedence. The Associates column shows how the order of similar precedence operations is determined; for example, a - b + c is evaluated as (a - b) + c because the '+' and '-' operators are left-associative. The function call syntax consists of a function name, followed by optional white space, followed by an opening parenthesis token, followed by a sequence of zero or more arguments separated by commas (with each comma optionally preceded and/or followed by zero or more white space characters, followed by a closing parenthesis token. The function name must be chosen from one of the pre-defined functions in SBML or a user-defined function in the model. The following table lists the names of certain common mathematical functions; this table corresponds to Table 6 in the SBML Level 1 Version 2 specification: +-------+------+-------------------------------------------------------------------+--------------------------------+--------------------+ | Name | Args | Formula or meaning | Argument Constraints | Result constraints | +-------+------+-------------------------------------------------------------------+--------------------------------+--------------------+ | abs | x | absolute value of x | | | | acos | x | arc cosine of x in radians | -1.0 <= x <= 1.0 | 0 <= acos(x) <= Pi | | asin | x | arc sine of x in radians | -1.0 <= x <= 1.0 | 0 <= asin(x) <= Pi | | atan | x | arc tangent of x in radians | | 0 <= atan(x) <= Pi | | ceil | x | smallest number not less than x whose value is an exact integer | | | | cos | x | cosine of x | | | | exp | x | e^x, where e is the base of the natural logarithm | | | | floor | x | largest number not greater than x whose value is an exact integer | | | | log | x | natural logarithm of x | x > 0 | | | log10 | x | base 10 logarithm of x | x > 0 | | | pow | x, y | x^y | | | | sqr | x | x^2 | | | | sqrt | x | √x | x > 0 | sqrt(x) >= 0 | | sin | x | sine of x | | | | tan | x | tangent of x | x != n*Pi/2, for odd integer n | | +-------+------+-------------------------------------------------------------------+--------------------------------+--------------------+ WARNING: There are differences between the symbols used to represent the common mathematical functions and the corresponding MathML token names. This is a potential source of incompatibilities. Note in particular that in this text-string syntax, log(x) represents the natural logarithm, whereas in MathML, the natural logarithm is <ln/>. Application writers are urged to be careful when translating between text forms and MathML forms, especially if they provide a direct text-string input facility to users of their software systems. @copydetails doc_warning_L1_math_string_syntax Parameter 'formula' is the text-string formula expression to be parsed Returns the root node of the AST corresponding to the 'formula', or 'None' if an error occurred in parsing the formula See also libsbml.formulaToString(), libsbml.parseL3FormulaWithSettings(), libsbml.parseL3Formula(), libsbml.parseL3FormulaWithModel(), libsbml.getLastParseL3Error(), libsbml.getDefaultL3ParserSettings(). """ return _libsbml.parseFormula(formula) def formulaToL3String(tree): """ formulaToL3String(ASTNode tree) -> char * Converts an AST to a string representation of a formula using a syntax derived from SBML Level 1, but extended to include elements from SBML Level 2 and SBML Level 3. The text-string form of mathematical formulas read by the function parseL3Formula() and written by the function formulaToL3String() uses an expanded version of the syntax read and written by parseFormula() and formulaToString(), respectively. The latter two libSBML functions were originally developed to support conversion between SBML Levels 1 and 2, and were focused on the syntax of mathematical formulas used in SBML Level 1. With time, and the use of MathML in SBML Levels 2 and 3, it became clear that supporting Level 2 and 3's expanded mathematical syntax would be useful for software developers. To maintain backwards compatibility for libSBML users, the original formulaToString() and parseFormula() have been left untouched, and instead, the new functionality is provided in the form of parseL3Formula() and formulaToL3String(). The following lists the main differences in the formula syntax supported by the Level 3 ('L3') versions of the formula parsers and formatters, compared to what is supported by the Level 1-oriented parseFormula() and formulaToString(): * Units may be asociated with bare numbers, using the following syntax: number unit The number may be in any form (an integer, real, or rational number), and the unit must conform to the syntax of an SBML identifier (technically, the type defined as 'SId' in the SBML specifications). The whitespace between number and unit is optional. * The Boolean function symbols '&&' (and), '||' (or), '!' (not), and '!=' (not equals) may be used. * The modulo operation is allowed as the symbol '%' and will produce a <piecewise> function in the corresponding MathML output by default, or can produce the MathML function 'rem,' depending on the L3ParserSettings object (see L3ParserSettings_setParseModuloL3v2() ). * All inverse trigonometric functions may be defined in the infix either using 'arc' as a prefix or simply 'a;' in other words, both 'arccsc' and 'acsc' are interpreted as the operator arccosecant as defined in MathML 2.0. (Many functions in the simpler SBML Level 1 oriented parser implemented by parseFormula() are defined this way as well, but not all.) * The following expression is parsed as a rational number instead of as a numerical division: (integer/integer) Spaces are not allowed in this construct; in other words, "(3 / 4)" (with whitespace between the numbers and the operator) will be parsed into the MathML <divide> construct rather than a rational number. You can, however, assign units to a rational number as a whole; here is an example: "(3/4) ml". (In the case of division rather than a rational number, units are not interpreted in this way.) * Various parser and formatter behaviors may be altered through the use of a L3ParserSettings object in conjunction with the functions parseL3FormulaWithSettings() and formulaToL3StringWithSettings() The settings available include the following: * The function 'log' with a single argument ("log(x)") can be parsed as log10(x), ln(x), or treated as an error, as desired. * Unary minus signs can be collapsed or preserved; that is, sequential pairs of unary minuses (e.g., "- -3") can be removed from the input entirely and single unary minuses can be incorporated into the number node, or all minuses can be preserved in the AST node structure. * Parsing of units embedded in the input string can be turned on and off. * The string 'avogadro' can be parsed as a MathML csymbol or as an identifier. * The string % can be parsed either as a piecewise function or as the 'rem' function: a % b will either become piecewise(a - b*ceil(a/b), xor((a < 0), (b < 0)), a - b*floor(a/b)) or rem(a, b). The latter is simpler, but the 'rem' MathML is only allowed as of SBML Level 3 Version 2.* A Model object may optionally be provided to the parser using the variant function call parseL3FormulaWithModel() or stored in a L3ParserSettings object passed to the variant function parseL3FormulaWithSettings(). When a Model object is provided, identifiers (values of type 'SId' ) from that model are used in preference to pre-defined MathML definitions for both symbols and functions. More precisely: * In the case of symbols: the Model entities whose identifiers will shadow identical symbols in the mathematical formula are: Species, Compartment, Parameter, Reaction, and SpeciesReference. For instance, if the parser is given a Model containing a Species with the identifier "pi", and the formula to be parsed is "3*pi", the MathML produced will contain the construct <ci> pi </ci> instead of the construct <pi/>. * In the case of user-defined functions: when a Model object is provided, 'SId' values of user-defined functions present in the model will be used preferentially over pre-defined MathML functions. For example, if the passed-in Model contains a FunctionDefinition object with the identifier "sin", that function will be used instead of the predefined MathML function <sin/>. * An SBMLNamespaces object may optionally be provided to identify SBML Level 3 packages that extend the syntax understood by the formula parser. When the namespaces are provided, the parser will interpret possible additional syntax defined by the libSBML plug-ins implementing the SBML Level 3 packages; for example, it may understand vector/array extensions introduced by the SBML Level 3 Arrays package. These configuration settings cannot be changed directly using the basic parser and formatter functions, but can be changed on a per-call basis by using the alternative functions parseL3FormulaWithSettings() and formulaToL3StringWithSettings(). Neither SBML nor the MathML standard define a 'string-form' equivalent to MathML expressions. The approach taken by libSBML is to start with the formula syntax defined by SBML Level 1 (which in fact used a custom text-string representation of formulas, and not MathML), and expand it to include the functionality described above. This formula syntax is based mostly on C programming syntax, and may contain operators, function calls, symbols, and white space characters. The following table provides the precedence rules for the different entities that may appear in formula strings. +----------------------+--------------------------+---------+---------+--------+ | Token | Operation | Class | Preced. | Assoc. | +----------------------+--------------------------+---------+---------+--------+ | name | symbol reference | operand | 8 | n/a | | (expression) | expression grouping | operand | 8 | n/a | | f(...) | function call | prefix | 8 | left | | ^ | power | binary | 7 | left | | -, ! | negation, Boolean 'not' | unary | 6 | right | | *, /, % | multip., div., modulo | binary | 5 | left | | +, - | addition and subtraction | binary | 4 | left | | ==, <, >, <=, >=, != | Boolean comparisons | binary | 3 | left | | &&, || | Boolean 'and' and 'or' | binary | 2 | left | | , | argument delimiter | binary | 1 | left | +----------------------+--------------------------+---------+---------+--------+ In the table above, operand implies the construct is an operand, prefix implies the operation is applied to the following arguments, unary implies there is one argument, and binary implies there are two arguments. The values in the Precedence column show how the order of different types of operation are determined. For example, the expression a + b * c is evaluated as a + (b * c) because the '*' operator has higher precedence. The Associates column shows how the order of similar precedence operations is determined; for example, a && b || c is evaluated as (a && b) || c because the '&&' and '||' operators are left-associative and have the same precedence. The function call syntax consists of a function name, followed by optional white space, followed by an opening parenthesis token, followed by a sequence of zero or more arguments separated by commas (with each comma optionally preceded and/or followed by zero or more white space characters), followed by a closing parenthesis token. The function name must be chosen from one of the pre-defined functions in SBML or a user-defined function in the model. The following table lists the names of certain common mathematical functions; this table corresponds to Table 6 in the SBML Level 1 Version 2 specification with additions based on the functions added in SBML Level 2 and Level 3: +----------------+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------+--------------------+ | Name | Argument(s) | Formula or meaning | Argument Constraints | Result constraints | +----------------+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------+--------------------+ | abs | x | Absolute value of x. | | | | acos, arccos | x | Arccosine of x in radians. | -1.0 <= x <= 1.0 | 0 <= acos(x) <= Pi | | acosh, arccosh | x | Hyperbolic arccosine of x in radians. | | | | acot, arccot | x | Arccotangent of x in radians. | | | | acoth, arccoth | x | Hyperbolic arccotangent of x in radians. | | | | acsc, arccsc | x | Arccosecant of x in radians. | | | | acsch, arccsch | x | Hyperbolic arccosecant of x in radians. | | | | asec, arcsec | x | Arcsecant of x in radians. | | | | asech, arcsech | x | Hyperbolic arcsecant of x in radians. | | | | asin, arcsin | x | Arcsine of x in radians. | -1.0 <= x <= 1.0 | 0 <= asin(x) <= Pi | | atan, arctan | x | Arctangent of x in radians. | | 0 <= atan(x) <= Pi | | atanh, arctanh | x | Hyperbolic arctangent of x in radians. | | | | ceil, ceiling | x | Smallest number not less than x whose value is an exact integer. | | | | cos | x | Cosine of x | | | | cosh | x | Hyperbolic cosine of x. | | | | cot | x | Cotangent of x. | | | | coth | x | Hyperbolic cotangent of x. | | | | csc | x | Cosecant of x. | | | | csch | x | Hyperbolic cosecant of x. | | | | delay | x, y | The value of x at y time units in the past. | | | | factorial | n | The factorial of n. Factorials are defined by n! = n*(n-1)* ... * 1. | n must be an integer. | | | exp | x | e^x, where e is the base of the natural logarithm. | | | | floor | x | The largest number not greater than x whose value is an exact integer. | | | | ln | x | Natural logarithm of x. | x > 0 | | | log | x | By default, the base 10 logarithm of x, but can be set to be the natural logarithm of x, or to be an illegal construct. | x > 0 | | | log | x, y | The base x logarithm of y. | y > 0 | | | log10 | x | Base 10 logarithm of x. | x > 0 | | | piecewise | x1, y1, [x2, y2,] [...] [z] | A piecewise function: if (y1), x1. Otherwise, if (y2), x2, etc. Otherwise, z. | y1, y2, y3 [etc] must be Boolean | | | pow, power | x, y | x^y. | | | | root | b, x | The root base b of x. | | | | sec | x | Secant of x. | | | | sech | x | Hyperbolic secant of x. | | | | sqr | x | x^2. | | | | sqrt | x | √x. | x > 0 | sqrt(x) >= 0 | | sin | x | Sine of x. | | | | sinh | x | Hyperbolic sine of x. | | | | tan | x | Tangent of x. | x != n*Pi/2, for odd integer n | | | tanh | x | Hyperbolic tangent of x. | | | | and | x, y, z... | Boolean and(x, y, z...): returns true if all of its arguments are true. Note that and is an n-ary function, taking 0 or more arguments, and that and() returns true. | All arguments must be Boolean | | | not | x | Boolean not(x) | x must be Boolean | | | or | x, y, z... | Boolean or(x, y, z...): returns true if at least one of its arguments is true. Note that or is an n-ary function, taking 0 or more arguments, and that or() returns false. | All arguments must be Boolean | | | xor | x, y, z... | Boolean xor(x, y, z...): returns true if an odd number of its arguments is true. Note that xor is an n-ary function, taking 0 or more arguments, and that xor() returns false. | All arguments must be Boolean | | | eq | x, y, z... | Boolean eq(x, y, z...): returns true if all arguments are equal. Note that eq is an n-ary function, but must take 2 or more arguments. | | | | geq | x, y, z... | Boolean geq(x, y, z...): returns true if each argument is greater than or equal to the argument following it. Note that geq is an n-ary function, but must take 2 or more arguments. | | | | gt | x, y, z... | Boolean gt(x, y, z...): returns true if each argument is greater than the argument following it. Note that gt is an n-ary function, but must take 2 or more arguments. | | | | leq | x, y, z... | Boolean leq(x, y, z...): returns true if each argument is less than or equal to the argument following it. Note that leq is an n-ary function, but must take 2 or more arguments. | | | | lt | x, y, z... | Boolean lt(x, y, z...): returns true if each argument is less than the argument following it. Note that lt is an n-ary function, but must take 2 or more arguments. | | | | neq | x, y | Boolean x != y: returns true unless x and y are equal. | | | | plus | x, y, z... | x + y + z + ...: The sum of the arguments of the function. Note that plus is an n-ary function taking 0 or more arguments, and that plus() returns 0. | | | | times | x, y, z... | x * y * z * ...: The product of the arguments of the function. Note that times is an n-ary function taking 0 or more arguments, and that times() returns 1. | | | | minus | x, y | x - y. | | | | divide | x, y | x / y. | | | +----------------+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------+--------------------+ Parsing of the various MathML functions and constants are all case- insensitive by default: function names such as cos, Cos and COS are all parsed as the MathML cosine operator, <cos>. However, when a Model object is used in conjunction with either parseL3FormulaWithModel() or parseL3FormulaWithSettings(), any identifiers found in that model will be parsed in a case-sensitive way. For example, if a model contains a Species having the identifier Pi, the parser will parse "Pi" in the input as "<ci> Pi </ci>" but will continue to parse the symbols "pi" and "PI" as "<pi>". As mentioned above, the manner in which the 'L3' versions of the formula parser and formatter interpret the function "log" can be changed. To do so, callers should use the function parseL3FormulaWithSettings() and pass it an appropriate L3ParserSettings object. By default, unlike the SBML Level 1 parser implemented by parseFormula(), the string "log" is interpreted as the base 10 logarithm, and not as the natural logarithm. However, you can change the interpretation to be base-10 log, natural log, or as an error; since the name 'log' by itself is ambiguous, you require that the parser uses 'log10' or 'ln' instead, which are more clear. Please refer to parseL3FormulaWithSettings(). In addition, the following symbols will be translated to their MathML equivalents, if no symbol with the same 'SId' identifier string exists in the Model object provided: +-----------------+-------------------------------------------------+--------------------------------------------------------------------------------------------------------------+ | Name | Meaning | MathML | +-----------------+-------------------------------------------------+--------------------------------------------------------------------------------------------------------------+ | true | Boolean value true | <true/> | | false | Boolean value false | <false/> | | pi | Mathematical constant pi | <pi/> | | avogadro | Value of Avogadro's constant stipulated by SBML | <csymbol encoding="text" definitionURL="http://www.sbml.org/sbml/symbols/avogadro"> avogadro </csymbol/> | | time | Simulation time as defined in SBML | <csymbol encoding="text" definitionURL="http://www.sbml.org/sbml/symbols/time"> time </csymbol/> | | inf, infinity | Mathematical constant "infinity" | <infinity/> | | nan, notanumber | Mathematical concept "not a number" | <notanumber/> | +-----------------+-------------------------------------------------+--------------------------------------------------------------------------------------------------------------+ Again, as mentioned above, whether the string "avogadro" is parsed as an AST node of type AST_NAME_AVOGADRO or AST_NAME is configurable; use the version of the parser function called parseL3FormulaWithSettings(). This Avogadro-related functionality is provided because SBML Level 2 models may not use AST_NAME_AVOGADRO AST nodes. Parameter 'tree' is the AST to be converted. Returns the formula from the given AST as an SBML Level 3 text-string mathematical formula. The caller owns the returned string and is responsible for freeing it when it is no longer needed. See also libsbml.formulaToString(), libsbml.parseL3FormulaWithSettings(), libsbml.parseL3Formula(), libsbml.parseL3FormulaWithModel(), libsbml.getLastParseL3Error(), libsbml.getDefaultL3ParserSettings(). """ return _libsbml.formulaToL3String(tree) def formulaToL3StringWithSettings(tree, settings): """ formulaToL3StringWithSettings(ASTNode tree, L3ParserSettings settings) -> char * Converts an AST to a string representation of a formula using a syntax basically derived from SBML Level 1, with behavior modifiable with custom settings. This function behaves identically to SBML_formulaToL3String(), but its behavior can be modified by two settings in the Parameter 'settings' is object, namely: * ParseUnits: If this is set to 'true' (the default), the function will write out the units of any numerical ASTNodes that have them, producing (for example) '3 mL', '(3/4) m', or '5.5e-10 M'. If this is set to 'false', this function will only write out the number itself ('3', '(3/4)', and '5.5e-10', in the previous examples). * CollapseMinus: If this is set to 'false' (the default), the function will write out explicitly any doubly-nested unary minus ASTNodes, producing (for example) '--x' or even '-----3.1'. If this is set to 'true', the function will collapse the nodes before producing the infix, producing 'x' and '-3.1' in the previous examples. All other settings will not affect the behavior of this function: the 'parseLog' setting is ignored, and 'log10(x)', 'ln(x)', and 'log(x, y)' are always produced. Nothing in the Model object is used, and whether Avogadro is a csymbol or not is immaterial to the produced infix. Parameter 'tree' is the AST to be converted. Parameter 'settings' is the L3ParserSettings object used to modify behavior. Returns the formula from the given AST as an SBML Level 3 text-string mathematical formula. The caller owns the returned string and is responsible for freeing it when it is no longer needed. See also SBML_parseFormula(), SBML_parseL3Formula(), SBML_formulaToL3String(). """ return _libsbml.formulaToL3StringWithSettings(tree, settings) def formulaToString(tree): """ formulaToString(ASTNode tree) -> char * Converts an AST to a string representation of a formula using a syntax basically derived from SBML Level 1. The text-string form of mathematical formulas produced by formulaToString() and read by parseFormula() use a simple C-inspired infix notation taken from SBML Level 1. A formula in this text-string form therefore can be handed to a program that understands SBML Level 1 mathematical expressions, or used as part of a formula translation system. The syntax is described in detail in the documentation for ASTNode. The following are illustrative examples of formulas expressed using this syntax: 0.10 * k4^2 (vm * s1)/(km + s1) Note that this facility is provided as a convenience by libSBML---the MathML standard does not actually define a 'string-form' equivalent to MathML expression trees, so the choice of formula syntax is somewhat arbitrary. The approach taken by libSBML is to use the syntax defined by SBML Level 1 (which in fact used a text-string representation of formulas and not MathML). This formula syntax is based mostly on C programming syntax, and may contain operators, function calls, symbols, and white space characters. The following table provides the precedence rules for the different entities that may appear in formula strings. +--------------+---------------------+---------+------------+------------+ | Token | Operation | Class | Precedence | Associates | +--------------+---------------------+---------+------------+------------+ | name | symbol reference | operand | 6 | n/a | | (expression) | expression grouping | operand | 6 | n/a | | f(...) | function call | prefix | 6 | left | | - | negation | unary | 5 | right | | ^ | power | binary | 4 | left | | * | multiplication | binary | 3 | left | | / | divison | binary | 3 | left | | + | addition | binary | 2 | left | | - | subtraction | binary | 2 | left | | , | argument delimiter | binary | 1 | left | +--------------+---------------------+---------+------------+------------+ In the table above, operand implies the construct is an operand, prefix implies the operation is applied to the following arguments, unary implies there is one argument, and binary implies there are two arguments. The values in the Precedence column show how the order of different types of operation are determined. For example, the expression a * b + c is evaluated as (a * b) + c because the '*' operator has higher precedence. The Associates column shows how the order of similar precedence operations is determined; for example, a - b + c is evaluated as (a - b) + c because the '+' and '-' operators are left-associative. The function call syntax consists of a function name, followed by optional white space, followed by an opening parenthesis token, followed by a sequence of zero or more arguments separated by commas (with each comma optionally preceded and/or followed by zero or more white space characters, followed by a closing parenthesis token. The function name must be chosen from one of the pre-defined functions in SBML or a user-defined function in the model. The following table lists the names of certain common mathematical functions; this table corresponds to Table 6 in the SBML Level 1 Version 2 specification: +-------+------+-------------------------------------------------------------------+--------------------------------+--------------------+ | Name | Args | Formula or meaning | Argument Constraints | Result constraints | +-------+------+-------------------------------------------------------------------+--------------------------------+--------------------+ | abs | x | absolute value of x | | | | acos | x | arc cosine of x in radians | -1.0 <= x <= 1.0 | 0 <= acos(x) <= Pi | | asin | x | arc sine of x in radians | -1.0 <= x <= 1.0 | 0 <= asin(x) <= Pi | | atan | x | arc tangent of x in radians | | 0 <= atan(x) <= Pi | | ceil | x | smallest number not less than x whose value is an exact integer | | | | cos | x | cosine of x | | | | exp | x | e^x, where e is the base of the natural logarithm | | | | floor | x | largest number not greater than x whose value is an exact integer | | | | log | x | natural logarithm of x | x > 0 | | | log10 | x | base 10 logarithm of x | x > 0 | | | pow | x, y | x^y | | | | sqr | x | x^2 | | | | sqrt | x | √x | x > 0 | sqrt(x) >= 0 | | sin | x | sine of x | | | | tan | x | tangent of x | x != n*Pi/2, for odd integer n | | +-------+------+-------------------------------------------------------------------+--------------------------------+--------------------+ WARNING: There are differences between the symbols used to represent the common mathematical functions and the corresponding MathML token names. This is a potential source of incompatibilities. Note in particular that in this text-string syntax, log(x) represents the natural logarithm, whereas in MathML, the natural logarithm is <ln/>. Application writers are urged to be careful when translating between text forms and MathML forms, especially if they provide a direct text-string input facility to users of their software systems. @copydetails doc_warning_L1_math_string_syntax Parameter 'tree' is the AST to be converted. Returns the formula from the given AST as an SBML Level 1 text-string mathematical formula. The caller owns the returned string and is responsible for freeing it when it is no longer needed. See also libsbml.formulaToString(), libsbml.parseL3FormulaWithSettings(), libsbml.parseL3Formula(), libsbml.parseL3FormulaWithModel(), libsbml.getLastParseL3Error(), libsbml.getDefaultL3ParserSettings(). """ return _libsbml.formulaToString(tree) def parseL3Formula(formula): """ parseL3Formula(char const * formula) -> ASTNode Parses a text string as a mathematical formula and returns an AST representation of it. The text-string form of mathematical formulas read by the function parseL3Formula() and written by the function formulaToL3String() uses an expanded version of the syntax read and written by parseFormula() and formulaToString(), respectively. The latter two libSBML functions were originally developed to support conversion between SBML Levels 1 and 2, and were focused on the syntax of mathematical formulas used in SBML Level 1. With time, and the use of MathML in SBML Levels 2 and 3, it became clear that supporting Level 2 and 3's expanded mathematical syntax would be useful for software developers. To maintain backwards compatibility for libSBML users, the original formulaToString() and parseFormula() have been left untouched, and instead, the new functionality is provided in the form of parseL3Formula() and formulaToL3String(). The following lists the main differences in the formula syntax supported by the Level 3 ('L3') versions of the formula parsers and formatters, compared to what is supported by the Level 1-oriented parseFormula() and formulaToString(): * Units may be asociated with bare numbers, using the following syntax: number unit The number may be in any form (an integer, real, or rational number), and the unit must conform to the syntax of an SBML identifier (technically, the type defined as 'SId' in the SBML specifications). The whitespace between number and unit is optional. * The Boolean function symbols '&&' (and), '||' (or), '!' (not), and '!=' (not equals) may be used. * The modulo operation is allowed as the symbol '%' and will produce a <piecewise> function in the corresponding MathML output by default, or can produce the MathML function 'rem,' depending on the L3ParserSettings object (see L3ParserSettings_setParseModuloL3v2() ). * All inverse trigonometric functions may be defined in the infix either using 'arc' as a prefix or simply 'a;' in other words, both 'arccsc' and 'acsc' are interpreted as the operator arccosecant as defined in MathML 2.0. (Many functions in the simpler SBML Level 1 oriented parser implemented by parseFormula() are defined this way as well, but not all.) * The following expression is parsed as a rational number instead of as a numerical division: (integer/integer) Spaces are not allowed in this construct; in other words, "(3 / 4)" (with whitespace between the numbers and the operator) will be parsed into the MathML <divide> construct rather than a rational number. You can, however, assign units to a rational number as a whole; here is an example: "(3/4) ml". (In the case of division rather than a rational number, units are not interpreted in this way.) * Various parser and formatter behaviors may be altered through the use of a L3ParserSettings object in conjunction with the functions parseL3FormulaWithSettings() and formulaToL3StringWithSettings() The settings available include the following: * The function 'log' with a single argument ("log(x)") can be parsed as log10(x), ln(x), or treated as an error, as desired. * Unary minus signs can be collapsed or preserved; that is, sequential pairs of unary minuses (e.g., "- -3") can be removed from the input entirely and single unary minuses can be incorporated into the number node, or all minuses can be preserved in the AST node structure. * Parsing of units embedded in the input string can be turned on and off. * The string 'avogadro' can be parsed as a MathML csymbol or as an identifier. * The string % can be parsed either as a piecewise function or as the 'rem' function: a % b will either become piecewise(a - b*ceil(a/b), xor((a < 0), (b < 0)), a - b*floor(a/b)) or rem(a, b). The latter is simpler, but the 'rem' MathML is only allowed as of SBML Level 3 Version 2.* A Model object may optionally be provided to the parser using the variant function call parseL3FormulaWithModel() or stored in a L3ParserSettings object passed to the variant function parseL3FormulaWithSettings(). When a Model object is provided, identifiers (values of type 'SId' ) from that model are used in preference to pre-defined MathML definitions for both symbols and functions. More precisely: * In the case of symbols: the Model entities whose identifiers will shadow identical symbols in the mathematical formula are: Species, Compartment, Parameter, Reaction, and SpeciesReference. For instance, if the parser is given a Model containing a Species with the identifier "pi", and the formula to be parsed is "3*pi", the MathML produced will contain the construct <ci> pi </ci> instead of the construct <pi/>. * In the case of user-defined functions: when a Model object is provided, 'SId' values of user-defined functions present in the model will be used preferentially over pre-defined MathML functions. For example, if the passed-in Model contains a FunctionDefinition object with the identifier "sin", that function will be used instead of the predefined MathML function <sin/>. * An SBMLNamespaces object may optionally be provided to identify SBML Level 3 packages that extend the syntax understood by the formula parser. When the namespaces are provided, the parser will interpret possible additional syntax defined by the libSBML plug-ins implementing the SBML Level 3 packages; for example, it may understand vector/array extensions introduced by the SBML Level 3 Arrays package. These configuration settings cannot be changed directly using the basic parser and formatter functions, but can be changed on a per-call basis by using the alternative functions parseL3FormulaWithSettings() and formulaToL3StringWithSettings(). Neither SBML nor the MathML standard define a 'string-form' equivalent to MathML expressions. The approach taken by libSBML is to start with the formula syntax defined by SBML Level 1 (which in fact used a custom text-string representation of formulas, and not MathML), and expand it to include the functionality described above. This formula syntax is based mostly on C programming syntax, and may contain operators, function calls, symbols, and white space characters. The following table provides the precedence rules for the different entities that may appear in formula strings. +----------------------+--------------------------+---------+---------+--------+ | Token | Operation | Class | Preced. | Assoc. | +----------------------+--------------------------+---------+---------+--------+ | name | symbol reference | operand | 8 | n/a | | (expression) | expression grouping | operand | 8 | n/a | | f(...) | function call | prefix | 8 | left | | ^ | power | binary | 7 | left | | -, ! | negation, Boolean 'not' | unary | 6 | right | | *, /, % | multip., div., modulo | binary | 5 | left | | +, - | addition and subtraction | binary | 4 | left | | ==, <, >, <=, >=, != | Boolean comparisons | binary | 3 | left | | &&, || | Boolean 'and' and 'or' | binary | 2 | left | | , | argument delimiter | binary | 1 | left | +----------------------+--------------------------+---------+---------+--------+ In the table above, operand implies the construct is an operand, prefix implies the operation is applied to the following arguments, unary implies there is one argument, and binary implies there are two arguments. The values in the Precedence column show how the order of different types of operation are determined. For example, the expression a + b * c is evaluated as a + (b * c) because the '*' operator has higher precedence. The Associates column shows how the order of similar precedence operations is determined; for example, a && b || c is evaluated as (a && b) || c because the '&&' and '||' operators are left-associative and have the same precedence. The function call syntax consists of a function name, followed by optional white space, followed by an opening parenthesis token, followed by a sequence of zero or more arguments separated by commas (with each comma optionally preceded and/or followed by zero or more white space characters), followed by a closing parenthesis token. The function name must be chosen from one of the pre-defined functions in SBML or a user-defined function in the model. The following table lists the names of certain common mathematical functions; this table corresponds to Table 6 in the SBML Level 1 Version 2 specification with additions based on the functions added in SBML Level 2 and Level 3: +----------------+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------+--------------------+ | Name | Argument(s) | Formula or meaning | Argument Constraints | Result constraints | +----------------+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------+--------------------+ | abs | x | Absolute value of x. | | | | acos, arccos | x | Arccosine of x in radians. | -1.0 <= x <= 1.0 | 0 <= acos(x) <= Pi | | acosh, arccosh | x | Hyperbolic arccosine of x in radians. | | | | acot, arccot | x | Arccotangent of x in radians. | | | | acoth, arccoth | x | Hyperbolic arccotangent of x in radians. | | | | acsc, arccsc | x | Arccosecant of x in radians. | | | | acsch, arccsch | x | Hyperbolic arccosecant of x in radians. | | | | asec, arcsec | x | Arcsecant of x in radians. | | | | asech, arcsech | x | Hyperbolic arcsecant of x in radians. | | | | asin, arcsin | x | Arcsine of x in radians. | -1.0 <= x <= 1.0 | 0 <= asin(x) <= Pi | | atan, arctan | x | Arctangent of x in radians. | | 0 <= atan(x) <= Pi | | atanh, arctanh | x | Hyperbolic arctangent of x in radians. | | | | ceil, ceiling | x | Smallest number not less than x whose value is an exact integer. | | | | cos | x | Cosine of x | | | | cosh | x | Hyperbolic cosine of x. | | | | cot | x | Cotangent of x. | | | | coth | x | Hyperbolic cotangent of x. | | | | csc | x | Cosecant of x. | | | | csch | x | Hyperbolic cosecant of x. | | | | delay | x, y | The value of x at y time units in the past. | | | | factorial | n | The factorial of n. Factorials are defined by n! = n*(n-1)* ... * 1. | n must be an integer. | | | exp | x | e^x, where e is the base of the natural logarithm. | | | | floor | x | The largest number not greater than x whose value is an exact integer. | | | | ln | x | Natural logarithm of x. | x > 0 | | | log | x | By default, the base 10 logarithm of x, but can be set to be the natural logarithm of x, or to be an illegal construct. | x > 0 | | | log | x, y | The base x logarithm of y. | y > 0 | | | log10 | x | Base 10 logarithm of x. | x > 0 | | | piecewise | x1, y1, [x2, y2,] [...] [z] | A piecewise function: if (y1), x1. Otherwise, if (y2), x2, etc. Otherwise, z. | y1, y2, y3 [etc] must be Boolean | | | pow, power | x, y | x^y. | | | | root | b, x | The root base b of x. | | | | sec | x | Secant of x. | | | | sech | x | Hyperbolic secant of x. | | | | sqr | x | x^2. | | | | sqrt | x | √x. | x > 0 | sqrt(x) >= 0 | | sin | x | Sine of x. | | | | sinh | x | Hyperbolic sine of x. | | | | tan | x | Tangent of x. | x != n*Pi/2, for odd integer n | | | tanh | x | Hyperbolic tangent of x. | | | | and | x, y, z... | Boolean and(x, y, z...): returns true if all of its arguments are true. Note that and is an n-ary function, taking 0 or more arguments, and that and() returns true. | All arguments must be Boolean | | | not | x | Boolean not(x) | x must be Boolean | | | or | x, y, z... | Boolean or(x, y, z...): returns true if at least one of its arguments is true. Note that or is an n-ary function, taking 0 or more arguments, and that or() returns false. | All arguments must be Boolean | | | xor | x, y, z... | Boolean xor(x, y, z...): returns true if an odd number of its arguments is true. Note that xor is an n-ary function, taking 0 or more arguments, and that xor() returns false. | All arguments must be Boolean | | | eq | x, y, z... | Boolean eq(x, y, z...): returns true if all arguments are equal. Note that eq is an n-ary function, but must take 2 or more arguments. | | | | geq | x, y, z... | Boolean geq(x, y, z...): returns true if each argument is greater than or equal to the argument following it. Note that geq is an n-ary function, but must take 2 or more arguments. | | | | gt | x, y, z... | Boolean gt(x, y, z...): returns true if each argument is greater than the argument following it. Note that gt is an n-ary function, but must take 2 or more arguments. | | | | leq | x, y, z... | Boolean leq(x, y, z...): returns true if each argument is less than or equal to the argument following it. Note that leq is an n-ary function, but must take 2 or more arguments. | | | | lt | x, y, z... | Boolean lt(x, y, z...): returns true if each argument is less than the argument following it. Note that lt is an n-ary function, but must take 2 or more arguments. | | | | neq | x, y | Boolean x != y: returns true unless x and y are equal. | | | | plus | x, y, z... | x + y + z + ...: The sum of the arguments of the function. Note that plus is an n-ary function taking 0 or more arguments, and that plus() returns 0. | | | | times | x, y, z... | x * y * z * ...: The product of the arguments of the function. Note that times is an n-ary function taking 0 or more arguments, and that times() returns 1. | | | | minus | x, y | x - y. | | | | divide | x, y | x / y. | | | +----------------+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------+--------------------+ Parsing of the various MathML functions and constants are all case- insensitive by default: function names such as cos, Cos and COS are all parsed as the MathML cosine operator, <cos>. However, when a Model object is used in conjunction with either parseL3FormulaWithModel() or parseL3FormulaWithSettings(), any identifiers found in that model will be parsed in a case-sensitive way. For example, if a model contains a Species having the identifier Pi, the parser will parse "Pi" in the input as "<ci> Pi </ci>" but will continue to parse the symbols "pi" and "PI" as "<pi>". As mentioned above, the manner in which the 'L3' versions of the formula parser and formatter interpret the function "log" can be changed. To do so, callers should use the function parseL3FormulaWithSettings() and pass it an appropriate L3ParserSettings object. By default, unlike the SBML Level 1 parser implemented by parseFormula(), the string "log" is interpreted as the base 10 logarithm, and not as the natural logarithm. However, you can change the interpretation to be base-10 log, natural log, or as an error; since the name 'log' by itself is ambiguous, you require that the parser uses 'log10' or 'ln' instead, which are more clear. Please refer to parseL3FormulaWithSettings(). In addition, the following symbols will be translated to their MathML equivalents, if no symbol with the same 'SId' identifier string exists in the Model object provided: +-----------------+-------------------------------------------------+--------------------------------------------------------------------------------------------------------------+ | Name | Meaning | MathML | +-----------------+-------------------------------------------------+--------------------------------------------------------------------------------------------------------------+ | true | Boolean value true | <true/> | | false | Boolean value false | <false/> | | pi | Mathematical constant pi | <pi/> | | avogadro | Value of Avogadro's constant stipulated by SBML | <csymbol encoding="text" definitionURL="http://www.sbml.org/sbml/symbols/avogadro"> avogadro </csymbol/> | | time | Simulation time as defined in SBML | <csymbol encoding="text" definitionURL="http://www.sbml.org/sbml/symbols/time"> time </csymbol/> | | inf, infinity | Mathematical constant "infinity" | <infinity/> | | nan, notanumber | Mathematical concept "not a number" | <notanumber/> | +-----------------+-------------------------------------------------+--------------------------------------------------------------------------------------------------------------+ Again, as mentioned above, whether the string "avogadro" is parsed as an AST node of type AST_NAME_AVOGADRO or AST_NAME is configurable; use the version of the parser function called parseL3FormulaWithSettings(). This Avogadro-related functionality is provided because SBML Level 2 models may not use AST_NAME_AVOGADRO AST nodes. Parameter 'formula' is the text-string formula expression to be parsed. Returns the root node of an AST representing the mathematical formula, or 'None' if an error occurred while parsing the formula. When 'None' is returned, an error is recorded internally; information about the error can be retrieved using getLastParseL3Error(). See also parseL3FormulaWithSettings(), parseL3FormulaWithModel(), parseFormula(), formulaToL3StringWithSettings(), formulaToL3String(), formulaToString(), L3ParserSettings, getDefaultL3ParserSettings(), getLastParseL3Error(). Note: We urge developers to keep in mind that the text-string formula syntax is specific to libSBML. Neither MathML nor SBML define a text- string format for mathematical formulas. LibSBML's particular syntax should not be considered to be a canonical or standard general-purpose mathematical expression syntax. LibSBML provides methods for parsing and transforming text-string math formulas back and forth from AST structures for the convenience of calling applications, but it is important to keep the system's limitations in mind. """ return _libsbml.parseL3Formula(formula) def parseL3FormulaWithModel(formula, model): """ parseL3FormulaWithModel(char const * formula, Model model) -> ASTNode Parses a text string as a mathematical formula using a Model to resolve symbols, and returns an AST representation of the result. This is identical to parseL3Formula(), except that this function uses the given model in the argument 'model' to check against identifiers that appear in the 'formula'. For more information about the parser, please see the definition of L3ParserSettings and the function parseL3Formula(). Parameter 'formula' is the mathematical formula expression to be parsed. Parameter 'model' is the Model object to use for checking identifiers. Returns the root node of an AST representing the mathematical formula, or 'None' if an error occurred while parsing the formula. When 'None' is returned, an error is recorded internally; information about the error can be retrieved using getLastParseL3Error(). See also parseL3Formula(), parseL3FormulaWithSettings(), parseL3FormulaWithModel(), parseFormula(), getLastParseL3Error(), L3ParserSettings. """ return _libsbml.parseL3FormulaWithModel(formula, model) def parseL3FormulaWithSettings(formula, settings): """ parseL3FormulaWithSettings(char const * formula, L3ParserSettings settings) -> ASTNode Parses a text string as a mathematical formula using specific parser settings and returns an AST representation of the result. This is identical to parseL3Formula(), except that this function uses the parser settings given in the argument 'settings'. The settings override the default parsing behavior. The following parsing behaviors can be configured: * A Model object may optionally be provided to use identifiers (values of type 'SId)' from the model in preference to pre-defined MathML symbols More precisely, the Model entities whose identifiers will shadow identical symbols in the mathematical formula are: Species, Compartment, Parameter, Reaction, and SpeciesReference. For instance, if the parser is given a Model containing a Species with the identifier "pi", and the formula to be parsed is "3*pi", the MathML produced by the parser will contain the construct <ci> pi </ci> instead of the construct <pi/>. Another example, if the passed-in Model contains a FunctionDefinition with the identifier "sin", that function will be used instead of the predefined MathML function <sin/>. * The function 'log' with a single argument ("log(x)") can be parsed as log10(x), ln(x), or treated as an error, as desired. * Unary minus signs can be either collapsed or preserved; that is, the parser can either (1) remove sequential pairs of unary minuses (e.g., "- -3") from the input and incorporate single unary minuses into the number node, or (2) preserve all minuses in the AST node structure, turning them into ASTNode objects of type AST_MINUS. * The character sequence "number id" can be interpreted as a numerical value 'number' followed by units of measurement indicated by 'id,' or it can be treated as a syntax error. (In Level 3, MathML <cn> elements can have an attribute named 'units' placed in the SBML namespace, which can be used to indicate the units to be associated with the number. The text-string infix formula parser allows units to be placed after raw numbers; they are interpreted as unit identifiers for units defined by the SBML specification or in the containing Model object.) * The symbol 'avogadro' can be parsed either as a MathML csymbol or as a identifier. More specifically, "avogadro" can be treated as an ASTNode of type AST_NAME_AVOGADRO or of type AST_NAME. * Strings that match built-in functions and constants can either be parsed as a match regardless of capitalization, or may be required to be all-lower-case to be considered a match. * LibSBML plug-ins implementing support for SBML Level 3 packages may introduce extensions to the syntax understood by the parser. The precise nature of the extensions will be documented by the individual package plug-ins. An example of a possible extension is a notation for vectors and arrays, introduced by the SBML Level 3 Arrays package. For more details about the parser, please see the definition of L3ParserSettings and parseL3FormulaWithSettings(). Parameter 'formula' is the mathematical formula expression to be parsed. Parameter 'settings' is the settings to be used for this parser invocation. Returns the root node of an AST representing the mathematical formula, or 'None' if an error occurred while parsing the formula. When 'None' is returned, an error is recorded internally; information about the error can be retrieved using getLastParseL3Error(). See also parseL3Formula(), parseL3FormulaWithSettings(), parseL3FormulaWithModel(), parseFormula(), getLastParseL3Error(), L3ParserSettings. """ return _libsbml.parseL3FormulaWithSettings(formula, settings) def getDefaultL3ParserSettings(): """ getDefaultL3ParserSettings() -> L3ParserSettings Returns a copy of the default Level 3 ('L3') formula parser settings. The data structure storing the settings allows callers to change the following parsing behaviors: The text-string form of mathematical formulas read by the function parseL3Formula() and written by the function formulaToL3String() uses an expanded version of the syntax read and written by parseFormula() and formulaToString(), respectively. The latter two libSBML functions were originally developed to support conversion between SBML Levels 1 and 2, and were focused on the syntax of mathematical formulas used in SBML Level 1. With time, and the use of MathML in SBML Levels 2 and 3, it became clear that supporting Level 2 and 3's expanded mathematical syntax would be useful for software developers. To maintain backwards compatibility for libSBML users, the original formulaToString() and parseFormula() have been left untouched, and instead, the new functionality is provided in the form of parseL3Formula() and formulaToL3String(). The following lists the main differences in the formula syntax supported by the Level 3 ('L3') versions of the formula parsers and formatters, compared to what is supported by the Level 1-oriented parseFormula() and formulaToString(): * Units may be asociated with bare numbers, using the following syntax: number unit The number may be in any form (an integer, real, or rational number), and the unit must conform to the syntax of an SBML identifier (technically, the type defined as 'SId' in the SBML specifications). The whitespace between number and unit is optional. * The Boolean function symbols '&&' (and), '||' (or), '!' (not), and '!=' (not equals) may be used. * The modulo operation is allowed as the symbol '%' and will produce a <piecewise> function in the corresponding MathML output by default, or can produce the MathML function 'rem,' depending on the L3ParserSettings object (see L3ParserSettings_setParseModuloL3v2() ). * All inverse trigonometric functions may be defined in the infix either using 'arc' as a prefix or simply 'a;' in other words, both 'arccsc' and 'acsc' are interpreted as the operator arccosecant as defined in MathML 2.0. (Many functions in the simpler SBML Level 1 oriented parser implemented by parseFormula() are defined this way as well, but not all.) * The following expression is parsed as a rational number instead of as a numerical division: (integer/integer) Spaces are not allowed in this construct; in other words, "(3 / 4)" (with whitespace between the numbers and the operator) will be parsed into the MathML <divide> construct rather than a rational number. You can, however, assign units to a rational number as a whole; here is an example: "(3/4) ml". (In the case of division rather than a rational number, units are not interpreted in this way.) * Various parser and formatter behaviors may be altered through the use of a L3ParserSettings object in conjunction with the functions parseL3FormulaWithSettings() and formulaToL3StringWithSettings() The settings available include the following: * The function 'log' with a single argument ("log(x)") can be parsed as log10(x), ln(x), or treated as an error, as desired. * Unary minus signs can be collapsed or preserved; that is, sequential pairs of unary minuses (e.g., "- -3") can be removed from the input entirely and single unary minuses can be incorporated into the number node, or all minuses can be preserved in the AST node structure. * Parsing of units embedded in the input string can be turned on and off. * The string 'avogadro' can be parsed as a MathML csymbol or as an identifier. * The string % can be parsed either as a piecewise function or as the 'rem' function: a % b will either become piecewise(a - b*ceil(a/b), xor((a < 0), (b < 0)), a - b*floor(a/b)) or rem(a, b). The latter is simpler, but the 'rem' MathML is only allowed as of SBML Level 3 Version 2.* A Model object may optionally be provided to the parser using the variant function call parseL3FormulaWithModel() or stored in a L3ParserSettings object passed to the variant function parseL3FormulaWithSettings(). When a Model object is provided, identifiers (values of type 'SId' ) from that model are used in preference to pre-defined MathML definitions for both symbols and functions. More precisely: * In the case of symbols: the Model entities whose identifiers will shadow identical symbols in the mathematical formula are: Species, Compartment, Parameter, Reaction, and SpeciesReference. For instance, if the parser is given a Model containing a Species with the identifier "pi", and the formula to be parsed is "3*pi", the MathML produced will contain the construct <ci> pi </ci> instead of the construct <pi/>. * In the case of user-defined functions: when a Model object is provided, 'SId' values of user-defined functions present in the model will be used preferentially over pre-defined MathML functions. For example, if the passed-in Model contains a FunctionDefinition object with the identifier "sin", that function will be used instead of the predefined MathML function <sin/>. * An SBMLNamespaces object may optionally be provided to identify SBML Level 3 packages that extend the syntax understood by the formula parser. When the namespaces are provided, the parser will interpret possible additional syntax defined by the libSBML plug-ins implementing the SBML Level 3 packages; for example, it may understand vector/array extensions introduced by the SBML Level 3 Arrays package. These configuration settings cannot be changed directly using the basic parser and formatter functions, but can be changed on a per-call basis by using the alternative functions parseL3FormulaWithSettings() and formulaToL3StringWithSettings(). Neither SBML nor the MathML standard define a 'string-form' equivalent to MathML expressions. The approach taken by libSBML is to start with the formula syntax defined by SBML Level 1 (which in fact used a custom text-string representation of formulas, and not MathML), and expand it to include the functionality described above. This formula syntax is based mostly on C programming syntax, and may contain operators, function calls, symbols, and white space characters. The following table provides the precedence rules for the different entities that may appear in formula strings. +----------------------+--------------------------+---------+---------+--------+ | Token | Operation | Class | Preced. | Assoc. | +----------------------+--------------------------+---------+---------+--------+ | name | symbol reference | operand | 8 | n/a | | (expression) | expression grouping | operand | 8 | n/a | | f(...) | function call | prefix | 8 | left | | ^ | power | binary | 7 | left | | -, ! | negation, Boolean 'not' | unary | 6 | right | | *, /, % | multip., div., modulo | binary | 5 | left | | +, - | addition and subtraction | binary | 4 | left | | ==, <, >, <=, >=, != | Boolean comparisons | binary | 3 | left | | &&, || | Boolean 'and' and 'or' | binary | 2 | left | | , | argument delimiter | binary | 1 | left | +----------------------+--------------------------+---------+---------+--------+ In the table above, operand implies the construct is an operand, prefix implies the operation is applied to the following arguments, unary implies there is one argument, and binary implies there are two arguments. The values in the Precedence column show how the order of different types of operation are determined. For example, the expression a + b * c is evaluated as a + (b * c) because the '*' operator has higher precedence. The Associates column shows how the order of similar precedence operations is determined; for example, a && b || c is evaluated as (a && b) || c because the '&&' and '||' operators are left-associative and have the same precedence. The function call syntax consists of a function name, followed by optional white space, followed by an opening parenthesis token, followed by a sequence of zero or more arguments separated by commas (with each comma optionally preceded and/or followed by zero or more white space characters), followed by a closing parenthesis token. The function name must be chosen from one of the pre-defined functions in SBML or a user-defined function in the model. The following table lists the names of certain common mathematical functions; this table corresponds to Table 6 in the SBML Level 1 Version 2 specification with additions based on the functions added in SBML Level 2 and Level 3: +----------------+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------+--------------------+ | Name | Argument(s) | Formula or meaning | Argument Constraints | Result constraints | +----------------+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------+--------------------+ | abs | x | Absolute value of x. | | | | acos, arccos | x | Arccosine of x in radians. | -1.0 <= x <= 1.0 | 0 <= acos(x) <= Pi | | acosh, arccosh | x | Hyperbolic arccosine of x in radians. | | | | acot, arccot | x | Arccotangent of x in radians. | | | | acoth, arccoth | x | Hyperbolic arccotangent of x in radians. | | | | acsc, arccsc | x | Arccosecant of x in radians. | | | | acsch, arccsch | x | Hyperbolic arccosecant of x in radians. | | | | asec, arcsec | x | Arcsecant of x in radians. | | | | asech, arcsech | x | Hyperbolic arcsecant of x in radians. | | | | asin, arcsin | x | Arcsine of x in radians. | -1.0 <= x <= 1.0 | 0 <= asin(x) <= Pi | | atan, arctan | x | Arctangent of x in radians. | | 0 <= atan(x) <= Pi | | atanh, arctanh | x | Hyperbolic arctangent of x in radians. | | | | ceil, ceiling | x | Smallest number not less than x whose value is an exact integer. | | | | cos | x | Cosine of x | | | | cosh | x | Hyperbolic cosine of x. | | | | cot | x | Cotangent of x. | | | | coth | x | Hyperbolic cotangent of x. | | | | csc | x | Cosecant of x. | | | | csch | x | Hyperbolic cosecant of x. | | | | delay | x, y | The value of x at y time units in the past. | | | | factorial | n | The factorial of n. Factorials are defined by n! = n*(n-1)* ... * 1. | n must be an integer. | | | exp | x | e^x, where e is the base of the natural logarithm. | | | | floor | x | The largest number not greater than x whose value is an exact integer. | | | | ln | x | Natural logarithm of x. | x > 0 | | | log | x | By default, the base 10 logarithm of x, but can be set to be the natural logarithm of x, or to be an illegal construct. | x > 0 | | | log | x, y | The base x logarithm of y. | y > 0 | | | log10 | x | Base 10 logarithm of x. | x > 0 | | | piecewise | x1, y1, [x2, y2,] [...] [z] | A piecewise function: if (y1), x1. Otherwise, if (y2), x2, etc. Otherwise, z. | y1, y2, y3 [etc] must be Boolean | | | pow, power | x, y | x^y. | | | | root | b, x | The root base b of x. | | | | sec | x | Secant of x. | | | | sech | x | Hyperbolic secant of x. | | | | sqr | x | x^2. | | | | sqrt | x | √x. | x > 0 | sqrt(x) >= 0 | | sin | x | Sine of x. | | | | sinh | x | Hyperbolic sine of x. | | | | tan | x | Tangent of x. | x != n*Pi/2, for odd integer n | | | tanh | x | Hyperbolic tangent of x. | | | | and | x, y, z... | Boolean and(x, y, z...): returns true if all of its arguments are true. Note that and is an n-ary function, taking 0 or more arguments, and that and() returns true. | All arguments must be Boolean | | | not | x | Boolean not(x) | x must be Boolean | | | or | x, y, z... | Boolean or(x, y, z...): returns true if at least one of its arguments is true. Note that or is an n-ary function, taking 0 or more arguments, and that or() returns false. | All arguments must be Boolean | | | xor | x, y, z... | Boolean xor(x, y, z...): returns true if an odd number of its arguments is true. Note that xor is an n-ary function, taking 0 or more arguments, and that xor() returns false. | All arguments must be Boolean | | | eq | x, y, z... | Boolean eq(x, y, z...): returns true if all arguments are equal. Note that eq is an n-ary function, but must take 2 or more arguments. | | | | geq | x, y, z... | Boolean geq(x, y, z...): returns true if each argument is greater than or equal to the argument following it. Note that geq is an n-ary function, but must take 2 or more arguments. | | | | gt | x, y, z... | Boolean gt(x, y, z...): returns true if each argument is greater than the argument following it. Note that gt is an n-ary function, but must take 2 or more arguments. | | | | leq | x, y, z... | Boolean leq(x, y, z...): returns true if each argument is less than or equal to the argument following it. Note that leq is an n-ary function, but must take 2 or more arguments. | | | | lt | x, y, z... | Boolean lt(x, y, z...): returns true if each argument is less than the argument following it. Note that lt is an n-ary function, but must take 2 or more arguments. | | | | neq | x, y | Boolean x != y: returns true unless x and y are equal. | | | | plus | x, y, z... | x + y + z + ...: The sum of the arguments of the function. Note that plus is an n-ary function taking 0 or more arguments, and that plus() returns 0. | | | | times | x, y, z... | x * y * z * ...: The product of the arguments of the function. Note that times is an n-ary function taking 0 or more arguments, and that times() returns 1. | | | | minus | x, y | x - y. | | | | divide | x, y | x / y. | | | +----------------+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------+--------------------+ Parsing of the various MathML functions and constants are all case- insensitive by default: function names such as cos, Cos and COS are all parsed as the MathML cosine operator, <cos>. However, when a Model object is used in conjunction with either parseL3FormulaWithModel() or parseL3FormulaWithSettings(), any identifiers found in that model will be parsed in a case-sensitive way. For example, if a model contains a Species having the identifier Pi, the parser will parse "Pi" in the input as "<ci> Pi </ci>" but will continue to parse the symbols "pi" and "PI" as "<pi>". As mentioned above, the manner in which the 'L3' versions of the formula parser and formatter interpret the function "log" can be changed. To do so, callers should use the function parseL3FormulaWithSettings() and pass it an appropriate L3ParserSettings object. By default, unlike the SBML Level 1 parser implemented by parseFormula(), the string "log" is interpreted as the base 10 logarithm, and not as the natural logarithm. However, you can change the interpretation to be base-10 log, natural log, or as an error; since the name 'log' by itself is ambiguous, you require that the parser uses 'log10' or 'ln' instead, which are more clear. Please refer to parseL3FormulaWithSettings(). In addition, the following symbols will be translated to their MathML equivalents, if no symbol with the same 'SId' identifier string exists in the Model object provided: +-----------------+-------------------------------------------------+--------------------------------------------------------------------------------------------------------------+ | Name | Meaning | MathML | +-----------------+-------------------------------------------------+--------------------------------------------------------------------------------------------------------------+ | true | Boolean value true | <true/> | | false | Boolean value false | <false/> | | pi | Mathematical constant pi | <pi/> | | avogadro | Value of Avogadro's constant stipulated by SBML | <csymbol encoding="text" definitionURL="http://www.sbml.org/sbml/symbols/avogadro"> avogadro </csymbol/> | | time | Simulation time as defined in SBML | <csymbol encoding="text" definitionURL="http://www.sbml.org/sbml/symbols/time"> time </csymbol/> | | inf, infinity | Mathematical constant "infinity" | <infinity/> | | nan, notanumber | Mathematical concept "not a number" | <notanumber/> | +-----------------+-------------------------------------------------+--------------------------------------------------------------------------------------------------------------+ Again, as mentioned above, whether the string "avogadro" is parsed as an AST node of type AST_NAME_AVOGADRO or AST_NAME is configurable; use the version of the parser function called parseL3FormulaWithSettings(). This Avogadro-related functionality is provided because SBML Level 2 models may not use AST_NAME_AVOGADRO AST nodes. For more details about the parser, please see the definition of L3ParserSettings and parseL3Formula(). See also parseL3Formula(), parseL3FormulaWithSettings(), formulaToL3StringWithSettings(), L3ParserSettings. """ return _libsbml.getDefaultL3ParserSettings() def getLastParseL3Error(): """ getLastParseL3Error() -> char * Returns the last error reported by the 'L3' mathematical formula parser. If the functions parseL3Formula(), parseL3FormulaWithSettings(), or parseL3FormulaWithModel() return 'None,' an error is set internally. This function allows callers to retrieve information about the error. Returns a string describing the error that occurred. This will contain the input string the parser was trying to parse, the character it had parsed when it encountered the error, and a description of the error. See also parseL3Formula(), parseL3FormulaWithSettings(), parseL3FormulaWithModel(), getDefaultL3ParserSettings(). """ return _libsbml.getLastParseL3Error() def SBML_deleteL3Parser(): """ SBML_deleteL3Parser() Internal implementation method. """ return _libsbml.SBML_deleteL3Parser() L3P_PARSE_LOG_AS_LOG10 = _libsbml.L3P_PARSE_LOG_AS_LOG10 L3P_PARSE_LOG_AS_LN = _libsbml.L3P_PARSE_LOG_AS_LN L3P_PARSE_LOG_AS_ERROR = _libsbml.L3P_PARSE_LOG_AS_ERROR L3P_COLLAPSE_UNARY_MINUS = _libsbml.L3P_COLLAPSE_UNARY_MINUS L3P_EXPAND_UNARY_MINUS = _libsbml.L3P_EXPAND_UNARY_MINUS L3P_PARSE_UNITS = _libsbml.L3P_PARSE_UNITS L3P_NO_UNITS = _libsbml.L3P_NO_UNITS L3P_AVOGADRO_IS_CSYMBOL = _libsbml.L3P_AVOGADRO_IS_CSYMBOL L3P_AVOGADRO_IS_NAME = _libsbml.L3P_AVOGADRO_IS_NAME L3P_COMPARE_BUILTINS_CASE_INSENSITIVE = _libsbml.L3P_COMPARE_BUILTINS_CASE_INSENSITIVE L3P_COMPARE_BUILTINS_CASE_SENSITIVE = _libsbml.L3P_COMPARE_BUILTINS_CASE_SENSITIVE L3P_MODULO_IS_REM = _libsbml.L3P_MODULO_IS_REM L3P_MODULO_IS_PIECEWISE = _libsbml.L3P_MODULO_IS_PIECEWISE L3P_PARSE_L3V2_FUNCTIONS_DIRECTLY = _libsbml.L3P_PARSE_L3V2_FUNCTIONS_DIRECTLY L3P_PARSE_L3V2_FUNCTIONS_AS_GENERIC = _libsbml.L3P_PARSE_L3V2_FUNCTIONS_AS_GENERIC L3P_PARSE_PACKAGE_MATH_DIRECTLY = _libsbml.L3P_PARSE_PACKAGE_MATH_DIRECTLY L3P_PARSE_PACKAGE_MATH_AS_GENERIC = _libsbml.L3P_PARSE_PACKAGE_MATH_AS_GENERIC INFIX_SYNTAX_NAMED_SQUARE_BRACKETS = _libsbml.INFIX_SYNTAX_NAMED_SQUARE_BRACKETS INFIX_SYNTAX_CURLY_BRACES = _libsbml.INFIX_SYNTAX_CURLY_BRACES INFIX_SYNTAX_CURLY_BRACES_SEMICOLON = _libsbml.INFIX_SYNTAX_CURLY_BRACES_SEMICOLON class L3ParserSettings(_object): """ Controls the behavior of the Level 3 formula parser. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. The function parseL3FormulaWithSettings(), along with its variants parseL3Formula() and parseL3FormulaWithModel(), are the interfaces to a parser for mathematical formulas written as text strings. The inverse function is formulaToL3String() and its variants such as formulaToL3StringWithSettings(). The parsers and the formula writers convert between a text-string representation of mathematical formulas and Abstract Syntax Trees (ASTs), represented in libSBML using ASTNode objects. Compared to the parser and writer implemented by the functions parseFormula() and formulaToString(), which were designed primarily for converting the mathematical formula strings in SBML Level 1, the SBML Level 3 or 'L3' variants of the parser and writer use an extended formula syntax. They also have a number of configurable behaviors. This class (L3ParserSettings) is an object used to communicate the configuration settings with callers. The following aspects of the parser are configurable using L3ParserSettings objects. (For the formula writer, only a subset of these settings is relevant; please see the documentation for formulaToL3StringWithSettings() for more information about which ones). * A Model object may optionally be provided to use identifiers (values of type 'SId)' from the model in preference to pre-defined MathML symbols More precisely, the Model entities whose identifiers will shadow identical symbols in the mathematical formula are: Species, Compartment, Parameter, Reaction, and SpeciesReference. For instance, if the parser is given a Model containing a Species with the identifier "pi", and the formula to be parsed is "3*pi", the MathML produced by the parser will contain the construct <ci> pi </ci> instead of the construct <pi/>. Another example, if the passed-in Model contains a FunctionDefinition with the identifier "sin", that function will be used instead of the predefined MathML function <sin/>. * The function 'log' with a single argument ("log(x)") can be parsed as log10(x), ln(x), or treated as an error, as desired. * Unary minus signs can be either collapsed or preserved; that is, the parser can either (1) remove sequential pairs of unary minuses (e.g., "- -3") from the input and incorporate single unary minuses into the number node, or (2) preserve all minuses in the AST node structure, turning them into ASTNode objects of type AST_MINUS. * The character sequence "number id" can be interpreted as a numerical value 'number' followed by units of measurement indicated by 'id,' or it can be treated as a syntax error. (In Level 3, MathML <cn> elements can have an attribute named 'units' placed in the SBML namespace, which can be used to indicate the units to be associated with the number. The text-string infix formula parser allows units to be placed after raw numbers; they are interpreted as unit identifiers for units defined by the SBML specification or in the containing Model object.) * The symbol 'avogadro' can be parsed either as a MathML csymbol or as a identifier. More specifically, "avogadro" can be treated as an ASTNode of type AST_NAME_AVOGADRO or of type AST_NAME. * Strings that match built-in functions and constants can either be parsed as a match regardless of capitalization, or may be required to be all-lower-case to be considered a match. * LibSBML plug-ins implementing support for SBML Level 3 packages may introduce extensions to the syntax understood by the parser. The precise nature of the extensions will be documented by the individual package plug-ins. An example of a possible extension is a notation for vectors and arrays, introduced by the SBML Level 3 Arrays package. To obtain the default configuration values, callers can use the function getDefaultL3ParserSettings(). To change the configuration, callers can create an L3ParserSettings object, set the desired characteristics using the methods provided, and pass that object to parseL3FormulaWithSettings(). See also parseL3Formula(), parseL3FormulaWithSettings(), parseL3FormulaWithModel(), parseFormula(), formulaToL3StringWithSettings(), formulaToL3String(), formulaToString(), getDefaultL3ParserSettings(). """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, L3ParserSettings, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, L3ParserSettings, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(L3ParserSettings self) -> L3ParserSettings __init__(L3ParserSettings self, Model model, ParseLogType_t parselog, bool collapseminus, bool parseunits, bool avocsymbol, bool caseSensitive=False, SBMLNamespaces sbmlns=None, bool moduloL3v2=False, bool l3v2functions=False) -> L3ParserSettings __init__(L3ParserSettings self, Model model, ParseLogType_t parselog, bool collapseminus, bool parseunits, bool avocsymbol, bool caseSensitive=False, SBMLNamespaces sbmlns=None, bool moduloL3v2=False) -> L3ParserSettings __init__(L3ParserSettings self, Model model, ParseLogType_t parselog, bool collapseminus, bool parseunits, bool avocsymbol, bool caseSensitive=False, SBMLNamespaces sbmlns=None) -> L3ParserSettings __init__(L3ParserSettings self, Model model, ParseLogType_t parselog, bool collapseminus, bool parseunits, bool avocsymbol, bool caseSensitive=False) -> L3ParserSettings __init__(L3ParserSettings self, Model model, ParseLogType_t parselog, bool collapseminus, bool parseunits, bool avocsymbol) -> L3ParserSettings __init__(L3ParserSettings self, L3ParserSettings source) -> L3ParserSettings This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: L3ParserSettings() Creates a new L3ParserSettings object with default values. This is the default constructor for the L3ParserSettings object. It sets the stored Model object to 'None' and sets the following field values in the L3ParserSettings object: * parseunits ('parse units') is set to L3P_PARSE_UNITS. * collapseminus ('collapse minus') is set to L3P_EXPAND_UNARY_MINUS. * parselog ('parse log') is set to L3P_PARSE_LOG_AS_LOG10. * avocsymbol ('Avogadro csymbol') is set to L3P_AVOGADRO_IS_CSYMBOL. * caseSensitive ('case sensitive') is set to L3P_COMPARE_BUILTINS_CASE_INSENSITIVE. * moduloL3v2 ('modulo l3v2') is set to L3P_MODULO_IS_PIECEWISE. * sbmlns ('SBML namespaces') is set to 'None' (which indicates that no syntax extensions due to SBML Level 3 packages will be assumed ---the formula parser will only understand the core syntax described in the documentation for parseL3Formula()). ______________________________________________________________________ Method variant with the following signature: L3ParserSettings(L3ParserSettings source) Copy constructor. Parameter 'source' is the instance to copy. ______________________________________________________________________ Method variant with the following signature: L3ParserSettings(Model model, ParseLogType_t parselog, bool collapseminus, bool parseunits, bool avocsymbol, bool caseSensitive = false, SBMLNamespaces sbmlns = None, bool moduloL3v2 = false, bool l3v2functions = false) Creates a new L3ParserSettings object with specific values for all possible settings. Parameter 'model' is a Model object to be used for disambiguating identifiers encountered by parseL3FormulaWithSettings() in mathematical formulas. Parameter 'parselog' is ('parse log') a flag that controls how the parser will handle the symbol 'log' in mathematical formulas. The function 'log' with a single argument ("log(x)") can be parsed as log10(x), ln(x), or treated as an error, as desired, by using the parameter values L3P_PARSE_LOG_AS_LOG10, L3P_PARSE_LOG_AS_LN, or L3P_PARSE_LOG_AS_ERROR, respectively. Parameter 'collapseminus' is ('collapse minus') a flag that controls how the parser will handle minus signs in formulas. Unary minus signs can be collapsed or preserved; that is, sequential pairs of unary minuses (e.g., "- -3") can be removed from the input entirely and single unary minuses can be incorporated into the number node, or all minuses can be preserved in the AST node structure. The possible values of this field are L3P_COLLAPSE_UNARY_MINUS (to collapse unary minuses) and L3P_EXPAND_UNARY_MINUS (to expand unary minuses). Parameter 'parseunits' is ('parse units') a flag that controls how the parser will handle apparent references to units of measurement associated with raw numbers in a formula. If set to the value L3P_PARSE_UNITS, units are parsed; if set to the value L3P_NO_UNITS, units are not parsed. Parameter 'avocsymbol' is ('Avogadro csymbol') a flag that controls how the parser will handle the appearance of the symbol 'avogadro' in a formula. If set to the value L3P_AVOGADRO_IS_CSYMBOL, the symbol is interpreted as the SBML/MathML csymbol 'avogadro;' if set to the value L3P_AVOGADRO_IS_NAME, the symbol is interpreted as a plain symbol name. Parameter 'caseSensitive' is ('case sensitive') a flag that controls how the cases of alphabetical characters are treated when symbols are compared. If the flag is set to the value L3P_COMPARE_BUILTINS_CASE_INSENSITIVE, symbols are compared in a case- insensitive manner, which means that mathematical functions such as ''sin'' will be matched no matter what their case is: ''Sin',' ''SIN',' etc. If the flag is set to the value L3P_COMPARE_BUILTINS_CASE_SENSITIVE, symbols are interpreted in a case-sensitive manner. Parameter 'modulol3v2' is ('modulo l3v2') a flag that controls how the parser will handle the '%' ('modulo') symbol in formulas. By default, the parser will convert 'a % b' to a piecewise function that properly calculates the remainder of a with respect to be, but the parser can also be set to produce the MathML 'rem' function, should the target of the produced ASTNode be an SBML Level 3 Version 2 document, where the 'rem' function is legal. The possible values of this field are L3P_MODULO_IS_PIECEWISE (to parse '%' as a piecewise function) and L3P_MODULO_IS_REM (to parse '%' as 'rem).' Parameter 'sbmlns' is ('SBML namespaces') an SBML namespaces object. The namespaces identify the SBML Level 3 packages that can extend the syntax understood by the formula parser. When non-'None,' the parser will interpret additional syntax defined by the packages; for example, it may understand vector/array extensions introduced by the SBML Level 3 Arrays package. </dl><dl class="docnote"><dt>Documentation note:</dt><dd> The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation. </dd></dl> See also getModel(), setModel(), unsetModel(), getParseLog(), setParseLog(), getParseUnits(), setParseUnits(), getParseCollapseMinus(), setParseCollapseMinus(), getParseAvogadroCsymbol(), setParseAvogadroCsymbol(), getParseModuloL3v2(), setParseModuloL3v2(), getParseL3v2Functions(), setParseL3v2Functions(). Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ this = _libsbml.new_L3ParserSettings(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_L3ParserSettings __del__ = lambda self: None def setModel(self, model): """ setModel(L3ParserSettings self, Model model) Sets the model reference in this L3ParserSettings object. When a Model object is provided, identifiers (values of type 'SId)' from that model are used in preference to pre-defined MathML symbol definitions. More precisely, the Model entities whose identifiers will shadow identical symbols in the mathematical formula are: Species, Compartment, Parameter, Reaction, and SpeciesReference. For instance, if the parser is given a Model containing a Species with the identifier "pi", and the formula to be parsed is "3*pi", the MathML produced will contain the construct <ci> pi </ci> instead of the construct <pi/>. Similarly, when a Model object is provided, 'SId' values of user-defined functions present in the Model will be used preferentially over pre-defined MathML functions. For example, if the passed-in Model contains a FunctionDefinition with the identifier "sin", that function will be used instead of the predefined MathML function <sin/>. Parameter 'model' is a Model object to be used for disambiguating identifiers. WARNING: This does not copy the Model object. This means that modifications made to the Model after invoking this method may affect parsing behavior, because the parser will query the current contents of the model. See also getModel(), unsetModel(). """ return _libsbml.L3ParserSettings_setModel(self, model) def getModel(self): """ getModel(L3ParserSettings self) -> Model Returns the Model object referenced by this L3ParserSettings object. When a Model object is provided, identifiers (values of type 'SId)' from that model are used in preference to pre-defined MathML symbol definitions. More precisely, the Model entities whose identifiers will shadow identical symbols in the mathematical formula are: Species, Compartment, Parameter, Reaction, and SpeciesReference. For instance, if the parser is given a Model containing a Species with the identifier "pi", and the formula to be parsed is "3*pi", the MathML produced will contain the construct <ci> pi </ci> instead of the construct <pi/>. Similarly, when a Model object is provided, 'SId' values of user-defined functions present in the Model will be used preferentially over pre-defined MathML functions. For example, if the passed-in Model contains a FunctionDefinition with the identifier "sin", that function will be used instead of the predefined MathML function <sin/>. See also setModel(), unsetModel(). """ return _libsbml.L3ParserSettings_getModel(self) def unsetModel(self): """ unsetModel(L3ParserSettings self) Unsets the Model reference in this L3ParserSettings object. The effect of calling this method is to set the stored model value to 'None.' See also setModel(), getModel(). """ return _libsbml.L3ParserSettings_unsetModel(self) def setParseLog(self, type): """ setParseLog(L3ParserSettings self, ParseLogType_t type) Sets the behavior for handling 'log' in mathematical formulas. The function 'log' with a single argument ("log(x)") can be parsed as log10(x), ln(x), or treated as an error. These three behaviors are set, respectively, by using the value L3P_PARSE_LOG_AS_LOG10, L3P_PARSE_LOG_AS_LN, or L3P_PARSE_LOG_AS_ERROR for the 'type' parameter. Parameter 'type' is a constant, one of following three possibilities: * L3P_PARSE_LOG_AS_LOG10 * L3P_PARSE_LOG_AS_LN * L3P_PARSE_LOG_AS_ERROR See also getParseLog(). """ return _libsbml.L3ParserSettings_setParseLog(self, type) def getParseLog(self): """ getParseLog(L3ParserSettings self) -> ParseLogType_t Indicates the current behavior set for handling the function 'log' with one argument. The function 'log' with a single argument ("log(x)") can be parsed as log10(x), ln(x), or treated as an error, as desired. These three possible behaviors are indicated, respectively, by the values L3P_PARSE_LOG_AS_LOG10, L3P_PARSE_LOG_AS_LN, and L3P_PARSE_LOG_AS_ERROR. Returns One of following three constants: * L3P_PARSE_LOG_AS_LOG10 * L3P_PARSE_LOG_AS_LN * L3P_PARSE_LOG_AS_ERROR See also setParseLog(). """ return _libsbml.L3ParserSettings_getParseLog(self) def setParseCollapseMinus(self, collapseminus): """ setParseCollapseMinus(L3ParserSettings self, bool collapseminus) Sets the behavior for handling unary minuses appearing in mathematical formulas. This setting affects two behaviors. First, pairs of multiple unary minuses in a row (e.g., "- -3") can be collapsed and ignored in the input, or the multiple minuses can be preserved in the AST node tree that is generated by the parser. Second, minus signs in front of numbers can be collapsed into the number node itself; for example, a "- 4.1" can be turned into a single ASTNode of type AST_REAL with a value of -4.1, or it can be turned into a node of type AST_MINUS having a child node of type AST_REAL. This method lets you tell the parser which behavior to use---either collapse minuses or always preserve them. The two possibilities are represented using the following constants: * L3P_COLLAPSE_UNARY_MINUS (value = 'True):' collapse unary minuses where possible. * L3P_EXPAND_UNARY_MINUS (value = 'False):' do not collapse unary minuses, and instead translate each one into an AST node of type AST_MINUS. Parameter 'collapseminus' is a boolean value (one of the constants L3P_COLLAPSE_UNARY_MINUS or L3P_EXPAND_UNARY_MINUS) indicating how unary minus signs in the input should be handled. See also getParseCollapseMinus(). """ return _libsbml.L3ParserSettings_setParseCollapseMinus(self, collapseminus) def getParseCollapseMinus(self): """ getParseCollapseMinus(L3ParserSettings self) -> bool Indicates the current behavior set for handling multiple unary minuses in formulas. This setting affects two behaviors. First, pairs of multiple unary minuses in a row (e.g., "- -3") can be collapsed and ignored in the input, or the multiple minuses can be preserved in the AST node tree that is generated by the parser. Second, minus signs in front of numbers can be collapsed into the number node itself; for example, a "- 4.1" can be turned into a single ASTNode of type AST_REAL with a value of -4.1, or it can be turned into a node of type AST_MINUS having a child node of type AST_REAL. Returns A boolean indicating the behavior currently set. The possible values are as follows: * L3P_COLLAPSE_UNARY_MINUS (value = 'True):' collapse unary minuses where possible. * L3P_EXPAND_UNARY_MINUS (value = 'False):' do not collapse unary minuses, and instead translate each one into an AST node of type AST_MINUS. See also setParseCollapseMinus(). """ return _libsbml.L3ParserSettings_getParseCollapseMinus(self) def setParseUnits(self, units): """ setParseUnits(L3ParserSettings self, bool units) Sets the parser's behavior in handling units associated with numbers in a mathematical formula. In SBML Level 2, there is no means of associating a unit of measurement with a pure number in a formula, while SBML Level 3 does define a syntax for this. In Level 3, MathML <cn> elements can have an attribute named 'units' placed in the SBML namespace, which can be used to indicate the units to be associated with the number. The text-string infix formula parser allows units to be placed after raw numbers; they are interpreted as unit identifiers for units defined by the SBML specification or in the containing Model object. Some examples include: "4 mL", "2.01 Hz", "3.1e-6 M", and "(5/8) inches". To produce a valid SBML model, there must either exist a UnitDefinition corresponding to the identifier of the unit, or the unit must be defined in Table 2 of the SBML Level 3 specification. This method sets the formula parser's behavior with respect to units. Parameter 'units' is a boolean indicating whether to parse units. The possible values are as follows: * L3P_PARSE_UNITS (value = 'True):' parse units in the text-string formula. * L3P_NO_UNITS (value = 'False):' treat units in the text-string formula as errors. See also getParseUnits(). """ return _libsbml.L3ParserSettings_setParseUnits(self, units) def getParseUnits(self): """ getParseUnits(L3ParserSettings self) -> bool Indicates the current behavior set for handling units in text-string mathematical formulas. In SBML Level 2, there is no means of associating a unit of measurement with a pure number in a formula, while SBML Level 3 does define a syntax for this. In Level 3, MathML <cn> elements can have an attribute named 'units' placed in the SBML namespace, which can be used to indicate the units to be associated with the number. The text-string infix formula parser allows units to be placed after raw numbers; they are interpreted as unit identifiers for units defined by the SBML specification or in the containing Model object. Some examples include: "4 mL", "2.01 Hz", "3.1e-6 M", and "(5/8) inches". To produce a valid SBML model, there must either exist a UnitDefinition corresponding to the identifier of the unit, or the unit must be defined in Table 2 of the SBML Level 3 specification. Since SBML Level 2 does not have the ability to associate units with pure numbers, the value should be expected to be 'False' (L3P_NO_UNITS) when parsing text-string formulas intended for use in SBML Level 2 documents. Returns A boolean indicating whether to parse units. The possible values are as follows: * L3P_PARSE_UNITS (value = 'True):' parse units in the text-string formula. * L3P_NO_UNITS (value = 'False):' treat units in the text-string formula as errors. See also setParseUnits(). """ return _libsbml.L3ParserSettings_getParseUnits(self) def setParseAvogadroCsymbol(self, l2only): """ setParseAvogadroCsymbol(L3ParserSettings self, bool l2only) Sets the parser's behavior in handling the symbol 'avogadro' in mathematical formulas. SBML Level 3 defines a symbol for representing the value of Avogadro's constant, but it is not defined in SBML Level 2. As a result, the text-string formula parser must behave differently depending on which SBML Level is being targeted. For Level 3 documents, it can interpret instances of 'avogadro' in the input as a reference to the MathML csymbol for Avogadro's constant defined in the SBML Level 3 specification. For Level 2, it must treat 'avogadro' as just another plain symbol. This method allows callers to set the avogadro-handling behavior in this L3ParserSettings object. The possible values of 'l2only' are as follows: * L3P_AVOGADRO_IS_CSYMBOL (value = 'True):' tells the parser to translate the string 'avogadro' (in any capitalization) into an AST node of type AST_NAME_AVOGADRO. * L3P_AVOGADRO_IS_NAME (value = 'False):' tells the parser to translate the string 'avogadro' into an AST of type AST_NAME. Since SBML Level 2 does not define a symbol for Avogadro's constant, the value should be set to L3P_AVOGADRO_IS_NAME when parsing text-string formulas intended for use in SBML Level 2 documents. Parameter 'l2only' is a boolean value indicating how the string 'avogadro' should be treated when encountered in a formula. This will be one of the values L3P_AVOGADRO_IS_CSYMBOL or L3P_AVOGADRO_IS_NAME. See also getParseAvogadroCsymbol(). """ return _libsbml.L3ParserSettings_setParseAvogadroCsymbol(self, l2only) def getParseAvogadroCsymbol(self): """ getParseAvogadroCsymbol(L3ParserSettings self) -> bool Indicates the current behavior set for handling 'avogadro' for SBML Level 3. SBML Level 3 defines a symbol for representing the value of Avogadro's constant, but it is not defined in SBML Level 2. As a result, the text-string formula parser must behave differently depending on which SBML Level is being targeted. For Level 3 documents, it can interpret instances of 'avogadro' in the input as a reference to the MathML csymbol for Avogadro's constant defined in the SBML Level 3 specification. For Level 2, it must treat 'avogadro' as just another plain symbol. This method returns the current setting of the avogadro-handling behavior in this L3ParserSettings object. The possible values are as follows: * L3P_AVOGADRO_IS_CSYMBOL (value = 'True):' tells the parser to translate the string 'avogadro' (in any capitalization) into an AST node of type AST_NAME_AVOGADRO. * L3P_AVOGADRO_IS_NAME (value = 'False):' tells the parser to translate the string 'avogadro' into an AST of type AST_NAME. Returns A boolean indicating which mode is currently set; one of L3P_AVOGADRO_IS_CSYMBOL or L3P_AVOGADRO_IS_NAME. See also setParseAvogadroCsymbol(). """ return _libsbml.L3ParserSettings_getParseAvogadroCsymbol(self) def setComparisonCaseSensitivity(self, strcmp): """ setComparisonCaseSensitivity(L3ParserSettings self, bool strcmp) Sets the parser's behavior with respect to case sensitivity for recognizing predefined symbols. By default (which is the value L3P_COMPARE_BUILTINS_CASE_INSENSITIVE), the parser compares symbols in a case insensitive manner for built-in functions such as ''sin'' and ''piecewise',' and for constants such as ''True'' and ''avogadro'.' Setting this option to L3P_COMPARE_BUILTINS_CASE_SENSITIVE causes the parser to become case sensitive. In that mode, for example, the symbols ''sin'' and ''True'' will match the built-in values, but the symbols ''SIN',' ''Sin',' ''True',' ''TRUE',' and so on, will not. Parameter 'strcmp' is a boolean indicating whether to be case sensitive (if 'True)' or be case insensitive (if 'False).' See also getComparisonCaseSensitivity(). """ return _libsbml.L3ParserSettings_setComparisonCaseSensitivity(self, strcmp) def getComparisonCaseSensitivity(self): """ getComparisonCaseSensitivity(L3ParserSettings self) -> bool Returns 'True' if the parser is configured to match built-in symbols in a case-insensitive way. By default (which is the value L3P_COMPARE_BUILTINS_CASE_INSENSITIVE), the parser compares symbols in a case insensitive manner for built-in functions such as ''sin'' and ''piecewise',' and for constants such as ''True'' and ''avogadro'.' Setting this option to L3P_COMPARE_BUILTINS_CASE_SENSITIVE causes the parser to become case sensitive. In that mode, for example, the symbols ''sin'' and ''True'' will match the built-in values, but the symbols ''SIN',' ''Sin',' ''True',' ''TRUE',' and so on, will not. Returns 'True' if matches are done in a case-sensitive manner, and 'False' if the parser will recognize built-in functions and constants regardless of case,. See also setComparisonCaseSensitivity(). """ return _libsbml.L3ParserSettings_getComparisonCaseSensitivity(self) def setParseModuloL3v2(self, modulol3v2): """ setParseModuloL3v2(L3ParserSettings self, bool modulol3v2) Sets the behavior for handling the '%' sumbol in mathematical formulas. This setting affects whether the '%' symbol (modulo) is parsed as a piecewise equation that returns the modulo value of the entries on either side of the symbol, or whether it is parsed as the MathML 'rem' function, which was allowed in SBML Level 3 Version 2, but not in previous level/versions. The latter is more succinct, but might not be legal SBML for the desired target SBML document. This method lets you tell the parser which behavior to use---either parse '%' as the 'rem' function or as a piecewise function with the same interpretation. The two possibilities are represented using the following constants: * L3P_MODULO_IS_REM (value = 'True):' use the 'rem' MathML function (AST_FUNCTION_REM). * L3P_MODULO_IS_PIECEWISE (value = 'False):' use a piecewise function (AST_FUNCTION_PIECEWISE) to encode the modulo rule explicitly. Parameter 'modulol3v2' is a boolean value (one of the constants L3P_MODULO_IS_PIECEWISE or L3P_MODULO_IS_REM) indicating how the '%' symbol in the input should be handled. See also getParseModuloL3v2(). """ return _libsbml.L3ParserSettings_setParseModuloL3v2(self, modulol3v2) def getParseModuloL3v2(self): """ getParseModuloL3v2(L3ParserSettings self) -> bool Indicates the current behavior set for handling the '%' sumbol in mathematical formulas. This setting affects whether the '%' symbol (modulo) is parsed as a piecewise equation that returns the modulo value of the entries on either side of the symbol, or whether it is parsed as the MathML 'rem' function, which was allowed in SBML Level 3 Version 2, but not in previous level/versions. The latter is more succinct, but might not be legal SBML for the desired target SBML document. Returns A boolean indicating the behavior currently set. The possible values are as follows: * L3P_MODULO_IS_REM (value = 'True):' use the 'rem' MathML function (AST_FUNCTION_REM). * L3P_MODULO_IS_PIECEWISE (value = 'False):' use a piecewise function (AST_FUNCTION_PIECEWISE) to encode the modulo rule explicitly. See also setParseModuloL3v2(). """ return _libsbml.L3ParserSettings_getParseModuloL3v2(self) def setParseL3v2Functions(self, l3v2functions): """ setParseL3v2Functions(L3ParserSettings self, bool l3v2functions) Sets the behavior for handling functions added in SBML L3v2 This setting affects whether the names of functions added in SBML Level 3 Version 2 are parsed as those added MathML functions, or whether they are added as generic functions with those names (to be used in SBML as function definitions). This method lets you tell the parser which behavior to use---either to parse the functions added in L3v2 as their built-in counterparts, or as generic functions with that name (to be defined by SBML as function definitions). The two possibilities are represented using the following constants: * L3P_PARSE_L3V2_FUNCTIONS_DIRECTLY (value = 'True):' parse the strings 'rateOf', 'implies', 'max', 'min', 'quotient', and 'rem' as AST_FUNCTION_RATE_OF, AST_LOGICAL_IMPLIES, AST_FUNCTION_MAX, AST_FUNCTION_MIN, AST_FUNCTION_QUOTIENT, and AST_FUNCTION_REM, respectively. * L3P_PARSE_L3V2_FUNCTIONS_AS_GENERIC (value = 'False):' parse the strings 'rateOf', 'implies', 'max', 'min', 'quotient', and 'rem' all as AST_FUNCTION with the appropriate name set. Parameter 'l3v2functions' is a boolean value (one of the constants L3P_PARSE_L3V2_FUNCTIONS_DIRECTLY or L3P_PARSE_L3V2_FUNCTIONS_AS_GENERIC) indicating how to interpret those function names. See also getParseL3v2Functions(). """ return _libsbml.L3ParserSettings_setParseL3v2Functions(self, l3v2functions) def getParseL3v2Functions(self): """ getParseL3v2Functions(L3ParserSettings self) -> bool Indicates the current behavior set for handling whether to parse the functions added in L3v2 as that MathML or not. This setting affects whether the names of functions added in SBML Level 3 Version 2 are parsed as those added MathML functions, or whether they are added as generic functions with those names (to be used in SBML as function definitions). Returns A boolean indicating the behavior currently set. The possible values are as follows: * L3P_PARSE_L3V2_FUNCTIONS_DIRECTLY (value = 'True):' parse the strings 'rateOf', 'implies', 'max', 'min', 'quotient', and 'rem' as AST_FUNCTION_RATE_OF, AST_LOGICAL_IMPLIES, AST_FUNCTION_MAX, AST_FUNCTION_MIN, AST_FUNCTION_QUOTIENT, and AST_FUNCTION_REM, respectively. * L3P_PARSE_L3V2_FUNCTIONS_AS_GENERIC (value = 'False):' parse the strings 'rateOf', 'implies', 'max', 'min', 'quotient', and 'rem' all as AST_FUNCTION with the appropriate name set. See also setParsePackageMath(). """ return _libsbml.L3ParserSettings_getParseL3v2Functions(self) def setParsePackageMath(self, package, parsepackage): """ setParsePackageMath(L3ParserSettings self, ExtendedMathType_t package, bool parsepackage) Sets the behavior for handling functions added in SBML packages This setting affects whether the math added in a given SBML Level 3 package are parsed as those added MathML elements, or whether they are added as generic functions or variables with those names. This method lets you tell the parser which behavior to use---either to parse the functions added in a given package as their built-in counterparts, or as generic functions with that name (to be defined by SBML as function definitions). The two possibilities are represented using the following constants: * L3P_PARSE_PACKAGE_MATH_DIRECTLY (value = 'True):' parse any string defined in a given SBML L3 package as its corresponding ASTType_t. * L3P_PARSE_PACKAGE_MATH_AS_GENERIC (value = 'False):' parse any string that would have been defined in the given SBML L3 package as AST_FUNCTION or AST_NAME with the appropriate name set. Parameter 'l3v2functions' is a boolean value (one of the constants L3P_PARSE_L3V2_FUNCTIONS_DIRECTLY or L3P_PARSE_L3V2_FUNCTIONS_AS_GENERIC) indicating how to interpret those function names. See also getParsePackageMath(). """ return _libsbml.L3ParserSettings_setParsePackageMath(self, package, parsepackage) def getParsePackageMath(self, package): """ getParsePackageMath(L3ParserSettings self, ExtendedMathType_t package) -> bool Indicates the current behavior set for handling whether to parse the functions added in the given package as that MathML or not. This setting affects whether the math added in a given SBML Level 3 package are parsed as those added MathML elements, or whether they are added as generic functions or variables with those names. Returns A boolean indicating the behavior currently set. The possible values are as follows: * L3P_PARSE_PACKAGE_MATH_DIRECTLY (value = 'True):' parse any string defined in a given SBML L3 package as its corresponding ASTType_t. * L3P_PARSE_PACKAGE_MATH_AS_GENERIC (value = 'False):' parse any string that would have been defined in the given SBML L3 package as AST_FUNCTION or AST_NAME with the appropriate name set. See also setParsePackageMath(). """ return _libsbml.L3ParserSettings_getParsePackageMath(self, package) def visitPackageInfixSyntax(self, parent, node, sb): """ visitPackageInfixSyntax(L3ParserSettings self, ASTNode parent, ASTNode node, StringBuffer_t * sb) Internal implementation method. """ return _libsbml.L3ParserSettings_visitPackageInfixSyntax(self, parent, node, sb) L3ParserSettings_swigregister = _libsbml.L3ParserSettings_swigregister L3ParserSettings_swigregister(L3ParserSettings) class ASTNodeValues_t(_object): """Proxy of C++ ASTNodeValues_t class.""" __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, ASTNodeValues_t, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, ASTNodeValues_t, name) __repr__ = _swig_repr __swig_setmethods__["name"] = _libsbml.ASTNodeValues_t_name_set __swig_getmethods__["name"] = _libsbml.ASTNodeValues_t_name_get if _newclass: name = _swig_property(_libsbml.ASTNodeValues_t_name_get, _libsbml.ASTNodeValues_t_name_set) __swig_setmethods__["type"] = _libsbml.ASTNodeValues_t_type_set __swig_getmethods__["type"] = _libsbml.ASTNodeValues_t_type_get if _newclass: type = _swig_property(_libsbml.ASTNodeValues_t_type_get, _libsbml.ASTNodeValues_t_type_set) __swig_setmethods__["isFunction"] = _libsbml.ASTNodeValues_t_isFunction_set __swig_getmethods__["isFunction"] = _libsbml.ASTNodeValues_t_isFunction_get if _newclass: isFunction = _swig_property(_libsbml.ASTNodeValues_t_isFunction_get, _libsbml.ASTNodeValues_t_isFunction_set) __swig_setmethods__["csymbolURL"] = _libsbml.ASTNodeValues_t_csymbolURL_set __swig_getmethods__["csymbolURL"] = _libsbml.ASTNodeValues_t_csymbolURL_get if _newclass: csymbolURL = _swig_property(_libsbml.ASTNodeValues_t_csymbolURL_get, _libsbml.ASTNodeValues_t_csymbolURL_set) __swig_setmethods__["allowedChildrenType"] = _libsbml.ASTNodeValues_t_allowedChildrenType_set __swig_getmethods__["allowedChildrenType"] = _libsbml.ASTNodeValues_t_allowedChildrenType_get if _newclass: allowedChildrenType = _swig_property(_libsbml.ASTNodeValues_t_allowedChildrenType_get, _libsbml.ASTNodeValues_t_allowedChildrenType_set) __swig_setmethods__["numAllowedChildren"] = _libsbml.ASTNodeValues_t_numAllowedChildren_set __swig_getmethods__["numAllowedChildren"] = _libsbml.ASTNodeValues_t_numAllowedChildren_get if _newclass: numAllowedChildren = _swig_property(_libsbml.ASTNodeValues_t_numAllowedChildren_get, _libsbml.ASTNodeValues_t_numAllowedChildren_set) def __init__(self): """__init__(ASTNodeValues_t self) -> ASTNodeValues_t""" this = _libsbml.new_ASTNodeValues_t() try: self.this.append(this) except __builtin__.Exception: self.this = this __swig_destroy__ = _libsbml.delete_ASTNodeValues_t __del__ = lambda self: None ASTNodeValues_t_swigregister = _libsbml.ASTNodeValues_t_swigregister ASTNodeValues_t_swigregister(ASTNodeValues_t) class ASTBasePlugin(_object): """ Internal implementation method. """ __swig_setmethods__ = {} __setattr__ = lambda self, name, value: _swig_setattr(self, ASTBasePlugin, name, value) __swig_getmethods__ = {} __getattr__ = lambda self, name: _swig_getattr(self, ASTBasePlugin, name) def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined") __repr__ = _swig_repr def getStringFor(self, type): """getStringFor(ASTBasePlugin self, ASTNodeType_t type) -> string""" return _libsbml.ASTBasePlugin_getStringFor(self, type) def getConstCharFor(self, type): """getConstCharFor(ASTBasePlugin self, ASTNodeType_t type) -> char const *""" return _libsbml.ASTBasePlugin_getConstCharFor(self, type) def getConstCharCsymbolURLFor(self, type): """getConstCharCsymbolURLFor(ASTBasePlugin self, ASTNodeType_t type) -> char const *""" return _libsbml.ASTBasePlugin_getConstCharCsymbolURLFor(self, type) def getASTNodeTypeFor(self, symbol): """getASTNodeTypeFor(ASTBasePlugin self, string symbol) -> ASTNodeType_t""" return _libsbml.ASTBasePlugin_getASTNodeTypeFor(self, symbol) def getASTNodeTypeForCSymbolURL(self, url): """getASTNodeTypeForCSymbolURL(ASTBasePlugin self, string url) -> ASTNodeType_t""" return _libsbml.ASTBasePlugin_getASTNodeTypeForCSymbolURL(self, url) def hasCorrectNamespace(self, namespaces): """hasCorrectNamespace(ASTBasePlugin self, SBMLNamespaces namespaces) -> bool""" return _libsbml.ASTBasePlugin_hasCorrectNamespace(self, namespaces) def defines(self, *args): """ defines(ASTBasePlugin self, ASTNodeType_t type) -> bool defines(ASTBasePlugin self, string name) -> bool """ return _libsbml.ASTBasePlugin_defines(self, *args) def isFunction(self, type): """isFunction(ASTBasePlugin self, ASTNodeType_t type) -> bool""" return _libsbml.ASTBasePlugin_isFunction(self, type) def isLogical(self, type): """isLogical(ASTBasePlugin self, ASTNodeType_t type) -> bool""" return _libsbml.ASTBasePlugin_isLogical(self, type) def isMathMLNodeTag(self, *args): """ isMathMLNodeTag(ASTBasePlugin self, string node) -> bool isMathMLNodeTag(ASTBasePlugin self, ASTNodeType_t type) -> bool """ return _libsbml.ASTBasePlugin_isMathMLNodeTag(self, *args) def getExtendedMathType(self): """getExtendedMathType(ASTBasePlugin self) -> ExtendedMathType_t""" return _libsbml.ASTBasePlugin_getExtendedMathType(self) def evaluateASTNode(self, node, m=None): """ evaluateASTNode(ASTBasePlugin self, ASTNode node, Model m=None) -> double evaluateASTNode(ASTBasePlugin self, ASTNode node) -> double """ return _libsbml.ASTBasePlugin_evaluateASTNode(self, node, m) def getUnitDefinitionFromPackage(self, uff, node, inKL, reactNo): """getUnitDefinitionFromPackage(ASTBasePlugin self, UnitFormulaFormatter * uff, ASTNode node, bool inKL, int reactNo) -> UnitDefinition""" return _libsbml.ASTBasePlugin_getUnitDefinitionFromPackage(self, uff, node, inKL, reactNo) def allowedInFunctionDefinition(self, type): """ allowedInFunctionDefinition(ASTBasePlugin self, ASTNodeType_t type) -> int Internal implementation method. """ return _libsbml.ASTBasePlugin_allowedInFunctionDefinition(self, type) __swig_destroy__ = _libsbml.delete_ASTBasePlugin __del__ = lambda self: None def clone(self): """ clone(ASTBasePlugin self) -> ASTBasePlugin Internal implementation method. """ return _libsbml.ASTBasePlugin_clone(self) def getElementNamespace(self): """ getElementNamespace(ASTBasePlugin self) -> string Internal implementation method. """ return _libsbml.ASTBasePlugin_getElementNamespace(self) def getPrefix(self): """ getPrefix(ASTBasePlugin self) -> string Internal implementation method. """ return _libsbml.ASTBasePlugin_getPrefix(self) def getPackageName(self): """ getPackageName(ASTBasePlugin self) -> string Internal implementation method. """ return _libsbml.ASTBasePlugin_getPackageName(self) def setSBMLExtension(self, ext): """ setSBMLExtension(ASTBasePlugin self, SBMLExtension ext) -> int Internal implementation method. """ return _libsbml.ASTBasePlugin_setSBMLExtension(self, ext) def setPrefix(self, prefix): """ setPrefix(ASTBasePlugin self, string prefix) -> int Internal implementation method. """ return _libsbml.ASTBasePlugin_setPrefix(self, prefix) def connectToParent(self, astbase): """ connectToParent(ASTBasePlugin self, ASTNode astbase) Internal implementation method. """ return _libsbml.ASTBasePlugin_connectToParent(self, astbase) def enablePackageInternal(self, pkgURI, pkgPrefix, flag): """ enablePackageInternal(ASTBasePlugin self, string pkgURI, string pkgPrefix, bool flag) Internal implementation method. """ return _libsbml.ASTBasePlugin_enablePackageInternal(self, pkgURI, pkgPrefix, flag) def stripPackage(self, pkgPrefix, flag): """ stripPackage(ASTBasePlugin self, string pkgPrefix, bool flag) -> bool Internal implementation method. """ return _libsbml.ASTBasePlugin_stripPackage(self, pkgPrefix, flag) def getURI(self): """ getURI(ASTBasePlugin self) -> string Internal implementation method. """ return _libsbml.ASTBasePlugin_getURI(self) def getParentASTObject(self, *args): """ getParentASTObject(ASTBasePlugin self) -> ASTNode getParentASTObject(ASTBasePlugin self) -> ASTNode Internal implementation method. """ return _libsbml.ASTBasePlugin_getParentASTObject(self, *args) def setElementNamespace(self, uri): """ setElementNamespace(ASTBasePlugin self, string uri) -> int Internal implementation method. """ return _libsbml.ASTBasePlugin_setElementNamespace(self, uri) def getLevel(self): """ getLevel(ASTBasePlugin self) -> unsigned int Internal implementation method. """ return _libsbml.ASTBasePlugin_getLevel(self) def getVersion(self): """ getVersion(ASTBasePlugin self) -> unsigned int Internal implementation method. """ return _libsbml.ASTBasePlugin_getVersion(self) def getPackageVersion(self): """ getPackageVersion(ASTBasePlugin self) -> unsigned int Internal implementation method. """ return _libsbml.ASTBasePlugin_getPackageVersion(self) def getSBMLNamespaces(self): """ getSBMLNamespaces(ASTBasePlugin self) -> SBMLNamespaces Internal implementation method. """ return _libsbml.ASTBasePlugin_getSBMLNamespaces(self) def renameSIdRefs(self, oldid, newid): """ renameSIdRefs(ASTBasePlugin self, string oldid, string newid) Internal implementation method. """ return _libsbml.ASTBasePlugin_renameSIdRefs(self, oldid, newid) def renameUnitSIdRefs(self, oldid, newid): """ renameUnitSIdRefs(ASTBasePlugin self, string oldid, string newid) Internal implementation method. """ return _libsbml.ASTBasePlugin_renameUnitSIdRefs(self, oldid, newid) def replaceIDWithFunction(self, id, function): """ replaceIDWithFunction(ASTBasePlugin self, string id, ASTNode function) Internal implementation method. """ return _libsbml.ASTBasePlugin_replaceIDWithFunction(self, id, function) def checkNumArguments(self, function, error): """ checkNumArguments(ASTBasePlugin self, ASTNode function, std::stringstream & error) -> int Internal implementation method. """ return _libsbml.ASTBasePlugin_checkNumArguments(self, function, error) def getL3PackageInfixPrecedence(self): """ getL3PackageInfixPrecedence(ASTBasePlugin self) -> int Internal implementation method. """ return _libsbml.ASTBasePlugin_getL3PackageInfixPrecedence(self) def hasCorrectNumArguments(self, function): """ hasCorrectNumArguments(ASTBasePlugin self, ASTNode function) -> bool Internal implementation method. """ return _libsbml.ASTBasePlugin_hasCorrectNumArguments(self, function) def hasPackageOnlyInfixSyntax(self): """ hasPackageOnlyInfixSyntax(ASTBasePlugin self) -> bool Internal implementation method. """ return _libsbml.ASTBasePlugin_hasPackageOnlyInfixSyntax(self) def hasUnambiguousPackageInfixGrammar(self, child): """ hasUnambiguousPackageInfixGrammar(ASTBasePlugin self, ASTNode child) -> bool Internal implementation method. """ return _libsbml.ASTBasePlugin_hasUnambiguousPackageInfixGrammar(self, child) def isPackageInfixFunction(self): """ isPackageInfixFunction(ASTBasePlugin self) -> bool Internal implementation method. """ return _libsbml.ASTBasePlugin_isPackageInfixFunction(self) ASTBasePlugin_swigregister = _libsbml.ASTBasePlugin_swigregister ASTBasePlugin_swigregister(ASTBasePlugin) class L3v2extendedmathPkgNamespaces(SBMLNamespaces): """ Set of SBML Level + Version + namespace triples. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. SBMLExtensionNamespaces is a template class. It is extended from SBMLNamespaces and is meant to be used by package extensions to store the SBML Level, Version within a Level, and package version of the SBML Level 3 package implemented by a libSBML package extension. Basic principles of SBML package extensions in libSBML ====================================================================== SBML Level 3's package structure permits modular extensions to the core SBML format. In libSBML, support for SBML Level 3 packages is provided through optional package extensions that can be plugged into libSBML at the time it is built/compiled. Users of libSBML can thus choose which extensions are enabled in their software applications. LibSBML defines a number of classes that developers of package extensions can use to implement support for an SBML Level 3 package. These classes make it easier to extend libSBML objects with new attributes and/or subobjects as needed by a particular Level 3 package. Three overall categories of classes make up libSBML's facilities for implementing package extensions. There are (1) classes that serve as base classes meant to be subclassed, (2) template classes meant to be instantiated rather than subclassed, and (3) support classes that provide utility features. A given package implementation for libSBML will take the form of code using these and other libSBML classes, placed in a subdirectory of src/sbml/packages/. The basic libSBML distribution includes a number of package extensions implementing support for officially-endorsed SBML Level 3 packages; among these are Flux Balance Constraints ('fbc'), Hierarchical Model Composition ('comp'), Layout ('layout'), and Qualitative Models ('qual'). They can serve as working examples for developers working to implement other packages. Extensions in libSBML can currently only be implemented in C++ or C; there is no mechanism to implement them first in languages such as Java or Python. However, once implemented in C++ or C, language interfaces can be generated semi-automatically using the framework in place in libSBML. (The approach is based on using SWIG and facilities in libSBML's build system.) """ __swig_setmethods__ = {} for _s in [SBMLNamespaces]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, L3v2extendedmathPkgNamespaces, name, value) __swig_getmethods__ = {} for _s in [SBMLNamespaces]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, L3v2extendedmathPkgNamespaces, name) __repr__ = _swig_repr __swig_destroy__ = _libsbml.delete_L3v2extendedmathPkgNamespaces __del__ = lambda self: None def __init__(self, *args): """ __init__(SBMLExtensionNamespaces<(L3v2extendedmathExtension)> self, unsigned int level, unsigned int version, unsigned int pkgVersion, string prefix) -> L3v2extendedmathPkgNamespaces __init__(SBMLExtensionNamespaces<(L3v2extendedmathExtension)> self, unsigned int level, unsigned int version, unsigned int pkgVersion) -> L3v2extendedmathPkgNamespaces __init__(SBMLExtensionNamespaces<(L3v2extendedmathExtension)> self, unsigned int level, unsigned int version) -> L3v2extendedmathPkgNamespaces __init__(SBMLExtensionNamespaces<(L3v2extendedmathExtension)> self, unsigned int level) -> L3v2extendedmathPkgNamespaces __init__(SBMLExtensionNamespaces<(L3v2extendedmathExtension)> self) -> L3v2extendedmathPkgNamespaces __init__(SBMLExtensionNamespaces<(L3v2extendedmathExtension)> self, L3v2extendedmathPkgNamespaces orig) -> L3v2extendedmathPkgNamespaces Set of SBML Level + Version + namespace triples. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. SBMLExtensionNamespaces is a template class. It is extended from SBMLNamespaces and is meant to be used by package extensions to store the SBML Level, Version within a Level, and package version of the SBML Level 3 package implemented by a libSBML package extension. Basic principles of SBML package extensions in libSBML ====================================================================== SBML Level 3's package structure permits modular extensions to the core SBML format. In libSBML, support for SBML Level 3 packages is provided through optional package extensions that can be plugged into libSBML at the time it is built/compiled. Users of libSBML can thus choose which extensions are enabled in their software applications. LibSBML defines a number of classes that developers of package extensions can use to implement support for an SBML Level 3 package. These classes make it easier to extend libSBML objects with new attributes and/or subobjects as needed by a particular Level 3 package. Three overall categories of classes make up libSBML's facilities for implementing package extensions. There are (1) classes that serve as base classes meant to be subclassed, (2) template classes meant to be instantiated rather than subclassed, and (3) support classes that provide utility features. A given package implementation for libSBML will take the form of code using these and other libSBML classes, placed in a subdirectory of src/sbml/packages/. The basic libSBML distribution includes a number of package extensions implementing support for officially-endorsed SBML Level 3 packages; among these are Flux Balance Constraints ('fbc'), Hierarchical Model Composition ('comp'), Layout ('layout'), and Qualitative Models ('qual'). They can serve as working examples for developers working to implement other packages. Extensions in libSBML can currently only be implemented in C++ or C; there is no mechanism to implement them first in languages such as Java or Python. However, once implemented in C++ or C, language interfaces can be generated semi-automatically using the framework in place in libSBML. (The approach is based on using SWIG and facilities in libSBML's build system.) """ this = _libsbml.new_L3v2extendedmathPkgNamespaces(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(L3v2extendedmathPkgNamespaces self) -> ISBMLExtensionNamespaces Creates and returns a deep copy of this SBMLNamespaces object. Returns the (deep) copy of this SBMLNamespaces object. """ return _libsbml.L3v2extendedmathPkgNamespaces_clone(self) def getURI(self): """ getURI(L3v2extendedmathPkgNamespaces self) -> string Returns a string representing the SBML XML namespace of this object. Returns a string representing the SBML namespace that reflects the SBML Level and Version of this object. """ return _libsbml.L3v2extendedmathPkgNamespaces_getURI(self) def getPackageVersion(self): """getPackageVersion(L3v2extendedmathPkgNamespaces self) -> unsigned int""" return _libsbml.L3v2extendedmathPkgNamespaces_getPackageVersion(self) def getPackageName(self): """ getPackageName(L3v2extendedmathPkgNamespaces self) -> string Returns the name of the main package for this namespace. Returns the name of the main package for this namespace. 'core' will be returned if this namespace is defined in the SBML core. """ return _libsbml.L3v2extendedmathPkgNamespaces_getPackageName(self) L3v2extendedmathPkgNamespaces_swigregister = _libsbml.L3v2extendedmathPkgNamespaces_swigregister L3v2extendedmathPkgNamespaces_swigregister(L3v2extendedmathPkgNamespaces) class L3v2extendedmathExtension(SBMLExtension): """ Base extension class for the package. This class of objects is defined by libSBML only and has no direct equivalent in terms of SBML components. This class is not prescribed by the SBML specifications, although it is used to implement features defined in SBML. This is the L3v2extendedmath package extension of the SBMLExtension class that is used to facilitate libSBML plug-ins in the implementation of an SBMLLevel 3 package. """ __swig_setmethods__ = {} for _s in [SBMLExtension]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, L3v2extendedmathExtension, name, value) __swig_getmethods__ = {} for _s in [SBMLExtension]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, L3v2extendedmathExtension, name) __repr__ = _swig_repr def getPackageName(): """ getPackageName() -> string Returns the nickname of the SBML Level 3 package implemented by this libSBML extension. Returns the package nickname, as a string. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.L3v2extendedmathExtension_getPackageName() getPackageName = staticmethod(getPackageName) def getDefaultLevel(): """ getDefaultLevel() -> unsigned int Returns the default SBML Level implemented by this libSBML extension. Returns the SBML Level, as a long integereger. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.L3v2extendedmathExtension_getDefaultLevel() getDefaultLevel = staticmethod(getDefaultLevel) def getDefaultVersion(): """ getDefaultVersion() -> unsigned int Returns the default SBML Version implemented by this libSBML extension. Returns the Version within the default SBML Level, as a long integereger. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.L3v2extendedmathExtension_getDefaultVersion() getDefaultVersion = staticmethod(getDefaultVersion) def getDefaultPackageVersion(): """ getDefaultPackageVersion() -> unsigned int Returns the default version of the SBML Level 3 package implemented by this libSBML extension. Returns the default version number of the SBML Level 3 package definition, as a long integereger. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.L3v2extendedmathExtension_getDefaultPackageVersion() getDefaultPackageVersion = staticmethod(getDefaultPackageVersion) def getXmlnsL3V1V1(): """ getXmlnsL3V1V1() -> string Returns the XML namespace URI of the SBML Level 3 package implemented by this libSBML extension. Returns the XML namespace, as a string. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.L3v2extendedmathExtension_getXmlnsL3V1V1() getXmlnsL3V1V1 = staticmethod(getXmlnsL3V1V1) def getXmlnsL3V2(): """ getXmlnsL3V2() -> string Returns the XML namespace URI of the SBML Level 3 package automatically included in L3V2. Returns the XML namespace, as a string. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.L3v2extendedmathExtension_getXmlnsL3V2() getXmlnsL3V2 = staticmethod(getXmlnsL3V2) def __init__(self, *args): """ __init__(L3v2extendedmathExtension self) -> L3v2extendedmathExtension __init__(L3v2extendedmathExtension self, L3v2extendedmathExtension orig) -> L3v2extendedmathExtension This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: L3v2extendedmathExtension() Creates a new L3v2extendedmathExtension instance. ______________________________________________________________________ Method variant with the following signature: L3v2extendedmathExtension(L3v2extendedmathExtension orig) Copy constructor for L3v2extendedmathExtension. Parameter 'orig' is the L3v2extendedmathExtension instance to copy. """ this = _libsbml.new_L3v2extendedmathExtension(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(L3v2extendedmathExtension self) -> L3v2extendedmathExtension Creates and returns a deep copy of this L3v2extendedmathExtension object. Returns a (deep) copy of this L3v2extendedmathExtension object. """ return _libsbml.L3v2extendedmathExtension_clone(self) __swig_destroy__ = _libsbml.delete_L3v2extendedmathExtension __del__ = lambda self: None def getName(self): """ getName(L3v2extendedmathExtension self) -> string Returns the name of this SBML Level 3 package ('l3v2extendedmath'). Returns a string representing the name of this package ('l3v2extendedmath'). """ return _libsbml.L3v2extendedmathExtension_getName(self) def getURI(self, sbmlLevel, sbmlVersion, pkgVersion): """ getURI(L3v2extendedmathExtension self, unsigned int sbmlLevel, unsigned int sbmlVersion, unsigned int pkgVersion) -> string Returns a string representing the SBML XML namespace of this SBML Level 3 package. Parameter 'sbmlLevel' is the level of SBML. Parameter 'sbmlVersion' is the version of SBML. Parameter 'pkgVersion' is the version of this package. Returns a string representing the name of this package ('l3v2extendedmath'). The namespace URI constructed by this method corresponds to the combination of the Level and Version of SBML, and the Version of the SBML Level 3 package. (At the time of this writing, the only SBML Level that supports packages is Level 3, so the value of 'sbmlLevel' is necessarily always 3.) """ return _libsbml.L3v2extendedmathExtension_getURI(self, sbmlLevel, sbmlVersion, pkgVersion) def getLevel(self, uri): """ getLevel(L3v2extendedmathExtension self, string uri) -> unsigned int Returns the SBML Level for the given URI of this package. Parameter 'uri' is the string of the URI that represents one of the versions of the 'l3v2extendedmath' package. Returns the SBML Level for the given URI of this package, or '0' if the given URI is invalid, or for a different package. """ return _libsbml.L3v2extendedmathExtension_getLevel(self, uri) def getVersion(self, uri): """ getVersion(L3v2extendedmathExtension self, string uri) -> unsigned int Returns the Version within the SBML Level for the given URI of this package. Parameter 'uri' is the string of the URI that represents one of the versions of the 'l3v2extendedmath' package. Returns the SBML Version within the SBML Level for the given URI of this package, or '0' if the given URI is invalid, or for a different package. """ return _libsbml.L3v2extendedmathExtension_getVersion(self, uri) def getPackageVersion(self, uri): """ getPackageVersion(L3v2extendedmathExtension self, string uri) -> unsigned int Returns the SBML Level 3 package version for the given URI of this package. Parameter 'uri' is the string of the URI that represents one of the versions of the 'l3v2extendedmath' package. Returns the version of the SBML Level 3 package for the given URI of this package, or '0' if the given URI is invalid, or for a different package. """ return _libsbml.L3v2extendedmathExtension_getPackageVersion(self, uri) def getSBMLExtensionNamespaces(self, uri): """ getSBMLExtensionNamespaces(L3v2extendedmathExtension self, string uri) -> SBMLNamespaces Returns a L3v2extendedmathPkgNamespaces object. Parameter 'uri' is the string of the URI that represents one of the versions of the 'l3v2extendedmath' package. Returns L3v2extendedmathPkgNamespaces object corresponding to the given URI of this package, or 'None' if the given URI is not defined in the 'l3v2extendedmath' package. """ return _libsbml.L3v2extendedmathExtension_getSBMLExtensionNamespaces(self, uri) def getStringFromTypeCode(self, typeCode): """ getStringFromTypeCode(L3v2extendedmathExtension self, int typeCode) -> char const * Takes a type code of the "l3v2extendedmath" package and returns a string describing the code. Parameter 'typeCode' is a libSBML type code defined by the libSBML extension implementing support for the SBML Level 3 "l3v2extendedmath" package. Returns a text string representing the type code given by 'typeCode'. If the type code is unrecognized for this implementation of the libSBML "l3v2extendedmath" package, the string returned will be '(Unknown SBML L3v2extendedmath Type)'. """ return _libsbml.L3v2extendedmathExtension_getStringFromTypeCode(self, typeCode) def getErrorTable(self, index): """ getErrorTable(L3v2extendedmathExtension self, unsigned int index) -> packageErrorTableEntry Internal implementation method. """ return _libsbml.L3v2extendedmathExtension_getErrorTable(self, index) def getErrorTableIndex(self, errorId): """ getErrorTableIndex(L3v2extendedmathExtension self, unsigned int errorId) -> unsigned int Internal implementation method. """ return _libsbml.L3v2extendedmathExtension_getErrorTableIndex(self, errorId) def getErrorIdOffset(self): """ getErrorIdOffset(L3v2extendedmathExtension self) -> unsigned int Internal implementation method. """ return _libsbml.L3v2extendedmathExtension_getErrorIdOffset(self) def init(): """ init() Internal implementation method. """ return _libsbml.L3v2extendedmathExtension_init() init = staticmethod(init) L3v2extendedmathExtension_swigregister = _libsbml.L3v2extendedmathExtension_swigregister L3v2extendedmathExtension_swigregister(L3v2extendedmathExtension) def L3v2extendedmathExtension_getPackageName(): """ L3v2extendedmathExtension_getPackageName() -> string Returns the nickname of the SBML Level 3 package implemented by this libSBML extension. Returns the package nickname, as a string. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.L3v2extendedmathExtension_getPackageName() def L3v2extendedmathExtension_getDefaultLevel(): """ L3v2extendedmathExtension_getDefaultLevel() -> unsigned int Returns the default SBML Level implemented by this libSBML extension. Returns the SBML Level, as a long integereger. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.L3v2extendedmathExtension_getDefaultLevel() def L3v2extendedmathExtension_getDefaultVersion(): """ L3v2extendedmathExtension_getDefaultVersion() -> unsigned int Returns the default SBML Version implemented by this libSBML extension. Returns the Version within the default SBML Level, as a long integereger. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.L3v2extendedmathExtension_getDefaultVersion() def L3v2extendedmathExtension_getDefaultPackageVersion(): """ L3v2extendedmathExtension_getDefaultPackageVersion() -> unsigned int Returns the default version of the SBML Level 3 package implemented by this libSBML extension. Returns the default version number of the SBML Level 3 package definition, as a long integereger. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.L3v2extendedmathExtension_getDefaultPackageVersion() def L3v2extendedmathExtension_getXmlnsL3V1V1(): """ L3v2extendedmathExtension_getXmlnsL3V1V1() -> string Returns the XML namespace URI of the SBML Level 3 package implemented by this libSBML extension. Returns the XML namespace, as a string. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.L3v2extendedmathExtension_getXmlnsL3V1V1() def L3v2extendedmathExtension_getXmlnsL3V2(): """ L3v2extendedmathExtension_getXmlnsL3V2() -> string Returns the XML namespace URI of the SBML Level 3 package automatically included in L3V2. Returns the XML namespace, as a string. Note: Because this is a static method on a class, the Python language interface for libSBML will contain two variants. One will be the expected, normal static method on the class (i.e., a regular methodName), and the other will be a standalone top-level function with the name ClassName_methodName(). This is merely an artifact of how the language interfaces are created in libSBML. The methods are functionally identical. """ return _libsbml.L3v2extendedmathExtension_getXmlnsL3V2() def L3v2extendedmathExtension_init(): """ L3v2extendedmathExtension_init() Internal implementation method. """ return _libsbml.L3v2extendedmathExtension_init() class L3v2extendedmathSBMLDocumentPlugin(SBMLDocumentPlugin): """ Extension of SBMLDocument. """ __swig_setmethods__ = {} for _s in [SBMLDocumentPlugin]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, L3v2extendedmathSBMLDocumentPlugin, name, value) __swig_getmethods__ = {} for _s in [SBMLDocumentPlugin]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, L3v2extendedmathSBMLDocumentPlugin, name) __repr__ = _swig_repr def __init__(self, *args): """ __init__(L3v2extendedmathSBMLDocumentPlugin self, string uri, string prefix, L3v2extendedmathPkgNamespaces l3v2extendedmathns) -> L3v2extendedmathSBMLDocumentPlugin __init__(L3v2extendedmathSBMLDocumentPlugin self, L3v2extendedmathSBMLDocumentPlugin orig) -> L3v2extendedmathSBMLDocumentPlugin This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: L3v2extendedmathSBMLDocumentPlugin(string uri, string prefix, L3v2extendedmathPkgNamespaces l3v2extendedmathns) Creates a new L3v2extendedmathSBMLDocumentPlugin using the given URI, prefix and package namespace. Parameter 'uri' is a string, representing the URI of the SBML Level 3 package implemented by this libSBML package extension. Parameter 'prefix' is a string, the XML namespace prefix being used for this package. Parameter 'l3v2extendedmathns' is a pointer to the namesspaces object (L3v2extendedmathPkgNamespaces) for this package. In the XML representation of an SBML document, XML namespaces are used to identify the origin of each XML construct used. XML namespaces are identified by their unique resource identifiers (URIs). The core SBML specifications stipulate the namespaces that must be used for core SBML constructs; for example, all XML elements that belong to SBML Level 3 Version 1 Core must be placed in the XML namespace identified by the URI 'http://www.sbml.org/sbml/level3/version1/core'. Individual SBML Level 3 packages define their own XML namespaces; for example, all elements belonging to the SBML Level 3 Layout Version 1 package must be placed in the XML namespace 'http://www.sbml.org/sbml/level3/version1/layout/version1/'. The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments. ______________________________________________________________________ Method variant with the following signature: L3v2extendedmathSBMLDocumentPlugin(L3v2extendedmathSBMLDocume ntPlugin orig) Copy constructor for L3v2extendedmathSBMLDocumentPlugin. Parameter 'orig' is the L3v2extendedmathSBMLDocumentPlugin instance to copy. """ this = _libsbml.new_L3v2extendedmathSBMLDocumentPlugin(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def clone(self): """ clone(L3v2extendedmathSBMLDocumentPlugin self) -> L3v2extendedmathSBMLDocumentPlugin Creates and returns a deep copy of this L3v2extendedmathSBMLDocumentPlugin object. Returns a (deep) copy of this L3v2extendedmathSBMLDocumentPlugin object. """ return _libsbml.L3v2extendedmathSBMLDocumentPlugin_clone(self) __swig_destroy__ = _libsbml.delete_L3v2extendedmathSBMLDocumentPlugin __del__ = lambda self: None def isCompFlatteningImplemented(self): """ isCompFlatteningImplemented(L3v2extendedmathSBMLDocumentPlugin self) -> bool Internal implementation method. """ return _libsbml.L3v2extendedmathSBMLDocumentPlugin_isCompFlatteningImplemented(self) def checkConsistency(self): """ checkConsistency(L3v2extendedmathSBMLDocumentPlugin self) -> unsigned int Internal implementation method. """ return _libsbml.L3v2extendedmathSBMLDocumentPlugin_checkConsistency(self) L3v2extendedmathSBMLDocumentPlugin_swigregister = _libsbml.L3v2extendedmathSBMLDocumentPlugin_swigregister L3v2extendedmathSBMLDocumentPlugin_swigregister(L3v2extendedmathSBMLDocumentPlugin) class L3v2extendedmathASTPlugin(ASTBasePlugin): """ Extension of AST. """ __swig_setmethods__ = {} for _s in [ASTBasePlugin]: __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {})) __setattr__ = lambda self, name, value: _swig_setattr(self, L3v2extendedmathASTPlugin, name, value) __swig_getmethods__ = {} for _s in [ASTBasePlugin]: __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {})) __getattr__ = lambda self, name: _swig_getattr(self, L3v2extendedmathASTPlugin, name) __repr__ = _swig_repr def clone(self): """ clone(L3v2extendedmathASTPlugin self) -> L3v2extendedmathASTPlugin Creates and returns a deep copy of this L3v2extendedmathASTPlugin object. Returns the (deep) copy of this L3v2extendedmathASTPlugin object. """ return _libsbml.L3v2extendedmathASTPlugin_clone(self) __swig_destroy__ = _libsbml.delete_L3v2extendedmathASTPlugin __del__ = lambda self: None def hasCorrectNamespace(self, namespaces): """ hasCorrectNamespace(L3v2extendedmathASTPlugin self, SBMLNamespaces namespaces) -> bool """ return _libsbml.L3v2extendedmathASTPlugin_hasCorrectNamespace(self, namespaces) def __init__(self, *args): """ __init__(L3v2extendedmathASTPlugin self) -> L3v2extendedmathASTPlugin __init__(L3v2extendedmathASTPlugin self, L3v2extendedmathASTPlugin orig) -> L3v2extendedmathASTPlugin __init__(L3v2extendedmathASTPlugin self, string uri) -> L3v2extendedmathASTPlugin This method has multiple variants; they differ in the arguments they accept. Each variant is described separately below. ______________________________________________________________________ Method variant with the following signature: L3v2extendedmathASTPlugin() Creates a new L3v2extendedmathASTPlugin object. ______________________________________________________________________ Method variant with the following signature: L3v2extendedmathASTPlugin(string &uri) ______________________________________________________________________ Method variant with the following signature: L3v2extendedmathASTPlugin( L3v2extendedmathASTPlugin orig) """ this = _libsbml.new_L3v2extendedmathASTPlugin(*args) try: self.this.append(this) except __builtin__.Exception: self.this = this def checkNumArguments(self, function, error): """ checkNumArguments(L3v2extendedmathASTPlugin self, ASTNode function, std::stringstream & error) -> int """ return _libsbml.L3v2extendedmathASTPlugin_checkNumArguments(self, function, error) def evaluateASTNode(self, node, m=None): """ evaluateASTNode(L3v2extendedmathASTPlugin self, ASTNode node, Model m=None) -> double evaluateASTNode(L3v2extendedmathASTPlugin self, ASTNode node) -> double Note: Owing to the way that language interfaces are created in libSBML, this documentation may show methods that define default values for parameters with text that has the form parameter = value. This is not to be intepreted as a Python keyword argument; the use of a parameter name followed by an equals sign followed by a value is only meant to indicate a default value if the argument is not provided at all. It is not a keyword in the Python sense. """ return _libsbml.L3v2extendedmathASTPlugin_evaluateASTNode(self, node, m) def getUnitDefinitionFromRem(self, uff, node, inKL, reactNo): """ getUnitDefinitionFromRem(L3v2extendedmathASTPlugin self, UnitFormulaFormatter * uff, ASTNode node, bool inKL, int reactNo) -> UnitDefinition returns the unitDefinition for the ASTNode from a rem function """ return _libsbml.L3v2extendedmathASTPlugin_getUnitDefinitionFromRem(self, uff, node, inKL, reactNo) def getUnitDefinitionFromRateOf(self, uff, node, inKL, reactNo): """ getUnitDefinitionFromRateOf(L3v2extendedmathASTPlugin self, UnitFormulaFormatter * uff, ASTNode node, bool inKL, int reactNo) -> UnitDefinition returns the unitDefinition for the ASTNode from a rateOf function """ return _libsbml.L3v2extendedmathASTPlugin_getUnitDefinitionFromRateOf(self, uff, node, inKL, reactNo) def getUnitDefinitionFromPackage(self, uff, node, inKL, reactNo): """ getUnitDefinitionFromPackage(L3v2extendedmathASTPlugin self, UnitFormulaFormatter * uff, ASTNode node, bool inKL, int reactNo) -> UnitDefinition """ return _libsbml.L3v2extendedmathASTPlugin_getUnitDefinitionFromPackage(self, uff, node, inKL, reactNo) def isLogical(self, type): """ isLogical(L3v2extendedmathASTPlugin self, ASTNodeType_t type) -> bool """ return _libsbml.L3v2extendedmathASTPlugin_isLogical(self, type) def allowedInFunctionDefinition(self, type): """ allowedInFunctionDefinition(L3v2extendedmathASTPlugin self, ASTNodeType_t type) -> int Check if the node type is known to be allowed inside function definitions. Function definitions must be able to be evaluated without resort to outside information. Therefore, some ASTNodes (like AST_TIME and AST_FUNCTION_RATE_OF) are disallowed from appearing there. This function checks whether this is true for a given type: a return value of '-1' means the plugin has no knowledge of that type; a return value of '1' means the plugin knows that the type is indeed allowed, and a return value of '0' means that the plugin knows that the type is not allowed. """ return _libsbml.L3v2extendedmathASTPlugin_allowedInFunctionDefinition(self, type) L3v2extendedmathASTPlugin_swigregister = _libsbml.L3v2extendedmathASTPlugin_swigregister L3v2extendedmathASTPlugin_swigregister(L3v2extendedmathASTPlugin) # This file is compatible with both classic and new-style classes.