Skip to content
BranchesTags

Repository files navigation

TRuML: A translator for rule-based modeling

Summary

TRuML is a Python application designed to translate models written in either Kappa or the BioNetGen language (BNGL) into the other language. Currently TRuML is only compatible with Python 2 and work is being done to adapt TRuML for use with Python 3. Documentation can be found on Read the Docs

Installation

From PyPI:

pip install TRuML

Usage

TRuML is invoked on the command line using the command truml. All options can be seen with the -h or --help flags:

truml -h

Conversion of a model written in BNGL to the Kappa language is done using the command:

truml -b model.bngl

The corresponding Kappa model will then exist in the same directory as the source BNGL file. The reverse translation is done in an equivalent manner:

truml -k model.ka

Varying levels of verbosity can be achieved. TRuML uses Python's logging library to track the translation process, and it's default logging level is WARNING. The -v (--verbose) and -d (--debug) flags will set the logging level to INFO and DEBUG, respectively. The logging output can be redirected to a file with the -l (--log_file) flag and a corresponding file name.

Note that TRuML only translates the model structure. It does not consider any simulation or simulation perturbation directives from either language.

Caveats

The two languages are not interchangeable (there are models in both languages that cannot be exactly translated to the other). In many cases, TRuML will raise issues explicitly. However the languages are both still under development and unidentified incompatibilities could cause the translation process to crash. Some cases that cannot be exactly translated include:

BNGL to Kappa

  • Patterns containing molecules in complex but without explicit binding:

    A().B()

Kappa to BNGL

  • Models containing infinities ([inf])

Finally, the BioNetGen language is interpreted slightly differently for different simulation engines. The NFsim engine does not consider molecularity constraints on the right hand side of the rule. As this is similar to Kappa's purely local pattern representation (which cannot consider right hand side molecularity), TRuML assumes this convention.

About

No description, website, or topics provided.

Resources

Readme
License
Activity
Custom properties

Stars

3 stars

Watchers

1 watching

Forks

4 forks
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
GitHub - lanl/TRuML · GitHub
Skip to content
BranchesTags
Repository files navigation
TRuML: A translator for rule-based modeling
Summary
TRuML is a Python application designed to translate models written in either Kappa or the BioNetGen language (BNGL)
into the other language. Currently TRuML is only compatible with Python 2 and work is being done to adapt TRuML for
use with Python 3. Documentation can be found on Read the Docs
Installation
From PyPI:
pip install TRuML

Usage
TRuML is invoked on the command line using the command truml. All options can be seen with the -h or --help
flags:
truml -h

Conversion of a model written in BNGL to the Kappa language is done using the command:
truml -b model.bngl

The corresponding Kappa model will then exist in the same directory as the source BNGL file. The reverse translation
is done in an equivalent manner:
truml -k model.ka

Varying levels of verbosity can be achieved. TRuML uses Python's logging library to track the translation process,
and it's default logging level is WARNING. The -v (--verbose) and -d (--debug) flags will set the
logging level to INFO and DEBUG, respectively. The logging output can be redirected to a file with the -l (--log_file)
flag and a corresponding file name.
Note that TRuML only translates the model structure. It does not consider any simulation or simulation perturbation
directives from either language.
Caveats
The two languages are not interchangeable (there are models in both languages that cannot be exactly translated to the
other). In many cases, TRuML will raise issues explicitly. However the languages are both still under development and
unidentified incompatibilities could cause the translation process to crash. Some cases that cannot be exactly translated
include:
BNGL to Kappa
  • Patterns containing molecules in complex but without explicit binding:
    A().B()

Kappa to BNGL
  • Models containing infinities ([inf])
Finally, the BioNetGen language is interpreted slightly differently for different simulation engines. The NFsim engine
does not consider molecularity constraints on the right hand side of the rule. As this is similar to Kappa's purely
local pattern representation (which cannot consider right hand side molecularity), TRuML assumes this convention.
About
No description, website, or topics provided.
Resources
Readme
License
Activity
Custom properties
Stars
3 stars
Watchers
1 watching
Forks
4 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - lanl/TRuML · GitHub
Skip to content
BranchesTags
Repository files navigation
TRuML: A translator for rule-based modeling
Summary
TRuML is a Python application designed to translate models written in either Kappa or the BioNetGen language (BNGL)
into the other language. Currently TRuML is only compatible with Python 2 and work is being done to adapt TRuML for
use with Python 3. Documentation can be found on Read the Docs
Installation
From PyPI:
pip install TRuML

Usage
TRuML is invoked on the command line using the command truml. All options can be seen with the -h or --help
flags:
truml -h

Conversion of a model written in BNGL to the Kappa language is done using the command:
truml -b model.bngl

The corresponding Kappa model will then exist in the same directory as the source BNGL file. The reverse translation
is done in an equivalent manner:
truml -k model.ka

Varying levels of verbosity can be achieved. TRuML uses Python's logging library to track the translation process,
and it's default logging level is WARNING. The -v (--verbose) and -d (--debug) flags will set the
logging level to INFO and DEBUG, respectively. The logging output can be redirected to a file with the -l (--log_file)
flag and a corresponding file name.
Note that TRuML only translates the model structure. It does not consider any simulation or simulation perturbation
directives from either language.
Caveats
The two languages are not interchangeable (there are models in both languages that cannot be exactly translated to the
other). In many cases, TRuML will raise issues explicitly. However the languages are both still under development and
unidentified incompatibilities could cause the translation process to crash. Some cases that cannot be exactly translated
include:
BNGL to Kappa
  • Patterns containing molecules in complex but without explicit binding:
    A().B()

Kappa to BNGL
  • Models containing infinities ([inf])
Finally, the BioNetGen language is interpreted slightly differently for different simulation engines. The NFsim engine
does not consider molecularity constraints on the right hand side of the rule. As this is similar to Kappa's purely
local pattern representation (which cannot consider right hand side molecularity), TRuML assumes this convention.
About
No description, website, or topics provided.
Resources
Readme
License
Activity
Custom properties
Stars
3 stars
Watchers
1 watching
Forks
4 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - lanl/TRuML · GitHub
Skip to content
BranchesTags
Repository files navigation
TRuML: A translator for rule-based modeling
Summary
TRuML is a Python application designed to translate models written in either Kappa or the BioNetGen language (BNGL)
into the other language. Currently TRuML is only compatible with Python 2 and work is being done to adapt TRuML for
use with Python 3. Documentation can be found on Read the Docs
Installation
From PyPI:
pip install TRuML

Usage
TRuML is invoked on the command line using the command truml. All options can be seen with the -h or --help
flags:
truml -h

Conversion of a model written in BNGL to the Kappa language is done using the command:
truml -b model.bngl

The corresponding Kappa model will then exist in the same directory as the source BNGL file. The reverse translation
is done in an equivalent manner:
truml -k model.ka

Varying levels of verbosity can be achieved. TRuML uses Python's logging library to track the translation process,
and it's default logging level is WARNING. The -v (--verbose) and -d (--debug) flags will set the
logging level to INFO and DEBUG, respectively. The logging output can be redirected to a file with the -l (--log_file)
flag and a corresponding file name.
Note that TRuML only translates the model structure. It does not consider any simulation or simulation perturbation
directives from either language.
Caveats
The two languages are not interchangeable (there are models in both languages that cannot be exactly translated to the
other). In many cases, TRuML will raise issues explicitly. However the languages are both still under development and
unidentified incompatibilities could cause the translation process to crash. Some cases that cannot be exactly translated
include:
BNGL to Kappa
  • Patterns containing molecules in complex but without explicit binding:
    A().B()

Kappa to BNGL
  • Models containing infinities ([inf])
Finally, the BioNetGen language is interpreted slightly differently for different simulation engines. The NFsim engine
does not consider molecularity constraints on the right hand side of the rule. As this is similar to Kappa's purely
local pattern representation (which cannot consider right hand side molecularity), TRuML assumes this convention.
About
No description, website, or topics provided.
Resources
Readme
License
Activity
Custom properties
Stars
3 stars
Watchers
1 watching
Forks
4 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
GitHub - lanl/TRuML · GitHub
Skip to content
BranchesTags
Repository files navigation
TRuML: A translator for rule-based modeling
Summary
TRuML is a Python application designed to translate models written in either Kappa or the BioNetGen language (BNGL)
into the other language. Currently TRuML is only compatible with Python 2 and work is being done to adapt TRuML for
use with Python 3. Documentation can be found on Read the Docs
Installation
From PyPI:
pip install TRuML

Usage
TRuML is invoked on the command line using the command truml. All options can be seen with the -h or --help
flags:
truml -h

Conversion of a model written in BNGL to the Kappa language is done using the command:
truml -b model.bngl

The corresponding Kappa model will then exist in the same directory as the source BNGL file. The reverse translation
is done in an equivalent manner:
truml -k model.ka

Varying levels of verbosity can be achieved. TRuML uses Python's logging library to track the translation process,
and it's default logging level is WARNING. The -v (--verbose) and -d (--debug) flags will set the
logging level to INFO and DEBUG, respectively. The logging output can be redirected to a file with the -l (--log_file)
flag and a corresponding file name.
Note that TRuML only translates the model structure. It does not consider any simulation or simulation perturbation
directives from either language.
Caveats
The two languages are not interchangeable (there are models in both languages that cannot be exactly translated to the
other). In many cases, TRuML will raise issues explicitly. However the languages are both still under development and
unidentified incompatibilities could cause the translation process to crash. Some cases that cannot be exactly translated
include:
BNGL to Kappa
  • Patterns containing molecules in complex but without explicit binding:
    A().B()

Kappa to BNGL
  • Models containing infinities ([inf])
Finally, the BioNetGen language is interpreted slightly differently for different simulation engines. The NFsim engine
does not consider molecularity constraints on the right hand side of the rule. As this is similar to Kappa's purely
local pattern representation (which cannot consider right hand side molecularity), TRuML assumes this convention.
About
No description, website, or topics provided.
Resources
Readme
License
Activity
Custom properties
Stars
3 stars
Watchers
1 watching
Forks
4 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - lanl/TRuML · GitHub
Skip to content
BranchesTags
Repository files navigation
TRuML: A translator for rule-based modeling
Summary
TRuML is a Python application designed to translate models written in either Kappa or the BioNetGen language (BNGL)
into the other language. Currently TRuML is only compatible with Python 2 and work is being done to adapt TRuML for
use with Python 3. Documentation can be found on Read the Docs
Installation
From PyPI:
pip install TRuML

Usage
TRuML is invoked on the command line using the command truml. All options can be seen with the -h or --help
flags:
truml -h

Conversion of a model written in BNGL to the Kappa language is done using the command:
truml -b model.bngl

The corresponding Kappa model will then exist in the same directory as the source BNGL file. The reverse translation
is done in an equivalent manner:
truml -k model.ka

Varying levels of verbosity can be achieved. TRuML uses Python's logging library to track the translation process,
and it's default logging level is WARNING. The -v (--verbose) and -d (--debug) flags will set the
logging level to INFO and DEBUG, respectively. The logging output can be redirected to a file with the -l (--log_file)
flag and a corresponding file name.
Note that TRuML only translates the model structure. It does not consider any simulation or simulation perturbation
directives from either language.
Caveats
The two languages are not interchangeable (there are models in both languages that cannot be exactly translated to the
other). In many cases, TRuML will raise issues explicitly. However the languages are both still under development and
unidentified incompatibilities could cause the translation process to crash. Some cases that cannot be exactly translated
include:
BNGL to Kappa
  • Patterns containing molecules in complex but without explicit binding:
    A().B()

Kappa to BNGL
  • Models containing infinities ([inf])
Finally, the BioNetGen language is interpreted slightly differently for different simulation engines. The NFsim engine
does not consider molecularity constraints on the right hand side of the rule. As this is similar to Kappa's purely
local pattern representation (which cannot consider right hand side molecularity), TRuML assumes this convention.
About
No description, website, or topics provided.
Resources
Readme
License
Activity
Custom properties
Stars
3 stars
Watchers
1 watching
Forks
4 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - lanl/TRuML · GitHub
Skip to content
BranchesTags
Repository files navigation
TRuML: A translator for rule-based modeling
Summary
TRuML is a Python application designed to translate models written in either Kappa or the BioNetGen language (BNGL)
into the other language. Currently TRuML is only compatible with Python 2 and work is being done to adapt TRuML for
use with Python 3. Documentation can be found on Read the Docs
Installation
From PyPI:
pip install TRuML

Usage
TRuML is invoked on the command line using the command truml. All options can be seen with the -h or --help
flags:
truml -h

Conversion of a model written in BNGL to the Kappa language is done using the command:
truml -b model.bngl

The corresponding Kappa model will then exist in the same directory as the source BNGL file. The reverse translation
is done in an equivalent manner:
truml -k model.ka

Varying levels of verbosity can be achieved. TRuML uses Python's logging library to track the translation process,
and it's default logging level is WARNING. The -v (--verbose) and -d (--debug) flags will set the
logging level to INFO and DEBUG, respectively. The logging output can be redirected to a file with the -l (--log_file)
flag and a corresponding file name.
Note that TRuML only translates the model structure. It does not consider any simulation or simulation perturbation
directives from either language.
Caveats
The two languages are not interchangeable (there are models in both languages that cannot be exactly translated to the
other). In many cases, TRuML will raise issues explicitly. However the languages are both still under development and
unidentified incompatibilities could cause the translation process to crash. Some cases that cannot be exactly translated
include:
BNGL to Kappa
  • Patterns containing molecules in complex but without explicit binding:
    A().B()

Kappa to BNGL
  • Models containing infinities ([inf])
Finally, the BioNetGen language is interpreted slightly differently for different simulation engines. The NFsim engine
does not consider molecularity constraints on the right hand side of the rule. As this is similar to Kappa's purely
local pattern representation (which cannot consider right hand side molecularity), TRuML assumes this convention.
About
No description, website, or topics provided.
Resources
Readme
License
Activity
Custom properties
Stars
3 stars
Watchers
1 watching
Forks
4 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
GitHub - lanl/TRuML · GitHub
Skip to content
BranchesTags
Repository files navigation
TRuML: A translator for rule-based modeling
Summary
TRuML is a Python application designed to translate models written in either Kappa or the BioNetGen language (BNGL)
into the other language. Currently TRuML is only compatible with Python 2 and work is being done to adapt TRuML for
use with Python 3. Documentation can be found on Read the Docs
Installation
From PyPI:
pip install TRuML

Usage
TRuML is invoked on the command line using the command truml. All options can be seen with the -h or --help
flags:
truml -h

Conversion of a model written in BNGL to the Kappa language is done using the command:
truml -b model.bngl

The corresponding Kappa model will then exist in the same directory as the source BNGL file. The reverse translation
is done in an equivalent manner:
truml -k model.ka

Varying levels of verbosity can be achieved. TRuML uses Python's logging library to track the translation process,
and it's default logging level is WARNING. The -v (--verbose) and -d (--debug) flags will set the
logging level to INFO and DEBUG, respectively. The logging output can be redirected to a file with the -l (--log_file)
flag and a corresponding file name.
Note that TRuML only translates the model structure. It does not consider any simulation or simulation perturbation
directives from either language.
Caveats
The two languages are not interchangeable (there are models in both languages that cannot be exactly translated to the
other). In many cases, TRuML will raise issues explicitly. However the languages are both still under development and
unidentified incompatibilities could cause the translation process to crash. Some cases that cannot be exactly translated
include:
BNGL to Kappa
  • Patterns containing molecules in complex but without explicit binding:
    A().B()

Kappa to BNGL
  • Models containing infinities ([inf])
Finally, the BioNetGen language is interpreted slightly differently for different simulation engines. The NFsim engine
does not consider molecularity constraints on the right hand side of the rule. As this is similar to Kappa's purely
local pattern representation (which cannot consider right hand side molecularity), TRuML assumes this convention.
About
No description, website, or topics provided.
Resources
Readme
License
Activity
Custom properties
Stars
3 stars
Watchers
1 watching
Forks
4 forks
Report repository
Releases
Packages
Contributors
Languages