API
+| + | Lewis - a library for creating hardware device simulators |
+
-
+
- Languages + ${languages + .map( + (translation) => ` +
- + ${translation.language.code} + + `, + ) + .join("\n")} +
-
+
- Versions + ${config.versions.active + .map( + (version) => ` +
- + ${version.slug} + + `, + ) + .join("\n")} +
-
+
- Downloads + ${Object.entries(config.versions.current.downloads) + .map( + ([name, url]) => ` +
- + ${downloadsNameDisplay[name]} + + `, + ) + .join("\n")} +
+
+ Read the Docs
+ v: ${config.versions.current.slug}
+
+
+ Developing Lewis — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Framework Details — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Release Checklist — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Writing Device Simulators — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.adapters.epics — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.adapters — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.adapters.modbus — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.adapters.stream — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.core.adapters — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.core.approaches — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.core.control_client — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.core.control_server — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.core.devices — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.core.exceptions — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.core — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.core.logging — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.core.processor — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.core.simulation — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.core.statemachine — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.core.utils — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.chopper.devices.bearings — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.chopper.devices.device — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.chopper.devices — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.chopper.devices.states — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.chopper — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.chopper.interfaces.epics_interface — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.chopper.interfaces — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.julabo.devices.device — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.julabo.devices — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.julabo.devices.states — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.julabo — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.julabo.interfaces — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.julabo.interfaces.julabo_stream_interface_1 — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.julabo.interfaces.julabo_stream_interface_2 — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.linkam_t95.devices.device — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.linkam_t95.devices — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.linkam_t95.devices.states — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.linkam_t95 — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.linkam_t95.interfaces — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.linkam_t95.interfaces.stream_interface — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.examples.dual_device — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.examples.example_motor — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.examples — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.examples.modbus_device — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.examples.simple_device — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.examples.timeout_device — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.scripts.control — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.scripts — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.scripts.run — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.utils.byte_conversions — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.utils.command_builder — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.utils.constants — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.utils — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.utils.replies — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Index — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Welcome to the Lewis documentation! — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Python Module Index — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Quickstart Guide — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Release 1.0 — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Release 1.0.1 — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Release 1.0.2 — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Release 1.0.3 — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Release 1.1 — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Release 1.1.1 — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Release 1.2 — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Release 1.2.1 — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Release 1.2.2 — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Release 1.3.0 — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Release 1.3.1 — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Release 1.3.2 — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Release 1.3.3 — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Release notes — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Search — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Adapter Specifics — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Command line tools — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Remote Access to Devices — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Remote Access to Simulation Parameters — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Usage with Python — lewis documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ `;
+
+ // Inject the generated flyout into the body HTML element.
+ document.body.insertAdjacentHTML("beforeend", flyout);
+
+ // Trigger the Read the Docs Addons Search modal when clicking on the "Search docs" input from inside the flyout.
+ document
+ .querySelector("#flyout-search-form")
+ .addEventListener("focusin", () => {
+ const event = new CustomEvent("readthedocs-search-show");
+ document.dispatchEvent(event);
+ });
+ })
+}
+
+if (themeLanguageSelector || themeVersionSelector) {
+ function onSelectorSwitch(event) {
+ const option = event.target.selectedIndex;
+ const item = event.target.options[option];
+ window.location.href = item.dataset.url;
+ }
+
+ document.addEventListener("readthedocs-addons-data-ready", function (event) {
+ const config = event.detail.data();
+
+ const versionSwitch = document.querySelector(
+ "div.switch-menus > div.version-switch",
+ );
+ if (themeVersionSelector) {
+ let versions = config.versions.active;
+ if (config.versions.current.hidden || config.versions.current.type === "external") {
+ versions.unshift(config.versions.current);
+ }
+ const versionSelect = `
+
+ `;
+
+ versionSwitch.innerHTML = versionSelect;
+ versionSwitch.firstElementChild.addEventListener("change", onSelectorSwitch);
+ }
+
+ const languageSwitch = document.querySelector(
+ "div.switch-menus > div.language-switch",
+ );
+
+ if (themeLanguageSelector) {
+ if (config.projects.translations.length) {
+ // Add the current language to the options on the selector
+ let languages = config.projects.translations.concat(
+ config.projects.current,
+ );
+ languages = languages.sort((a, b) =>
+ a.language.name.localeCompare(b.language.name),
+ );
+
+ const languageSelect = `
+
+ `;
+
+ languageSwitch.innerHTML = languageSelect;
+ languageSwitch.firstElementChild.addEventListener("change", onSelectorSwitch);
+ }
+ else {
+ languageSwitch.remove();
+ }
+ }
+ });
+}
+
+document.addEventListener("readthedocs-addons-data-ready", function (event) {
+ // Trigger the Read the Docs Addons Search modal when clicking on "Search docs" input from the topnav.
+ document
+ .querySelector("[role='search'] input")
+ .addEventListener("focusin", () => {
+ const event = new CustomEvent("readthedocs-search-show");
+ document.dispatchEvent(event);
+ });
+});
\ No newline at end of file
diff --git a/_static/language_data.js b/_static/language_data.js
new file mode 100644
index 00000000..c7fe6c6f
--- /dev/null
+++ b/_static/language_data.js
@@ -0,0 +1,192 @@
+/*
+ * This script contains the language-specific data used by searchtools.js,
+ * namely the list of stopwords, stemmer, scorer and splitter.
+ */
+
+var stopwords = ["a", "and", "are", "as", "at", "be", "but", "by", "for", "if", "in", "into", "is", "it", "near", "no", "not", "of", "on", "or", "such", "that", "the", "their", "then", "there", "these", "they", "this", "to", "was", "will", "with"];
+
+
+/* Non-minified version is copied as a separate JS file, if available */
+
+/**
+ * Porter Stemmer
+ */
+var Stemmer = function() {
+
+ var step2list = {
+ ational: 'ate',
+ tional: 'tion',
+ enci: 'ence',
+ anci: 'ance',
+ izer: 'ize',
+ bli: 'ble',
+ alli: 'al',
+ entli: 'ent',
+ eli: 'e',
+ ousli: 'ous',
+ ization: 'ize',
+ ation: 'ate',
+ ator: 'ate',
+ alism: 'al',
+ iveness: 'ive',
+ fulness: 'ful',
+ ousness: 'ous',
+ aliti: 'al',
+ iviti: 'ive',
+ biliti: 'ble',
+ logi: 'log'
+ };
+
+ var step3list = {
+ icate: 'ic',
+ ative: '',
+ alize: 'al',
+ iciti: 'ic',
+ ical: 'ic',
+ ful: '',
+ ness: ''
+ };
+
+ var c = "[^aeiou]"; // consonant
+ var v = "[aeiouy]"; // vowel
+ var C = c + "[^aeiouy]*"; // consonant sequence
+ var V = v + "[aeiou]*"; // vowel sequence
+
+ var mgr0 = "^(" + C + ")?" + V + C; // [C]VC... is m>0
+ var meq1 = "^(" + C + ")?" + V + C + "(" + V + ")?$"; // [C]VC[V] is m=1
+ var mgr1 = "^(" + C + ")?" + V + C + V + C; // [C]VCVC... is m>1
+ var s_v = "^(" + C + ")?" + v; // vowel in stem
+
+ this.stemWord = function (w) {
+ var stem;
+ var suffix;
+ var firstch;
+ var origword = w;
+
+ if (w.length < 3)
+ return w;
+
+ var re;
+ var re2;
+ var re3;
+ var re4;
+
+ firstch = w.substr(0,1);
+ if (firstch == "y")
+ w = firstch.toUpperCase() + w.substr(1);
+
+ // Step 1a
+ re = /^(.+?)(ss|i)es$/;
+ re2 = /^(.+?)([^s])s$/;
+
+ if (re.test(w))
+ w = w.replace(re,"$1$2");
+ else if (re2.test(w))
+ w = w.replace(re2,"$1$2");
+
+ // Step 1b
+ re = /^(.+?)eed$/;
+ re2 = /^(.+?)(ed|ing)$/;
+ if (re.test(w)) {
+ var fp = re.exec(w);
+ re = new RegExp(mgr0);
+ if (re.test(fp[1])) {
+ re = /.$/;
+ w = w.replace(re,"");
+ }
+ }
+ else if (re2.test(w)) {
+ var fp = re2.exec(w);
+ stem = fp[1];
+ re2 = new RegExp(s_v);
+ if (re2.test(stem)) {
+ w = stem;
+ re2 = /(at|bl|iz)$/;
+ re3 = new RegExp("([^aeiouylsz])\\1$");
+ re4 = new RegExp("^" + C + v + "[^aeiouwxy]$");
+ if (re2.test(w))
+ w = w + "e";
+ else if (re3.test(w)) {
+ re = /.$/;
+ w = w.replace(re,"");
+ }
+ else if (re4.test(w))
+ w = w + "e";
+ }
+ }
+
+ // Step 1c
+ re = /^(.+?)y$/;
+ if (re.test(w)) {
+ var fp = re.exec(w);
+ stem = fp[1];
+ re = new RegExp(s_v);
+ if (re.test(stem))
+ w = stem + "i";
+ }
+
+ // Step 2
+ re = /^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/;
+ if (re.test(w)) {
+ var fp = re.exec(w);
+ stem = fp[1];
+ suffix = fp[2];
+ re = new RegExp(mgr0);
+ if (re.test(stem))
+ w = stem + step2list[suffix];
+ }
+
+ // Step 3
+ re = /^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/;
+ if (re.test(w)) {
+ var fp = re.exec(w);
+ stem = fp[1];
+ suffix = fp[2];
+ re = new RegExp(mgr0);
+ if (re.test(stem))
+ w = stem + step3list[suffix];
+ }
+
+ // Step 4
+ re = /^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/;
+ re2 = /^(.+?)(s|t)(ion)$/;
+ if (re.test(w)) {
+ var fp = re.exec(w);
+ stem = fp[1];
+ re = new RegExp(mgr1);
+ if (re.test(stem))
+ w = stem;
+ }
+ else if (re2.test(w)) {
+ var fp = re2.exec(w);
+ stem = fp[1] + fp[2];
+ re2 = new RegExp(mgr1);
+ if (re2.test(stem))
+ w = stem;
+ }
+
+ // Step 5
+ re = /^(.+?)e$/;
+ if (re.test(w)) {
+ var fp = re.exec(w);
+ stem = fp[1];
+ re = new RegExp(mgr1);
+ re2 = new RegExp(meq1);
+ re3 = new RegExp("^" + C + v + "[^aeiouwxy]$");
+ if (re.test(stem) || (re2.test(stem) && !(re3.test(stem))))
+ w = stem;
+ }
+ re = /ll$/;
+ re2 = new RegExp(mgr1);
+ if (re.test(w) && re2.test(w)) {
+ re = /.$/;
+ w = w.replace(re,"");
+ }
+
+ // and turn initial Y back to y
+ if (firstch == "y")
+ w = firstch.toLowerCase() + w.substr(1);
+ return w;
+ }
+}
+
diff --git a/_static/lewis-logo.png b/_static/lewis-logo.png
new file mode 100644
index 00000000..da6e4003
Binary files /dev/null and b/_static/lewis-logo.png differ
diff --git a/_static/minus.png b/_static/minus.png
new file mode 100644
index 00000000..d96755fd
Binary files /dev/null and b/_static/minus.png differ
diff --git a/_static/plus.png b/_static/plus.png
new file mode 100644
index 00000000..7107cec9
Binary files /dev/null and b/_static/plus.png differ
diff --git a/_static/pygments.css b/_static/pygments.css
new file mode 100644
index 00000000..84ab3030
--- /dev/null
+++ b/_static/pygments.css
@@ -0,0 +1,75 @@
+pre { line-height: 125%; }
+td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
+span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
+td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
+span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
+.highlight .hll { background-color: #ffffcc }
+.highlight { background: #f8f8f8; }
+.highlight .c { color: #3D7B7B; font-style: italic } /* Comment */
+.highlight .err { border: 1px solid #FF0000 } /* Error */
+.highlight .k { color: #008000; font-weight: bold } /* Keyword */
+.highlight .o { color: #666666 } /* Operator */
+.highlight .ch { color: #3D7B7B; font-style: italic } /* Comment.Hashbang */
+.highlight .cm { color: #3D7B7B; font-style: italic } /* Comment.Multiline */
+.highlight .cp { color: #9C6500 } /* Comment.Preproc */
+.highlight .cpf { color: #3D7B7B; font-style: italic } /* Comment.PreprocFile */
+.highlight .c1 { color: #3D7B7B; font-style: italic } /* Comment.Single */
+.highlight .cs { color: #3D7B7B; font-style: italic } /* Comment.Special */
+.highlight .gd { color: #A00000 } /* Generic.Deleted */
+.highlight .ge { font-style: italic } /* Generic.Emph */
+.highlight .ges { font-weight: bold; font-style: italic } /* Generic.EmphStrong */
+.highlight .gr { color: #E40000 } /* Generic.Error */
+.highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */
+.highlight .gi { color: #008400 } /* Generic.Inserted */
+.highlight .go { color: #717171 } /* Generic.Output */
+.highlight .gp { color: #000080; font-weight: bold } /* Generic.Prompt */
+.highlight .gs { font-weight: bold } /* Generic.Strong */
+.highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
+.highlight .gt { color: #0044DD } /* Generic.Traceback */
+.highlight .kc { color: #008000; font-weight: bold } /* Keyword.Constant */
+.highlight .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */
+.highlight .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */
+.highlight .kp { color: #008000 } /* Keyword.Pseudo */
+.highlight .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */
+.highlight .kt { color: #B00040 } /* Keyword.Type */
+.highlight .m { color: #666666 } /* Literal.Number */
+.highlight .s { color: #BA2121 } /* Literal.String */
+.highlight .na { color: #687822 } /* Name.Attribute */
+.highlight .nb { color: #008000 } /* Name.Builtin */
+.highlight .nc { color: #0000FF; font-weight: bold } /* Name.Class */
+.highlight .no { color: #880000 } /* Name.Constant */
+.highlight .nd { color: #AA22FF } /* Name.Decorator */
+.highlight .ni { color: #717171; font-weight: bold } /* Name.Entity */
+.highlight .ne { color: #CB3F38; font-weight: bold } /* Name.Exception */
+.highlight .nf { color: #0000FF } /* Name.Function */
+.highlight .nl { color: #767600 } /* Name.Label */
+.highlight .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */
+.highlight .nt { color: #008000; font-weight: bold } /* Name.Tag */
+.highlight .nv { color: #19177C } /* Name.Variable */
+.highlight .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */
+.highlight .w { color: #bbbbbb } /* Text.Whitespace */
+.highlight .mb { color: #666666 } /* Literal.Number.Bin */
+.highlight .mf { color: #666666 } /* Literal.Number.Float */
+.highlight .mh { color: #666666 } /* Literal.Number.Hex */
+.highlight .mi { color: #666666 } /* Literal.Number.Integer */
+.highlight .mo { color: #666666 } /* Literal.Number.Oct */
+.highlight .sa { color: #BA2121 } /* Literal.String.Affix */
+.highlight .sb { color: #BA2121 } /* Literal.String.Backtick */
+.highlight .sc { color: #BA2121 } /* Literal.String.Char */
+.highlight .dl { color: #BA2121 } /* Literal.String.Delimiter */
+.highlight .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */
+.highlight .s2 { color: #BA2121 } /* Literal.String.Double */
+.highlight .se { color: #AA5D1F; font-weight: bold } /* Literal.String.Escape */
+.highlight .sh { color: #BA2121 } /* Literal.String.Heredoc */
+.highlight .si { color: #A45A77; font-weight: bold } /* Literal.String.Interpol */
+.highlight .sx { color: #008000 } /* Literal.String.Other */
+.highlight .sr { color: #A45A77 } /* Literal.String.Regex */
+.highlight .s1 { color: #BA2121 } /* Literal.String.Single */
+.highlight .ss { color: #19177C } /* Literal.String.Symbol */
+.highlight .bp { color: #008000 } /* Name.Builtin.Pseudo */
+.highlight .fm { color: #0000FF } /* Name.Function.Magic */
+.highlight .vc { color: #19177C } /* Name.Variable.Class */
+.highlight .vg { color: #19177C } /* Name.Variable.Global */
+.highlight .vi { color: #19177C } /* Name.Variable.Instance */
+.highlight .vm { color: #19177C } /* Name.Variable.Magic */
+.highlight .il { color: #666666 } /* Literal.Number.Integer.Long */
\ No newline at end of file
diff --git a/_static/searchtools.js b/_static/searchtools.js
new file mode 100644
index 00000000..2c774d17
--- /dev/null
+++ b/_static/searchtools.js
@@ -0,0 +1,632 @@
+/*
+ * Sphinx JavaScript utilities for the full-text search.
+ */
+"use strict";
+
+/**
+ * Simple result scoring code.
+ */
+if (typeof Scorer === "undefined") {
+ var Scorer = {
+ // Implement the following function to further tweak the score for each result
+ // The function takes a result array [docname, title, anchor, descr, score, filename]
+ // and returns the new score.
+ /*
+ score: result => {
+ const [docname, title, anchor, descr, score, filename, kind] = result
+ return score
+ },
+ */
+
+ // query matches the full name of an object
+ objNameMatch: 11,
+ // or matches in the last dotted part of the object name
+ objPartialMatch: 6,
+ // Additive scores depending on the priority of the object
+ objPrio: {
+ 0: 15, // used to be importantResults
+ 1: 5, // used to be objectResults
+ 2: -5, // used to be unimportantResults
+ },
+ // Used when the priority is not in the mapping.
+ objPrioDefault: 0,
+
+ // query found in title
+ title: 15,
+ partialTitle: 7,
+ // query found in terms
+ term: 5,
+ partialTerm: 2,
+ };
+}
+
+// Global search result kind enum, used by themes to style search results.
+class SearchResultKind {
+ static get index() { return "index"; }
+ static get object() { return "object"; }
+ static get text() { return "text"; }
+ static get title() { return "title"; }
+}
+
+const _removeChildren = (element) => {
+ while (element && element.lastChild) element.removeChild(element.lastChild);
+};
+
+/**
+ * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#escaping
+ */
+const _escapeRegExp = (string) =>
+ string.replace(/[.*+\-?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string
+
+const _displayItem = (item, searchTerms, highlightTerms) => {
+ const docBuilder = DOCUMENTATION_OPTIONS.BUILDER;
+ const docFileSuffix = DOCUMENTATION_OPTIONS.FILE_SUFFIX;
+ const docLinkSuffix = DOCUMENTATION_OPTIONS.LINK_SUFFIX;
+ const showSearchSummary = DOCUMENTATION_OPTIONS.SHOW_SEARCH_SUMMARY;
+ const contentRoot = document.documentElement.dataset.content_root;
+
+ const [docName, title, anchor, descr, score, _filename, kind] = item;
+
+ let listItem = document.createElement("li");
+ // Add a class representing the item's type:
+ // can be used by a theme's CSS selector for styling
+ // See SearchResultKind for the class names.
+ listItem.classList.add(`kind-${kind}`);
+ let requestUrl;
+ let linkUrl;
+ if (docBuilder === "dirhtml") {
+ // dirhtml builder
+ let dirname = docName + "/";
+ if (dirname.match(/\/index\/$/))
+ dirname = dirname.substring(0, dirname.length - 6);
+ else if (dirname === "index/") dirname = "";
+ requestUrl = contentRoot + dirname;
+ linkUrl = requestUrl;
+ } else {
+ // normal html builders
+ requestUrl = contentRoot + docName + docFileSuffix;
+ linkUrl = docName + docLinkSuffix;
+ }
+ let linkEl = listItem.appendChild(document.createElement("a"));
+ linkEl.href = linkUrl + anchor;
+ linkEl.dataset.score = score;
+ linkEl.innerHTML = title;
+ if (descr) {
+ listItem.appendChild(document.createElement("span")).innerHTML =
+ " (" + descr + ")";
+ // highlight search terms in the description
+ if (SPHINX_HIGHLIGHT_ENABLED) // set in sphinx_highlight.js
+ highlightTerms.forEach((term) => _highlightText(listItem, term, "highlighted"));
+ }
+ else if (showSearchSummary)
+ fetch(requestUrl)
+ .then((responseData) => responseData.text())
+ .then((data) => {
+ if (data)
+ listItem.appendChild(
+ Search.makeSearchSummary(data, searchTerms, anchor)
+ );
+ // highlight search terms in the summary
+ if (SPHINX_HIGHLIGHT_ENABLED) // set in sphinx_highlight.js
+ highlightTerms.forEach((term) => _highlightText(listItem, term, "highlighted"));
+ });
+ Search.output.appendChild(listItem);
+};
+const _finishSearch = (resultCount) => {
+ Search.stopPulse();
+ Search.title.innerText = _("Search Results");
+ if (!resultCount)
+ Search.status.innerText = Documentation.gettext(
+ "Your search did not match any documents. Please make sure that all words are spelled correctly and that you've selected enough categories."
+ );
+ else
+ Search.status.innerText = Documentation.ngettext(
+ "Search finished, found one page matching the search query.",
+ "Search finished, found ${resultCount} pages matching the search query.",
+ resultCount,
+ ).replace('${resultCount}', resultCount);
+};
+const _displayNextItem = (
+ results,
+ resultCount,
+ searchTerms,
+ highlightTerms,
+) => {
+ // results left, load the summary and display it
+ // this is intended to be dynamic (don't sub resultsCount)
+ if (results.length) {
+ _displayItem(results.pop(), searchTerms, highlightTerms);
+ setTimeout(
+ () => _displayNextItem(results, resultCount, searchTerms, highlightTerms),
+ 5
+ );
+ }
+ // search finished, update title and status message
+ else _finishSearch(resultCount);
+};
+// Helper function used by query() to order search results.
+// Each input is an array of [docname, title, anchor, descr, score, filename, kind].
+// Order the results by score (in opposite order of appearance, since the
+// `_displayNextItem` function uses pop() to retrieve items) and then alphabetically.
+const _orderResultsByScoreThenName = (a, b) => {
+ const leftScore = a[4];
+ const rightScore = b[4];
+ if (leftScore === rightScore) {
+ // same score: sort alphabetically
+ const leftTitle = a[1].toLowerCase();
+ const rightTitle = b[1].toLowerCase();
+ if (leftTitle === rightTitle) return 0;
+ return leftTitle > rightTitle ? -1 : 1; // inverted is intentional
+ }
+ return leftScore > rightScore ? 1 : -1;
+};
+
+/**
+ * Default splitQuery function. Can be overridden in ``sphinx.search`` with a
+ * custom function per language.
+ *
+ * The regular expression works by splitting the string on consecutive characters
+ * that are not Unicode letters, numbers, underscores, or emoji characters.
+ * This is the same as ``\W+`` in Python, preserving the surrogate pair area.
+ */
+if (typeof splitQuery === "undefined") {
+ var splitQuery = (query) => query
+ .split(/[^\p{Letter}\p{Number}_\p{Emoji_Presentation}]+/gu)
+ .filter(term => term) // remove remaining empty strings
+}
+
+/**
+ * Search Module
+ */
+const Search = {
+ _index: null,
+ _queued_query: null,
+ _pulse_status: -1,
+
+ htmlToText: (htmlString, anchor) => {
+ const htmlElement = new DOMParser().parseFromString(htmlString, 'text/html');
+ for (const removalQuery of [".headerlink", "script", "style"]) {
+ htmlElement.querySelectorAll(removalQuery).forEach((el) => { el.remove() });
+ }
+ if (anchor) {
+ const anchorContent = htmlElement.querySelector(`[role="main"] ${anchor}`);
+ if (anchorContent) return anchorContent.textContent;
+
+ console.warn(
+ `Anchored content block not found. Sphinx search tries to obtain it via DOM query '[role=main] ${anchor}'. Check your theme or template.`
+ );
+ }
+
+ // if anchor not specified or not found, fall back to main content
+ const docContent = htmlElement.querySelector('[role="main"]');
+ if (docContent) return docContent.textContent;
+
+ console.warn(
+ "Content block not found. Sphinx search tries to obtain it via DOM query '[role=main]'. Check your theme or template."
+ );
+ return "";
+ },
+
+ init: () => {
+ const query = new URLSearchParams(window.location.search).get("q");
+ document
+ .querySelectorAll('input[name="q"]')
+ .forEach((el) => (el.value = query));
+ if (query) Search.performSearch(query);
+ },
+
+ loadIndex: (url) =>
+ (document.body.appendChild(document.createElement("script")).src = url),
+
+ setIndex: (index) => {
+ Search._index = index;
+ if (Search._queued_query !== null) {
+ const query = Search._queued_query;
+ Search._queued_query = null;
+ Search.query(query);
+ }
+ },
+
+ hasIndex: () => Search._index !== null,
+
+ deferQuery: (query) => (Search._queued_query = query),
+
+ stopPulse: () => (Search._pulse_status = -1),
+
+ startPulse: () => {
+ if (Search._pulse_status >= 0) return;
+
+ const pulse = () => {
+ Search._pulse_status = (Search._pulse_status + 1) % 4;
+ Search.dots.innerText = ".".repeat(Search._pulse_status);
+ if (Search._pulse_status >= 0) window.setTimeout(pulse, 500);
+ };
+ pulse();
+ },
+
+ /**
+ * perform a search for something (or wait until index is loaded)
+ */
+ performSearch: (query) => {
+ // create the required interface elements
+ const searchText = document.createElement("h2");
+ searchText.textContent = _("Searching");
+ const searchSummary = document.createElement("p");
+ searchSummary.classList.add("search-summary");
+ searchSummary.innerText = "";
+ const searchList = document.createElement("ul");
+ searchList.setAttribute("role", "list");
+ searchList.classList.add("search");
+
+ const out = document.getElementById("search-results");
+ Search.title = out.appendChild(searchText);
+ Search.dots = Search.title.appendChild(document.createElement("span"));
+ Search.status = out.appendChild(searchSummary);
+ Search.output = out.appendChild(searchList);
+
+ const searchProgress = document.getElementById("search-progress");
+ // Some themes don't use the search progress node
+ if (searchProgress) {
+ searchProgress.innerText = _("Preparing search...");
+ }
+ Search.startPulse();
+
+ // index already loaded, the browser was quick!
+ if (Search.hasIndex()) Search.query(query);
+ else Search.deferQuery(query);
+ },
+
+ _parseQuery: (query) => {
+ // stem the search terms and add them to the correct list
+ const stemmer = new Stemmer();
+ const searchTerms = new Set();
+ const excludedTerms = new Set();
+ const highlightTerms = new Set();
+ const objectTerms = new Set(splitQuery(query.toLowerCase().trim()));
+ splitQuery(query.trim()).forEach((queryTerm) => {
+ const queryTermLower = queryTerm.toLowerCase();
+
+ // maybe skip this "word"
+ // stopwords array is from language_data.js
+ if (
+ stopwords.indexOf(queryTermLower) !== -1 ||
+ queryTerm.match(/^\d+$/)
+ )
+ return;
+
+ // stem the word
+ let word = stemmer.stemWord(queryTermLower);
+ // select the correct list
+ if (word[0] === "-") excludedTerms.add(word.substr(1));
+ else {
+ searchTerms.add(word);
+ highlightTerms.add(queryTermLower);
+ }
+ });
+
+ if (SPHINX_HIGHLIGHT_ENABLED) { // set in sphinx_highlight.js
+ localStorage.setItem("sphinx_highlight_terms", [...highlightTerms].join(" "))
+ }
+
+ // console.debug("SEARCH: searching for:");
+ // console.info("required: ", [...searchTerms]);
+ // console.info("excluded: ", [...excludedTerms]);
+
+ return [query, searchTerms, excludedTerms, highlightTerms, objectTerms];
+ },
+
+ /**
+ * execute search (requires search index to be loaded)
+ */
+ _performSearch: (query, searchTerms, excludedTerms, highlightTerms, objectTerms) => {
+ const filenames = Search._index.filenames;
+ const docNames = Search._index.docnames;
+ const titles = Search._index.titles;
+ const allTitles = Search._index.alltitles;
+ const indexEntries = Search._index.indexentries;
+
+ // Collect multiple result groups to be sorted separately and then ordered.
+ // Each is an array of [docname, title, anchor, descr, score, filename, kind].
+ const normalResults = [];
+ const nonMainIndexResults = [];
+
+ _removeChildren(document.getElementById("search-progress"));
+
+ const queryLower = query.toLowerCase().trim();
+ for (const [title, foundTitles] of Object.entries(allTitles)) {
+ if (title.toLowerCase().trim().includes(queryLower) && (queryLower.length >= title.length/2)) {
+ for (const [file, id] of foundTitles) {
+ const score = Math.round(Scorer.title * queryLower.length / title.length);
+ const boost = titles[file] === title ? 1 : 0; // add a boost for document titles
+ normalResults.push([
+ docNames[file],
+ titles[file] !== title ? `${titles[file]} > ${title}` : title,
+ id !== null ? "#" + id : "",
+ null,
+ score + boost,
+ filenames[file],
+ SearchResultKind.title,
+ ]);
+ }
+ }
+ }
+
+ // search for explicit entries in index directives
+ for (const [entry, foundEntries] of Object.entries(indexEntries)) {
+ if (entry.includes(queryLower) && (queryLower.length >= entry.length/2)) {
+ for (const [file, id, isMain] of foundEntries) {
+ const score = Math.round(100 * queryLower.length / entry.length);
+ const result = [
+ docNames[file],
+ titles[file],
+ id ? "#" + id : "",
+ null,
+ score,
+ filenames[file],
+ SearchResultKind.index,
+ ];
+ if (isMain) {
+ normalResults.push(result);
+ } else {
+ nonMainIndexResults.push(result);
+ }
+ }
+ }
+ }
+
+ // lookup as object
+ objectTerms.forEach((term) =>
+ normalResults.push(...Search.performObjectSearch(term, objectTerms))
+ );
+
+ // lookup as search terms in fulltext
+ normalResults.push(...Search.performTermsSearch(searchTerms, excludedTerms));
+
+ // let the scorer override scores with a custom scoring function
+ if (Scorer.score) {
+ normalResults.forEach((item) => (item[4] = Scorer.score(item)));
+ nonMainIndexResults.forEach((item) => (item[4] = Scorer.score(item)));
+ }
+
+ // Sort each group of results by score and then alphabetically by name.
+ normalResults.sort(_orderResultsByScoreThenName);
+ nonMainIndexResults.sort(_orderResultsByScoreThenName);
+
+ // Combine the result groups in (reverse) order.
+ // Non-main index entries are typically arbitrary cross-references,
+ // so display them after other results.
+ let results = [...nonMainIndexResults, ...normalResults];
+
+ // remove duplicate search results
+ // note the reversing of results, so that in the case of duplicates, the highest-scoring entry is kept
+ let seen = new Set();
+ results = results.reverse().reduce((acc, result) => {
+ let resultStr = result.slice(0, 4).concat([result[5]]).map(v => String(v)).join(',');
+ if (!seen.has(resultStr)) {
+ acc.push(result);
+ seen.add(resultStr);
+ }
+ return acc;
+ }, []);
+
+ return results.reverse();
+ },
+
+ query: (query) => {
+ const [searchQuery, searchTerms, excludedTerms, highlightTerms, objectTerms] = Search._parseQuery(query);
+ const results = Search._performSearch(searchQuery, searchTerms, excludedTerms, highlightTerms, objectTerms);
+
+ // for debugging
+ //Search.lastresults = results.slice(); // a copy
+ // console.info("search results:", Search.lastresults);
+
+ // print the results
+ _displayNextItem(results, results.length, searchTerms, highlightTerms);
+ },
+
+ /**
+ * search for object names
+ */
+ performObjectSearch: (object, objectTerms) => {
+ const filenames = Search._index.filenames;
+ const docNames = Search._index.docnames;
+ const objects = Search._index.objects;
+ const objNames = Search._index.objnames;
+ const titles = Search._index.titles;
+
+ const results = [];
+
+ const objectSearchCallback = (prefix, match) => {
+ const name = match[4]
+ const fullname = (prefix ? prefix + "." : "") + name;
+ const fullnameLower = fullname.toLowerCase();
+ if (fullnameLower.indexOf(object) < 0) return;
+
+ let score = 0;
+ const parts = fullnameLower.split(".");
+
+ // check for different match types: exact matches of full name or
+ // "last name" (i.e. last dotted part)
+ if (fullnameLower === object || parts.slice(-1)[0] === object)
+ score += Scorer.objNameMatch;
+ else if (parts.slice(-1)[0].indexOf(object) > -1)
+ score += Scorer.objPartialMatch; // matches in last name
+
+ const objName = objNames[match[1]][2];
+ const title = titles[match[0]];
+
+ // If more than one term searched for, we require other words to be
+ // found in the name/title/description
+ const otherTerms = new Set(objectTerms);
+ otherTerms.delete(object);
+ if (otherTerms.size > 0) {
+ const haystack = `${prefix} ${name} ${objName} ${title}`.toLowerCase();
+ if (
+ [...otherTerms].some((otherTerm) => haystack.indexOf(otherTerm) < 0)
+ )
+ return;
+ }
+
+ let anchor = match[3];
+ if (anchor === "") anchor = fullname;
+ else if (anchor === "-") anchor = objNames[match[1]][1] + "-" + fullname;
+
+ const descr = objName + _(", in ") + title;
+
+ // add custom score for some objects according to scorer
+ if (Scorer.objPrio.hasOwnProperty(match[2]))
+ score += Scorer.objPrio[match[2]];
+ else score += Scorer.objPrioDefault;
+
+ results.push([
+ docNames[match[0]],
+ fullname,
+ "#" + anchor,
+ descr,
+ score,
+ filenames[match[0]],
+ SearchResultKind.object,
+ ]);
+ };
+ Object.keys(objects).forEach((prefix) =>
+ objects[prefix].forEach((array) =>
+ objectSearchCallback(prefix, array)
+ )
+ );
+ return results;
+ },
+
+ /**
+ * search for full-text terms in the index
+ */
+ performTermsSearch: (searchTerms, excludedTerms) => {
+ // prepare search
+ const terms = Search._index.terms;
+ const titleTerms = Search._index.titleterms;
+ const filenames = Search._index.filenames;
+ const docNames = Search._index.docnames;
+ const titles = Search._index.titles;
+
+ const scoreMap = new Map();
+ const fileMap = new Map();
+
+ // perform the search on the required terms
+ searchTerms.forEach((word) => {
+ const files = [];
+ const arr = [
+ { files: terms[word], score: Scorer.term },
+ { files: titleTerms[word], score: Scorer.title },
+ ];
+ // add support for partial matches
+ if (word.length > 2) {
+ const escapedWord = _escapeRegExp(word);
+ if (!terms.hasOwnProperty(word)) {
+ Object.keys(terms).forEach((term) => {
+ if (term.match(escapedWord))
+ arr.push({ files: terms[term], score: Scorer.partialTerm });
+ });
+ }
+ if (!titleTerms.hasOwnProperty(word)) {
+ Object.keys(titleTerms).forEach((term) => {
+ if (term.match(escapedWord))
+ arr.push({ files: titleTerms[term], score: Scorer.partialTitle });
+ });
+ }
+ }
+
+ // no match but word was a required one
+ if (arr.every((record) => record.files === undefined)) return;
+
+ // found search word in contents
+ arr.forEach((record) => {
+ if (record.files === undefined) return;
+
+ let recordFiles = record.files;
+ if (recordFiles.length === undefined) recordFiles = [recordFiles];
+ files.push(...recordFiles);
+
+ // set score for the word in each file
+ recordFiles.forEach((file) => {
+ if (!scoreMap.has(file)) scoreMap.set(file, {});
+ scoreMap.get(file)[word] = record.score;
+ });
+ });
+
+ // create the mapping
+ files.forEach((file) => {
+ if (!fileMap.has(file)) fileMap.set(file, [word]);
+ else if (fileMap.get(file).indexOf(word) === -1) fileMap.get(file).push(word);
+ });
+ });
+
+ // now check if the files don't contain excluded terms
+ const results = [];
+ for (const [file, wordList] of fileMap) {
+ // check if all requirements are matched
+
+ // as search terms with length < 3 are discarded
+ const filteredTermCount = [...searchTerms].filter(
+ (term) => term.length > 2
+ ).length;
+ if (
+ wordList.length !== searchTerms.size &&
+ wordList.length !== filteredTermCount
+ )
+ continue;
+
+ // ensure that none of the excluded terms is in the search result
+ if (
+ [...excludedTerms].some(
+ (term) =>
+ terms[term] === file ||
+ titleTerms[term] === file ||
+ (terms[term] || []).includes(file) ||
+ (titleTerms[term] || []).includes(file)
+ )
+ )
+ break;
+
+ // select one (max) score for the file.
+ const score = Math.max(...wordList.map((w) => scoreMap.get(file)[w]));
+ // add result to the result list
+ results.push([
+ docNames[file],
+ titles[file],
+ "",
+ null,
+ score,
+ filenames[file],
+ SearchResultKind.text,
+ ]);
+ }
+ return results;
+ },
+
+ /**
+ * helper function to return a node containing the
+ * search summary for a given text. keywords is a list
+ * of stemmed words.
+ */
+ makeSearchSummary: (htmlText, keywords, anchor) => {
+ const text = Search.htmlToText(htmlText, anchor);
+ if (text === "") return null;
+
+ const textLower = text.toLowerCase();
+ const actualStartPosition = [...keywords]
+ .map((k) => textLower.indexOf(k.toLowerCase()))
+ .filter((i) => i > -1)
+ .slice(-1)[0];
+ const startWithContext = Math.max(actualStartPosition - 120, 0);
+
+ const top = startWithContext === 0 ? "" : "...";
+ const tail = startWithContext + 240 < text.length ? "..." : "";
+
+ let summary = document.createElement("p");
+ summary.classList.add("context");
+ summary.textContent = top + text.substr(startWithContext, 240).trim() + tail;
+
+ return summary;
+ },
+};
+
+_ready(Search.init);
diff --git a/_static/sphinx_highlight.js b/_static/sphinx_highlight.js
new file mode 100644
index 00000000..8a96c69a
--- /dev/null
+++ b/_static/sphinx_highlight.js
@@ -0,0 +1,154 @@
+/* Highlighting utilities for Sphinx HTML documentation. */
+"use strict";
+
+const SPHINX_HIGHLIGHT_ENABLED = true
+
+/**
+ * highlight a given string on a node by wrapping it in
+ * span elements with the given class name.
+ */
+const _highlight = (node, addItems, text, className) => {
+ if (node.nodeType === Node.TEXT_NODE) {
+ const val = node.nodeValue;
+ const parent = node.parentNode;
+ const pos = val.toLowerCase().indexOf(text);
+ if (
+ pos >= 0 &&
+ !parent.classList.contains(className) &&
+ !parent.classList.contains("nohighlight")
+ ) {
+ let span;
+
+ const closestNode = parent.closest("body, svg, foreignObject");
+ const isInSVG = closestNode && closestNode.matches("svg");
+ if (isInSVG) {
+ span = document.createElementNS("http://www.w3.org/2000/svg", "tspan");
+ } else {
+ span = document.createElement("span");
+ span.classList.add(className);
+ }
+
+ span.appendChild(document.createTextNode(val.substr(pos, text.length)));
+ const rest = document.createTextNode(val.substr(pos + text.length));
+ parent.insertBefore(
+ span,
+ parent.insertBefore(
+ rest,
+ node.nextSibling
+ )
+ );
+ node.nodeValue = val.substr(0, pos);
+ /* There may be more occurrences of search term in this node. So call this
+ * function recursively on the remaining fragment.
+ */
+ _highlight(rest, addItems, text, className);
+
+ if (isInSVG) {
+ const rect = document.createElementNS(
+ "http://www.w3.org/2000/svg",
+ "rect"
+ );
+ const bbox = parent.getBBox();
+ rect.x.baseVal.value = bbox.x;
+ rect.y.baseVal.value = bbox.y;
+ rect.width.baseVal.value = bbox.width;
+ rect.height.baseVal.value = bbox.height;
+ rect.setAttribute("class", className);
+ addItems.push({ parent: parent, target: rect });
+ }
+ }
+ } else if (node.matches && !node.matches("button, select, textarea")) {
+ node.childNodes.forEach((el) => _highlight(el, addItems, text, className));
+ }
+};
+const _highlightText = (thisNode, text, className) => {
+ let addItems = [];
+ _highlight(thisNode, addItems, text, className);
+ addItems.forEach((obj) =>
+ obj.parent.insertAdjacentElement("beforebegin", obj.target)
+ );
+};
+
+/**
+ * Small JavaScript module for the documentation.
+ */
+const SphinxHighlight = {
+
+ /**
+ * highlight the search words provided in localstorage in the text
+ */
+ highlightSearchWords: () => {
+ if (!SPHINX_HIGHLIGHT_ENABLED) return; // bail if no highlight
+
+ // get and clear terms from localstorage
+ const url = new URL(window.location);
+ const highlight =
+ localStorage.getItem("sphinx_highlight_terms")
+ || url.searchParams.get("highlight")
+ || "";
+ localStorage.removeItem("sphinx_highlight_terms")
+ url.searchParams.delete("highlight");
+ window.history.replaceState({}, "", url);
+
+ // get individual terms from highlight string
+ const terms = highlight.toLowerCase().split(/\s+/).filter(x => x);
+ if (terms.length === 0) return; // nothing to do
+
+ // There should never be more than one element matching "div.body"
+ const divBody = document.querySelectorAll("div.body");
+ const body = divBody.length ? divBody[0] : document.querySelector("body");
+ window.setTimeout(() => {
+ terms.forEach((term) => _highlightText(body, term, "highlighted"));
+ }, 10);
+
+ const searchBox = document.getElementById("searchbox");
+ if (searchBox === null) return;
+ searchBox.appendChild(
+ document
+ .createRange()
+ .createContextualFragment(
+ '
+ ${renderLanguages(config)}
+ ${renderVersions(config)}
+ ${renderDownloads(config)}
+
+ + Hosted by Read the Docs + +
+ -
+
- On Read the Docs +
- + Project Home + +
- + Builds + +
- + Downloads + +
-
+
- Search +
- + + +
+ + Hosted by Read the Docs + +
' + + '' + + _("Hide Search Matches") + + "
" + ) + ); + }, + + /** + * helper function to hide the search marks again + */ + hideSearchWords: () => { + document + .querySelectorAll("#searchbox .highlight-link") + .forEach((el) => el.remove()); + document + .querySelectorAll("span.highlighted") + .forEach((el) => el.classList.remove("highlighted")); + localStorage.removeItem("sphinx_highlight_terms") + }, + + initEscapeListener: () => { + // only install a listener if it is really needed + if (!DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS) return; + + document.addEventListener("keydown", (event) => { + // bail for input elements + if (BLACKLISTED_KEY_CONTROL_ELEMENTS.has(document.activeElement.tagName)) return; + // bail with special keys + if (event.shiftKey || event.altKey || event.ctrlKey || event.metaKey) return; + if (DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS && (event.key === "Escape")) { + SphinxHighlight.hideSearchWords(); + event.preventDefault(); + } + }); + }, +}; + +_ready(() => { + /* Do not call highlightSearchWords() when we are on the search page. + * It will highlight words from the *previous* search query. + */ + if (typeof Search === "undefined") SphinxHighlight.highlightSearchWords(); + SphinxHighlight.initEscapeListener(); +}); diff --git a/developer_guide/developing_lewis.html b/developer_guide/developing_lewis.html new file mode 100644 index 00000000..fedd462e --- /dev/null +++ b/developer_guide/developing_lewis.html @@ -0,0 +1,202 @@ + + + + + + + + +
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/developer_guide/framework_details.html b/developer_guide/framework_details.html
new file mode 100644
index 00000000..63a8c2c3
--- /dev/null
+++ b/developer_guide/framework_details.html
@@ -0,0 +1,206 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Developing Lewis
+Begin by checking-out the source from GitHub:
+(lewis-dev)$ git clone https://github.com/ISISComputingGroup/lewis.git
+To develop Lewis, it is strongly recommended to work in a dedicated virtual environment, otherwise +it is not possible to have another version of Lewis installed system wide in parallel.
+With the virtual environment activated, Lewis can be installed as an editable package:
+(lewis-dev)$ cd lewis
+(lewis-dev)$ python -m pip install ".[dev]"
+Now the Lewis package that resides in lewis can be modified, while it is still treated like a
+normal package that has been installed via pip.
Alternatively, Lewis can be run from source. For this it is necessary to install the requirements first:
+(lewis-dev)$ cd lewis
+(lewis-dev)$ python -m pip install -r requirements-dev.txt
+Either way, to make sure that everything is working as +intended, run the unit tests and check for pep8 errors, as well as build the documentation:
+(lewis-dev)$ pytest tests
+(lewis-dev)$ flake8 setup.py lewis scripts system-tests tests
+(lewis-dev)$ sphinx-build -W -b html docs/ docs/_build/html
+There are also system-tests that (partially) test Lewis from the application/run-time level. These tests are based on
+the Approval Tests Framework <https://approvaltests.com/>__ which works by comparing a program’s standard output
+against a “golden master” - if the output doesn’t match then the tests fail.
+For lewis and lewis-control the tests check that the programs work together correctly. For example: if a value
+on a simulated device in lewis is changed via ``lewis-control``` then by querying the status of the device the
+values can be compared against the expected status (the “golden master”). The tests can be run like so:
(lewis-dev)$ pytest system_tests/lewis_tests.py
+It is good practice to run these tests regularly during development and, also, look for opportunities to add +more tests. The tests will also be run via the CI system.
+A more comprehensive way of running all tests is to use tox, which creates fresh virtual
+environments for all of these tasks:
(lewis-dev)$ tox
+The advantage of tox is that it generates a source package from the source tree and installs +it in the virtual environments that it creates, testing closer to the thing that is actually +installed in the end. Running all the verification steps this way takes a bit longer, so during +development it might be more desirable to just run the components that are necessary.
+Before starting development it is important to install the pre-commit hooks, so that formatting and flake8 checks
+are performed before code is committed:
(lewis-dev)$ pre-commit install
+To test that the hooks are installed correctly and to run them manually use the following command:
+(lewis-dev)$ pre-commit run --all-files
+Development should happen in a separate branch. If the work is related to a specific issue, +it is good practice to include the issue number in the branch name, along with a short +summary of a few words, for example:
+(lewis-dev)$ git checkout -b 123_enhance_logic_flow
+It’s also good practice to push the branch back to github from time to time, so that other +members of the development team can see what’s going on (even before a pull request is opened):
+(lewis-dev)$ git push origin 123_enhance_logic_flow
+During development it is good practice to regularly test that changes do not break existing +or new tests. Before opening a pull request on github (which will run all the tests again +under different Python environments via the CI system), it is recommended to run tox one last time +locally, as that resembles the conditions in the CI environment quite closely.
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/developer_guide/release_checklist.html b/developer_guide/release_checklist.html
new file mode 100644
index 00000000..7c71cdc6
--- /dev/null
+++ b/developer_guide/release_checklist.html
@@ -0,0 +1,261 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Framework Details
+The Lewis framework is built around a cycle-driven core which in turn drives +the device simulation, including an optional StateMachine, and shared protocol +adapters that separate the communication layer from the simulated device.
+
Cycle-driven
+All processing in the framework occurs during “heartbeat” simulation ticks
+which propagate calls to process methods throughout the simulation,
+along with a Δt parameter that contains the time that has
+passed since the last tick. The device simulation is then responsible for
+updating its state based on how much time has passed and what input has
+been received during that time.
The benefits of this approach include:
+-
+
This closely models real device behaviour, since processing in +electronic devices naturally occurs on a cycle basis.
+As a side-effect of the above, certain quirks of real devices are +often captured by the simulated device naturally, without additional +effort.
+The simulation becomes deterministic: The same amount of process +cycles, with the same Δt parameters along the way, and +the same input via the device protocol, will always result in exactly +the same device state.
+Simulation speed can be controlled by increasing (fast-forward) or +decreasing (slow-motion) the Δt parameter by a given factor.
+Simulation fidelity can be controlled independently from speed by +increasing or decreasing the number of cycles per second while +adjusting the Δt parameter to compensate.
+
The above traits are very desirable both for running automated tests +against the simulation, and for debugging any issues that are +identified.
+Statemachine
+A class designed for a cycle-driven approach is provided to allow modeling complex +device behaviour in an event-driven fashion.
+A device may initialize a statemachine on construction, telling it what +states the device can be in and what conditions should cause it to +transition between them. The statemachine will automatically check +eligible (exiting current state) transition conditions every cycle and +perform transitions as necessary, triggering callbacks for any event +that occurs. The following events are available for every state:
+-
+
on_exitis triggered once just before exiting the state
+on_entryis triggered once when entering the state
+in_stateis triggered every cycle that ends in the state
+
Every cycle will trigger exactly one in_state event. This will
+always be the last event of the cycle. When no transition occurs, this
+is the only event. On the very first cycle of a simulation run,
+on_entry is raised against the initial state before raising an
+in_state against it. Any other cycles that involve a transition
+first raise on_exit against the current state, and then raise
+on_entry and in_state against the new state. Only one transition
+may occur per cycle.
There are three ways to specify event handlers when initializing the +statemachine:
+-
+
Object-Oriented: Implement one class per state, derived from +
lewis.core.statemachine.State, which optionally contains up to +one of each event handler
+Function-Driven: Bind individual functions to individual events that +need handling
+Implicit: Implement handlers in the device class, with standard names +like
on_entry_initfor a state called “init”, and call +bindHandlersByName()
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/developer_guide/writing_devices.html b/developer_guide/writing_devices.html
new file mode 100644
index 00000000..ae95ac30
--- /dev/null
+++ b/developer_guide/writing_devices.html
@@ -0,0 +1,549 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Release Checklist
+This document provides a check list of steps to take and things to watch out +for when preparing a new release of Lewis. It is organized roughly in the order +that these things need to be done or checked.
+If any issues are found, it is best to start again at the top once they are +resolved and the fix is merged.
+Preparing for Release
+These steps are to prepare for a release on Git, and to commit as a pull +request named “Prepare release x.y.z”. This pull request should be merged +prior to proceeding to the next section.
+Git Milestones
+-
+
Go to https://github.com/ISISComputingGroup/lewis/milestones
+Ensure all issues and PRs included in this release are tagged correctly
+Create milestone for next release
+Ensure any open issues or PRs not included are tagged for next release
+
Release Notes
+-
+
Ensure release notes are up to date against all included changes
+If changes to existing devices may be required to update Lewis, include an +Update Guide section in the release notes
+Include new release notes in
docs/release_notes/
+Remove orphan tag from release notes for this release
+
Update Version
+-
+
Update
__version__inlewis/__init__.py
+Update
releaseindocs/conf.py
+Update
versioninsetup.py
+
GitHub Release
+-
+
Draft release blurb at https://github.com/ISISComputingGroup/lewis/releases
+
Merge Changes
+-
+
Merge any changes made in this section into the main branch
+Ensure this pull request is also tagged for the current version
+
Build and Finalize Release
+These steps should be taken once the ones in the previous section have been +completed.
+Build PyPI Package
+This should be done in a clean directory.
+$ python -m venv build
+$ . build/bin/activate
+(build) $ git clone https://github.com/ISISComputingGroup/lewis.git
+(build) $ cd lewis
+(build) $ pip install twine wheel
+(build) $ python setup.py sdist bdist_wheel
+(build) $ twine check dist/*
+(build) $ deactivate
+Test PyPI Package
+Ideally, .tar.gz and .whl produced in previous step should also be shared
+with and tested by another developer.
Make sure tests are run in a fresh virtual environment:
+$ python -m venv targz
+$ . targz/bin/activate
+(targz) $ pip install lewis/dist/lewis-X.Y.Z.tar.gz
+(targz) $ lewis linkam_t95
+...
+(targz) $ deactivate
+
+$ python -m venv whl
+$ . whl/bin/activate
+(whl) $ pip install lewis/dist/lewis-X.Y.Z-py3-none-any.whl
+(whl) $ lewis linkam_t95
+...
+(whl) $ deactivate
+Since these are release packages, unit tests aren’t available. Run a few manual +tests against the packaged version of Lewis to double check that things still +work as expected.
+Git Release
+-
+
Finalize and submit release blurb at: +https://github.com/ISISComputingGroup/lewis/releases
+Close the current milestone at: +https://github.com/ISISComputingGroup/lewis/milestones
+
Upload PyPI Package
+The twine utility can be used to upload the packages to PyPI:
$ twine upload dist/*
+Note: requires a PyPi account and lewis permissions.
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.adapters.epics.html b/generated/lewis.adapters.epics.html
new file mode 100644
index 00000000..25c7e21f
--- /dev/null
+++ b/generated/lewis.adapters.epics.html
@@ -0,0 +1,452 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Writing Device Simulators
+The following section describes how to write a new device simulator, what to +consider, and how to get the changes upstream.
+Preparations
+The Lewis framework provides all the infrastructure to run device +simulations so that developing a new simulation requires little more +than writing code for the actual device.
+The process of writing a new device simulator is best explained using +the example of a stateful device.
+All that is required to develop a new device is to install Lewis, preferably +in a fresh virtual environment:
+$ pip install lewis
+Device analysis
+The hypothetical device that is to be simulated is a simple controller
+that controls one motor and can be communicated with via a
+TCP <https://en.wikipedia.org/wiki/Transmission_Control_Protocol>__
+connection. The user can connect to the device using telnet and submit
+commands followed by \r\n (automatically added by
+telnet <https://linux.die.net/man/1/telnet>__). Responses are followed
+by \r\n as well. The following commands and responses are available:
-
+
S?: Returns the status of the motor connected to the controller. +Can be eitheridleormoving, is initiallyidle.
+P?: Returns the current position of the motor in mm. Is initially 0.
+T=10.0: Sets the target position to10.0(accepts any +floating point number) and starts a movement if the position is +within the limits [0, 250] and returnsT=10.0. If the motor is +not in idle state, it returnserr: not idle. If the value +violates the limits, it returnserr: not 0<=T<=250.
+T?Returns the current target of the motor in mm. Is initially 0.
+H: Stops the movement by setting the target to the current +position and returnsT=6.555,P=6.555. If the motor is idle, +nothing happens, but the values are returned anyway.
+
In the simplest approach, the parameters that can describe the device +are:
+-
+
position: Read only.
+target: Can be read and written by the user, but with certain +restrictions.
+
Additionally, the device is stateful in the sense that it can be in one +of three states.
+-
+
idle: The motor is powered on and ready to receive commands.
+moving: The motor is moving towards the user supplied target.
+
Between those three states, different transitions exist:
+-
+
idle->moving: The target position is different from the +current position, the motor starts moving.
+moving->idle: The motor has reached the target position or +the user has supplied a stop command, which sets the target position +to the current position, causing the motor to stop.
+
The states and transitions described above form a finite state machine +with two states and two transitions. This state machine forms the heart +of the simulated device, so it should be implemented using Lewis’ +cycle based finite state +machine, which +will be explained below.
+Implementing the device simulation
+In many cases there may eventually be more than one device simulation, so the directory
+structure should be something like this, assuming your directory is /some/path:
/some/path
+ |
+ +- my_devices
+ |
+ +- device_1
+ |
+ +- device_2
+ |
+ +- __init__.py (Empty file)
+Each device resides in the sub-package my_devices in the. The first step is to create a
+new directory in the my_devices directory called example_motor,
+which should contain a single file, __init__.py. For simple devices
+like this it’s acceptable to put everything into one file, but for more
+complex simulators it’s recommended to follow the structure of the
+devices that are already part of the Lewis distribution.
Conceptually, in Lewis, devices are split in two Parts: a device +model, which contains internal device state, as well as potentially a +state machine, and an interface that exposes the device to the outside +world via a communication protocol that is provided by an “adapter”. The +adapter specifies the communication protocol (for example +EPICS or TCP/IP), whereas the +interface specifies the syntax and semantics of the actual command +language of the device.
+For the actual device simulation there are two classes to choose between
+for sub-classing. The class lewis.devices.Device can be used for very simple
+devices that do not require a state machine to represent their
+operation. On each simulation cycle, the method doProcess is
+executed if it is implemented. This can be used to implement
+time-dependent behavior. For the majority of cases, such as in the
+example, it is more convenient to inherit from lewis.devices.StateMachineDevice.
+It provides an internal state machine and options to override
+characteristics of the state machine on initialization.
lewis.devices.StateMachineDevice has three methods that must be implemented by
+sub-classes: lewis.devices.StateMachineDevice._get_state_handlers,
+lewis.devices.StateMachineDevice._get_initial_state and
+lewis.devices.StateMachineDevice._get_transition_handlers. They are used to define
+the state machine. A fourth, optional method can be used to initialize internal device
+state, it’s calld lewis.devices.StateMachineDevice._initialize_data. In this case
+the device implementation should also go into __init__.py:
from lewis.devices import StateMachineDevice
+
+from lewis.core.statemachine import State
+from lewis.core import approaches
+
+from collections import OrderedDict
+
+class DefaultMovingState(State):
+ def in_state(self, dt):
+ old_position = self._context.position
+ self._context.position = approaches.linear(old_position, self._context.target,
+ self._context.speed, dt)
+ self.log.info('Moved position (%s -> %s), target=%s, speed=%s', old_position,
+ self._context.position, self._context.target, self._context.speed)
+
+class SimulatedExampleMotor(StateMachineDevice):
+ def _initialize_data(self):
+ self.position = 0.0
+ self._target = 0.0
+ self.speed = 2.0
+
+ def _get_state_handlers(self):
+ return {
+ 'idle': State(),
+ 'moving': DefaultMovingState()
+ }
+
+ def _get_initial_state(self):
+ return 'idle'
+
+ def _get_transition_handlers(self):
+ return OrderedDict([
+ (('idle', 'moving'), lambda: self.position != self.target),
+ (('moving', 'idle'), lambda: self.position == self.target)])
+
+ @property
+ def state(self):
+ return self._csm.state
+
+ @property
+ def target(self):
+ return self._target
+
+ @target.setter
+ def target(self, new_target):
+ if self.state == 'moving':
+ raise RuntimeError('Can not set new target while moving.')
+
+ if not (0 <= new_target <= 250):
+ raise ValueError('Target is out of range [0, 250]')
+
+ self._target = new_target
+
+ def stop(self):
+ self._target = self.position
+
+ self.log.info('Stopping movement after user request.')
+
+ return self.target, self.position
+This defines the state machine according to the description at the top
+of the page and some internal state variables, for example target,
+which has some limits on when and to what values it can be set.
Both states of the motor are described by a state handler. In case of
+the idle-state it is enough to use lewis.core.statemachine.State,
+which simply does nothing. lewis.core.statemachine.State has three methods that
+can be overridden:
-
+
lewis.core.statemachine.State.on_entry
+lewis.core.statemachine.State.in_state
+lewis.core.statemachine.State.on_exit.
+
For other ways to specify those state handlers, please consult the documentation of
+lewis.core.statemachine.StateMachine, where this is described in detail.
+The advantage of using the lewis.core.statemachine.State-class is that it
+has a so called context, which is stored in the _context-member. In case of
+lewis.devices.StateMachineDevice, this context is the device object.
+This means that device data can be modified in a state handler.
This is the case for the moving-state, where a state handler has
+been defined by sub-classing lewis.core.statemachine.State.
+In its in_state-method it modifies the position member of the device until it has reached
+target with a rate that is stored in the speed-member. This
+linear change behavior is implemented in the ~lewis.core.approaches.linear-function from
+lewis.core.approaches. It automatically makes sure that the target is
+always obtained even for very coarse dt-values.
The transitions between states are defined using lambda-functions in +this case, which simply check whether the current position is identical +with the target or not.
+The device also provides a read-only property state, which forwards
+the state machine’s (in the device as member _csm) state. The speed
+of the motor is not part of the device specification, but it is added as
+a member so that it can be changed via the lewis-control script to test
+how the motor behaves at different speeds. The device is now fully
+functional, but it’s not possible to interact with it yet, because the
+interface is not specified yet.
Implementing the device interface
+Device interfaces are implemented by sub-classing an appropriate
+pre-written, protocol specific interface base class from the framework’s
+lewis.adapters-package and overriding a few members. In this case this
+base class is called lewis.adapters.stream.StreamInterface. The first step
+is to specify the available commands in terms of a collection of
+lewis.adapters.stream.Cmd-objects. These objects effectively bind
+commands specified in terms of regular expressions to the interface’s methods.
+According to the specifications above, the commands are defined like this:
from lewis.adapters.stream import StreamInterface, Cmd, scanf
+
+class ExampleMotorStreamInterface(StreamInterface):
+ commands = {
+ Cmd('get_status', r'^S\?$'),
+ Cmd('get_position', r'^P\?$'),
+ Cmd('get_target', r'^T\?$'),
+ Cmd('set_target', scanf('T=%f'), argument_mappings=(float,)),
+ Cmd('stop', r'^H$',
+ return_mapping=lambda x: 'T={},P={}'.format(x[0], x[1])),
+ }
+
+ in_terminator = '\r\n'
+ out_terminator = '\r\n'
+
+ def get_status(self):
+ return self.device.state
+
+ def get_position(self):
+ return self.device.position
+
+ def get_target(self):
+ return self.device.target
+
+ def set_target(self, new_target):
+ try:
+ self.device.target = new_target
+ return 'T={}'.format(new_target)
+ except RuntimeError:
+ return 'err: not idle'
+ except ValueError:
+ return 'err: not 0<=T<=250'
+The first argument to lewis.adapters.stream.Cmd specifies the method
+name the command is bound to, whereas the second argument is a pattern that a
+request coming in over the TCP stream must match. If the pattern is specified as a string,
+it is treated as a regular expression. In the above example, lewis.adapters.stream.scanf
+is used for one of the functions, it allows for scanf-like format specifiers. If a method has
+arguments (such as set_target), these need to be defined as capture
+groups in the regular expression. These groups are passed as strings to
+the bound method. If any sort of conversion is required for these
+arguments, the argument_mapping-parameter can be a tuple of
+conversion functions with the same lengths as the number of capture
+groups in the regular expression. In the case of set_target it’s
+enough to convert the string to float, but lewis.adapters.stream.scanf does that
+automatically, so it is not strictly required here. Return values (except None)
+are converted to strings automatically, but this conversion can be
+overridden by supplying a callable object to return_mapping, as it
+is the case for the stop-command.
You may have noticed that stop is not a method of the interface.
+lewis.adapters.stream.StreamInterface tries to resolve the supplied method
+names in multiple ways. First it checks its own members, then it checks the members of the
+device it owns (accessible in the interface via the device-member)
+and binds to the appropriate method. If the method name can not be
+found in either the device or the interface, an error is produced, which
+minimizes the likelihood of typos. The definitions in the interface
+always have precedence, this is intentionally done so that device
+behavior can be overridden later on with minimal changes to the code.
In case of the stop-method, which returns two floating point numbers
+(target and position), the return_mapping is used to format the
+device’s position and target as specified in the protocol definition at
+the top of the page.
Finally, in- and out-terminators need to be specified. These are +stripped from and appended to requests and replies respectively.
+This entire device can also be found in the lewis.examples module. It can be
+started using the -a and -k parameters of lewis.py:
$ lewis -a /some/path -k my_devices example_motor -p "stream: {bind_address: 127.0.0.1, port: 9999}"
+All functionality described in the
+user_guide, such as accessing the device and the simulation via the
+lewis-control.py-script are automatically available.
Logging
+Both device and interface support logging, they supply a log member which is
+a logger configured with the right name. The adapter already logs all important actions
+that influence the device, so in the interface it should not be necessary to do too much
+logging, but it might be interesting for debugging purposes.
Note that the simulation already produces one debug log message per simulation cycle logging
+the elapsed (real-)time, so it is not necessary to log the dt parameters in addition.
+lewis.core.statemachine.StateMachine also logs on each cycle which state it is in and
+which transitions are triggered (if any). In the lewis.core.statemachine.State-handlers
+that are device specific, any logging should focus on the behavior in that concrete state, as
+for example demonstrated in the example above.
It is also important to consider the log level. Log messages that occur on each cycle must be
+strictly limited to the debug-level, because they potentially produce a lot of data.
+The info-level and above should be used for information that is relevant to anyone running
+the simulation, such as failures or other “virtual problems” that might otherwise go unnoticed.
+A good example would be a device that ignores faulty commands - a warning could be logged
+with details about the command and that it was ignored.
User facing documentation
+The lewis.adapters.stream.StreamAdapter-class has a property
+documentation, which generates user facing documentation from the
+lewis.adapters.stream.Cmd-objects (it can be displayed via the -i-flag of
+lewis from the interface object via lewis-control.py). The regular expression of
+each command is listed, along with a documentation string. If the doc-parameter is provided
+to Cmd, it is used,otherwise the docstring of the wrapped method is used (it does not matter
+whether the method is part of the device or the interface for feature to work). The latter is the
+recommended way, because it avoids duplication. But in some cases, the user- and the
+developer facing documentation may be so different that it’s useful to override the docstring.
This is also combined with the docstring of the interface (in this case
+ExampleMotorStreamInterface), and some information about the configured host/port,
+as well as terminators. The documentation has been left out from the above code samples for
+brevity, but in the examples-directory, the docs are present.
All adapters offer similar functionality, the purpose is that the devices are documented in +a way that makes them easy to use by non-developers. This is especially important if the +protocol is non-obvious.
+Unit tests
+Unit tests should be added to the test-directory. While it would be
+best to have unit tests for device and interface separately, it is most
+important that the tests capture overall device behavior, so that it’s
+immediately noticed when a change to Lewis’ core parts breaks the
+simulation. It also makes it easier later on to refactor and change the
+device.
Adding setups
+In order to test certain failure scenarios of a device, setups can be
+added to a device. The easiest way is to define a dictionary called
+setups in the __init__.py file. A setup consists of a device
+type and initialization parameters:
setups = dict(
+ moving=dict(
+ device_type=SimulatedExampleMotor,
+ parameters=dict(
+ override_initial_state='moving',
+ override_initial_data=dict(
+ _target=120.0, position=20.0
+ )
+ )
+ )
+)
+In this case a moving-scenario is defined where the motor is already
+moving to a target when the simulation is started.
Compatibility with framework versions
+To make sure that users have a good experience using the newly added device, +it should specify what version of Lewis it works with. This is achieved by +adding another variable to the top level of the device module which contains +a version specification:
+framework_version = '1.0.1'
+This will make sure that older or newer versions of Lewis do not present odd exceptions +or error messages to users trying to start the device. If Lewis detects a mismatch +between the required version and the existing version, an error message is logged +so that users know where the problem comes from. In the ideal case this variable +would be updated with each release of Lewis after it has been made sure that the +device is compatible.
+Further steps
+Once a device is developed far enough, it’s time to submit a pull +request. As an external contributor, this happens via a fork on github. +Members of the development team will review the code and may make +suggestions for changes. Once the code is acceptable, it will be merged +into Lewis’ main branch and become a part of the distribution.
+If a second interface is added to a device, either using a different
+interface type or the same but with different commands, the interface
+definitions should be moved out of the __init__.py file. Lewis
+will continue to work if the interfaces are moved to a sub-folder of the
+device called interfaces. This needs to have its own
+__init__.py, where interface-classes can be imported from other
+files in that module. It’s best to look at the chopper and linkam_t95
+devices that are already in Lewis.
The same is true for setups. For complex setups, these should be moved
+to a sub-module of the device called setups, where each setup can
+live in its own file. Please see the documentation of
+lewis.devices.import_device for reference.
More Examples
+More example devices and interfaces are provided in the lewis.examples directory.
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.adapters.html b/generated/lewis.adapters.html
new file mode 100644
index 00000000..02a86692
--- /dev/null
+++ b/generated/lewis.adapters.html
@@ -0,0 +1,168 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.adapters.epics
+Members
+| + | Class to represent PVs that are bound to an adapter |
+
| + | This adapter provides ChannelAccess server functionality through the pcaspy module. |
+
| + | Inheriting from this class provides an EPICS-interface to a device for use with |
+
| + | The PV-class is used to declare the EPICS-interface exposed by a sub-class of EpicsAdapter. |
+
|
++ |
-
+
- +class lewis.adapters.epics.BoundPV(pv, target, meta_target=None)[source] +
Bases:
+objectClass to represent PVs that are bound to an adapter
+This class is very similar to
+Func, in that +it is the result of a binding operation between a user-specifiedPV-object +and a Device and/or Adapter object. Also, it should rarely be used directly. objects +are generated automatically byEpicsAdapter.The binding happens by supplying a
+target-object which has an attribute or a property +named according to the property-name stored in the PV-object, and ameta_target-object +which has an attribute named according to the meta_data_property in PV.The properties
+read_only,config, andpoll_intervalsimply forward the +data of PV, whiledocuses the target object to potentially obtain the property’s +docstring.To get and set the value of the property on the target, the
+value-property of +this class can be used, to get the meta data dict, there’s ameta-property.-
+
- Parameters: +
-
+
pv – PV object to bind to target and meta_target.
+target – Object that has an attribute named pv.property.
+meta_target – Object that has an attribute named pv.meta_data_property.
+
+
-
+
- +property config +
Config dict passed on to pcaspy-machinery.
+
-
+
- +property doc +
Docstring of property on target or override specified on PV-object.
+
-
+
- +property meta +
Value of the bound meta-property on the target.
+
-
+
- +property poll_interval +
Interval at which to update PV in pcaspy.
+
-
+
- +property read_only +
True if the PV is read-only.
+
-
+
- +property value +
Value of the bound property on the target.
+
-
+
- +class lewis.adapters.epics.EpicsAdapter(options=None)[source] +
Bases:
+AdapterThis adapter provides ChannelAccess server functionality through the pcaspy module.
+It’s possible to configure the prefix for the PVs provided by this adapter. The +corresponding key in the
+optionsdictionary is calledprefix:++options = {"prefix": "PVPREFIX:"} +
-
+
- Parameters: +
options – Dictionary with options.
+
+
-
+
- +property documentation +
This property can be overridden in a sub-class to provide protocol documentation to users +at runtime. By default it returns the indentation cleaned-up docstring of the class.
+
-
+
- +handle(cycle_delay=0.1) None[source] +
Call this method to spend about
+cycle_delayseconds processing +requests in the pcaspy server. Under load, for example when runningcagetat a +high frequency, the actual time spent in the method may be much shorter. This effect +is not corrected for.-
+
- Parameters: +
cycle_delay – Approximate time to be spent processing requests in pcaspy server.
+
+
-
+
- +property is_running +
This property indicates whether the Adapter’s server is running and listening. The result +of calls to
+start_server()andstop_server()should be reflected as expected.
-
+
- +start_server() None[source] +
Creates a pcaspy-server.
+++Note
+The server does not process requests unless
+handle()is called regularly.
-
+
- +stop_server() None[source] +
This method must be re-implemented to stop and tear down anything that has been setup +in
+start_server(). This method should close all connections to clients that have +been established since the adapter has been started.++Note
+This method may be called multiple times over the lifetime of the Adapter, so it is +important to make sure that this does not cause problems.
+
-
+
- +class lewis.adapters.epics.EpicsInterface[source] +
Bases:
+InterfaceBaseInheriting from this class provides an EPICS-interface to a device for use with +
+EpicsAdapter. In the simplest case all that is required is to inherit +from this class and override thepvs-member. It should be a dictionary +that contains PV-names (without prefix) as keys and instances of PV as +values. The prefix is handled byEpicsAdapter.For a simple device with two properties, speed and position, the first of which +should be read-only, it’s enough to define the following:
+++class SimpleDeviceEpicsInterface(EpicsInterface): + pvs = {"VELO": PV("speed", read_only=True), "POS": PV("position", lolo=0, hihi=100)} +
For more complex behavior, the interface could contain properties that do not +exist in the device itself. If the device should also have a PV called STOP +that “stops the device”, the interface could look like this:
+++class SimpleDeviceEpicsInterface(EpicsInterface): + pvs = { + "VELO": PV("speed", read_only=True), + "POS": PV("position", lolo=0, hihi=100), + "STOP": PV("stop", type="int"), + } + + @property + def stop(self): + return 0 + + @stop.setter + def stop(self, value): + if value == 1: + self.device.halt() +
Even though the device does not have a property called
+stop(but a method called +halt), issuing the command++$ caput STOP 1 +
will achieve the desired behavior, because
+EpicsInterfacemerges the properties +of the device intoSimpleDeviceEpicsInterfaceitself, so that it is does not +matter whether the specified property in PV exists in the device or the adapter.The intention of this design is to keep device classes small and free of +protocol specific stuff, such as in the case above where stopping a device +via EPICS might involve writing a value to a PV, whereas other protocols may +offer an RPC-way of achieving the same thing.
+-
+
- +property adapter +
Adapter type that is required to process and expose interfaces of this type. Must be +implemented in subclasses.
+
-
+
- +class lewis.adapters.epics.PV(target_property, poll_interval=1.0, read_only=False, meta_data_property=None, doc=None, **kwargs)[source] +
Bases:
+objectThe PV-class is used to declare the EPICS-interface exposed by a sub-class of +EpicsAdapter. The
+target_propertyargument specifies which property of the adapter +the PV maps to. To make development easier it can also be a part of the exposed +device. If the property exists on both the Adapter-subclass and the device, the former +has precedence. This is useful for overriding behavior for protocol specific “quirks”.If the PV should be read only, this needs to be specified via +the corresponding parameter. The information about the poll interval is used +py EpicsAdapter to update the PV in regular intervals. All other named arguments +are forwarded to the pcaspy server’s pvdb, so it’s possible to pass on +limits, types, enum-values and so on.
+In case those arguments change at runtime, it’s possible to provide
+meta_data_property, +which should contain the name of a property that returns a dict containing these values. +For example if limits change:++class Interface(EpicsInterface): + pvs = {"example": PV("example", meta_data_property="example_meta")} + + @property + def example_meta(self): + return { + "lolim": self.device._example_low_limit, + "hilim": self.device._example_high_limit, + } +
The PV infos are then updated together with the value, determined by
+poll_interval.In cases where the device is accessed via properties alone, this class provides the possibility +to expose methods as PVs. A common use case would be to model a getter:
+++class SomeDevice(Device): + def get_example(self): + return 42 + + +class Interface(EpicsInterface): + pvs = {"example": PV("get_example")} +
It is also possible to model a getter/setter pair, in this case a tuple has to be provided:
+++class SomeDevice(Device): + _ex = 40 + + def get_example(self): + return self._ex + 2 + + def set_example(self, new_example): + self._ex = new_example - 2 + + +class Interface(EpicsInterface): + pvs = {"example": PV(("get_example", "set_example"))} +
Any of the two members in the tuple can be substituted with
+Nonein case it does not apply. +Besides method names it is also allowed to provide callables. Valid callables are for example +bound methods and free functions, but also lambda expressions and partials.There are however restrictions for the supplied functions (be it as method names or directly +as callables) with respect to their signature. Getter functions must be callable without any +arguments, setter functions must be callable with exactly one argument. The
+selfof +methods does not count towards this.-
+
- Parameters: +
-
+
target_property – Property or method name, getter function, tuple of getter/setter.
+poll_interval – Update interval of the PV.
+read_only – Should be True if the PV is read only. If not specified, the PV is +read_only if only a getter is supplied.
+meta_data_property – Property or method name, getter function, tuple of getter/setter.
+doc – Description of the PV. If not supplied, docstring of mapped property is used.
+kwargs – Arguments forwarded into pcaspy pvdb-dict.
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.adapters.modbus.html b/generated/lewis.adapters.modbus.html
new file mode 100644
index 00000000..1b3aabc8
--- /dev/null
+++ b/generated/lewis.adapters.modbus.html
@@ -0,0 +1,488 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.adapters
+The core Adapter API is located in lewis.core.adapters. This package contains concrete
+implementations of Adapter in its submodules, along with
+specific tools for each adapter.
Submodules
+| + | + |
| + | This module provides components to expose a Device via a Modbus-interface. |
+
| + | + |
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.adapters.stream.html b/generated/lewis.adapters.stream.html
new file mode 100644
index 00000000..705faf96
--- /dev/null
+++ b/generated/lewis.adapters.stream.html
@@ -0,0 +1,670 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.adapters.modbus
+This module provides components to expose a Device via a Modbus-interface. The following resources +were used as guidelines and references for implementing the protocol:
+++
+
+Note
+For an example how Modbus can be used in the current implementation, please look +at lewis/examples/modbus_device.
+Members
+| + | Modbus standard exception codes |
+
| + | + |
| + | A basic ModbusDataBank instance. |
+
| + | Preliminary DataBank implementation for Modbus. |
+
| + | Convenience struct to hold the four types of DataBanks in Modbus |
+
|
++ |
| + | + |
| + | This class implements the Modbus TCP Protocol. |
+
|
++ |
| + | This class models a frame of the Modbus TCP protocol. |
+
-
+
- +class lewis.adapters.modbus.ModbusAdapter(options=None)[source] +
Bases:
+Adapter-
+
- +handle(cycle_delay=0.1) None[source] +
This function is called on each cycle of a simulation. It should process requests that are +made via the protocol that exposes the device. The time spent processing should be +approximately
+cycle_delayseconds, during which the adapter may block the current +process. It is desirable to stick to the provided time, but deviations are permissible if +necessary due to the way the protocol works.-
+
- Parameters: +
cycle_delay – Approximate time spent processing requests.
+
+
-
+
- +property is_running +
This property indicates whether the Adapter’s server is running and listening. The result +of calls to
+start_server()andstop_server()should be reflected as expected.
-
+
- +start_server() None[source] +
This method must be re-implemented to start the infrastructure required for the +protocol in question. These startup operations are not supposed to be carried out on +construction of the adapter in order to preserve control over when services are +started during a run of a simulation.
+++Note
+This method may be called multiple times over the lifetime of the Adapter, so it is +important to make sure that this does not cause problems.
+++See also
+See
+stop_server()for shutting down the adapter.
-
+
- +stop_server() None[source] +
This method must be re-implemented to stop and tear down anything that has been setup +in
+start_server(). This method should close all connections to clients that have +been established since the adapter has been started.++Note
+This method may be called multiple times over the lifetime of the Adapter, so it is +important to make sure that this does not cause problems.
+
-
+
- +class lewis.adapters.modbus.ModbusBasicDataBank(default_value=0, start_addr=0, last_addr=65535)[source] +
Bases:
+ModbusDataBankA basic ModbusDataBank instance.
+This type of DataBank simply serves as a memory space for Modbus requests to read from and +write to. It does not support binding addresses to attributes or functions of the device +or interface. Example usage:
+++di = ModbusBasicDataBank(False, 0x1000, 0x1FFF) +
-
+
- Parameters: +
-
+
default_value – Value to initialize memory with
+start_addr – First valid address
+last_addr – Last valid address
+
+
-
+
- +class lewis.adapters.modbus.ModbusDataBank(**kwargs)[source] +
Bases:
+objectPreliminary DataBank implementation for Modbus.
+This is a very generic implementation of a databank for Modbus. It’s meant to set the +groundwork for future implementations. Only derived classes should be instantiated, not +this class directly. The signature of this __init__ method is subject to change.
+-
+
- Parameters: +
kwargs – Configuration
+
+
-
+
- +class lewis.adapters.modbus.ModbusDataStore(di=None, co=None, ir=None, hr=None)[source] +
Bases:
+objectConvenience struct to hold the four types of DataBanks in Modbus
+
-
+
- +class lewis.adapters.modbus.ModbusInterface[source] +
Bases:
+InterfaceBase-
+
- +property adapter +
Adapter type that is required to process and expose interfaces of this type. Must be +implemented in subclasses.
+
-
+
- +class lewis.adapters.modbus.ModbusProtocol(sender, datastore)[source] +
Bases:
+objectThis class implements the Modbus TCP Protocol.
+The user of this class should provide a ModbusDataStore instance that will be used to +fulfill read and write requests, and a callable sender which accepts one bytearray +parameter. The sender will be called whenever a response frame is generated, with a +bytearray containing the response frame as the parameter.
+Processing occurs when the user calls ModbusProtocol.process(), passing in the raw frame +data to process as a bytearray. The data may include multiple frames and partial frame +fragments. Any data that could not be processed (due to incomplete frames) is buffered for +the next call to process.
+-
+
- Parameters: +
-
+
sender – callable that accepts one bytearray parameter, called to send responses.
+datastore – ModbusDataStore instance to reference when processing requests
+
+
-
+
- +process(data, device_lock) None[source] +
Process as much of given data as possible.
+Any remainder, in case there is an incomplete frame at the end, is stored so that +processing may continue where it left off when more data is provided.
+-
+
- Parameters: +
-
+
data – Incoming byte data. Must be compatible with bytearray.
+device_lock – threading.Lock instance that is acquired for device interaction.
+
+
-
+
- +class lewis.adapters.modbus.ModbusTCPFrame(stream=None)[source] +
Bases:
+objectThis class models a frame of the Modbus TCP protocol.
+It may be a request, a response or an exception. Typically, requests are constructed using the +init method, while responses and exceptions are constructed by called create_request or +create_exception on an instance that is a request.
+Note that data from the passed in bytearray stream is consumed. That is, bytes will be removed +from the front of the bytearray if construction is successful.
+-
+
- Parameters: +
stream – bytearray to consume data from to construct this frame.
+
+- Raises: +
EOFError – Not enough data for complete frame; no data consumed.
+
+
-
+
- +create_exception(code)[source] +
Create an exception frame based on this frame.
+-
+
- Parameters: +
code – Modbus exception code to use for this exception
+
+- Returns: +
ModbusTCPFrame instance that represents an exception
+
+
-
+
- +create_response(data=None)[source] +
Create a response frame based on this frame.
+-
+
- Parameters: +
data – Data section of response as bytearray. If None, request data section is kept.
+
+- Returns: +
ModbusTCPFrame instance that represents a response
+
+
-
+
- +from_bytearray(stream) None[source] +
Constructs this frame from input data stream, consuming as many bytes as necessary from +the beginning of the stream.
+If stream does not contain enough data to construct a complete modbus frame, an EOFError +is raised and no data is consumed.
+-
+
- Parameters: +
stream – bytearray to consume data from to construct this frame.
+
+- Raises: +
EOFError – Not enough data for complete frame; no data consumed.
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.core.adapters.html b/generated/lewis.core.adapters.html
new file mode 100644
index 00000000..14df6e74
--- /dev/null
+++ b/generated/lewis.core.adapters.html
@@ -0,0 +1,430 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.adapters.stream
+Members
+| + | This class is an implementation of |
+
| + | + |
| + | Objects of this type connect a callable object to a pattern matcher ( |
+
| + | This class defines an interface for general command-matchers that use any kind of technique to match a certain request in string form. |
+
| + | The StreamAdapter is the bridge between the Device Interface and the TCP Stream networking backend implementation. |
+
| + | + |
| + | This class is used to provide a TCP-stream based interface to a device. |
+
|
++ |
| + | With this implementation of |
+
| + | Implementation of |
+
| + | Interprets the specified pattern as a scanf format. |
+
-
+
- +class lewis.adapters.stream.Cmd(func, pattern, argument_mappings=None, return_mapping=<function Cmd.<lambda>>, doc=None)[source] +
Bases:
+CommandBaseThis class is an implementation of
+CommandBasethat can expose a callable object +or a named method of the device/interface controlled byStreamAdapter.++def random(): + return 6 + +SomeInterface(StreamInterface): + commands = { + Cmd(lambda: 4, pattern='^R$', doc='Returns a random number.'), + Cmd('random', pattern='^RR$', doc='Better random number.'), + Cmd(random, pattern='^RRR$', doc='The best random number.'), + } + + def random(self): + return 5 +
The interface defined by the above example has three commands,
+Rwhich calls a lambda +function that always returns 4,RR, which callsSomeInterface.randomand returns 5 and +lastlyRRRwhich calls the free function defined above and returns the best random number.For a detailed explanation of requirements to the constructor arguments, please refer to the +documentation of
+Func, to which the arguments are forwarded.++See also
+
+Varexposes attributes and properties of a device object. The documentation +ofFuncprovides more information about the common constructor arguments.-
+
- Parameters: +
-
+
func – Function to be called when pattern matches or member of device/interface.
+pattern – Pattern to match (
PatternMatcheror string).
+argument_mappings – Iterable with mapping functions from string to some type.
+return_mapping – Mapping function for return value of method.
+doc – Description of the command. If not supplied, the docstring is used.
+
+
-
+
- +class lewis.adapters.stream.CommandBase(func, pattern, argument_mappings=None, return_mapping=None, doc=None)[source] +
Bases:
+objectThis is the common base class of
+CmdandVar. The concept of commands for +the stream adapter is based on connecting a callable object to a pattern that matches an +inbound request.The type of pattern can be either an implementation of
+PatternMatcher+(regex or scanf format specification) or a plain string (which is treated as a regular +expression).For free function and lambda expressions this is straightforward: the function object can +simply be stored together with the pattern. Most often however, the callable +is a method of the device or interface object - these do not exist when the commands are +defined.
+This problem is solved by introducing a “bind”-step in
+StreamAdapter. So instead +of a function object, bothCmdandVarstore the name of a member of device +or interface. At “bind-time”, this is translated into the correct callable.So instead of using
+CmdorVardirectly, both classes’bind()-methods +return an iterable ofFunc-objects which can be used for processing requests. +StreamAdapterperforms this bind-step when it’s constructed. For details regarding +the implementations, please see the corresponding classes.++See also
+Please take a look at
+Cmdfor exposing callable objects or methods of +device/interface andVarfor exposing attributes and properties.To see how argument_mappings, return_mapping and doc are applied, please look at +
+Func.-
+
- Parameters: +
-
+
func – Function to be called when pattern matches or member of device/interface.
+pattern – Pattern to match (
PatternMatcheror string).
+argument_mappings – Iterable with mapping functions from string to some type.
+return_mapping – Mapping function for return value of method.
+doc – Description of the command. If not supplied, the docstring is used.
+
+
-
+
- +class lewis.adapters.stream.Func(func, pattern, argument_mappings=None, return_mapping=None, doc=None)[source] +
Bases:
+objectObjects of this type connect a callable object to a pattern matcher (
+PatternMatcher), +which currently comprisesregexandscanf. Strings are also +accepted, they are treated like a regular expression internally. This preserves default +behavior from older versions of Lewis.In general, Func-objects should not be created directly, instead they are created by one of +the sub-classes of
+CommandBaseusingbind().Function arguments are indicated by groups in the regular expression. The number of +groups has to match the number of arguments of the function. In earlier versions of Lewis it +was possible to pass flags to
+re.compile, this has been removed for consistency issues +inVar. It is however still possible to use the exact same flags as part of the +regular expression. In the documentation of re, this is outlined, simply add a group to the +expression that contains the flags, for example(?i)to make the expression case +insensitive. This special group does not count towards the matching groups used for argument +capture.The optional argument_mappings can be an iterable of callables with one parameter of the +same length as the number of arguments of the function. The first parameter will be +transformed using the first function, the second using the second function and so on. +This can be useful to automatically transform strings provided by the adapter into a proper +data type such as
+intorfloatbefore they are passed to the function. In case the +pattern is of typescanf, this is optional (but will override the mappings +provided by the matcher).The return_mapping argument is similar, it should map the return value of the function +to a string. The default map function only does that when the supplied value +is not None. It can also be set to a numeric value or a string constant so that the +command always returns the same value. If it is
+None, the return value is not +modified at all.Finally, documentation can be provided by passing the doc-argument. If it is omitted, +the docstring of the bound function is used and if that is not present, left empty.
+-
+
- Parameters: +
-
+
func – Function to be called when pattern matches or member of device/interface.
+- +
argument_mappings – Iterable with mapping functions from string to some type.
+return_mapping – Mapping function for return value of method.
+doc – Description of the command. If not supplied, the docstring is used.
+
+- Raises: +
RuntimeError: If the function cannot be mapped for any reason.
+
+
-
+
- +map_arguments(arguments)[source] +
Returns the mapped function arguments. If no mapping functions are defined, the arguments +are returned as they were supplied.
+-
+
- Parameters: +
arguments – List of arguments for bound function as strings.
+
+- Returns: +
Mapped arguments.
+
+
-
+
- +map_return_value(return_value)[source] +
Returns the mapped return_value of a processed request. If no return_mapping has been +defined, the value is returned as is. If return_mapping is a static value, that value +is returned, ignoring return_value completely.
+-
+
- Parameters: +
return_value – Value to map.
+
+- Returns: +
Mapped return value.
+
+
-
+
- +class lewis.adapters.stream.PatternMatcher(pattern)[source] +
Bases:
+objectThis class defines an interface for general command-matchers that use any kind of +technique to match a certain request in string form. It is used by
+Functo check +whether a request can be processed using a function and to extract any function arguments.Sub-classes must implement all defined abstract methods/properties.
+ +-
+
- +property arg_count: NoReturn +
Number of arguments that are matched in a request.
+
-
+
- +property argument_mappings: NoReturn +
Mapping functions that can be applied to the arguments returned by
+match().
-
+
- +match(request) NoReturn[source] +
Tries to match the request against the internally stored pattern. Returns any matched +function arguments.
+-
+
- Parameters: +
request – Request to attempt matching.
+
+- Returns: +
List of matched argument values (possibly empty) or None if not matching.
+
+
-
+
- +property pattern +
The pattern definition used for matching a request.
+
-
+
- +class lewis.adapters.stream.StreamAdapter(options=None)[source] +
Bases:
+AdapterThe StreamAdapter is the bridge between the Device Interface and the TCP Stream networking +backend implementation.
+Available adapter options are:
++
+-
+
bind_address: IP of network adapter to bind on (defaults to 0.0.0.0, or all adapters)
+port: Port to listen on (defaults to 9999)
+telnet_mode: When True, overrides in- and out-terminator for CRNL (defaults to False)
+
-
+
- Parameters: +
options – Dictionary with options.
+
+
-
+
- +property documentation +
This property can be overridden in a sub-class to provide protocol documentation to users +at runtime. By default it returns the indentation cleaned-up docstring of the class.
+
-
+
- +handle(cycle_delay=0.1) None[source] +
Spend approximately
+cycle_delayseconds to process requests to the server.-
+
- Parameters: +
cycle_delay – S
+
+
-
+
- +property is_running +
This property indicates whether the Adapter’s server is running and listening. The result +of calls to
+start_server()andstop_server()should be reflected as expected.
-
+
- +start_server() None[source] +
Starts the TCP stream server, binding to the configured host and port. +Host and port are configured via the command line arguments.
+++Note
+The server does not process requests unless +
+handle()is called in regular intervals.
-
+
- +stop_server() None[source] +
This method must be re-implemented to stop and tear down anything that has been setup +in
+start_server(). This method should close all connections to clients that have +been established since the adapter has been started.++Note
+This method may be called multiple times over the lifetime of the Adapter, so it is +important to make sure that this does not cause problems.
+
-
+
- +class lewis.adapters.stream.StreamHandler(sock, target, stream_server)[source] +
Bases:
+async_chat
-
+
- +class lewis.adapters.stream.StreamInterface[source] +
Bases:
+InterfaceBaseThis class is used to provide a TCP-stream based interface to a device.
+Many hardware devices use a protocol that is based on exchanging text with a client via +a TCP stream. Sometimes RS232-based devices are also exposed this way via an adapter-box. +This adapter makes it easy to mimic such a protocol.
+This class has the following attributes which may be overridden by subclasses:
++
+-
+
protocol: What this interface is called for purposes of the -p commandline option. +Defaults to “stream”.
+in_terminator, out_terminator: These define how lines are terminated when transferred +to and from the device respectively. They are stripped/added automatically. +Inverse of protocol file InTerminator and OutTerminator. The default is
\\r.
+readtimeout: How many msec to wait for additional data between packets, once transmission +of an incoming command has begun. Inverse of ReadTimeout in protocol files. +Defaults to 100 (ms). Set to 0 to disable timeout completely.
+commands: A list of
CommandBase-objects that define mappings between protocol +and device/interface methods/attributes.
+
By default, commands are expressed as regular expressions, a simple example may look like this:
+++class SimpleDeviceStreamInterface(StreamInterface): + commands = [ + Cmd('set_speed', r'^S=([0-9]+)$', argument_mappings=[int]), + Cmd('get_speed', r'^S\?$') + Var('speed', read_pattern=r'^V\?$', write_pattern=r'^V=([0-9]+)$') + ] + + def set_speed(self, new_speed): + self.device.speed = new_speed + + def get_speed(self): + return self.device.speed +
The interface has two commands,
+S?to return the speed andS=10to set the speed +to an integer value. It also exposes the same speed attribute as a variable, using auto- +generatedV?andV=10commands.As in the
+lewis.adapters.epics.EpicsInterface, it does not matter whether the +wrapped method is a part of the device or of the interface, this is handled automatically when +a new device is assigned to thedevice-property.In addition, the
+handle_error()-method can be overridden. It is called when an exception +is raised while handling commands.-
+
- +property adapter +
Adapter type that is required to process and expose interfaces of this type. Must be +implemented in subclasses.
+
-
+
- +handle_error(request, error) None[source] +
Override this method to handle exceptions that are raised during command processing. +The default implementation does nothing, so that any errors are silently ignored.
+-
+
- Parameters: +
-
+
request – The request that resulted in the error.
+error – The exception that was raised.
+
+
-
+
- +class lewis.adapters.stream.Var(target_member, read_pattern=None, write_pattern=None, argument_mappings=None, return_mapping=<function Var.<lambda>>, doc=None)[source] +
Bases:
+CommandBaseWith this implementation of
+CommandBaseit’s possible to expose plain data attributes +or properties of device or interface. Getting and setting a value are separate procedures +which both have their own pattern, read_pattern and write_pattern to match a command each. +Please note that write_pattern has to have exactly one group defined to match a parameter.Due to this separation, parameters can be made read-only, write-only or read-write in the +interface:
+++class SomeInterface(StreamInterface): + commands = { + Var('foo', read_pattern='^F$', write_pattern=r'^F=(\d+)$', + argument_mappings=(int,), doc='An integer attribute.'), + Var('bar' read_pattern='^B$') + } + + foo = 10 + + @property + def bar(self): + return self.foo + 5 + + @bar.setter + def bar(self, new_bar): + self.foo = new_bar - 5 +
In the above example, the foo attribute can be read and written, it’s automatically converted +to an integer, while bar is a property that can only be read via the stream protocol.
+++See also
+For exposing methods and free functions, there’s the
+Cmd-class.-
+
- Parameters: +
-
+
target_member – Attribute or property of device/interface to expose.
+read_pattern – Pattern to match for getter (
PatternMatcheror string).
+write_pattern – Pattern to match for setter (
PatternMatcheror string).
+argument_mappings – Iterable with mapping functions from string to some type, +only applied to setter.
+return_mapping – Mapping function for return value of method, +applied to getter and setter.
+doc – Description of the command. If not supplied, the docstring is used. For plain data +attributes the only way to get docs is to supply this argument.
+
+
-
+
- +class lewis.adapters.stream.regex(pattern)[source] +
Bases:
+PatternMatcherImplementation of
+PatternMatcherthat compiles the specified pattern into a regular +expression.-
+
- +property arg_count +
Number of arguments that are matched in a request.
+
-
+
- +class lewis.adapters.stream.scanf(pattern, exact_match=True)[source] +
Bases:
+regexInterprets the specified pattern as a scanf format. Internally, the scanf package is used +to transform the format into a regular expression. Please consult the documentation of scanf +for valid pattern specifications.
+By default, the resulting regular expression matches exactly. Consider this example:
+++exact = scanf("T=%f") +not_exact = scanf("T=%f", exact_match=False) +
The first pattern only matches the string
+T=4.0, whereas the second would also match +T=4.0garbage. Please note that the specifiers like%fare automatically turned into +groups in the generated regular expression.-
+
- Parameters: +
-
+
pattern – Scanf format specification.
+exact_match – Match only if the entire string matches.
+
+
-
+
- +property argument_mappings +
Mapping functions that can be applied to the arguments returned by
+match().
-
+
- +property pattern +
The pattern definition used for matching a request.
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.core.approaches.html b/generated/lewis.core.approaches.html
new file mode 100644
index 00000000..0b5a78f0
--- /dev/null
+++ b/generated/lewis.core.approaches.html
@@ -0,0 +1,200 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.core.adapters
+This module contains Adapter, which serves as a base class for concrete adapter
+implementations in lewis.adapters. It also contains AdapterCollection which can
+be used to store multiple adapters and manage them together.
Members
+| + | Base class for adapters |
+
| + | A container to manage the adapters of a device |
+
| + | A dummy context manager that raises a RuntimeError when it's used. |
+
-
+
- +class lewis.core.adapters.Adapter(options: dict[str, Any] | None = None)[source] +
Bases:
+objectBase class for adapters
+This class serves as a base class for concrete adapter implementations that expose a device via +a certain communication protocol. It defines the minimal interface that an adapter must provide +in order to fit seamlessly into other parts of the framework +(most importantly
+Simulation).Sub-classes should re-define the
+protocol-member to something appropriate. While it is +explicitly supported to modify it in concrete device interface implementations, it is good +to have a default (for exampleepicsorstream).An adapter should provide everything that is needed for the communication via the protocol it +defines. This might involve constructing a server-object, configuring it and starting the +service (this should happen in
+start_server()). Due to the large differences between +protocols it is very hard to provide general guidelines here. Please take a look at the +implementations of existing adapters (EpicsAdapter, +StreamAdapter),to get some examples.In principle, an adapter can exist on its own, but it only really becomes useful when a device +is bound to it. To do this, assign an object derived from +
+lewis.core.devices.DeviceBaseto thedevice-property. Sub-classes have to +implement_bind_device()to achieve actual binding behavior.It is possible to pass a dictionary with configuration options to Adapter. The keys of +the dictionary are accessible as properties of the
+_options-member. Only keys that are +in thedefault_optionsmember of the class are accepted. Inheriting classes must override +default_optionsto be a dictionary with the possible options for the adapter.Each adapter has a
+lockmember, which contains aNoLockby default. To make +device access thread-safe, any adapter should acquire this lock before interacting with +the device (or interface). This means that before starting the server component of an Adapter, +a proper Lock-object needs to be assigned tolock.-
+
- Parameters: +
options – Configuration options for the adapter.
+
+
-
+
- +property documentation: str +
This property can be overridden in a sub-class to provide protocol documentation to users +at runtime. By default it returns the indentation cleaned-up docstring of the class.
+
-
+
- +handle(cycle_delay: float = 0.1) None[source] +
This function is called on each cycle of a simulation. It should process requests that are +made via the protocol that exposes the device. The time spent processing should be +approximately
+cycle_delayseconds, during which the adapter may block the current +process. It is desirable to stick to the provided time, but deviations are permissible if +necessary due to the way the protocol works.-
+
- Parameters: +
cycle_delay – Approximate time spent processing requests.
+
+
-
+
- +property interface: InterfaceBase | None +
The device property contains the device-object exposed by the adapter.
+The property can be set from the outside, at that point the adapter will +call
+_bind_device()(which is implemented in each adapter sub-class) +and thus re-bind its commands etc. to call the new device.
-
+
- +property is_running: bool +
This property indicates whether the Adapter’s server is running and listening. The result +of calls to
+start_server()andstop_server()should be reflected as expected.
-
+
- +start_server() None[source] +
This method must be re-implemented to start the infrastructure required for the +protocol in question. These startup operations are not supposed to be carried out on +construction of the adapter in order to preserve control over when services are +started during a run of a simulation.
+++Note
+This method may be called multiple times over the lifetime of the Adapter, so it is +important to make sure that this does not cause problems.
+++See also
+See
+stop_server()for shutting down the adapter.
-
+
- +stop_server() None[source] +
This method must be re-implemented to stop and tear down anything that has been setup +in
+start_server(). This method should close all connections to clients that have +been established since the adapter has been started.++Note
+This method may be called multiple times over the lifetime of the Adapter, so it is +important to make sure that this does not cause problems.
+
-
+
- +class lewis.core.adapters.AdapterCollection(*args: Adapter)[source] +
Bases:
+objectA container to manage the adapters of a device
+This container is designed to keep all adapters that expose a device in one place and interact +with them in a uniform way.
+Adapters can be passed as arguments upon construction or added later on using +
+add_adapter()(and removed usingremove_adapter()). The available protocols can be +queried using theprotocols()property.Each adapter can be started and stopped separately by supplying protocol names to +
+connect()anddisconnect(), both methods accept an arbitrary number of arguments, +so that any subset of the stored protocols can be handled at any time. Supplying no protocol +names at all will start/stop all adapters. These semantics also apply foris_connected()+and documentation.This class also makes sure that all adapters use the same Lock for device interaction.
+-
+
- Parameters: +
args – List of adapters to add to the container
+
+
-
+
- +add_adapter(adapter: Adapter) None[source] +
Adds the supplied adapter to the container but raises a
+RuntimeErrorif there’s +already an adapter registered for the same protocol.-
+
- Parameters: +
adapter – Adapter to add to the container
+
+
-
+
- +configuration(*args: str) dict[str | None, dict[str, Any]][source] +
Returns a dictionary that contains the options for the specified adapter. The dictionary +keys are the adapter protocols.
+-
+
- Parameters: +
args – List of protocols for which to list options, empty for all adapters.
+
+- Returns: +
Dict of protocol: option-dict pairs.
+
+
-
+
- +connect(*args: str) None[source] +
This method starts an adapter for each specified protocol in a separate thread, if the +adapter is not already running.
+-
+
- Parameters: +
args – List of protocols for which to start adapters or empty for all.
+
+
-
+
- +property device_lock: allocate_lock +
This lock is passed to each adapter when it’s started. It’s supposed to be used to ensure +that the device is only accessed from one thread at a time, for example during network IO. +
+Simulationuses this lock to block the device during the +simulation cycle calculations.
-
+
- +disconnect(*args: str) None[source] +
Stops all adapters for the specified protocols. The method waits for each adapter thread +to join, so it might hang if the thread is not terminating correctly.
+-
+
- Parameters: +
args – List of protocols for which to stop adapters or empty for all.
+
+
-
+
- +documentation(*args: str) str[source] +
Returns the concatenated documentation for the adapters specified by the supplied +protocols or all of them if no arguments are provided.
+-
+
- Parameters: +
args – List of protocols for which to get documentation or empty for all.
+
+- Returns: +
Documentation for all selected adapters.
+
+
-
+
- +is_connected(*args: str) bool | dict[str | None, bool][source] +
If only one protocol is supplied, a single bool is returned with the connection status. +Otherwise, this method returns a dictionary of adapter connection statuses for the supplied +protocols. If no protocols are supplied, all adapter statuses are returned.
+-
+
- Parameters: +
args – List of protocols for which to start adapters or empty for all.
+
+- Returns: +
Boolean for single adapter or dict of statuses for multiple.
+
+
-
+
- +property protocols: list[str] +
List of protocols for which adapters are registered.
+
-
+
- +remove_adapter(protocol: str) None[source] +
Tries to remove the adapter for the specified protocol, raises a
+RuntimeErrorif there +is no adapter registered for that particular protocol.-
+
- Parameters: +
protocol – Protocol to remove from container
+
+
-
+
- +set_device(new_device: DeviceBase) None[source] +
Bind the new device to all interfaces managed by the adapters in the collection.
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.core.control_client.html b/generated/lewis.core.control_client.html
new file mode 100644
index 00000000..746db44c
--- /dev/null
+++ b/generated/lewis.core.control_client.html
@@ -0,0 +1,299 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.core.approaches
+Defines functions that model typical behavior, such as a value approaching a target linearly at +a certain rate.
+Members
+| + | This function returns the new value after moving towards target at the given speed constantly for the time dt. |
+
-
+
- +lewis.core.approaches.linear(current: float, target: float, rate: float, dt: float)[source] +
This function returns the new value after moving towards +target at the given speed constantly for the time dt.
+If for example the current position is 10 and the target is -20, +the returned value will be less than 10 if rate and dt are greater +than 0:
+++new_pos = linear(10, -20, 10, 0.1) # new_pos = 9 +
The function makes sure that the returned value never overshoots:
+++new_pos = linear(10, -20, 10, 100) # new_pos = -20 +
-
+
- Parameters: +
-
+
current – The current value of the variable to be changed.
+target – The target value to approach.
+rate – The rate at which the parameter should move towards target.
+dt – The time for which to calculate the change.
+
+- Returns: +
The new variable value.
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.core.control_server.html b/generated/lewis.core.control_server.html
new file mode 100644
index 00000000..04cb3497
--- /dev/null
+++ b/generated/lewis.core.control_server.html
@@ -0,0 +1,355 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.core.control_client
+This module provides client code for objects exposed via JSON-RPC over ZMQ.
+
+
+See also
+The server-part for these client classes is defined
+in the module control_server.
Members
+| + | This class provides an interface to a ControlServer instance on the server side. |
+
| + | This class serves as a base class for dynamically created classes on the client side that represent server-side objects. |
+
| + | An exception type for exceptions related to the transport protocol, i.e. malformed requests etc. |
+
| + | This exception type replaces exceptions that are raised on the server, but unknown (i.e. not in the exceptions-module) on the client side. |
+
-
+
- +class lewis.core.control_client.ControlClient(host='127.0.0.1', port='10000', timeout=3000)[source] +
Bases:
+objectThis class provides an interface to a ControlServer instance on +the server side. Proxies to exposed objects can be obtained either +directly via get_object or, in case the server exposes a collection +of objects at the top level, a dictionary of named objects can be +obtained via get_object_collection.
+If a timeout is supplied, all underlying network operations time out +after the specified time (in milliseconds), for no timeout specify
+None.-
+
- Parameters: +
-
+
host – Host the control server is running on.
+port – Port on which the control server is listening.
+timeout – Timeout in milliseconds for ZMQ operations.
+
+
-
+
- +get_object_collection(object_name='')[source] +
If the remote end exposes a collection of objects under the supplied object name (empty +for top level), this method returns a dictionary of these objects stored under their +names on the server.
+This function performs n + 1 calls to the server, where n is the number of objects.
+-
+
- Parameters: +
object_name – Object name on the server. This is required if the object collection +is not the top level object.
+
+
-
+
- +json_rpc(method, *args)[source] +
This method takes a ZMQ REQ-socket and submits a JSON-object containing +the RPC (JSON-RPC 2.0 format) to the supplied method with the supplied arguments. +Then it waits for a reply from the server and blocks until it has received +a JSON-response. The method returns the response and the id it used to tag +the original request, which is a random UUID (uuid.uuid4).
+-
+
- Parameters: +
-
+
method – Method to call on remote.
+args – Arguments to method call.
+
+- Returns: +
JSON result and request id.
+
+
-
+
- +class lewis.core.control_client.ObjectProxy(connection, members, prefix='')[source] +
Bases:
+objectThis class serves as a base class for dynamically created classes on the +client side that represent server-side objects. Upon initialization, +this class takes the supplied methods and installs appropriate proxy methods +or properties into the object and class respectively. Because of that +class manipulation, this class must never be used directly. +Instead, it should be used as a base-class for dynamically created types +that mirror types on the server, like this:
+++proxy = type("SomeClassName", (ObjectProxy,), {})(connection, methods, prefix) +
There is however, the class ControlClient, which automates all that +and provides objects that are ready to use.
+Exceptions on the server are propagated to the client. If the exception is not part +of the exceptions-module (builtins for Python 3), a RemoteException is raised instead +which contains information about the server side exception.
+All RPC method names are prefixed with the supplied prefix, which is usually the +object name on the server plus a dot.
+-
+
- Parameters: +
-
+
connection – ControlClient-object for remote calls.
+members – List of strings to generate methods and properties.
+prefix – Usually object name on the server plus dot.
+
+
-
+
- +exception lewis.core.control_client.ProtocolException[source] +
Bases:
+ExceptionAn exception type for exceptions related to the transport protocol, i.e. +malformed requests etc.
+
-
+
- +exception lewis.core.control_client.RemoteException(exception_type, message)[source] +
Bases:
+ExceptionThis exception type replaces exceptions that are raised on the server, +but unknown (i.e. not in the exceptions-module) on the client side. +To retain as much information as possible, the exception type on the server and +the message are stored.
+-
+
- Parameters: +
-
+
exception_type – Type of the exception on the server side.
+message – Exception message on the server side.
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.core.devices.html b/generated/lewis.core.devices.html
new file mode 100644
index 00000000..6a9dfb39
--- /dev/null
+++ b/generated/lewis.core.devices.html
@@ -0,0 +1,436 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.core.control_server
+This module contains classes to expose objects via a JSON-RPC over ZMQ server. Lewis uses
+this infrastructure in Simulation.
+
+See also
+Client classes for the service defined in this module can be found in
+control_client.
Members
+| + | This server opens a ZMQ REP-socket at the given host and port when start_server is called. |
+
| + | ExposedObject is a class that makes it easy to expose an object via the JSONRPCResponseManager from the json-rpc package, where it can serve as a dispatcher. |
+
| + | This class helps expose a number of objects (plain or RPCObject) by exposing the methods of each object as |
+
-
+
- +class lewis.core.control_server.ControlServer(object_map, connection_string)[source] +
Bases:
+objectThis server opens a ZMQ REP-socket at the given host and port when start_server +is called.
+The server constructs an
+ExposedObjectCollectionfrom the supplied +name: object-dictionary and uses that as a handler for JSON-RPC requests. If it is an +instance ofExposedObject, that is used directly.Each time process is called, the server tries to get request data and responds to that. +If there is no data, the method does nothing.
+Please note that this RPC-service comes without any security, authentication, etc. +Only use it to expose objects on a trusted network and be aware that anyone on that +network can access the exposed objects without any restrictions.
+-
+
- Parameters: +
-
+
object_map – Dictionary with name: object-pairs to construct an +ExposedObjectCollection or ExposedObject
+connection_string – String with host:port pair for binding control server.
+
+
-
+
- +property exposed_object +
The exposed object. This is a read only property.
+
-
+
- +property is_running +
This property is
+Trueif the server is running.
-
+
- +process(blocking=False) None[source] +
Each time this method is called, the socket tries to retrieve data and passes +it to the JSONRPCResponseManager, which in turn passes the RPC to the +ExposedObjectCollection.
+In case no data are available, the method does nothing. This behavior is required for +Lewis where everything is running in one thread. The central loop can call process +at some point to process remote calls, so the RPC-server does not introduce its own +infinite processing loop.
+If the server has not been started yet (via
+start_server()), a RuntimeError +is raised.-
+
- Parameters: +
blocking – If True, this function will block until it has received data or a timeout +is triggered. Default is False to preserve behavior of prior versions.
+
+
-
+
- +class lewis.core.control_server.ExposedObject(obj, members=None, exclude=None, exclude_inherited=False, lock=None)[source] +
Bases:
+objectExposedObject is a class that makes it easy to expose an object via the +JSONRPCResponseManager from the json-rpc package, where it can serve as a dispatcher. +For this purpose it exposes a read-only dict-like interface.
+The basic problem solved by this wrapper is that plain data members of an object are not +really captured well by the RPC-approach, where a client performs function calls on a +remote machine and gets the result back.
+The supplied object is inspected using dir(object) and all entries that do not start +with a _ are exposed in a way that depends on whether the corresponding member +is a method or a property (either in the Python-sense or the general OO-sense). Methods +are stored directly, and stored in an internal dict where the method name is the key and +the callable method object is the value. For properties, a getter- and a setter function +are generated, which are then stored in the same dict. The names of these methods for +a property called
+aarea:getanda:set. The separator has been chosen to be +colon because it can’t be part of a valid Python identifier.If the second argument is not empty, it is interpreted to be the list of members +to expose and only those are actually exposed. This can be used to explicitly expose +members of an object that start with an underscore. If all but one or two members +should be exposed, it’s also possible to use the exclude-argument to explicitly +exclude a few members. Both parameters can be used in combination, the exclude-list +takes precedence.
+In certain situations it is desirable to acquire a lock before accessing the exposed object, +for example when multiple threads are accessing it on the server side. For this purpose, +the
+lock-parameter can be used. If it is notNone, the exposed methods are wrapped +in a function that acquires the lock before accessingobj, and releases it afterwards.-
+
- Parameters: +
-
+
obj – The object to expose.
+members – This list of methods will be exposed. (defaults to all public members)
+exclude – Members in this list will not be exposed.
+exclude_inherited – Should inherited members be excluded? (defaults to False)
+lock –
threading.Lockthat is used when accessingobj.
+
+
-
+
- +class lewis.core.control_server.ExposedObjectCollection(named_objects)[source] +
Bases:
+ExposedObjectThis class helps expose a number of objects (plain or RPCObject) by +exposing the methods of each object as
+++name.method +
Furthermore it exposes each object’s API as a method with the following name:
+++name: api +
A list of exposed objects can be obtained by calling the following method from the client:
+++:objects +
-
+
- Parameters: +
named_objects – Dictionary of of name: object pairs.
+
+
-
+
- +add_object(obj, name) None[source] +
Adds the supplied object to the collection under the supplied name. If the name is already +in use, a RuntimeError is raised. If the object is not an instance of +
+ExposedObject, the method automatically constructs one.-
+
- Parameters: +
-
+
obj – Object to add to the collection.
+name – Name of the exposed object.
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.core.exceptions.html b/generated/lewis.core.exceptions.html
new file mode 100644
index 00000000..b0337597
--- /dev/null
+++ b/generated/lewis.core.exceptions.html
@@ -0,0 +1,202 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.core.devices
+This module contains DeviceBase as a base class for other device classes and
+infrastructure that can import devices from a module (DeviceRegistry). The latter also
+produces factory-like objects that create device instances and interfaces based on setups
+(DeviceBuilder).
Members
+| + | This class is a common base for |
+
| + | This class takes a module object (for example imported via importlib.import_module or via the |
+
| + | This class takes the name of a module and constructs a |
+
| + | This class is a common base for protocol specific interfaces that are exposed by a subclass of |
+
| + | Returns True if obj is a device type (derived from DeviceBase), but not defined in |
+
| + | Returns True if obj is an interface (derived from |
+
-
+
- +class lewis.core.devices.DeviceBase[source] +
Bases:
+objectThis class is a common base for
+Deviceand +StateMachineDevice. It is mainly used in the device +discovery process.
-
+
- +class lewis.core.devices.DeviceBuilder(module)[source] +
Bases:
+objectThis class takes a module object (for example imported via importlib.import_module or via the +
+DeviceRegistry) and inspects it so that it’s possible to construct devices and +interfaces.In order for the class to work properly, the device module has to adhere to a few rules. +Device types, which means classes inheriting from
+DeviceBase, are imported directly +from the device module, equivalent to the following:++from device_name import SimulatedDeviceType +
If
+SimulatedDeviceTypeis defined in the__init__.py, there’s nothing else to do. If +the device class is defined elsewhere, it must be imported in the__init__.pyfile as +written above. If there is only one device type (which is probably the most common case), it is +assumed to be default device type.Setups are discovered in two locations, the first one is a dict called
+setupsin the device +module, which must contain setup names as keys and as values again a dict. This inner dict has +one mandatory key calleddevice_typeand one optional keyparameterscontaining the +constructor arguments for the specified device type:++setups = dict( + broken=dict( + device_type=SimulatedDeviceType, + parameters=dict( + override_initial_state="error", + override_initial_data=dict(target=-10, position=-20.0), + ), + ) +) +
The other location is a sub-package called setups, which should in turn contain modules. Each +module must contain a variable
+device_typeand a variableparameterswhich are +analogous to the keys in the dict described above. This allows for more complex setups which +define additional classes and so on.The
+defaultsetup is special, it is used when no setup is supplied to +create_device(). If the setupdefaultis not defined, one is created with the default +device type. This has two consequences, no setups need to be defined for very simple devices, +but if multiple device types are defined, adefaultsetup must be defined.A setup can be supplied to the
+create_device().Lastly, the builder tries to discover device interfaces, which are currently classes based on +
+lewis.adapters.InterfaceBase. These are looked for in the module and in a sub-package +calledinterfaces(which should contain modules with adapters like thesetupspackage).Each interface has a protocol, if a protocol occurs more than once in a device module, +a RuntimeError is raised.
+-
+
- +create_device(setup=None)[source] +
Creates a device object according to the provided setup. If no setup is provided, +the default setup is used. If the setup can’t be found, a LewisException is raised. +This can also happen if the device type specified in the setup is invalid.
+-
+
- Parameters: +
setup – Name of the setup from which to create device.
+
+- Returns: +
Device object initialized according to the provided setup.
+
+
-
+
- +create_interface(protocol=None, *args, **kwargs)[source] +
Returns an interface that implements the provided protocol. If the protocol is not +known, a LewisException is raised. All additional arguments are forwarded +to the interface constructor (see
+Adapterfor details).-
+
- Parameters: +
-
+
protocol – Protocol which the interface must implement.
+args – Positional arguments that are passed on to the interface.
+kwargs – Keyword arguments that are passed on to the interface.
+
+- Returns: +
Instance of the interface type.
+
+
-
+
- +property default_device_type +
If the module only defines one device type, it is the default device type. It is used +whenever a setup does not provide a
+device_type.
-
+
- +property default_protocol +
In case only one protocol exists for the device, this is the default protocol.
+
-
+
- +property device_types +
This property contains a dict of all device types in the device module. The keys are +type names, the values are the types themselves.
+
-
+
- +property interfaces +
This property contains a map with protocols as keys and interface types as values. +The types are imported from the
+interfacessub-module and from the device module +itself. If two interfaces with the same protocol are discovered, a RuntimeError is raiesed.
-
+
- +property name +
The name of the device, which is also the name of the device module.
+
-
+
- +property protocols +
All available protocols for this device.
+
-
+
- +property setups +
A map with all available setups. Setups are imported from the
+setupsdictionary +in a device module and from thesetupssub-module. If nodefault-setup exists, +one is created using the default_device_type. If there are several device types in +the module, the default setup must be provided explicitly.
-
+
- +class lewis.core.devices.DeviceRegistry(device_module)[source] +
Bases:
+objectThis class takes the name of a module and constructs a
+DeviceBuilderfrom +each sub-module. The available devices can be queried and a DeviceBuilder can be +obtained for each device:++from lewis.core.devices import DeviceRegistry + +registry = DeviceRegistry("lewis.devices") +chopper_builder = registry.device_builder("chopper") + +# construct device, interface, ... +
If the module can not be imported, a LewisException is raised.
+-
+
- Parameters: +
device_module – Name of device module from which devices are loaded.
+
+
-
+
- +device_builder(name)[source] +
Returns a
+DeviceBuilderinstance that can be used to create device objects +based on setups, as well as device interfaces. If the device name is not stored +in the internal map, a LewisException is raised.Each DeviceBuilder has a
+framework_version-member, which specifies the version +of Lewis the device has been written for. If the version does not match the current +framework version, it is only possible to obtain those device builders calling the +method withstrict_versionsset toFalse, otherwise a +LewisExceptionis raised. A warning message is logged +in all cases. Ifframework_versionisNone(e.g. not specified at all), it +is accepted unlessstrict_versionsis set toTrue.-
+
- Parameters: +
name – Name of the device.
+
+- Returns: +
+DeviceBuilder-object for requested device.
+
-
+
- +property devices +
All available device names.
+
-
+
- +class lewis.core.devices.InterfaceBase[source] +
Bases:
+objectThis class is a common base for protocol specific interfaces that are exposed by a subclass of +
+Adapter. This base class is not meant to be used directly in +a device package - this is what the interfaces inlewis.adaptersare for.There is a 1:1 correspondence between device and interface, where the interface holds a +reference to the device. It can be changed through the
+device-property.-
+
- +property adapter: NoReturn +
Adapter type that is required to process and expose interfaces of this type. Must be +implemented in subclasses.
+
-
+
- +property device +
The device this interface is bound to. When a new device is set,
+_bind_device()is +called, where the interface can react to the device change if necessary.
-
+
- +lewis.core.devices.is_device(obj)[source] +
Returns True if obj is a device type (derived from DeviceBase), but not defined in +
+lewis.core.devicesorlewis.devices.-
+
- Parameters: +
obj – Object to test.
+
+- Returns: +
True if obj is a device type.
+
+
-
+
- +lewis.core.devices.is_interface(obj)[source] +
Returns True if obj is an interface (derived from
+InterfaceBase), but not defined in +lewis.adapters, where concrete interfaces for protocols are defined.-
+
- Parameters: +
obj – Object to test.
+
+- Returns: +
True if obj is an interface type.
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.core.html b/generated/lewis.core.html
new file mode 100644
index 00000000..12843742
--- /dev/null
+++ b/generated/lewis.core.html
@@ -0,0 +1,197 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.core.exceptions
+Defines exception types specific to lewis. The main intention of these exception types is +that they can be caught and meaningful messages can be displayed to the user.
+Members
+| + | This exception can be raised in situation where the performed action (accessing a property or similar) is not allowed. |
+
| + | This exception type is used to distinguish exceptions that are expected from unexpected ones. |
+
| + | An exception that can be raised in a device to indicate a limit violation. |
+
-
+
- +exception lewis.core.exceptions.AccessViolationException[source] +
Bases:
+ExceptionThis exception can be raised in situation where the performed action (accessing a property or +similar) is not allowed. An example is
+BoundPVfor enforcing +read-only PVs.
-
+
- +exception lewis.core.exceptions.LewisException[source] +
Bases:
+ExceptionThis exception type is used to distinguish exceptions that are expected +from unexpected ones. This enables better error handling and more importantly +better presentation of errors to the users.
+
-
+
- +exception lewis.core.exceptions.LimitViolationException[source] +
Bases:
+ExceptionAn exception that can be raised in a device to indicate a limit violation. It is for example +raised by the
+check_limits.
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.core.logging.html b/generated/lewis.core.logging.html
new file mode 100644
index 00000000..55a14faf
--- /dev/null
+++ b/generated/lewis.core.logging.html
@@ -0,0 +1,243 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.core
+Submodules
+| + | This module contains |
+
| + | Defines functions that model typical behavior, such as a value approaching a target linearly at a certain rate. |
+
| + | This module provides client code for objects exposed via JSON-RPC over ZMQ. |
+
| + | This module contains classes to expose objects via a JSON-RPC over ZMQ server. |
+
| + | This module contains |
+
| + | Defines exception types specific to lewis. |
+
| + | This module contains everything logging-related in Lewis. |
+
| + | This module defines two classes related to one of lewis' essential concepts, namely the cycle-based approach. |
+
| + | A |
+
| + | The statemachine module contains one of lewis' central parts, the cycle-based |
+
| + | This module contains some useful helper classes and functions that are not specific to a certain module contained in the Core API. |
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.core.processor.html b/generated/lewis.core.processor.html
new file mode 100644
index 00000000..c03f4e92
--- /dev/null
+++ b/generated/lewis.core.processor.html
@@ -0,0 +1,211 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.core.logging
+This module contains everything logging-related in Lewis. There is one relevant
+module level variable that defines the default log format, default_log_format.
All places that use logging in Lewis prefix their logger names with lewis so
+that you can easily control the logs caused by Lewis if you use it as a library.
+Lewis uses the default settings of the logging module, so if you use Lewis as a
+library and do not have any logging enabled, messages that are more severe than WARNING
+are printed to stdout. For details on how to disable that behavior, change levels
+for certain loggers and so on, please refer to the documentation
+of the standard logging library.
Members
+| + | + |
| + | This is a decorator to add logging functionality to a class or function. |
+
-
+
- +lewis.core.logging.has_log(target: Type[T]) Type[T][source] +
- +lewis.core.logging.has_log(target: Callable[[P], T]) Callable[[P], T] +
This is a decorator to add logging functionality to a class or function.
+Applying this decorator to a class or function will add two new members:
++
+-
+
logis an instance oflogging.Logger. The name of the logger is +set tolewis.Foofor a class named Foo.
+_set_logging_contextis a method that modifies the name of the logger +when the class is used in a certain context.
+
If
+contextis a string, that string is directly inserted betweenlewis+andFoo, so that the logger name would belewis.bar.Fooif context +was'bar'. The more common case is probablycontextbeing an object of +some class, in which case the class name is inserted. Ifcontextis an object +of typeBar, the logger name ofFoowould belewis.Bar.Foo.To provide a more concrete example in terms of Lewis, this is used for the state +machine logger in a device. So the logs of the state machine belonging to a certain +device appear in the log as originating from
+lewis.DeviceName.StateMachine, which +makes it possible to distinguish between messages from different state machines.Example for how to use logging in a class:
+++from lewis.core.logging import has_log + + +@has_log +class Foo(Base): + def __init__(self): + super(Foo, self).__init__() + + def bar(self, baz): + self.log.debug("Called bar with parameter baz=%s", baz) + return baz is not None +
It works similarly for free functions, although the actual logging calls are a bit different:
+++from lewis.core.logging import has_log + + +@has_log +def foo(bar): + foo.log.info("Called with argument bar=%s", bar) + return bar +
The name of the logger is
+lewis.foo, the context could also be modified by calling +foo._set_logging_context.-
+
- Parameters: +
target – Target to decorate with logging functionality.
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.core.simulation.html b/generated/lewis.core.simulation.html
new file mode 100644
index 00000000..bc81f090
--- /dev/null
+++ b/generated/lewis.core.simulation.html
@@ -0,0 +1,392 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.core.processor
+This module defines two classes related to one of lewis’ essential concepts, namely
+the cycle-based approach. CanProcess and CanProcessComposite implement the
+composite design pattern so that it’s possible to form a tree of objects which can perform
+calculations based on an elapsed time Δt.
Members
+| + | The CanProcess class is meant as a base for all things that are able to process on the basis of a time delta (dt). |
+
| + | This subclass of CanProcess is a convenient way of collecting multiple items that implement the CanProcess interface. |
+
-
+
- +class lewis.core.processor.CanProcess[source] +
Bases:
+objectThe CanProcess class is meant as a base for all things that +are able to process on the basis of a time delta (dt).
+The base implementation does nothing.
+There are three methods that can be implemented by sub-classes and are called in the +process-method in this order:
++
+-
+
doBeforeProcess
+doProcess
+doAfterProcess
+
The doBefore- and doAfterProcess methods are only called if a doProcess-method exists.
+
-
+
- +class lewis.core.processor.CanProcessComposite(iterable=())[source] +
Bases:
+CanProcessThis subclass of CanProcess is a convenient way of collecting +multiple items that implement the CanProcess interface.
+Items can be added to the composite like this:
+++composite = CanProcessComposite() +composite.add_processor(item_that_implements_CanProcess) +
The process-method calls the process-method of each contained +item. Specific things that have to be done before or after the +containing items are processed can be implemented in the doBefore- +and doAfterProcess methods.
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.core.statemachine.html b/generated/lewis.core.statemachine.html
new file mode 100644
index 00000000..1f2e2d4f
--- /dev/null
+++ b/generated/lewis.core.statemachine.html
@@ -0,0 +1,410 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.core.simulation
+A Simulation combines a Device and its interface (derived from
+an Adapter).
Members
+| + | The Simulation class controls certain aspects of a device simulation, the most important one being time. |
+
| + | This class is used to create |
+
-
+
- +class lewis.core.simulation.Simulation(device, adapters=(), device_builder=None, control_server=None)[source] +
Bases:
+objectThe Simulation class controls certain aspects of a device simulation, +the most important one being time.
+Once
+start()is called, the process-method of the device +is called in regular intervals. The time between these calls is +influenced by the cycle_delay property. Because of the way some +network protocols work, the actual processing time can be +longer or shorter, so cycle_delay should be seen as a guideline +rather than a guaranteed parameter.In the simplest case, the actual time-delta between two cycles +is passed to the simulated device so that it can update its internal +state according to the elapsed time. It is however possible to set +a simulation speed, which serves as a multiplier for this time. +If the speed is set to 2 and 0.1 seconds pass between two cycles, +the simulation is asked to simulate 0.2 seconds, and so on. Speed 0 +effectively stops all time dependent calculations in the +simulated device.
+Another possibility to pause the simulation is the pause-method. After +calling it, all processing in the device is suspended, while the communication +adapters continue to work. This can be used to simulate that a device is “hanging”. +The simulation can be continued using the resume-method.
+A number of status properties provide information about the simulation. +The total uptime (in actually elapsed time) can be obtained through the +uptime-property, whereas the runtime-property contains the simulated time. +The cycles-property indicates the total number of simulation cycles, which +does not increase when the simulation is paused.
+Finally, the simulation can be stopped entirely with the stop-method.
+All functionality except for the start-method can be made available to remote +computers via a
+ControlServer-instance. The way to expose device and simulation +is to pass a ‘host:port’-string as the control_server argument, +which will construct the control server. Simulation will try to start the +control server using the start_server method.-
+
- Parameters: +
-
+
device – The simulated device.
+adapters – Adapters which expose the simulated device.
+device_builder –
DeviceBuilderinstance to enable setup- +switching at runtime.
+control_server – ‘host:port’-string to construct control server or None.
+
+
-
+
- +property control_server +
ControlServer-instance that exposes the object to remote machines. Can only +be set before start has been called or on a running simulation if no +control server was previously present. If the server is not running, it will be started +after it has been set.
+
-
+
- +property cycle_delay +
Desired time between simulation cycles, this can not be negative. +Use 0 for highest possible processing rate.
+
-
+
- +property cycles +
Simulation cycles processed since start has been called.
+
-
+
- +property is_paused +
True if the simulation is paused (implies that the simulation has been started).
+
-
+
- +property is_started +
This property is true if the simulation has been started.
+
-
+
- +resume() None[source] +
Resume a paused simulation. Can only be called after start +and pause have been called.
+
-
+
- +property runtime +
The accumulated simulation time. Whenever speed is different from 1, this +progresses at a different rate than uptime.
+
-
+
- +set_device_parameters(parameters) None[source] +
Set multiple parameters of the simulated device “simultaneously”. The passed +parameter is assumed to be device parameter/value dict. +The method only allows to set existing attributes. If there are invalid +attribute names, the attributes are not updated, instead a RuntimeError +is raised. The same happens if any of the parameters are methods, which +can not be updated with this mechanisms.
+-
+
- Parameters: +
parameters – Dict of device attribute/values to update the device.
+
+
-
+
- +property setups +
A list of setups that are available. Use
+switch_setup()to +change the setup.
-
+
- +property speed +
Simulation speed. Actual elapsed time is multiplied with this property +to determine simulated time. Values greater than 1 increase the simulation +speed, values between 1 and 0 decrease it. A speed of 0 effectively pauses +the simulation.
+
-
+
- +switch_setup(new_setup) None[source] +
This method switches the setup, which means that it replaces the currently +simulated device with a new device, as defined by the setup.
+If any error occurs during setup switching it is logged and re-raised.
+-
+
- Parameters: +
new_setup – Name of the new setup to load.
+
+
-
+
- +property uptime +
Elapsed time in seconds since the simulation has been started.
+
-
+
- +class lewis.core.simulation.SimulationFactory(devices_package)[source] +
Bases:
+objectThis class is used to create
+Simulation-objects according to a certain +set of parameters, such as device, setup and protocol. To create a simulation, it needs to +know where devices are stored:++factory = SimulationFactory("lewis.devices") +
The actual creation happens via the
+create()-method:++simulation = factory.create("device_name", protocol="protocol") +
The simulation can then be started and stopped as desired.
+++Warning
+This class is meant for internal use at the moment and may change frequently.
+-
+
- +create(device, setup=None, protocols=None, control_server=None)[source] +
Creates a
+Simulationaccording to the supplied parameters.-
+
- Parameters: +
-
+
device – Name of device.
+setup – Name of the setup for device creation.
+protocols – Dictionary where each key is assigned a dictionary with options for the +corresponding
Adapter. For available +protocols, seeget_protocols().
+control_server – String to construct a control server (host:port).
+
+- Returns: +
Simulation object according to input parameters.
+
+
-
+
- +property devices +
Names of available devices.
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.core.utils.html b/generated/lewis.core.utils.html
new file mode 100644
index 00000000..de835a1c
--- /dev/null
+++ b/generated/lewis.core.utils.html
@@ -0,0 +1,424 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.core.statemachine
+The statemachine module contains one of lewis’ central parts, the cycle-based
+StateMachine. The module also contains classes that make it easier to define the
+state machine (State, Transition). Despite its central nature, it’s unlikely
+to be used directly in client code for device simulations - these should be based on
+StateMachineDevice, which provides a more convenient interface for that purpose.
Members
+| + | Mixin to provide a Context. |
+
| + | StateMachine state handler base class. |
+
| + | Cycle based state machine. |
+
| + | Classes in this module should only raise this type of Exception. |
+
| + | StateMachine transition condition base class. |
+
-
+
- +class lewis.core.statemachine.HasContext[source] +
Bases:
+objectMixin to provide a Context.
+Creates a _context member variable that can be assigned with
+set_context().Any state handler or transition callable that derives from this mixin will +receive a context from its
+ + +StateMachineupon initialization (assuming the +StateMachine was provided with a context itself).
-
+
- +class lewis.core.statemachine.State[source] +
Bases:
+HasContextStateMachine state handler base class.
+Provides a way to implement StateMachine event handling behaviour using an +object-oriented interface. Once the StateMachine is configured to do so, it +will automatically invoke the events in this class when appropriate.
+To use this class, create a derived class and override any events that need +custom behaviour. Device context is provided via
+HasContextmixin.-
+
- +in_state(dt) None[source] +
Handle in-state event.
+Raised repeatedly, once per cycle, while idling in this state. Exactly one +in-state event occurs per cycle for every StateMachine. This is always the +last event of the cycle.
+-
+
- Parameters: +
dt – Delta T since last cycle.
+
+
-
+
- +class lewis.core.statemachine.StateMachine(cfg, context=None)[source] +
Bases:
+CanProcessCycle based state machine.
+-
+
- Parameters: +
-
+
cfg – dict which contains state machine configuration.
+context – object which is assigned to State and Transition objects as their _context.
+
+
The configuration dict may contain the following keys:
++
+-
+
initial: Name of the initial state of this machine
+states: [optional] Dict of custom state handlers
+transitions: [optional] Dict of transitions in this state machine.
+
State handlers may be given as a dict, list or State class:
++
+-
+
dict: May contain keys ‘on_entry’, ‘in_state’ and ‘on_exit’.
+list: May contain up to 3 entries, above events in that order.
+class: Should be an instance of a class that derives from State.
+
In case of handlers being provided as a dict or a list, values should be callable +and may take a single parameter: the Delta T since the last cycle.
+Transitions should be provided as a dict where:
++
+-
+
Each key is a tuple of two values, the FROM and TO states respectively.
+Each value is a callable transition condition that return True or False.
+
Transition conditions are called once per cycle when in the FROM state. If one of +the transition conditions returns True, the transition is executed that cycle. The +remaining conditions aren’t called.
+Consider using an OrderedDict if order matters.
+Only one transition may occur per cycle. Every cycle will, at the very least, +trigger an in_state event against the current state.
+++See also
+See
+doProcess()for details.-
+
- +bind_handlers_by_name(instance, override=False, prefix=None) None[source] +
Auto-bind state handlers based on naming convention.
+-
+
- Parameters: +
-
+
instance – Target object instance to search for handlers and bind events to.
+override – If set to True, matching handlers will replace +previously registered handlers.
+prefix – Dict or list of prefixes to override defaults +(keys: on_entry, in_state, on_exit)
+
+
This function enables automatically binding state handlers to events without having to +specify them in the constructor. When called, this function searches instance for +member functions that match the following patterns for all known states +(states mentioned in ‘states’ or ‘transitions’ dicts of cfg):
++
+-
+
instance._on_entry_[state]
+instance._in_state_[state]
+instance._on_exit_[state]
+
The default prefixes may be overridden using the prefix parameter. Supported keys are +‘on_entry’, ‘in_state’, and ‘on_exit’. Values should include any and +all desired underscores.
+Matching functions are assigned as handlers to the corresponding state events, +iff no handler was previously assigned to that event.
+If a state event already had a handler assigned (during construction or previous call +to this function), no changes are made even if a matching function is found. To force +previously assigned handlers to be overwritten, set the third parameter to True. +This may be useful to implement inheritance-like specialization using multiple +implementation classes but only one StateMachine instance.
+
-
+
- +can(state)[source] +
Returns true if the transition to ‘state’ is allowed from the current state.
+-
+
- Parameters: +
state – State to check transition to
+
+- Returns: +
True if state is reachable from current
+
+
-
+
- +doProcess(dt) None[source] +
Process a cycle of this state machine.
+-
+
- Parameters: +
dt – Delta T. “Time” passed since last cycle, passed on to event handlers.
+
+
A cycle will perform at most one transition and exactly one in_state event.
+A transition will only occur if one of the transition condition functions leaving +the current state returns True.
+-
+
- When a transition occurs, the following events are raised:
-
+
on_exit_old_state()
+on_entry_new_state()
+in_state_new_state()
+
+
The first cycle after init or reset will never call transition checks and, instead, +always performs on_entry and in_state on the initial state.
+Whether a transition occurs or not, and regardless of any other circumstances, a +cycle always ends by raising an in_state event on the current (potentially new) +state.
+
-
+
- +reset() None[source] +
Reset the state machine to before the first cycle. The next process() will +enter the initial state.
+
-
+
- +property state +
Name of the current state.
+
-
+
- +exception lewis.core.statemachine.StateMachineException[source] +
Bases:
+ExceptionClasses in this module should only raise this type of Exception.
+
-
+
- +class lewis.core.statemachine.Transition[source] +
Bases:
+HasContextStateMachine transition condition base class.
+Provides a way to implement a transition that requires access to the device +context. The device context is provided via
+HasContextmixin, and can be +accessed as self._context.To use this class, create a derived class and override the
+__call__()attribute.
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.devices.chopper.devices.bearings.html b/generated/lewis.devices.chopper.devices.bearings.html
new file mode 100644
index 00000000..9a6834fa
--- /dev/null
+++ b/generated/lewis.devices.chopper.devices.bearings.html
@@ -0,0 +1,168 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.core.utils
+This module contains some useful helper classes and functions that are not specific to a certain +module contained in the Core API.
+Members
+| + | This is a utility class for importing classes from a module or replacing them with dummy types if the module can not be loaded. |
+
| + | This decorator helps to make sure that the parameter of a property setter (or any other method with one argument) is within certain numerical limits. |
+
| + | This function updates base_dict with update_dict if and only if update_dict does not contain keys that are not already in base_dict. |
+
| + | This function tries to extract a valid module name from the basename of the supplied path. |
+
| + | A very thin wrapper around textwrap.fill to consistently wrap documentation text for display in a command line environment. |
+
| + | Returns all members of an object for which the supplied predicate is true and that do not begin with __. |
+
| + | This function imports all sub-modules of the supplied module and returns a dictionary with module names as keys and the sub-module objects as values. |
+
| + | This is a small helper function that returns the elapsed seconds since start using datetime.datetime.now(). |
+
-
+
- +class lewis.core.utils.FromOptionalDependency(module, exception=None)[source] +
Bases:
+objectThis is a utility class for importing classes from a module or +replacing them with dummy types if the module can not be loaded.
+Assume module ‘a’ that does:
+++from b import C, D +
and module ‘e’ which does:
+++from a import F +
where ‘b’ is a hard to install dependency which is thus optional. +To still be able to do:
+++import e +
without raising an error, for example for inspection purposes, +this class can be used as a workaround in module ‘a’:
+++C, D = FromOptionalDependency("b").do_import("C", "D") +
which is not as pretty as the actual syntax, but at least it +can be read in a similar way. If the module ‘b’ can not be imported, +stub-types are created that are called ‘C’ and ‘D’. Everything depending +on these types will work until any of those are instantiated - in that +case an exception is raised.
+The exception can be controlled via the exception-parameter. If it is a +string, a LewisException is constructed from it. Alternatively it can +be an instance of an exception-type. If not provided, a LewisException +with a standard message is constructed. If it is anything else, a RuntimeError +is raised.
+Essentially, this class helps deferring ImportErrors until anything from +the module that was attempted to load is actually used.
+-
+
- Parameters: +
-
+
module – Module from that symbols should be imported.
+exception – Text for LewisException or custom exception object.
+
+
-
+
- +do_import(*names)[source] +
Tries to import names from the module specified on initialization +of the FromOptionalDependency-object. In case an ImportError occurs, +the requested names are replaced with stub objects.
+-
+
- Parameters: +
names – List of strings that are used as type names.
+
+- Returns: +
Tuple of actual symbols or stub types with provided names. If there is only one +element in the tuple, that element is returned.
+
+
-
+
- +class lewis.core.utils.check_limits(lower=None, upper=None, silent=False)[source] +
Bases:
+objectThis decorator helps to make sure that the parameter of a property setter (or any other +method with one argument) is within certain numerical limits.
+It’s possible to set static limits using floats or ints:
+++class Foo: + _bar = 0 + + @property + def bar(self): + return self._bar + + @bar.setter + @check_limits(0, 15) + def bar(self, new_value): + self._bar = new_value +
But sometimes this is not flexible enough, so it’s also possible to supply strings, which +are the names of attributes of the object the decorated method belongs with:
+++class Foo: + _bar = 0 + + bar_min = 0 + bar_max = 24 + + @property + def bar(self): + return self._bar + + @bar.setter + @check_limits("bar_min", "bar_max") + def bar(self, new_value): + self._bar = new_value +
This will make sure that the new value is always between
+bar_minandbar_max, even +if they change at runtime. If the limit isNone(default), the value will not be limited +in that direction.Upper and lower limit can also be used exclusively, for example for a property that has a lower +bound but not an upper, say a temperature:
+++class Foo: + _temp = 273.15 + + @check_limits(lower=0) + def set_temperature(self, t_in_kelvin): + self._temp = t_in_kelvin +
If the value is outside the specified limits, the decorated function is not called and a +
+LimitViolationExceptionis raised if thesilent- +parameter isFalse(default). If that option is active, the call is simply silently +ignored.-
+
- Parameters: +
-
+
lower – Numerical lower limit or name of attribute that contains limit.
+upper – Numerical upper limit or name of attribute that contains limit.
+silent – A limit violation will not raise an exception if this option is
True.
+
+
-
+
- +lewis.core.utils.dict_strict_update(base_dict, update_dict) None[source] +
This function updates base_dict with update_dict if and only if update_dict does not contain +keys that are not already in base_dict. It is essentially a more strict interpretation of the +term “updating” the dict.
+If update_dict contains keys that are not in base_dict, a RuntimeError is raised.
+-
+
- Parameters: +
-
+
base_dict – The dict that is to be updated. This dict is modified.
+update_dict – The dict containing the new values.
+
+
-
+
- +lewis.core.utils.extract_module_name(absolute_path)[source] +
This function tries to extract a valid module name from the basename of the supplied path. +If it’s a directory, the directory name is returned, if it’s a file, the file name +without extension is returned. If the basename starts with _ or . or it’s a file with an +ending different from .py, the function returns None
+-
+
- Parameters: +
absolute_path – Absolute path of something that might be a module.
+
+- Returns: +
Module name or None.
+
+
-
+
- +lewis.core.utils.format_doc_text(text)[source] +
A very thin wrapper around textwrap.fill to consistently wrap documentation text +for display in a command line environment. The text is wrapped to 99 characters with an +indentation depth of 4 spaces. Each line is wrapped independently in order to preserve +manually added line breaks.
+-
+
- Parameters: +
text – The text to format, it is cleaned by inspect.cleandoc.
+
+- Returns: +
The formatted doc text.
+
+
-
+
- +lewis.core.utils.get_members(obj, predicate=None)[source] +
Returns all members of an object for which the supplied predicate is true and that do not +begin with __. Keep in mind that the supplied function must accept a potentially very broad +range of inputs, because the members of an object can be of any type. The function puts +those members into a dict with the member names as keys and returns it. If no predicate is +supplied, all members are put into the dict.
+-
+
- Parameters: +
-
+
obj – Object from which to get the members.
+predicate – Filter function for the members, only members for which True is returned are +part of the resulting dict.
+
+- Returns: +
Dict with name-object pairs of members of obj for which predicate returns true.
+
+
-
+
- +lewis.core.utils.get_submodules(module) dict[str, ModuleType][source] +
This function imports all sub-modules of the supplied module and returns a dictionary +with module names as keys and the sub-module objects as values. If the supplied parameter +is not a module object, a RuntimeError is raised.
+-
+
- Parameters: +
module – Module object from which to import sub-modules.
+
+- Returns: +
Dict with name-module pairs.
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.devices.chopper.devices.device.html b/generated/lewis.devices.chopper.devices.device.html
new file mode 100644
index 00000000..6bf0145b
--- /dev/null
+++ b/generated/lewis.devices.chopper.devices.device.html
@@ -0,0 +1,184 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.chopper.devices.bearings
+Members
+
|
++ |
|
++ |
|
++ |
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.devices.chopper.devices.html b/generated/lewis.devices.chopper.devices.html
new file mode 100644
index 00000000..34742a89
--- /dev/null
+++ b/generated/lewis.devices.chopper.devices.html
@@ -0,0 +1,167 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.chopper.devices.device
+Members
+| + | + |
| + | + |
-
+
- +class lewis.devices.chopper.devices.device.SimulatedBearings[source] +
Bases:
+CanProcess,MagneticBearings
-
+
- +class lewis.devices.chopper.devices.device.SimulatedChopper(override_states: dict[str, State] | None = None, override_transitions: dict[tuple[State, State], Callable[[], bool]] | None = None, override_initial_state: State | None = None, override_initial_data: dict[str, float] | None = None)[source] +
Bases:
+StateMachineDevice-
+
- +property state +
The current state of the chopper. This parameter is read-only, it is +determined by the internal state machine of the device.
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.devices.chopper.devices.states.html b/generated/lewis.devices.chopper.devices.states.html
new file mode 100644
index 00000000..5043c7cd
--- /dev/null
+++ b/generated/lewis.devices.chopper.devices.states.html
@@ -0,0 +1,379 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.devices.chopper.html b/generated/lewis.devices.chopper.html
new file mode 100644
index 00000000..ce9392a2
--- /dev/null
+++ b/generated/lewis.devices.chopper.html
@@ -0,0 +1,163 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.chopper.devices.states
+Members
+| + | + |
| + | + |
| + | + |
| + | + |
| + | + |
| + | + |
| + | + |
| + | + |
| + | + |
|
++ |
-
+
- +class lewis.devices.chopper.devices.states.DefaultAcceleratingState(acceleration=5.0)[source] +
Bases:
+ + + + +State
-
+
- +class lewis.devices.chopper.devices.states.DefaultIdleState(acceleration=0.05)[source] +
Bases:
+ + +State
-
+
- +class lewis.devices.chopper.devices.states.DefaultParkingState(parking_speed=5.0)[source] +
Bases:
+ + + + +State
-
+
- +class lewis.devices.chopper.devices.states.DefaultPhaseLockingState(phase_locking_speed=5.0)[source] +
Bases:
+ + + + +State
-
+
- +class lewis.devices.chopper.devices.states.DefaultStoppingState(acceleration=5.0)[source] +
Bases:
+ + + + +State
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.devices.chopper.interfaces.epics_interface.html b/generated/lewis.devices.chopper.interfaces.epics_interface.html
new file mode 100644
index 00000000..acd09e69
--- /dev/null
+++ b/generated/lewis.devices.chopper.interfaces.epics_interface.html
@@ -0,0 +1,210 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.chopper
+Submodules
+| + | + |
| + | + |
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.devices.chopper.interfaces.html b/generated/lewis.devices.chopper.interfaces.html
new file mode 100644
index 00000000..e65d4850
--- /dev/null
+++ b/generated/lewis.devices.chopper.interfaces.html
@@ -0,0 +1,161 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.chopper.interfaces.epics_interface
+Members
+| + | ESS chopper EPICS interface |
+
-
+
- +class lewis.devices.chopper.interfaces.epics_interface.ChopperEpicsInterface[source] +
Bases:
+EpicsInterfaceESS chopper EPICS interface
+Interaction with this interface should happen via ChannelAccess (CA). The PV-names +usually carry a prefix which depends on the concrete device and environment, so +it is omitted in this description. The dynamically generated description of the PVs +does however contain the prefix so that the names can be copy-pasted easily.
+The first step is to initialize the chopper, for example via caput on the command line:
++
+$ caput CmdS init
+After this, the chopper is in a state where it can be started:
++
+$ caget State +State stopped
+To set a specific speed and phase, the setpoints have to be configured via caput:
++
+$ caput Spd 100 +$ caput Phs 34.5
+Then the chopper can be commanded to move towards those values:
++
+$ caput CmdS start
+Now the disc accelerates to the setpoints, the state should now be different:
++
+$ caget State +State accelerating
+The possible commands are part of the PV-specific documentation.
+-
+
- +property execute_command: str +
Command to execute. Possible commands are start, stop, set_phase, +unlock, park, init, deinit.
+
-
+
- +property last_command +
The last command that was executed successfully.
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.devices.html b/generated/lewis.devices.html
new file mode 100644
index 00000000..b61abe4b
--- /dev/null
+++ b/generated/lewis.devices.html
@@ -0,0 +1,244 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.chopper.interfaces
+Submodules
+| + | + |
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.devices.julabo.devices.device.html b/generated/lewis.devices.julabo.devices.device.html
new file mode 100644
index 00000000..053f7ea4
--- /dev/null
+++ b/generated/lewis.devices.julabo.devices.device.html
@@ -0,0 +1,286 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices
+This module contains base classes for devices. Inherit from Device for simple devices
+or from StateMachineDevice for devices that are more complex and can be described
+using a state machine.
Submodules
+| + | + |
| + | + |
| + | + |
Members
+| + | This class exists mainly for consistency. |
+
| + | This class is intended to be sub-classed to implement devices using a finite state machine internally. |
+
-
+
- +class lewis.devices.Device[source] +
Bases:
+DeviceBase,CanProcessThis class exists mainly for consistency. It is meant to implement very simple devices that +do not require a state machine for their simulation. For such devices, all that is required +is subclassing from Device and possibly implementing doProcess, but this is optional.
+StateMachineDevice offers more functionality and is more likely to be useful for implementing +simulations of real devices.
+
-
+
- +class lewis.devices.StateMachineDevice(override_states: dict[str, State] | None = None, override_transitions: dict[tuple[State, State], Callable[[], bool]] | None = None, override_initial_state: State | None = None, override_initial_data: dict[str, float] | None = None)[source] +
Bases:
+DeviceBase,CanProcessCompositeThis class is intended to be sub-classed to implement devices using a finite state machine +internally.
+Implementing such a device is straightforward, there are three methods +that must be overridden:
++
+-
+
_get_state_handlers()
+_get_initial_state()
+_get_transition_handlers()
+
The first method is supposed to return a dictionary with state handlers for each state +of the state machine, the second method must return the name of the initial state. +The third method must return a dict-like object (often an OrderedDict from collections) +that defines the conditions for transitions between the states of the state machine.
+They are implemented as methods and not as plain class member variables, because often +they use the self-variable, which does not exist at the class level.
+From these three methods, a
+StateMachine-instance is +constructed, it’s available as the device’s_csm-member. CSM is short for +“cycle-based state machine”.Most device implementation will also want to override this method:
++
+-
+
_initialize_data()
+
This method should initialise device state variables (such as temperature, speed, etc.). +Having this in a separate method from
+__init__has the advantage that it can be used +to reset those variables at a later stage, without having to write the same code again.Following this scheme, inheriting from StateMachineDevice also provides the possibility +for users of the class to override the states, the transitions, the initial state and +even the data. For states, transitions and data, dicts need to be passed to the +constructor, for the initial state that should be a string.
+All these overrides can be used to define device setups to describe certain scenarios +more easily.
+-
+
- Parameters: +
-
+
override_states – Dict with one entry per state. Only states defined in the state +machine are allowed.
+override_transitions – Dict with (state, state) tuples as keys and +callables as values.
+override_initial_state – The initial state.
+override_initial_data – A dict that contains data members +that should be overwritten on construction.
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.devices.julabo.devices.html b/generated/lewis.devices.julabo.devices.html
new file mode 100644
index 00000000..3a024a60
--- /dev/null
+++ b/generated/lewis.devices.julabo.devices.html
@@ -0,0 +1,164 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.julabo.devices.device
+Members
+| + | + |
-
+
- +class lewis.devices.julabo.devices.device.SimulatedJulabo(override_states: dict[str, State] | None = None, override_transitions: dict[tuple[State, State], Callable[[], bool]] | None = None, override_initial_state: State | None = None, override_initial_data: dict[str, float] | None = None)[source] +
Bases:
+StateMachineDevice-
+
- +set_circulating(param) str[source] +
Sets whether to circulate - in effect whether the heater is on.
+-
+
- Parameters: +
param – The mode to set, must be 0 or 1.
+
+- Returns: +
Empty string.
+
+
-
+
- +set_external_d(param) str[source] +
Sets the external derivative. +Tv in Julabo speak.
+-
+
- Parameters: +
param – The value to set, must be an integer between 0 and 999
+
+- Returns: +
Empty string.
+
+
-
+
- +set_external_i(param) str[source] +
Sets the external integral. +Tn in Julabo speak.
+-
+
- Parameters: +
param – The value to set, must be an integer between 3 and 9999
+
+- Returns: +
Empty string.
+
+
-
+
- +set_external_p(param) str[source] +
Sets the external proportional. +Xp in Julabo speak.
+-
+
- Parameters: +
param – The value to set, must be between 0.1 and 99.9
+
+- Returns: +
Empty string.
+
+
-
+
- +set_internal_d(param) str[source] +
Sets the internal derivative. +Tv in Julabo speak.
+-
+
- Parameters: +
param – The value to set, must be an integer between 0 and 999
+
+- Returns: +
Empty string.
+
+
-
+
- +set_internal_i(param) str[source] +
Sets the internal integral. +Tn in Julabo speak.
+-
+
- Parameters: +
param – The value to set, must be an integer between 3 and 9999
+
+- Returns: +
Empty string.
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.devices.julabo.devices.states.html b/generated/lewis.devices.julabo.devices.states.html
new file mode 100644
index 00000000..0e4e05ce
--- /dev/null
+++ b/generated/lewis.devices.julabo.devices.states.html
@@ -0,0 +1,191 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.devices.julabo.html b/generated/lewis.devices.julabo.html
new file mode 100644
index 00000000..0e7328d4
--- /dev/null
+++ b/generated/lewis.devices.julabo.html
@@ -0,0 +1,163 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.devices.julabo.interfaces.html b/generated/lewis.devices.julabo.interfaces.html
new file mode 100644
index 00000000..4500b31c
--- /dev/null
+++ b/generated/lewis.devices.julabo.interfaces.html
@@ -0,0 +1,164 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.julabo
+Submodules
+| + | + |
| + | + |
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.devices.julabo.interfaces.julabo_stream_interface_1.html b/generated/lewis.devices.julabo.interfaces.julabo_stream_interface_1.html
new file mode 100644
index 00000000..87ab8f5c
--- /dev/null
+++ b/generated/lewis.devices.julabo.interfaces.julabo_stream_interface_1.html
@@ -0,0 +1,170 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.julabo.interfaces
+Submodules
+| + | + |
| + | + |
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.devices.julabo.interfaces.julabo_stream_interface_2.html b/generated/lewis.devices.julabo.interfaces.julabo_stream_interface_2.html
new file mode 100644
index 00000000..9ba5c562
--- /dev/null
+++ b/generated/lewis.devices.julabo.interfaces.julabo_stream_interface_2.html
@@ -0,0 +1,170 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.julabo.interfaces.julabo_stream_interface_1
+Members
+| + | Julabos can have different commands sets depending on the version number of the hardware. |
+
-
+
- +class lewis.devices.julabo.interfaces.julabo_stream_interface_1.JulaboStreamInterfaceV1[source] +
Bases:
+StreamInterfaceJulabos can have different commands sets depending on the version number of the hardware.
+This protocol matches that for: FP50_MH (confirmed).
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.devices.linkam_t95.devices.device.html b/generated/lewis.devices.linkam_t95.devices.device.html
new file mode 100644
index 00000000..642994a5
--- /dev/null
+++ b/generated/lewis.devices.linkam_t95.devices.device.html
@@ -0,0 +1,168 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.julabo.interfaces.julabo_stream_interface_2
+Members
+| + | Julabos can have different commands sets depending on the version number of the hardware. |
+
-
+
- +class lewis.devices.julabo.interfaces.julabo_stream_interface_2.JulaboStreamInterfaceV2[source] +
Bases:
+StreamInterfaceJulabos can have different commands sets depending on the version number of the hardware.
+This protocol matches that for: FP50-HE (unconfirmed).
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.devices.linkam_t95.devices.html b/generated/lewis.devices.linkam_t95.devices.html
new file mode 100644
index 00000000..7f978a2b
--- /dev/null
+++ b/generated/lewis.devices.linkam_t95.devices.html
@@ -0,0 +1,164 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.linkam_t95.devices.device
+Members
+| + | + |
-
+
- +class lewis.devices.linkam_t95.devices.device.SimulatedLinkamT95(override_states: dict[str, State] | None = None, override_transitions: dict[tuple[State, State], Callable[[], bool]] | None = None, override_initial_state: State | None = None, override_initial_data: dict[str, float] | None = None)[source] +
Bases:
+StateMachineDevice
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.devices.linkam_t95.devices.states.html b/generated/lewis.devices.linkam_t95.devices.states.html
new file mode 100644
index 00000000..63ee6433
--- /dev/null
+++ b/generated/lewis.devices.linkam_t95.devices.states.html
@@ -0,0 +1,274 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.devices.linkam_t95.html b/generated/lewis.devices.linkam_t95.html
new file mode 100644
index 00000000..e4bf7ed0
--- /dev/null
+++ b/generated/lewis.devices.linkam_t95.html
@@ -0,0 +1,163 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.linkam_t95.devices.states
+Members
+| + | + |
| + | + |
| + | + |
| + | + |
| + | + |
| + | + |
-
+
- +class lewis.devices.linkam_t95.devices.states.DefaultCoolState[source] +
Bases:
+ + + + +State
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.devices.linkam_t95.interfaces.html b/generated/lewis.devices.linkam_t95.interfaces.html
new file mode 100644
index 00000000..693124cb
--- /dev/null
+++ b/generated/lewis.devices.linkam_t95.interfaces.html
@@ -0,0 +1,161 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.linkam_t95
+Submodules
+| + | + |
| + | + |
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.devices.linkam_t95.interfaces.stream_interface.html b/generated/lewis.devices.linkam_t95.interfaces.stream_interface.html
new file mode 100644
index 00000000..bf7f0930
--- /dev/null
+++ b/generated/lewis.devices.linkam_t95.interfaces.stream_interface.html
@@ -0,0 +1,304 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.linkam_t95.interfaces
+Submodules
+| + | + |
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.examples.dual_device.html b/generated/lewis.examples.dual_device.html
new file mode 100644
index 00000000..10d56273
--- /dev/null
+++ b/generated/lewis.examples.dual_device.html
@@ -0,0 +1,207 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.devices.linkam_t95.interfaces.stream_interface
+Members
+| + | Linkam T95 TCP stream interface. |
+
-
+
- +class lewis.devices.linkam_t95.interfaces.stream_interface.LinkamT95StreamInterface[source] +
Bases:
+StreamInterfaceLinkam T95 TCP stream interface.
+This is the interface of a simulated Linkam T95 device. The device listens on a configured +host:port-combination, one option to connect to it is via telnet:
++
+$ telnet host port
+Once connected, it’s possible to send the specified commands, described in the dynamically +generated documentation. Information about host, port and line terminators in the concrete +device instance are also generated dynamically.
+-
+
- +cool() bytes[source] +
Models “Cool Command” functionality of device.
+-
+
- Returns: +
Empty string.
+
+
-
+
- +get_status()[source] +
Models “T Command” functionality of device.
+Returns all available status information about the device as single byte array.
+-
+
- Returns: +
Byte array consisting of 10 status bytes.
+
+
-
+
- +handle_error(request, error) None[source] +
If command is not recognised print and error
+-
+
- Args:
request: requested string +error: problem
+
+
-
+
- +heat() bytes[source] +
Models “Heat Command” functionality of device.
+-
+
- Returns: +
Empty string.
+
+
-
+
- +hold() bytes[source] +
Models “Hold Command” functionality of device.
+Device will hold current temperature until a heat or cool command is issued.
+-
+
- Returns: +
Empty string.
+
+
-
+
- +pump_command(param) bytes[source] +
Models “LNP Pump Commands” functionality of device.
+Switches between automatic or manual pump mode, and adjusts speed when in manual mode.
+-
+
- Parameters: +
param – ‘a0’ for auto, ‘m0’ for manual, [0-N] for speed.
+
+- Returns: +
- + +
-
+
- +set_limit(param) bytes[source] +
Models “Limit Command” functionality of device.
+Sets the target temperate to be reached.
+-
+
- Parameters: +
param – Target temperature in C, multiplied by 10, as a string. Can be negative.
+
+- Returns: +
Empty string.
+
+
-
+
- +set_rate(param) bytes[source] +
Models “Rate Command” functionality of device.
+Sets the target rate of temperature change.
+-
+
- Parameters: +
param – Rate of temperature change in C/min, multiplied by 100, as a string. Must be positive.
+
+- Returns: +
Empty string.
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.examples.example_motor.html b/generated/lewis.examples.example_motor.html
new file mode 100644
index 00000000..3964a88d
--- /dev/null
+++ b/generated/lewis.examples.example_motor.html
@@ -0,0 +1,241 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.examples.dual_device
+Members
+| + | + |
| + | This is the EPICS interface to a quite simple device. |
+
| + | This is a TCP stream interface to the epics device, which only exposes param. |
+
-
+
- +class lewis.examples.dual_device.VerySimpleDevice[source] +
Bases:
+ + +Device-
+
- +property second +
A second (floating point) parameter.
+
-
+
- +class lewis.examples.dual_device.VerySimpleInterface[source] +
Bases:
+EpicsInterfaceThis is the EPICS interface to a quite simple device. It offers 5 PVs that expose +different things that are part of the device, the interface or neither.
+-
+
- +property second_int +
The second parameter as an integer.
+
-
+
- +class lewis.examples.dual_device.VerySimpleStreamInterface[source] +
Bases:
+StreamInterfaceThis is a TCP stream interface to the epics device, which only exposes param.
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.examples.html b/generated/lewis.examples.html
new file mode 100644
index 00000000..ff22d236
--- /dev/null
+++ b/generated/lewis.examples.html
@@ -0,0 +1,173 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.examples.example_motor
+Members
+| + | + |
| + | TCP-stream based example motor interface |
+
| + | + |
-
+
- +class lewis.examples.example_motor.ExampleMotorStreamInterface[source] +
Bases:
+StreamInterfaceTCP-stream based example motor interface
+This motor simulation can be controlled via telnet:
++
+$ telnet host port
+Where the host and port-parameter are part of the dynamically created documentation for +a concrete device instance.
+The motor starts moving immediately when a new target position is set. Once it’s moving, +it has to be stopped to receive a new target, otherwise an error is generated.
+ + + + + + + + +
-
+
- +class lewis.examples.example_motor.SimulatedExampleMotor(override_states: dict[str, State] | None = None, override_transitions: dict[tuple[State, State], Callable[[], bool]] | None = None, override_initial_state: State | None = None, override_initial_data: dict[str, float] | None = None)[source] +
Bases:
+ + +StateMachineDevice
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.examples.modbus_device.html b/generated/lewis.examples.modbus_device.html
new file mode 100644
index 00000000..2ebc8c48
--- /dev/null
+++ b/generated/lewis.examples.modbus_device.html
@@ -0,0 +1,184 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.examples
+Submodules
+| + | + |
| + | + |
| + | + |
| + | + |
| + | + |
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.examples.simple_device.html b/generated/lewis.examples.simple_device.html
new file mode 100644
index 00000000..8377303f
--- /dev/null
+++ b/generated/lewis.examples.simple_device.html
@@ -0,0 +1,222 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.examples.modbus_device
+Members
+| + | The class attributes di, co, ir and hr represent Discrete Inputs, Coils, Input Registers and Holding Registers, respectively. |
+
| + | + |
-
+
- +class lewis.examples.modbus_device.ExampleModbusInterface[source] +
Bases:
+ModbusInterfaceThe class attributes di, co, ir and hr represent Discrete Inputs, Coils, Input Registers and +Holding Registers, respectively. Each attribute should be assigned a ModbusDataBank instance +by the Interface implementation.
+Here, two basic ModbusDataBanks are created and initialized to a default value across the full +range of valid addresses. One DataBank is shared by di and co, and the other by ir and hr to +demonstrate overlaid memory segments. If you want each segment to have its own memory, just +create separate instances for all four.
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.examples.timeout_device.html b/generated/lewis.examples.timeout_device.html
new file mode 100644
index 00000000..6fbd93a8
--- /dev/null
+++ b/generated/lewis.examples.timeout_device.html
@@ -0,0 +1,216 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.examples.simple_device
+Members
+| + | + |
| + | A very simple device with TCP-stream interface |
+
-
+
- +class lewis.examples.simple_device.VerySimpleInterface[source] +
Bases:
+StreamInterfaceA very simple device with TCP-stream interface
+The device has only one parameter, which can be set to an arbitrary +value. The interface consists of five commands which can be invoked via telnet. +To connect:
++
+$ telnet host port
+After that, typing either of the commands and pressing enter sends them to the server.
+The commands are:
++
+ + +-
+
V: Returns the parameter as part of a verbose message.
+V=something: Sets the parameter tosomething.
+P: Returns the device parameter unmodified.
+P=something: Exactly the same asV=something.
+Rorr: Returns the number 4.
+
-
+
- +handle_error(request, error)[source] +
Override this method to handle exceptions that are raised during command processing. +The default implementation does nothing, so that any errors are silently ignored.
+-
+
- Parameters: +
-
+
request – The request that resulted in the error.
+error – The exception that was raised.
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.html b/generated/lewis.html
new file mode 100644
index 00000000..7635b9e8
--- /dev/null
+++ b/generated/lewis.html
@@ -0,0 +1,169 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.examples.timeout_device
+Members
+| + | + |
| + | A simple device where commands are terminated by a timeout. |
+
-
+
- +class lewis.examples.timeout_device.TimeTerminatedInterface[source] +
Bases:
+StreamInterfaceA simple device where commands are terminated by a timeout.
+This demonstrates how to implement devices that do not have standard +terminators and where a command is considered terminated after a certain +time delay of not receiving more data.
+To interact with this device, you must switch telnet into char mode, or use +netcat with special tty settings:
++
+$ telnet host port +^] +telnet> mode char +[type command and wait]
+$ stty -icanon && nc host port +hello world! +foobar!
+The following commands are available:
++
+-
+
- +handle_error(request, error)[source] +
Override this method to handle exceptions that are raised during command processing. +The default implementation does nothing, so that any errors are silently ignored.
+-
+
- Parameters: +
-
+
request – The request that resulted in the error.
+error – The exception that was raised.
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.scripts.control.html b/generated/lewis.scripts.control.html
new file mode 100644
index 00000000..99f82352
--- /dev/null
+++ b/generated/lewis.scripts.control.html
@@ -0,0 +1,204 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis
+Lewis - a library for creating hardware device simulators
+Submodules
+| + | The core Adapter API is located in |
+
| + | + |
| + | This module contains base classes for devices. |
+
| + | + |
| + | + |
| + | This package contains helpful utilities for people that are building emulators. |
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.scripts.html b/generated/lewis.scripts.html
new file mode 100644
index 00000000..5db7f16a
--- /dev/null
+++ b/generated/lewis.scripts.html
@@ -0,0 +1,187 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.scripts.control
+To interact with the control server of a running simulation, use this script. Usage:
+usage: lewis-control [-r RPC_HOST] [-t TIMEOUT] [-n] [-v] [-h]
+ [object] [member] [arguments ...]
+
+A client to manipulate the simulated device remotely through a separate
+channel. For this tool to be of any use, lewis must be invoked with the
+-r/--rpc-host option.
+
+Positional arguments:
+ object Object to control. If left out, all objects are
+ listed.
+ member Object-member to access. If omitted, API of the object
+ is listed.
+ arguments Arguments to method call. For setting a property,
+ supply the property value.
+
+Optional arguments:
+ -r RPC_HOST, --rpc-host RPC_HOST
+ HOST:PORT string specifying control server to connect
+ to.
+ -t TIMEOUT, --timeout TIMEOUT
+ Timeout after which the control client exits. Must be
+ at least as long as one simulation cycle.
+ -n, --print-none By default, no output is generated if the remote
+ function returns None. Specifying this flag will force
+ the client to print those None-values.
+ -v, --version Prints the version and exits.
+ -h, --h Shows this help message and exits.
+Members
+
|
++ |
|
++ |
|
++ |
|
++ |
|
++ |
|
++ |
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.scripts.run.html b/generated/lewis.scripts.run.html
new file mode 100644
index 00000000..9a5a7326
--- /dev/null
+++ b/generated/lewis.scripts.run.html
@@ -0,0 +1,252 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.scripts
+Submodules
+| + | To interact with the control server of a running simulation, use this script. |
+
| + | This script is the main interaction point of the user with Lewis. |
+
Members
+| + | This small helper function extracts the help information from an ArgumentParser instance and indents the text by the number of spaces supplied in the indent-argument. |
+
-
+
- +lewis.scripts.get_usage_text(parser, indent=None)[source] +
This small helper function extracts the help information from an ArgumentParser instance +and indents the text by the number of spaces supplied in the indent-argument.
+-
+
- Parameters: +
-
+
parser – ArgumentParser object.
+indent – Number of spaces to put before each line or None.
+
+- Returns: +
Formatted help string of the supplied parser.
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.utils.byte_conversions.html b/generated/lewis.utils.byte_conversions.html
new file mode 100644
index 00000000..32924210
--- /dev/null
+++ b/generated/lewis.utils.byte_conversions.html
@@ -0,0 +1,238 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.scripts.run
+This script is the main interaction point of the user with Lewis. The usage is as follows:
+usage: lewis [-s SETUP] [-n | -p ADAPTER_OPTIONS] [-l] [-L] [-i]
+ [-k DEVICE_PACKAGE] [-a ADD_PATH] [-c CYCLE_DELAY] [-e SPEED]
+ [-r RPC_HOST] [-o {none,critical,error,warning,info,debug}] [-V]
+ [-I] [-v] [-h] [-R]
+ [device]
+
+This script starts a simulated device that is exposed via the specified
+communication protocol. Complete documentation of Lewis is available in the
+online documentation on GitHub https://github.com/ess-dmsc/lewis/
+
+Positional arguments:
+ device Name of the device to simulate, omitting this argument
+ prints out a list of available devices.
+
+Device related parameters:
+ Parameters that influence the selected device, such as setup or protocol.
+
+ -s SETUP, --setup SETUP
+ Name of the setup to load. If not provided, the
+ default setup is selected. If thereis no default, a
+ list of setups is printed.
+ -n, --no-interface If supplied, the device simulation will not have any
+ communication interface.
+ -p ADAPTER_OPTIONS, --adapter-options ADAPTER_OPTIONS
+ Supply the protocol name and adapter options in the
+ format "name:{opt1: val, opt2: val}". Use the -l flag
+ to see which protocols are available for the selected
+ device. Can be supplied multiple times for multiple
+ protocols.
+ -l, --list-protocols List available protocols for selected device.
+ -L, --list-adapter-options
+ List available configuration options and their value.
+ Values that have not been modified in the -p argument
+ are default values.
+ -i, --show-interface Show command interface of device interface.
+ -k DEVICE_PACKAGE, --device-package DEVICE_PACKAGE
+ Name of packages where devices are found.
+ -a ADD_PATH, --add-path ADD_PATH
+ Path where the device package exists. Is added to the
+ path.
+
+Simulation related parameters:
+ Parameters that influence the simulation itself, such as timing and speed.
+
+ -c CYCLE_DELAY, --cycle-delay CYCLE_DELAY
+ Approximate time to spend in each cycle of the
+ simulation. 0 for maximum simulation rate.
+ -e SPEED, --speed SPEED
+ Simulation speed. The actually elapsed time between
+ two cycles is multiplied with this speed to determine
+ the simulated time.
+ -r RPC_HOST, --rpc-host RPC_HOST
+ HOST:PORT format string for exposing the device and
+ the simulation via JSON-RPC over ZMQ. Use lewis-
+ control to access this service from the command line.
+
+Other arguments:
+ -o {none,critical,error,warning,info,debug}, --output-level {none,critical,error,warning,info,debug}
+ Level of detail for logging to stderr.
+ -V, --verify Sets the output level to 'debug' and aborts before
+ starting the device simulation. This is intended to
+ help with diagnosing problems with devices or input
+ arguments.
+ -I, --ignore-versions
+ Ignore version mismatches between device and
+ framework. A warning will still be logged.
+ -v, --version Prints the version and exits.
+ -h, --help Shows this help message and exits.
+
+Deprecated arguments:
+ -R, --relaxed-versions
+ Renamed to --I/--ignore-versions. Using this old
+ option produces an error and it will be removed in a
+ future release.
+Members
+
|
++ |
| + | This is effectively the main function of a typical simulation run. |
+
-
+
- +lewis.scripts.run.run_simulation(argument_list=None) None[source] +
This is effectively the main function of a typical simulation run. Arguments passed in are +parsed and used to construct and run the simulation.
+This function only exits when the program has completed or is interrupted.
+-
+
- Parameters: +
argument_list – Argument list to pass to the argument parser declared in this module.
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.utils.command_builder.html b/generated/lewis.utils.command_builder.html
new file mode 100644
index 00000000..aceb1794
--- /dev/null
+++ b/generated/lewis.utils.command_builder.html
@@ -0,0 +1,495 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.utils.byte_conversions
+Members
+| + | Converts an floating point number to an unsigned set of bytes. |
+
| + | Converts an integer to an unsigned set of bytes with the specified length (represented as a string). |
+
| + | Convert a set of bytes to a floating point number |
+
| + | Converts an unsigned set of bytes to an integer. |
+
-
+
- +lewis.utils.byte_conversions.float_to_raw_bytes(real_number: float, low_byte_first: bool = True) bytes[source] +
Converts an floating point number to an unsigned set of bytes.
+-
+
- Parameters: +
-
+
real_number – The float to convert.
+low_byte_first – Whether to put the least significant byte first. True by default.
+
+- Returns: +
A string representation of the bytes.
+
+
-
+
- +lewis.utils.byte_conversions.int_to_raw_bytes(integer: int, length: int, low_byte_first: bool) bytes[source] +
Converts an integer to an unsigned set of bytes with the specified length (represented as a string). Unless the +integer is negative in which case it converts to a signed integer.
+If low byte first is True, the least significant byte comes first, otherwise the most significant byte comes first.
+-
+
- Parameters: +
-
+
integer – The integer to convert.
+length – The length of the result.
+low_byte_first – Whether to put the least significant byte first.
+
+- Returns: +
string representation of the bytes.
+
+
-
+
- +lewis.utils.byte_conversions.raw_bytes_to_float(raw_bytes: bytes) float[source] +
Convert a set of bytes to a floating point number
+-
+
- Parameters: +
raw_bytes – A string representation of the raw bytes.
+
+- Returns: +
float: The floating point number represented by the given bytes.
+
+
-
+
- +lewis.utils.byte_conversions.raw_bytes_to_int(raw_bytes: bytes, low_bytes_first: bool = True) int[source] +
Converts an unsigned set of bytes to an integer.
+-
+
- Parameters: +
-
+
raw_bytes – A string representation of the raw bytes.
+low_bytes_first – Whether the given raw bytes are in little endian or not. True by default.
+
+- Returns: +
The integer represented by the raw bytes passed in.
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.utils.constants.html b/generated/lewis.utils.constants.html
new file mode 100644
index 00000000..064a7a88
--- /dev/null
+++ b/generated/lewis.utils.constants.html
@@ -0,0 +1,154 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.utils.command_builder
+A fluent command builder for lewis.
+Members
+| + | Build a command for the stream adapter. |
+
-
+
- +class lewis.utils.command_builder.CmdBuilder(target_method, arg_sep='', ignore='', ignore_case=False)[source] +
Bases:
+objectBuild a command for the stream adapter.
+Do this by creating this object, adding the values and then building it (this uses a fluent interface).
+For example to read a pressure the ioc might send “pres?” and when that happens this should call get_pres +command would be: +>>> CmdBuilder(“get_pres”).escape(“pres?”).build() +This will generate the regex needed by Lewis. The escape is just making sure none of the characters are special +reg ex characters. +If you wanted to set a pressure the ioc might send “pres <pressure>” where <pressure> is a floating point number, +the interface should call set_pres with that number. Now use: +>>> CmdBuilder(“set_pres”).escape(“pres “).float().build() +this add float as a regularly expression capture group for your argument. It is equivalent to: +>>> Cmd(“set_pres”, “pres ([+-]?d+.?d*)”) +There are various arguments like int and digit. Finally some special characters are included so if your protocol +uses enquirey character ascii 5 you can match is using +>>> CmdBuilder(“set_pres”).escape(“pres?”).enq().build()
+Create a builder. Use build to create the final object
+-
+
- Parameters: +
-
+
target_method – name of the method target to call when the reg ex matches
+arg_sep – separators between arguments which are next to each other
+ignore – set of characters to ignore between text and arguments
+ignore_case – ignore the case when matching command
+
+
-
+
- +ack() CmdBuilder[source] +
Add the ACK character (0x6) to the string.
+-
+
- Returns: +
builder
+
+
-
+
- +add_ascii_character(char_number: int) CmdBuilder[source] +
Add a single character based on its integer value, e.g. 49 is ‘a’.
+-
+
- Parameters: +
char_number – character number
+
+- Returns: +
self
+
+
-
+
- +any() CmdBuilder[source] +
Add an argument that matches anything.
+-
+
- Returns: +
builder
+
+
-
+
- +any_except(char: str) CmdBuilder[source] +
Adds an argument that matches anything other than a specified character (useful for commands containing +delimiters)
+-
+
- Parameters: +
char – the character not to match
+
+- Returns: +
builder
+
+
-
+
- +arg(arg_regex, argument_mapping: ~functools.partial = functools.partial(<class 'str'>, encoding='utf-8')) CmdBuilder[source] +
Add an argument to the command.
+-
+
- Parameters: +
-
+
arg_regex – regex for the argument (capture group will be added)
+argument_mapping – the type mapping for the argument (default is str)
+
+- Returns: +
builder
+
+
-
+
- +build(*args, **kwargs) Cmd[source] +
Builds the CMd object based on the target and regular expression.
+-
+
- Parameters: +
-
+
args – arguments to pass to Cmd constructor
+kwargs – key word arguments to pass to Cmd constructor
+
+- Returns: +
Cmd object
+
+
-
+
- +char(not_chars: None | list[str] | str = None, ignore=False) CmdBuilder[source] +
Add a single character argument.
+-
+
- Parameters: +
-
+
not_chars – characters that the character can not be; None for can be anything
+ignore – True to match with a char but ignore the returned value (default: False)
+
+- Returns: +
builder
+
+
-
+
- +digit(mapping: type = <class 'int'>, ignore: bool = False) CmdBuilder[source] +
Add a single digit argument.
+-
+
- Parameters: +
-
+
mapping – The type to cast the response to (default: int)
+ignore – True to match with a digit but ignore the returned value (default: False)
+
+- Returns: +
builder
+
+
-
+
- +enq() CmdBuilder[source] +
Add the ENQ character (0x5) to the string.
+-
+
- Returns: +
builder
+
+
-
+
- +enum(*allowed_values: AnyStr) CmdBuilder[source] +
Matches one of a set of specified strings.
+-
+
- Parameters: +
allowed_values – the values this function is allowed to match
+
+- Returns: +
builder
+
+
-
+
- +eos() CmdBuilder[source] +
Adds the regex end-of-string character to a command.
+-
+
- Returns: +
builder
+
+
-
+
- +eot() CmdBuilder[source] +
Add the EOT character (0x4) to the string.
+-
+
- Returns: +
builder
+
+
-
+
- +escape(text) CmdBuilder[source] +
Add some text to the regex which is escaped.
+-
+
- Parameters: +
text – text to add
+
+- Returns: +
builder
+
+
-
+
- +etx() CmdBuilder[source] +
Add the ETX character (0x3) to the string.
+-
+
- Returns: +
builder
+
+
-
+
- +float(mapping: type = <class 'float'>, ignore: bool = False) CmdBuilder[source] +
Add a float argument.
+-
+
- Parameters: +
-
+
mapping – The type to cast the response to (default: float)
+ignore – True to match with a float but ignore the returned value (default: False)
+
+- Returns: +
builder
+
+
-
+
- +get_multicommands(command_separator: AnyStr) CmdBuilder[source] +
Allows emulator to split multiple commands separated by a defined command separator, e.g. “;”. +Must be accompanied by stream device methods. See Keithley 2700 for examples
+-
+
- Parameters: +
command_separator – Character(s) that separate commands
+
+- Returns: +
builder
+
+
-
+
- +int(mapping: type = <class 'int'>, ignore: bool = False) CmdBuilder[source] +
Add an integer argument.
+-
+
- Parameters: +
-
+
mapping – The type to cast the response to (default: int)
+ignore – True to match with a int but ignore the returned value (default: False)
+
+- Returns: +
builder
+
+
-
+
- +optional(text) CmdBuilder[source] +
Add some escaped text which does not necessarily need to be there. For commands with optional parameters +:param text: Text to add +:return: builder
+
-
+
- +regex(new_regex: str) CmdBuilder[source] +
Add a regex to match but not as an argument.
+-
+
- Parameters: +
new_regex – regex to add
+
+- Returns: +
builder
+
+
-
+
- +spaces(at_least_one: bool = False) CmdBuilder[source] +
Add a regex for any number of spaces
+-
+
- Parameters: +
at_least_one – true there must be at least one space; false there can be any number including zero
+
+- Returns: +
builder
+
+
-
+
- +string(length: None | int = None) CmdBuilder[source] +
Add an argument which is a string of a given length (if blank string is any length)
+-
+
- Parameters: +
length – length of string; None for any length
+
+- Returns: +
builder
+
+
-
+
- +stx() CmdBuilder[source] +
Add the STX character (0x2) to the string.
+-
+
- Returns: +
builder
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.utils.html b/generated/lewis.utils.html
new file mode 100644
index 00000000..97ffc435
--- /dev/null
+++ b/generated/lewis.utils.html
@@ -0,0 +1,170 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.utils.constants
+List of constants which are useful in communications
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/generated/lewis.utils.replies.html b/generated/lewis.utils.replies.html
new file mode 100644
index 00000000..5ab87b14
--- /dev/null
+++ b/generated/lewis.utils.replies.html
@@ -0,0 +1,221 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.utils
+This package contains helpful utilities for people that are building emulators.
+Submodules
+| + | + |
| + | A fluent command builder for lewis. |
+
| + | List of constants which are useful in communications |
+
| + | + |
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/genindex.html b/genindex.html
new file mode 100644
index 00000000..1bc78eec
--- /dev/null
+++ b/genindex.html
@@ -0,0 +1,1418 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis.utils.replies
+Members
+| + | Decorator that executes the command and replies if the device has a member called 'property name' and it is True in a boolean context. |
+
| + | Decorator that inhibits a command and performs an action if call time is less than some minimum time delay between the current and last input. |
+
-
+
- +lewis.utils.replies.conditional_reply(property_name: str, reply: str | None = None) Callable[[P], T][source] +
Decorator that executes the command and replies if the device has a member called +‘property name’ and it is True in a boolean context.
+Example usage:
+++@conditional_reply("connected") +def acknowledge_pressure(channel): + return ACK +
-
+
- Parameters: +
-
+
property_name – The name of the property to look for on the device
+reply – Desired output reply string when condition is false
+
+- Returns: +
The function returns as normal if property is true. +The command is not executed and there is no reply if property is false
+
+
:except AttributeError if the first argument of the decorated function (self) +does not contain .device or ._device +:except AttributeError if the device does not contain a property called property_name
+
-
+
- +lewis.utils.replies.timed_reply(action: str, reply: str | None = None, minimum_time_delay: float = 0) Callable[[P], T][source] +
Decorator that inhibits a command and performs an action if call time is less than +some minimum time delay between the current and last input.
+Example usage:
+++@timed_reply(action="crash_pump", reply="WARNING: Input too quick", minimum_time_delay=150) +def acknowledge_pressure(channel): + return ACK +
-
+
- Parameters: +
-
+
action – The name of the method to execute for on the device
+reply – Desired output reply string when input time delay is less than the minimum
+minimum_time_delay – The minimum time (ms) between commands sent to the device
+
+- Returns: +
The function returns as normal if minimum delay exceeded. +The command is not executed and the action method is called on the device instead
+
+
-
+
- :except AttributeError if the first argument of the decorated function (self)
does not contain .device or ._device
+
+
:except AttributeError if the device does not contain a property called action
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/index.html b/index.html
new file mode 100644
index 00000000..5747c202
--- /dev/null
+++ b/index.html
@@ -0,0 +1,287 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Index
+ +
+ A
+ | B
+ | C
+ | D
+ | E
+ | F
+ | G
+ | H
+ | I
+ | J
+ | L
+ | M
+ | N
+ | O
+ | P
+ | R
+ | S
+ | T
+ | U
+ | V
+
+
+A
+B
+| + | + |
C
+D
+E
+F
+| + | + |
G
+H
+I
+J
+| + | + |
L
+
|
+
|
+
M
+N
+| + | + |
O
+P
+| + | + |
R
+S
+T
+| + | + |
U
+| + |
V
+| + | + |
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/objects.inv b/objects.inv
new file mode 100644
index 00000000..d8e11a94
Binary files /dev/null and b/objects.inv differ
diff --git a/py-modindex.html b/py-modindex.html
new file mode 100644
index 00000000..b618e02b
--- /dev/null
+++ b/py-modindex.html
@@ -0,0 +1,399 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Welcome to the Lewis documentation!
+Lewis is a Python package that makes it easy to develop complex stateful device simulations. It +is licensed under GPL version 3 and the source is available on github, where you are welcome to +open new issues so the package can improve.
+Documentation contents:
+Quickstart
+
+
+Quickstart
+ +
+
+User guide
+ +
+
+Developer guide
+ +
+
+Release notes
+ +
+
+API reference
+-
+
- API
-
+
lewis-
+
lewis.adapters+
+lewis.core+
+lewis.devices+
+lewis.examples+
+lewis.scripts+
+lewis.utils+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/quickstart.html b/quickstart.html
new file mode 100644
index 00000000..e5d345ad
--- /dev/null
+++ b/quickstart.html
@@ -0,0 +1,331 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Python Module Index
+ +
+ l
+
+
+ 
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/release_notes/release_1_0_0.html b/release_notes/release_1_0_0.html
new file mode 100644
index 00000000..cc32a8c7
--- /dev/null
+++ b/release_notes/release_1_0_0.html
@@ -0,0 +1,170 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Quickstart Guide
+This section aims to get you started with Lewis as quickly as possible. It is meant as a basic starting point for becoming familiar with Lewis, and to give you a broad overview of what it can do. As such, many features are skimmed over or skipped entirely. See the detailed documentation sections for a more complete overview of features.
+This guide is presented as a step-by-step tutorial, so skipping sections may mean you will miss steps that are required for the examples to work.
+Install Lewis
+The recommended way to install Lewis is via PyPI and using a virtual environment. This guide assumes you have Python and Pip installed and in your PATH.
+-
+
Create a virtual environment (optional)
+Install Lewis from PyPI,
$ pip install lewis
+
Run the Motor Example
+Once Lewis is installed, you can use it to start some of the example devices it ships with.
+You can see which devices are available by just executing Lewis without parameters:
+$ lewis
+Please specify a device to simulate. The following devices are available:
+ julabo
+ chopper
+ linkam_t95
+Some additional, simpler examples are located in the lewis.examples module. You can tell Lewis which module to scan for devices using the -k parameter:
$ lewis -k lewis.examples
+Please specify a device to simulate. The following devices are available:
+ dual_device
+ simple_device
+ timeout_device
+ modbus_device
+ example_motor
+For this guide, we will launch the example_motor:
+$ lewis -k lewis.examples example_motor
+INFO lewis.DeviceBase: Creating device, setting up state machine
+INFO lewis.Simulation: Changed cycle delay to 0.1
+INFO lewis.Simulation: Changed speed to 1.0
+INFO lewis.Simulation: Starting simulation
+INFO lewis.AdapterCollection: Connecting device interface for protocol 'stream'
+INFO lewis.ExampleMotorStreamInterface.StreamServer: Listening on 0.0.0.0:9999
+The example motor is a TCP Stream device and listens on port 9999 on all adapters by default.
+Connect to Motor via Telnet
+With the last command from the previous section still running, open another terminal window.
+Since the example motor conveniently uses CRLF line terminators, we can use telnet to talk to it:
+$ telnet localhost 9999
+Trying 127.0.0.1...
+Connected to localhost.
+Escape character is '^]'.
+You’re now connected to the TCP Stream interface of the example motor device. It understands the following commands:
+Command |
+Meaning |
+
|---|---|
S? |
+get status |
+
P? |
+get position |
+
T? |
+get target |
+
T=%f |
+set target |
+
H |
+stop movement |
+
You can get more details, and details on the interface of any device, by using the -i or --show-interface argument:
$ lewis -k lewis.examples example_motor -i
+Note that the commands are case sensitive. Try entering a few commands in the Telnet session:
+S?
+idle
+P?
+0.0
+T=20.0
+T=20.0
+S?
+moving
+P?
+9.106584
+See the source code of the example motor if you want to see what makes it tick.
+Connect to Motor via Control Client
+In addition to the simulated TCP Stream interface, Lewis provides a so-called Control Server interface, which allows you to bypass the normal device protocol and access both device and simulation parameters directly while the simulation is running. This can be very useful for debugging and diagnostics, without having to modify the main device interface.
+Remote access is disabled by default and enabled only if you provide the -r argument when starting Lewis. Stop the previously launched instance of Lewis by pressing Ctrl-C and run Lewis again with the -r parameter to enable remote access like this:
$ lewis -r localhost:10000 -k lewis.examples example_motor
+Lewis ships with a Control Client commandline tool that allows you to connect to it. It also has an -r argument but for the client it defaults to localhost:10000, which is why it is recommended to use the same value above.
Open another terminal session. If you installed Lewis in a virtual environment, make sure to activate it in the new terminal session so that Lewis is available.
+Running lewis-control without any parameter displays the objects available to interact with:
$ lewis-control
+device
+interface
+simulation
+You can think of these as root nodes in a tree that lewis-control allows you to traverse. Passing one of them as an argument shows you what is available below that level:
$ lewis-control device
+Type: SimulatedExampleMotor
+Properties (current values):
+ position (20.0)
+ speed (2.0)
+ state (idle)
+ target (20.0)
+Methods:
+ stop
+Going down one more level retrieves the value of a single property, or calls a method (without passing arguments):
+$ lewis-control device target
+0.0
+And by specifying additional argument(s) we can set properties (or pass arguments to methods):
+$ lewis-control device target 100.0
+$ lewis-control device
+Type: SimulatedExampleMotor
+Properties (current values):
+ position (29.159932)
+ speed (2.0)
+ state (moving)
+ target (100.0)
+Methods:
+ stop
+$ lewis-control device stop
+[78.64038600000002, 78.64038600000002]
+$ lewis-control device
+Type: SimulatedExampleMotor
+Properties (current values):
+ position (78.640386)
+ speed (2.0)
+ state (idle)
+ target (78.640386)
+Methods:
+ stop
+Note that, as you go along, you can also use a Telnet session in another terminal to issue commands or request information, and that the state of the device will be consistent between the two connections.
+Aside from the simulated device itself, you can also access and modify parameters of the simulation and network interface(s):
+$ lewis-control simulation
+$ lewis-control interface
+See the respective sections of documentation for more details.
+Control Motor via Control API
+While the command line client is convenient for manual diagnostics and debugging, you may find the Control API more useful for automated testing. It exposes all the same functionality available on the CLI via a Python library (In fact, that is how the CLI client is implemented).
+If you installed Lewis in a virtual environment, make sure you activate it:
+$ . myenv/bin/activate
+Usually, you would use this API to write a Python script, but for demo purposes we will just use the interactive Python client:
+$ python
+>>> from lewis.core.control_client import ControlClient
+>>>
+>>> client = ControlClient(host='localhost', port='10000')
+>>> motor = client.get_object('device')
+>>>
+>>> motor.target
+78.64038600000002
+>>> motor.target = 20.0
+>>> motor.state
+u'moving'
+>>> motor.stop()
+[45.142721999999964, 45.142721999999964]
+>>> motor.state
+u'idle'
+>>> motor.position
+45.142721999999964
+As with the previous sections, you can also interact with the motor using any of the other interfaces as you are doing this and the state will always be consistent between them.
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/release_notes/release_1_0_1.html b/release_notes/release_1_0_1.html
new file mode 100644
index 00000000..0c9e36b7
--- /dev/null
+++ b/release_notes/release_1_0_1.html
@@ -0,0 +1,180 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Release 1.0
+The initial release of Lewis (at that point still plankton). These release notes have been +compiled after the release as we were not keeping any release notes at that time.
+Features
+-
+
Cycle-based, deterministic device simulations based on finite state machines
+Control over the simulation’s time granularity and speed (slow motion, fast forward)
+Simulation and device control via command line and via optional network service
+Two ready to use simulated devices using different protocols:
+-
+
ESS chopper abstraction (CHIC) using EPICS Channel Access
+Linkam T95 temperature controller using TCP Stream protocol
+
+Documentation in Markdown format for viewing in Github, both for users and developers
+Examples for implementing Stream protocol based devices
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/release_notes/release_1_0_2.html b/release_notes/release_1_0_2.html
new file mode 100644
index 00000000..e122e676
--- /dev/null
+++ b/release_notes/release_1_0_2.html
@@ -0,0 +1,225 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Release 1.0.1
+This release is the first one under the name “Lewis”. Its main purpose is to make a PyPI package +available as well as online documentation under the new name.
+Nevertheless version 1.0.1 fixes some bugs and introduces a few new features that were originally +scheduled for release 1.1 but had already been finished at the time of the release.
+New features
+-
+
It is now possible to obtain device interface documentation via the command line +and the control server, making it easier to communicate with unfamiliar devices. +For command line invocation there is a new flag:
lewis -i linkam_t95. +Thanks toDavid Michelfor requesting this feature.
+Lewis is now available as a
PyPI-package and can be installed viapip install lewis.
+Documentation is now generated via Sphinx and has been made available online on
RTD_.
+
Bug fixes and other improvements
+-
+
The control server can now be bound to a hostname instead of an IP-address (very useful +for
localhostin particular).
+pcaspy is now an optional requirement that has to be enabled explicitly in the requirements.txt +file or installation via
pip install lewis[epics].
+Error messages displayed on the command line have been improved.
+A flake8 job has been added to the continuous integration pipeline to enforce Python +style guidelines in the codebase.
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/release_notes/release_1_0_3.html b/release_notes/release_1_0_3.html
new file mode 100644
index 00000000..ee6eb258
--- /dev/null
+++ b/release_notes/release_1_0_3.html
@@ -0,0 +1,318 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Release 1.0.2
+This version of Lewis was released on January 26th, 2017. A few bugs have been fixed and a lot +of functionality has been added. The most notable changes are preliminary Modbus protocol support +and logging capabilities which make debugging easier.
+New features
+-
+
A preliminary Modbus Adapter has been added. The current version is mainly aimed at what is +currently required by the IBEX team for the
+nanodac. Since all that is needed is writing +and reading back from memory via the Modbus protocol, bindings toDeviceattributes or +functions have not been implemented yet. We will add these in a future version.The current version supports:
+-
+
Eight common Function Codes (0x01 through 0x06, 0x0F and 0x10)
+Overlaid memory segments (using the same databank for
diandcofor example)
+Modbus Exceptions for invalid Function Codes, bad memory addresses, invalid data, etc
+Request frames may arrive in arbitrary chunks of multiple or partial frames
+
For a usage example, see
+examples/modbus_device.
+Logging capabilities have been added to the framework through the standard Python
+logging_ +module. Thelewis-script logs messages to stderr, the level can be set using a new flag +-o/--output-level.All devices have a new member
+log, which can be used like this:
+
class SomeDevice(Device):
+ def some_method(self, param):
+ self.log.debug('some_method called with param=%s', param)
+This new behavior is also supported by lewis.core.statemachine.State,
+so that changes in device state can be logged as well.
-
+
A simulation for a Julabo FP50 waterbath was kindly contributed by Matt Clarke. It is +communicating through TCP Stream and offers two different protocol versions. The new device +can be started like the other available devices:
+++$ lewis -p julabo-version-1 julabo +
+Exposing devices via TCP Stream has been made easier. It is now possible to define commands +that expose lambda-functions, named functions and data attributes (with separate read/write +patterns). See the updated documentation of :mod:
lewis.adapters.stream.
+TCP Stream based devices are now easier to test with telnet due to a new adapter argument. +The new
+-t-flag makes the device interface “telnet compatible”:++$ lewis linkam_t95 -- -t +
Instead of the native in- and out-terminator of the device, the interface now looks for
+\r\n.
+The
lewis.adapters.epics.PV-class has been extended to allow for meta data updates +at runtime. A second property can now be specified that returns a dictionary to update the +PV’s metadata such as limits or alarm states.
+It is now possible to change multiple device parameters through lewis-control:
+
$ lewis-control simulation set_device_parameters "{'target_speed': 1, 'target_phase': 20}"
+Thanks to the IBEX team for requesting this.
+Bug fixes and other improvements
+-
+
Virtually disconnecting devices via the control server now actually closes all network +connections and shuts down any running servers, making it impossible to re-connect to the +device in that state. Virtually re-connecting the device returns the behavior back to normal.
+If a device contained members that are not JSON serializable, displaying the device’s API +using the lewis-control script failed. This has been fixed, instead a message is now printed +that informs the user about why fetching the attribute value failed. Thanks to Adrian Potter +for reporting this issue.
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/release_notes/release_1_1_0.html b/release_notes/release_1_1_0.html
new file mode 100644
index 00000000..00098c91
--- /dev/null
+++ b/release_notes/release_1_1_0.html
@@ -0,0 +1,267 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Release 1.0.3
+This version was released on March 24th, 2017. In this release, the lewis.adapters.epics-
+module has received some updates. Some important groundwork for future improvements has been
+laid as well, which resulted in the ability to switch device setups at runtime via the control
+server and a new command line syntax for configuring communications. The control server and client
+have been improved as well.
Command line interface change
+The way options are passed to the adapters has changed completely, the functionality has been
+merged into the -p-argument, which has a new long version now, --adapter-options.
For the default adapter options, it is still possible to use the lewis-command with -p
+in the same way as before:
$ lewis -p stream linkam_t95
+To supply options, such as the address and port to bind to, the argument accepts an extended +dictionary syntax now:
+$ lewis linkam_t95 -p "stream: {bind_address: localhost, port: 9998}"
+The space after each colon is significant, it can not be left out. For strings containing +special characters, such as colons, it is necessary to quote them:
+$ lewis chopper -p "epics: {prefix: 'PREF:'}"
+To see what options can be specified, use the new -L/--list-adapter-options flag:
$ lewis chopper -p epics -L
+New features
+-
+
Writing devices with an EPICS interface has been made more convenient for cases where the device +does not have properties, but does have getter and setter methods. +
lewis.adapters.epics.PVhas been extended to accept a wider range of values for +target_propertyandmeta_data_property, for example method names:
+
class FooDevice(Device):
+ _foo = 3
+
+ def get_foo(self):
+ return self._foo * 3
+
+ class FooDeviceInterface(EpicsAdapter):
+ pvs = {
+ 'Foo': PV('get_foo')
+ }
+For read/write cases, a tuple of names can be supplied. Instead of method names it is also
+allowed to specify callables, for example functions or lambda expressions. In that case, the
+signature of the function is checked. See also the new example in
+lewis.examples.epics_device.
-
+
The device setup (specified in the
setups-dict or module inside the device module) +can be changed at runtime through the control server. It is not possible to switch to +another device, only setups of the same device can be used. To query available setups:
+
$ lewis-control simulation setups
+Then, to actually activate the new setup, assuming it is called new_setup:
$ lewis-control simulation switch_setup new_setup
+-
+
It has been made easier to deposit devices in an external module while maintaining control over +compatibility with the rest of the Lewis-framework. Lewis now checks for a version specification +in each device module against the framework version before obtaining devices, adapters and +setups from it. Please add such a version specification to your devices.
+This way using devices from different sources becomes more reliable for users with different +versions of Lewis, or hint them to update. By default, Lewis won’t start if a device specifies +another framework version, but this behavior can be overridden by using the new flag +
+-R/--relaxed-versions:In this case the simulation will start, but a warning will still be logged so that this can be +identified as a potential source of errors later on.
+
+A new flag
-V/--verifyhas been added to thelewis-script. When activated, it sets +the output level todebugand exits before actually starting the simulation. This can +help diagnose problems with device modules or input parameters.
+
Bug fixes and other improvements
+-
+
The functionality for disconnecting and reconnecting a device’s communication interfaces that +used to be accessible via
+lewis-controlthrough thesimulationhas been moved into a +separate channel calledinterface. To disconnect a device use:In general, more fine-grained control over the device’s communication is now possible.
+
+Both
lewis.core.control_server.ControlServerand +lewis.core.control_client.ControlClientwere subject to some improvements, most +notably a settable timeout for requests was added so that incomplete requests do not cause the +client to hang anymore. Inlewis-controlscript, a new-t/--timeoutargument was added +to make use of that new functionality.
+Only members defined as part of the device class are listed when using
lewis-control device. +lewis-controlgenerally no longer lists inherited framework functions such aslog, +add_processor, etc.
+
Upgrade Guide
+The following changes have to be made to upgrade code working with Lewis 1.0.2 to work with
+Lewis 1.0.3:
-
+
Any scripts or code starting Lewis with the old style adapter parameters need to be updated to +the new style adapter options.
+For EPICS adapters:
+
+
Old style:
+ $ lewis chopper
+ $ lewis chopper -p epics
+ $ lewis chopper -p epics -- -p SIM:
+ $ lewis chopper -- --prefix SIM:
+ New style:
+ $ lewis chopper
+ $ lewis chopper -p epics
+ $ lewis chopper -p "epics: {prefix: 'SIM:'}"
+For TCP Stream adapters:
+ Old style:
+ $ lewis linkam_t95
+ $ lewis linkam_t95 -p stream
+ $ lewis linkam_t95 -p stream -- -b 127.0.0.1 -p 9999 -t
+ $ lewis linkam_t95 -- --bind_address 127.0.0.1 --port 9999 --telnet_mode
+ New style:
+ $ lewis linkam_t95
+ $ lewis linkam_t95 -p stream
+ $ lewis linkam_t95 -p "stream: {bind_address: 127.0.0.1, port: 9999, telnet_mode: True}"
+For Modbus adapters:
+ Old style:
+ $ lewis -k lewis.examples modbus_device
+ $ lewis -k lewis.examples modbus_device -p modbus
+ $ lewis -k lewis.examples modbus_device -p modbus -- -b 127.0.0.1 -p 5020
+ $ lewis -k lewis.examples modbus_device -- --bind_address 127.0.0.1 --port 5020
+ New style:
+ $ lewis -k lewis.examples modbus_device
+ $ lewis -k lewis.examples modbus_device -p modbus
+ $ lewis -k lewis.examples modbus_device -p "modbus: {bind_address: 127.0.0.1, port: 5020}"
+-
+
Devices must now specify a
framework_versionin the global namespace of their top-level +__init__.py, like this:
+
framework_version = '1.0.3'
+This will need to be updated with every release. If this version is missing or does not match +the current Lewis framework version, attempting to run the device simulation will fail with a +message informing the user of the mismatch. This can be bypassed by starting Lewis with the +following parameter:
+ $ lewis linkam_t95 -R
+ $ lewis linkam_t95 --relaxed-versions
+Warning: in the next release, specifying framework_version becomes optional and
+--relaxed-versions is renamed to --ignore-versions.
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/release_notes/release_1_1_1.html b/release_notes/release_1_1_1.html
new file mode 100644
index 00000000..ccb558cc
--- /dev/null
+++ b/release_notes/release_1_1_1.html
@@ -0,0 +1,163 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Release 1.1
+In this release, some key changes to the core framework have been implemented. It is now possible +to have more than one communication interface for a device, which enables some interesting use +cases like partial interfaces, or multiple communication protocols accessing the same device. One +prerequisite for this feature was running the network services in different threads than the +device simulation.
+Another key change, one that requires some minor changes to existing devices (see upgrade guide), +was that the communication interface definition has been completely separate from the network +services handling the network communication.
+Besides these major improvements, there have been a number of smaller improvements and new +features, and Lewis now also has a logo (see below).
+New features
+-
+
It is now possible to have devices with more than one communication interface. The
-p-option +can be supplied multiple times:
+
$ lewis some_device -p protocol1 -p protocol2
+When no -p option is specified, the script behaves as before (use default protocol if
+possible or produce an error message). To start a simulation without any device communication,
+use the new -n/--no-interface option:
$ lewis some_device -n
+It is not possible to use both -p and -n at the same time, this results in an error
+message.
The epics_device example has been renamed to dual_device and extended to include a
+second interface definition, so it exposes the device state via two different protocols:
$ lewis -k lewis.examples dual_device -p epics -p stream
+-
+
lewis.adapters.streamhas been extended. Besides regular expressions, it is now +possible to usescanfformat specifications to define commands. This makes handling +of for example floating point numbers much more convenient:
+
from lewis.adapters import StreamInterface, Cmd, scanf
+
+ class SomeInterface(StreamInterface):
+ commands = {
+ Cmd(lambda x: x**2, scanf('SQ %f'))
+ }
+lewis.adapters.stream.scanf provides argument mappings for the matched arguments
+automatically, so it is optional to pass them to Cmd. In the case outlined above, the
+argument is automatically converted to float.
If a string is specified directly (instead of scanf(...)), it is treated as a regular
+expression like in earlier versions.
Internally, the scanf package is used for handling these patterns, please check the package +documentation for all available format specifiers. Thanks to @joshburnett for accepting +a small patch to the package that made the package easier to integrate into Lewis.
+-
+
The control client, lewis-control, now provides a version argument via
--versionor-v.
+
$ lewis-control -v
+Bug fixes and other improvements
+-
+
Lewis now has a logo. It is based on a state machine with one state that is entered and +repeated infinitely - like the simulation cycles in Lewis.
+For low-resolution images or settings with little space, there is also a simplified version.
+The logo was made using inkscape, the font used in the logo is Rubik (in the SVG itself, +the text was converted into a path, so that the font does not need to be installed for the logo +to render correctly). The two PNGs and also the SVGs are in the source repository, feel +free to include them in presentations or posters.
+
+Adapters now run in a different thread than the simulation itself. The consequence of this is +that slow network communication or expensive computations in the device do not influence +one another anymore. Otherwise, communication still works exactly like in previous versions.
+The behavior of the
+framework_version-variable for devices that was introduced in version +1.0.3 has been modified to make it easier to convert from older versions of Lewis.With the default options of the
+lewis-command, devices that do not specify the variable +will be loaded after logging a warning. An error message is only displayed when strict +version checking is enabled through the new-S/--strict-versions-flag.The option to ignore version mismatches has been renamed to
+-I/--ignore-versions. When +that flag is specified, any device regardless of the contents offramework_versionis +loaded, but a warning is still logged.Specifying the
+framework_versionvariable is still encouraged as it can contribute to +more certainty on the user side as to whether a device can function with a certain function +of Lewis.
+
Upgrade guide
+-
+
Due to a change to how Adapters and Devices work together, device interfaces are not +inheriting from Adapter-classes anymore. Instead, there are dedicated Interface classes. +They are located in the same modules as the Adapters, so only small changes are necessary:
+Old:
+
+
from lewis.adapters.stream import StreamAdapter, Cmd
+
+ class DeviceInterface(StreamAdapter):
+ pass
+New:
+ from lewis.adapters.stream import StreamInterface, Cmd
+
+ class DeviceInterface(StreamInterface):
+ pass
+The same goes for EpicsAdapter and ModbusAdapter, which must be modified to
+EpicsInterface and ModbusInterface respectively.
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/release_notes/release_1_2_0.html b/release_notes/release_1_2_0.html
new file mode 100644
index 00000000..8b736cb4
--- /dev/null
+++ b/release_notes/release_1_2_0.html
@@ -0,0 +1,209 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Release 1.1.1
+This is a pure bug fix release that removes three problems that were overlooked in the 1.1 release.
+Bug fixes
+-
+
Version strings in
framework_versionare now coerced, so that for example1.1becomes +1.1.0automatically.
+Lewis does no longer hang forever when starting a network service fails.
+Switching setups at runtime works again as in release 1.0.3, in 1.1. it had been disabled due +to an oversight.
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/release_notes/release_1_2_1.html b/release_notes/release_1_2_1.html
new file mode 100644
index 00000000..79da7d88
--- /dev/null
+++ b/release_notes/release_1_2_1.html
@@ -0,0 +1,167 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Release 1.2
+After releasing 1.1.0 and 1.1.1, we decided to move to a more reproducible testing workflow that
+is operating closer to the packages that are released in the end. This only affects developers
+who work on the Lewis code base. In addition, lewis.adapters.epics was improved a bit
+with better error messages and more reasonable PV update frequencies. The lewis-control
+server now runs in its own thread, which has made it more responsive.
New Features
+-
+
+StreamInterfacehas been improved to support areadtimeoutattribute which is analogous +to the ReadTimeout system variable in Protocol files. The value ofreadtimeoutdetermines how +many milliseconds to wait for more input, once we have started receiving data for a command. Under +normal circumstances, this timeout being triggered is an error and causes the incoming buffer to be +flushed and ahandle_errorcall in the device interface. However, if thein_terminator+attribute is empty, this timeout is treated as the command terminator instead.
+readtimeoutdefaults to 100 (ms). +readtimeout = 0disables this feature entirely.The effective resolution is currently limited 10 ms increments due to the fixed adapter cycle rate.
+
+The
lewis.core.control_server.ControlServeris now running in its own thread, separate +from the simulation. As a result,lewis-controland the Python Control API are now much more +responsive. This is because requests are processed asynchronously and, therefore, multiple +requests can be processed per simulation cycle.
+
Bugfixes and other improvements
+-
+
Error messages in the binding step of :class:
PVhave been improved. It is now easier to find +the source of common problems (missing properties, spelling errors).
+PVs are only updated if the underlying value has actually changed. Changes to metadata are processed +and logged separately. This leads to cleaner logs even at small values for
poll_interval.
+Using
yaml.safe_loadinstead ofyaml.loadas a security precaution.
+
Changes for developers
+-
+
The
+lewis.pyandlewis-control.pyfiles have been removed, because especially the former +created some problems with the new package structure by interfering with the tests and docs- +generation.For using Lewis when it’s installed through pip, this does not change anything, but for +development of the Lewis framework (not of devices), it is now strongly recommended to do so +in a separate virtual environment, installing Lewis from source as an editable package. Details +on this can be found in the updated
+developer_guide.
+Tests are now run with pytest instead of nose. In addition, a tox configuration has been +added for more reproducible tests with different interpreters.
+The first run may take a bit longer, since each step is run in a fresh virtual environment that tox +creates automatically.
+To run specific tests, for example to verify that building the docs works, use the
+-eflag +of toxTo see all tests that are available, including a short description, use
+tox -l -v.
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/release_notes/release_1_2_2.html b/release_notes/release_1_2_2.html
new file mode 100644
index 00000000..a6c6f980
--- /dev/null
+++ b/release_notes/release_1_2_2.html
@@ -0,0 +1,159 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/release_notes/release_1_3_0.html b/release_notes/release_1_3_0.html
new file mode 100644
index 00000000..a225d766
--- /dev/null
+++ b/release_notes/release_1_3_0.html
@@ -0,0 +1,162 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/release_notes/release_1_3_1.html b/release_notes/release_1_3_1.html
new file mode 100644
index 00000000..b9f9efab
--- /dev/null
+++ b/release_notes/release_1_3_1.html
@@ -0,0 +1,161 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Release 1.3.0
+This is a major release because it removes Python 2 support. Any other changes are minor.
+Changes for developers
+-
+
Added pre-commit checking for formatting, flake8 and isort
+Uses Black for formatting
+Added a system test for checking that the overall system is functioning
+Added scripts for running lewis and lewis-control without installing
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/release_notes/release_1_3_2.html b/release_notes/release_1_3_2.html
new file mode 100644
index 00000000..fd5ceaae
--- /dev/null
+++ b/release_notes/release_1_3_2.html
@@ -0,0 +1,159 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/release_notes/release_1_3_3.html b/release_notes/release_1_3_3.html
new file mode 100644
index 00000000..7ee75a2e
--- /dev/null
+++ b/release_notes/release_1_3_3.html
@@ -0,0 +1,150 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/release_notes/release_notes.html b/release_notes/release_notes.html
new file mode 100644
index 00000000..aaaa703e
--- /dev/null
+++ b/release_notes/release_notes.html
@@ -0,0 +1,165 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Release 1.3.3
+This is a minor release that updates the supported versions list.
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/search.html b/search.html
new file mode 100644
index 00000000..a9b69dd3
--- /dev/null
+++ b/search.html
@@ -0,0 +1,144 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Release notes
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/searchindex.js b/searchindex.js
new file mode 100644
index 00000000..e46e12f5
--- /dev/null
+++ b/searchindex.js
@@ -0,0 +1 @@
+Search.setIndex({"alltitles": {"API": [[0, null]], "API reference": [[57, null]], "Accessing the Device Communication Interface": [[75, "accessing-the-device-communication-interface"]], "Adapter Specifics": [[73, null]], "Adding setups": [[4, "adding-setups"]], "Bug fixes": [[64, "bug-fixes"], [66, "bug-fixes"]], "Bug fixes and other improvements": [[60, "bug-fixes-and-other-improvements"], [61, "bug-fixes-and-other-improvements"], [62, "bug-fixes-and-other-improvements"], [63, "bug-fixes-and-other-improvements"]], "Bugfixes and other improvements": [[65, "bugfixes-and-other-improvements"]], "Build PyPI Package": [[3, "build-pypi-package"]], "Build and Finalize Release": [[3, "build-and-finalize-release"]], "Changes for developers": [[65, "changes-for-developers"], [68, "changes-for-developers"], [69, "changes-for-developers"], [70, "changes-for-developers"]], "Command line interface change": [[62, "command-line-interface-change"]], "Command line tools": [[74, null]], "Compatibility with framework versions": [[4, "compatibility-with-framework-versions"]], "Connect to Motor via Control Client": [[58, "connect-to-motor-via-control-client"]], "Connect to Motor via Telnet": [[58, "connect-to-motor-via-telnet"]], "Control Client Python API": [[75, "control-client-python-api"]], "Control Motor via Control API": [[58, "control-motor-via-control-api"]], "Cycle-driven": [[2, "cycle-driven"]], "Developer guide": [[57, null]], "Developing Lewis": [[1, null]], "Device analysis": [[4, "device-analysis"]], "Documentation": [[66, "documentation"]], "EPICS Adapter Specifics": [[73, "epics-adapter-specifics"]], "Features": [[59, "features"]], "Framework Details": [[2, null]], "Further steps": [[4, "further-steps"]], "Git Milestones": [[3, "git-milestones"]], "Git Release": [[3, "git-release"]], "GitHub Release": [[3, "github-release"]], "Implementing the device interface": [[4, "implementing-the-device-interface"]], "Implementing the device simulation": [[4, "implementing-the-device-simulation"]], "Install Lewis": [[58, "install-lewis"]], "Installation from source": [[77, "installation-from-source"]], "Installation via pip": [[77, "installation-via-pip"]], "Logging": [[4, "logging"]], "Merge Changes": [[3, "merge-changes"]], "More Examples": [[4, "more-examples"]], "New Features": [[65, "new-features"], [67, "new-features"]], "New features": [[60, "new-features"], [61, "new-features"], [62, "new-features"], [63, "new-features"]], "Preparations": [[4, "preparations"]], "Preparing for Release": [[3, "preparing-for-release"]], "Quickstart": [[57, "quickstart"], [57, null]], "Quickstart Guide": [[58, null]], "Release 1.0": [[59, null]], "Release 1.0.1": [[60, null]], "Release 1.0.2": [[61, null]], "Release 1.0.3": [[62, null]], "Release 1.1": [[63, null]], "Release 1.1.1": [[64, null]], "Release 1.2": [[65, null]], "Release 1.2.1": [[66, null]], "Release 1.2.2": [[67, null]], "Release 1.3.0": [[68, null]], "Release 1.3.1": [[69, null]], "Release 1.3.2": [[70, null]], "Release 1.3.3": [[71, null]], "Release Checklist": [[3, null]], "Release Notes": [[3, "release-notes"]], "Release notes": [[57, null], [72, null]], "Remote Access to Devices": [[75, null]], "Remote Access to Simulation Parameters": [[76, null]], "Run the Motor Example": [[58, "run-the-motor-example"]], "Running from source": [[77, "running-from-source"]], "Statemachine": [[2, "statemachine"]], "Stream Adapter Specifics": [[73, "stream-adapter-specifics"]], "Test PyPI Package": [[3, "test-pypi-package"]], "Unit tests": [[4, "unit-tests"]], "Update Version": [[3, "update-version"]], "Upgrade Guide": [[62, "upgrade-guide"]], "Upgrade guide": [[63, "upgrade-guide"]], "Upload PyPI Package": [[3, "upload-pypi-package"]], "Usage with Python": [[77, null]], "User facing documentation": [[4, "user-facing-documentation"]], "User guide": [[57, null]], "Value Interpretation and Syntax": [[75, "value-interpretation-and-syntax"]], "Virtual environments": [[77, "virtual-environments"]], "Welcome to the Lewis documentation!": [[57, null]], "Writing Device Simulators": [[4, null]], "lewis": [[5, null], [74, "lewis"]], "lewis-control": [[74, "lewis-control"]], "lewis.adapters": [[6, null]], "lewis.adapters.epics": [[7, null]], "lewis.adapters.modbus": [[8, null]], "lewis.adapters.stream": [[9, null]], "lewis.core": [[10, null]], "lewis.core.adapters": [[11, null]], "lewis.core.approaches": [[12, null]], "lewis.core.control_client": [[13, null]], "lewis.core.control_server": [[14, null]], "lewis.core.devices": [[15, null]], "lewis.core.exceptions": [[16, null]], "lewis.core.logging": [[17, null]], "lewis.core.processor": [[18, null]], "lewis.core.simulation": [[19, null]], "lewis.core.statemachine": [[20, null]], "lewis.core.utils": [[21, null]], "lewis.devices": [[22, null]], "lewis.devices.chopper": [[23, null]], "lewis.devices.chopper.devices": [[24, null]], "lewis.devices.chopper.devices.bearings": [[25, null]], "lewis.devices.chopper.devices.device": [[26, null]], "lewis.devices.chopper.devices.states": [[27, null]], "lewis.devices.chopper.interfaces": [[28, null]], "lewis.devices.chopper.interfaces.epics_interface": [[29, null]], "lewis.devices.julabo": [[30, null]], "lewis.devices.julabo.devices": [[31, null]], "lewis.devices.julabo.devices.device": [[32, null]], "lewis.devices.julabo.devices.states": [[33, null]], "lewis.devices.julabo.interfaces": [[34, null]], "lewis.devices.julabo.interfaces.julabo_stream_interface_1": [[35, null]], "lewis.devices.julabo.interfaces.julabo_stream_interface_2": [[36, null]], "lewis.devices.linkam_t95": [[37, null]], "lewis.devices.linkam_t95.devices": [[38, null]], "lewis.devices.linkam_t95.devices.device": [[39, null]], "lewis.devices.linkam_t95.devices.states": [[40, null]], "lewis.devices.linkam_t95.interfaces": [[41, null]], "lewis.devices.linkam_t95.interfaces.stream_interface": [[42, null]], "lewis.examples": [[43, null]], "lewis.examples.dual_device": [[44, null]], "lewis.examples.example_motor": [[45, null]], "lewis.examples.modbus_device": [[46, null]], "lewis.examples.simple_device": [[47, null]], "lewis.examples.timeout_device": [[48, null]], "lewis.scripts": [[49, null]], "lewis.scripts.control": [[50, null]], "lewis.scripts.run": [[51, null]], "lewis.utils": [[52, null]], "lewis.utils.byte_conversions": [[53, null]], "lewis.utils.command_builder": [[54, null]], "lewis.utils.constants": [[55, null]], "lewis.utils.replies": [[56, null]]}, "docnames": ["_api", "developer_guide/developing_lewis", "developer_guide/framework_details", "developer_guide/release_checklist", "developer_guide/writing_devices", "generated/lewis", "generated/lewis.adapters", "generated/lewis.adapters.epics", "generated/lewis.adapters.modbus", "generated/lewis.adapters.stream", "generated/lewis.core", "generated/lewis.core.adapters", "generated/lewis.core.approaches", "generated/lewis.core.control_client", "generated/lewis.core.control_server", "generated/lewis.core.devices", "generated/lewis.core.exceptions", "generated/lewis.core.logging", "generated/lewis.core.processor", "generated/lewis.core.simulation", "generated/lewis.core.statemachine", "generated/lewis.core.utils", "generated/lewis.devices", "generated/lewis.devices.chopper", "generated/lewis.devices.chopper.devices", "generated/lewis.devices.chopper.devices.bearings", "generated/lewis.devices.chopper.devices.device", "generated/lewis.devices.chopper.devices.states", "generated/lewis.devices.chopper.interfaces", "generated/lewis.devices.chopper.interfaces.epics_interface", "generated/lewis.devices.julabo", "generated/lewis.devices.julabo.devices", "generated/lewis.devices.julabo.devices.device", "generated/lewis.devices.julabo.devices.states", "generated/lewis.devices.julabo.interfaces", "generated/lewis.devices.julabo.interfaces.julabo_stream_interface_1", "generated/lewis.devices.julabo.interfaces.julabo_stream_interface_2", "generated/lewis.devices.linkam_t95", "generated/lewis.devices.linkam_t95.devices", "generated/lewis.devices.linkam_t95.devices.device", "generated/lewis.devices.linkam_t95.devices.states", "generated/lewis.devices.linkam_t95.interfaces", "generated/lewis.devices.linkam_t95.interfaces.stream_interface", "generated/lewis.examples", "generated/lewis.examples.dual_device", "generated/lewis.examples.example_motor", "generated/lewis.examples.modbus_device", "generated/lewis.examples.simple_device", "generated/lewis.examples.timeout_device", "generated/lewis.scripts", "generated/lewis.scripts.control", "generated/lewis.scripts.run", "generated/lewis.utils", "generated/lewis.utils.byte_conversions", "generated/lewis.utils.command_builder", "generated/lewis.utils.constants", "generated/lewis.utils.replies", "index", "quickstart", "release_notes/release_1_0_0", "release_notes/release_1_0_1", "release_notes/release_1_0_2", "release_notes/release_1_0_3", "release_notes/release_1_1_0", "release_notes/release_1_1_1", "release_notes/release_1_2_0", "release_notes/release_1_2_1", "release_notes/release_1_2_2", "release_notes/release_1_3_0", "release_notes/release_1_3_1", "release_notes/release_1_3_2", "release_notes/release_1_3_3", "release_notes/release_notes", "user_guide/adapter_specifics", "user_guide/command_line_tools", "user_guide/remote_access_devices", "user_guide/remote_access_simulation", "user_guide/usage_with_python"], "envversion": {"sphinx": 64, "sphinx.domains.c": 3, "sphinx.domains.changeset": 1, "sphinx.domains.citation": 1, "sphinx.domains.cpp": 9, "sphinx.domains.index": 1, "sphinx.domains.javascript": 3, "sphinx.domains.math": 2, "sphinx.domains.python": 4, "sphinx.domains.rst": 2, "sphinx.domains.std": 2, "sphinx.ext.intersphinx": 1, "sphinx.ext.viewcode": 1}, "filenames": ["_api.rst", "developer_guide/developing_lewis.md", "developer_guide/framework_details.md", "developer_guide/release_checklist.md", "developer_guide/writing_devices.md", "generated/lewis.rst", "generated/lewis.adapters.rst", "generated/lewis.adapters.epics.rst", "generated/lewis.adapters.modbus.rst", "generated/lewis.adapters.stream.rst", "generated/lewis.core.rst", "generated/lewis.core.adapters.rst", "generated/lewis.core.approaches.rst", "generated/lewis.core.control_client.rst", "generated/lewis.core.control_server.rst", "generated/lewis.core.devices.rst", "generated/lewis.core.exceptions.rst", "generated/lewis.core.logging.rst", "generated/lewis.core.processor.rst", "generated/lewis.core.simulation.rst", "generated/lewis.core.statemachine.rst", "generated/lewis.core.utils.rst", "generated/lewis.devices.rst", "generated/lewis.devices.chopper.rst", "generated/lewis.devices.chopper.devices.rst", "generated/lewis.devices.chopper.devices.bearings.rst", "generated/lewis.devices.chopper.devices.device.rst", "generated/lewis.devices.chopper.devices.states.rst", "generated/lewis.devices.chopper.interfaces.rst", "generated/lewis.devices.chopper.interfaces.epics_interface.rst", "generated/lewis.devices.julabo.rst", "generated/lewis.devices.julabo.devices.rst", "generated/lewis.devices.julabo.devices.device.rst", "generated/lewis.devices.julabo.devices.states.rst", "generated/lewis.devices.julabo.interfaces.rst", "generated/lewis.devices.julabo.interfaces.julabo_stream_interface_1.rst", "generated/lewis.devices.julabo.interfaces.julabo_stream_interface_2.rst", "generated/lewis.devices.linkam_t95.rst", "generated/lewis.devices.linkam_t95.devices.rst", "generated/lewis.devices.linkam_t95.devices.device.rst", "generated/lewis.devices.linkam_t95.devices.states.rst", "generated/lewis.devices.linkam_t95.interfaces.rst", "generated/lewis.devices.linkam_t95.interfaces.stream_interface.rst", "generated/lewis.examples.rst", "generated/lewis.examples.dual_device.rst", "generated/lewis.examples.example_motor.rst", "generated/lewis.examples.modbus_device.rst", "generated/lewis.examples.simple_device.rst", "generated/lewis.examples.timeout_device.rst", "generated/lewis.scripts.rst", "generated/lewis.scripts.control.rst", "generated/lewis.scripts.run.rst", "generated/lewis.utils.rst", "generated/lewis.utils.byte_conversions.rst", "generated/lewis.utils.command_builder.rst", "generated/lewis.utils.constants.rst", "generated/lewis.utils.replies.rst", "index.rst", "quickstart.md", "release_notes/release_1_0_0.md", "release_notes/release_1_0_1.md", "release_notes/release_1_0_2.md", "release_notes/release_1_0_3.md", "release_notes/release_1_1_0.md", "release_notes/release_1_1_1.md", "release_notes/release_1_2_0.md", "release_notes/release_1_2_1.md", "release_notes/release_1_2_2.md", "release_notes/release_1_3_0.md", "release_notes/release_1_3_1.md", "release_notes/release_1_3_2.md", "release_notes/release_1_3_3.md", "release_notes/release_notes.rst", "user_guide/adapter_specifics.md", "user_guide/command_line_tools.md", "user_guide/remote_access_devices.md", "user_guide/remote_access_simulation.md", "user_guide/usage_with_python.md"], "indexentries": {"accessviolationexception": [[16, "lewis.core.exceptions.AccessViolationException", false]], "ack() (lewis.utils.command_builder.cmdbuilder method)": [[54, "lewis.utils.command_builder.CmdBuilder.ack", false]], "adapter (class in lewis.core.adapters)": [[11, "lewis.core.adapters.Adapter", false]], "adapter (lewis.adapters.epics.epicsinterface property)": [[7, "lewis.adapters.epics.EpicsInterface.adapter", false]], "adapter (lewis.adapters.modbus.modbusinterface property)": [[8, "lewis.adapters.modbus.ModbusInterface.adapter", false]], "adapter (lewis.adapters.stream.streaminterface property)": [[9, "lewis.adapters.stream.StreamInterface.adapter", false]], "adapter (lewis.core.devices.interfacebase property)": [[15, "lewis.core.devices.InterfaceBase.adapter", false]], "adaptercollection (class in lewis.core.adapters)": [[11, "lewis.core.adapters.AdapterCollection", false]], "add_adapter() (lewis.core.adapters.adaptercollection method)": [[11, "lewis.core.adapters.AdapterCollection.add_adapter", false]], "add_ascii_character() (lewis.utils.command_builder.cmdbuilder method)": [[54, "lewis.utils.command_builder.CmdBuilder.add_ascii_character", false]], "add_object() (lewis.core.control_server.exposedobjectcollection method)": [[14, "lewis.core.control_server.ExposedObjectCollection.add_object", false]], "any() (lewis.utils.command_builder.cmdbuilder method)": [[54, "lewis.utils.command_builder.CmdBuilder.any", false]], "any_except() (lewis.utils.command_builder.cmdbuilder method)": [[54, "lewis.utils.command_builder.CmdBuilder.any_except", false]], "arg() (lewis.utils.command_builder.cmdbuilder method)": [[54, "lewis.utils.command_builder.CmdBuilder.arg", false]], "arg_count (lewis.adapters.stream.patternmatcher property)": [[9, "lewis.adapters.stream.PatternMatcher.arg_count", false]], "arg_count (lewis.adapters.stream.regex property)": [[9, "lewis.adapters.stream.regex.arg_count", false]], "argument_mappings (lewis.adapters.stream.patternmatcher property)": [[9, "lewis.adapters.stream.PatternMatcher.argument_mappings", false]], "argument_mappings (lewis.adapters.stream.regex property)": [[9, "lewis.adapters.stream.regex.argument_mappings", false]], "argument_mappings (lewis.adapters.stream.scanf property)": [[9, "lewis.adapters.stream.scanf.argument_mappings", false]], "bind() (lewis.adapters.epics.pv method)": [[7, "lewis.adapters.epics.PV.bind", false]], "bind_handlers_by_name() (lewis.core.statemachine.statemachine method)": [[20, "lewis.core.statemachine.StateMachine.bind_handlers_by_name", false]], "boundpv (class in lewis.adapters.epics)": [[7, "lewis.adapters.epics.BoundPV", false]], "build() (lewis.utils.command_builder.cmdbuilder method)": [[54, "lewis.utils.command_builder.CmdBuilder.build", false]], "can() (lewis.core.statemachine.statemachine method)": [[20, "lewis.core.statemachine.StateMachine.can", false]], "canprocess (class in lewis.core.processor)": [[18, "lewis.core.processor.CanProcess", false]], "canprocesscomposite (class in lewis.core.processor)": [[18, "lewis.core.processor.CanProcessComposite", false]], "char() (lewis.utils.command_builder.cmdbuilder method)": [[54, "lewis.utils.command_builder.CmdBuilder.char", false]], "check_limits (class in lewis.core.utils)": [[21, "lewis.core.utils.check_limits", false]], "chopperepicsinterface (class in lewis.devices.chopper.interfaces.epics_interface)": [[29, "lewis.devices.chopper.interfaces.epics_interface.ChopperEpicsInterface", false]], "cmd (class in lewis.adapters.stream)": [[9, "lewis.adapters.stream.Cmd", false]], "cmdbuilder (class in lewis.utils.command_builder)": [[54, "lewis.utils.command_builder.CmdBuilder", false]], "commandbase (class in lewis.adapters.stream)": [[9, "lewis.adapters.stream.CommandBase", false]], "conditional_reply() (in module lewis.utils.replies)": [[56, "lewis.utils.replies.conditional_reply", false]], "config (lewis.adapters.epics.boundpv property)": [[7, "lewis.adapters.epics.BoundPV.config", false]], "configuration() (lewis.core.adapters.adaptercollection method)": [[11, "lewis.core.adapters.AdapterCollection.configuration", false]], "connect() (lewis.core.adapters.adaptercollection method)": [[11, "lewis.core.adapters.AdapterCollection.connect", false]], "control_server (lewis.core.simulation.simulation property)": [[19, "lewis.core.simulation.Simulation.control_server", false]], "controlclient (class in lewis.core.control_client)": [[13, "lewis.core.control_client.ControlClient", false]], "controlserver (class in lewis.core.control_server)": [[14, "lewis.core.control_server.ControlServer", false]], "cool() (lewis.devices.linkam_t95.interfaces.stream_interface.linkamt95streaminterface method)": [[42, "lewis.devices.linkam_t95.interfaces.stream_interface.LinkamT95StreamInterface.cool", false]], "create() (lewis.core.simulation.simulationfactory method)": [[19, "lewis.core.simulation.SimulationFactory.create", false]], "create_device() (lewis.core.devices.devicebuilder method)": [[15, "lewis.core.devices.DeviceBuilder.create_device", false]], "create_exception() (lewis.adapters.modbus.modbustcpframe method)": [[8, "lewis.adapters.modbus.ModbusTCPFrame.create_exception", false]], "create_interface() (lewis.core.devices.devicebuilder method)": [[15, "lewis.core.devices.DeviceBuilder.create_interface", false]], "create_response() (lewis.adapters.modbus.modbustcpframe method)": [[8, "lewis.adapters.modbus.ModbusTCPFrame.create_response", false]], "cycle_delay (lewis.core.simulation.simulation property)": [[19, "lewis.core.simulation.Simulation.cycle_delay", false]], "cycles (lewis.core.simulation.simulation property)": [[19, "lewis.core.simulation.Simulation.cycles", false]], "default_device_type (lewis.core.devices.devicebuilder property)": [[15, "lewis.core.devices.DeviceBuilder.default_device_type", false]], "default_protocol (lewis.core.devices.devicebuilder property)": [[15, "lewis.core.devices.DeviceBuilder.default_protocol", false]], "defaultacceleratingstate (class in lewis.devices.chopper.devices.states)": [[27, "lewis.devices.chopper.devices.states.DefaultAcceleratingState", false]], "defaultcirculatingstate (class in lewis.devices.julabo.devices.states)": [[33, "lewis.devices.julabo.devices.states.DefaultCirculatingState", false]], "defaultcoolstate (class in lewis.devices.linkam_t95.devices.states)": [[40, "lewis.devices.linkam_t95.devices.states.DefaultCoolState", false]], "defaultheatstate (class in lewis.devices.linkam_t95.devices.states)": [[40, "lewis.devices.linkam_t95.devices.states.DefaultHeatState", false]], "defaultholdstate (class in lewis.devices.linkam_t95.devices.states)": [[40, "lewis.devices.linkam_t95.devices.states.DefaultHoldState", false]], "defaultidlestate (class in lewis.devices.chopper.devices.states)": [[27, "lewis.devices.chopper.devices.states.DefaultIdleState", false]], "defaultinitstate (class in lewis.devices.chopper.devices.states)": [[27, "lewis.devices.chopper.devices.states.DefaultInitState", false]], "defaultinitstate (class in lewis.devices.linkam_t95.devices.states)": [[40, "lewis.devices.linkam_t95.devices.states.DefaultInitState", false]], "defaultmovingstate (class in lewis.examples.example_motor)": [[45, "lewis.examples.example_motor.DefaultMovingState", false]], "defaultnotcirculatingstate (class in lewis.devices.julabo.devices.states)": [[33, "lewis.devices.julabo.devices.states.DefaultNotCirculatingState", false]], "defaultparkedstate (class in lewis.devices.chopper.devices.states)": [[27, "lewis.devices.chopper.devices.states.DefaultParkedState", false]], "defaultparkingstate (class in lewis.devices.chopper.devices.states)": [[27, "lewis.devices.chopper.devices.states.DefaultParkingState", false]], "defaultphaselockedstate (class in lewis.devices.chopper.devices.states)": [[27, "lewis.devices.chopper.devices.states.DefaultPhaseLockedState", false]], "defaultphaselockingstate (class in lewis.devices.chopper.devices.states)": [[27, "lewis.devices.chopper.devices.states.DefaultPhaseLockingState", false]], "defaultstartedstate (class in lewis.devices.linkam_t95.devices.states)": [[40, "lewis.devices.linkam_t95.devices.states.DefaultStartedState", false]], "defaultstoppedstate (class in lewis.devices.chopper.devices.states)": [[27, "lewis.devices.chopper.devices.states.DefaultStoppedState", false]], "defaultstoppedstate (class in lewis.devices.linkam_t95.devices.states)": [[40, "lewis.devices.linkam_t95.devices.states.DefaultStoppedState", false]], "defaultstoppingstate (class in lewis.devices.chopper.devices.states)": [[27, "lewis.devices.chopper.devices.states.DefaultStoppingState", false]], "device (class in lewis.devices)": [[22, "lewis.devices.Device", false]], "device (lewis.core.devices.interfacebase property)": [[15, "lewis.core.devices.InterfaceBase.device", false]], "device_builder() (lewis.core.devices.deviceregistry method)": [[15, "lewis.core.devices.DeviceRegistry.device_builder", false]], "device_lock (lewis.core.adapters.adaptercollection property)": [[11, "lewis.core.adapters.AdapterCollection.device_lock", false]], "device_types (lewis.core.devices.devicebuilder property)": [[15, "lewis.core.devices.DeviceBuilder.device_types", false]], "devicebase (class in lewis.core.devices)": [[15, "lewis.core.devices.DeviceBase", false]], "devicebuilder (class in lewis.core.devices)": [[15, "lewis.core.devices.DeviceBuilder", false]], "deviceregistry (class in lewis.core.devices)": [[15, "lewis.core.devices.DeviceRegistry", false]], "devices (lewis.core.devices.deviceregistry property)": [[15, "lewis.core.devices.DeviceRegistry.devices", false]], "devices (lewis.core.simulation.simulationfactory property)": [[19, "lewis.core.simulation.SimulationFactory.devices", false]], "dict_strict_update() (in module lewis.core.utils)": [[21, "lewis.core.utils.dict_strict_update", false]], "digit() (lewis.utils.command_builder.cmdbuilder method)": [[54, "lewis.utils.command_builder.CmdBuilder.digit", false]], "disconnect() (lewis.core.adapters.adaptercollection method)": [[11, "lewis.core.adapters.AdapterCollection.disconnect", false]], "do_import() (lewis.core.utils.fromoptionaldependency method)": [[21, "lewis.core.utils.FromOptionalDependency.do_import", false]], "doc (lewis.adapters.epics.boundpv property)": [[7, "lewis.adapters.epics.BoundPV.doc", false]], "documentation (lewis.adapters.epics.epicsadapter property)": [[7, "lewis.adapters.epics.EpicsAdapter.documentation", false]], "documentation (lewis.adapters.stream.streamadapter property)": [[9, "lewis.adapters.stream.StreamAdapter.documentation", false]], "documentation (lewis.core.adapters.adapter property)": [[11, "lewis.core.adapters.Adapter.documentation", false]], "documentation() (lewis.core.adapters.adaptercollection method)": [[11, "lewis.core.adapters.AdapterCollection.documentation", false]], "doprocess() (lewis.core.statemachine.statemachine method)": [[20, "lewis.core.statemachine.StateMachine.doProcess", false]], "enq() (lewis.utils.command_builder.cmdbuilder method)": [[54, "lewis.utils.command_builder.CmdBuilder.enq", false]], "enum() (lewis.utils.command_builder.cmdbuilder method)": [[54, "lewis.utils.command_builder.CmdBuilder.enum", false]], "eos() (lewis.utils.command_builder.cmdbuilder method)": [[54, "lewis.utils.command_builder.CmdBuilder.eos", false]], "eot() (lewis.utils.command_builder.cmdbuilder method)": [[54, "lewis.utils.command_builder.CmdBuilder.eot", false]], "epicsadapter (class in lewis.adapters.epics)": [[7, "lewis.adapters.epics.EpicsAdapter", false]], "epicsinterface (class in lewis.adapters.epics)": [[7, "lewis.adapters.epics.EpicsInterface", false]], "escape() (lewis.utils.command_builder.cmdbuilder method)": [[54, "lewis.utils.command_builder.CmdBuilder.escape", false]], "etx() (lewis.utils.command_builder.cmdbuilder method)": [[54, "lewis.utils.command_builder.CmdBuilder.etx", false]], "examplemodbusinterface (class in lewis.examples.modbus_device)": [[46, "lewis.examples.modbus_device.ExampleModbusInterface", false]], "examplemotorstreaminterface (class in lewis.examples.example_motor)": [[45, "lewis.examples.example_motor.ExampleMotorStreamInterface", false]], "execute_command (lewis.devices.chopper.interfaces.epics_interface.chopperepicsinterface property)": [[29, "lewis.devices.chopper.interfaces.epics_interface.ChopperEpicsInterface.execute_command", false]], "exposed_object (lewis.core.control_server.controlserver property)": [[14, "lewis.core.control_server.ControlServer.exposed_object", false]], "exposedobject (class in lewis.core.control_server)": [[14, "lewis.core.control_server.ExposedObject", false]], "exposedobjectcollection (class in lewis.core.control_server)": [[14, "lewis.core.control_server.ExposedObjectCollection", false]], "extract_module_name() (in module lewis.core.utils)": [[21, "lewis.core.utils.extract_module_name", false]], "float() (lewis.utils.command_builder.cmdbuilder method)": [[54, "lewis.utils.command_builder.CmdBuilder.float", false]], "float_to_raw_bytes() (in module lewis.utils.byte_conversions)": [[53, "lewis.utils.byte_conversions.float_to_raw_bytes", false]], "format_doc_text() (in module lewis.core.utils)": [[21, "lewis.core.utils.format_doc_text", false]], "from_bytearray() (lewis.adapters.modbus.modbustcpframe method)": [[8, "lewis.adapters.modbus.ModbusTCPFrame.from_bytearray", false]], "fromoptionaldependency (class in lewis.core.utils)": [[21, "lewis.core.utils.FromOptionalDependency", false]], "func (class in lewis.adapters.stream)": [[9, "lewis.adapters.stream.Func", false]], "get() (lewis.adapters.modbus.modbusdatabank method)": [[8, "lewis.adapters.modbus.ModbusDataBank.get", false]], "get_api() (lewis.core.control_server.exposedobject method)": [[14, "lewis.core.control_server.ExposedObject.get_api", false]], "get_members() (in module lewis.core.utils)": [[21, "lewis.core.utils.get_members", false]], "get_multicommands() (lewis.utils.command_builder.cmdbuilder method)": [[54, "lewis.utils.command_builder.CmdBuilder.get_multicommands", false]], "get_object_collection() (lewis.core.control_client.controlclient method)": [[13, "lewis.core.control_client.ControlClient.get_object_collection", false]], "get_objects() (lewis.core.control_server.exposedobjectcollection method)": [[14, "lewis.core.control_server.ExposedObjectCollection.get_objects", false]], "get_param() (lewis.examples.dual_device.verysimpledevice method)": [[44, "lewis.examples.dual_device.VerySimpleDevice.get_param", false]], "get_param() (lewis.examples.simple_device.verysimpleinterface method)": [[47, "lewis.examples.simple_device.VerySimpleInterface.get_param", false]], "get_position() (lewis.examples.example_motor.examplemotorstreaminterface method)": [[45, "lewis.examples.example_motor.ExampleMotorStreamInterface.get_position", false]], "get_protocols() (lewis.core.simulation.simulationfactory method)": [[19, "lewis.core.simulation.SimulationFactory.get_protocols", false]], "get_status() (lewis.devices.linkam_t95.interfaces.stream_interface.linkamt95streaminterface method)": [[42, "lewis.devices.linkam_t95.interfaces.stream_interface.LinkamT95StreamInterface.get_status", false]], "get_status() (lewis.examples.example_motor.examplemotorstreaminterface method)": [[45, "lewis.examples.example_motor.ExampleMotorStreamInterface.get_status", false]], "get_submodules() (in module lewis.core.utils)": [[21, "lewis.core.utils.get_submodules", false]], "get_target() (lewis.examples.example_motor.examplemotorstreaminterface method)": [[45, "lewis.examples.example_motor.ExampleMotorStreamInterface.get_target", false]], "get_usage_text() (in module lewis.scripts)": [[49, "lewis.scripts.get_usage_text", false]], "handle() (lewis.adapters.epics.epicsadapter method)": [[7, "lewis.adapters.epics.EpicsAdapter.handle", false]], "handle() (lewis.adapters.modbus.modbusadapter method)": [[8, "lewis.adapters.modbus.ModbusAdapter.handle", false]], "handle() (lewis.adapters.stream.streamadapter method)": [[9, "lewis.adapters.stream.StreamAdapter.handle", false]], "handle() (lewis.core.adapters.adapter method)": [[11, "lewis.core.adapters.Adapter.handle", false]], "handle_error() (lewis.adapters.stream.streaminterface method)": [[9, "lewis.adapters.stream.StreamInterface.handle_error", false]], "handle_error() (lewis.devices.linkam_t95.interfaces.stream_interface.linkamt95streaminterface method)": [[42, "lewis.devices.linkam_t95.interfaces.stream_interface.LinkamT95StreamInterface.handle_error", false]], "handle_error() (lewis.examples.simple_device.verysimpleinterface method)": [[47, "lewis.examples.simple_device.VerySimpleInterface.handle_error", false]], "handle_error() (lewis.examples.timeout_device.timeterminatedinterface method)": [[48, "lewis.examples.timeout_device.TimeTerminatedInterface.handle_error", false]], "has_log() (in module lewis.core.logging)": [[17, "lewis.core.logging.has_log", false]], "hascontext (class in lewis.core.statemachine)": [[20, "lewis.core.statemachine.HasContext", false]], "haslog (class in lewis.core.logging)": [[17, "lewis.core.logging.HasLog", false]], "heat() (lewis.devices.linkam_t95.interfaces.stream_interface.linkamt95streaminterface method)": [[42, "lewis.devices.linkam_t95.interfaces.stream_interface.LinkamT95StreamInterface.heat", false]], "hold() (lewis.devices.linkam_t95.interfaces.stream_interface.linkamt95streaminterface method)": [[42, "lewis.devices.linkam_t95.interfaces.stream_interface.LinkamT95StreamInterface.hold", false]], "in_state() (lewis.core.statemachine.state method)": [[20, "lewis.core.statemachine.State.in_state", false]], "in_state() (lewis.devices.chopper.devices.states.defaultacceleratingstate method)": [[27, "lewis.devices.chopper.devices.states.DefaultAcceleratingState.in_state", false]], "in_state() (lewis.devices.chopper.devices.states.defaultidlestate method)": [[27, "lewis.devices.chopper.devices.states.DefaultIdleState.in_state", false]], "in_state() (lewis.devices.chopper.devices.states.defaultparkingstate method)": [[27, "lewis.devices.chopper.devices.states.DefaultParkingState.in_state", false]], "in_state() (lewis.devices.chopper.devices.states.defaultphaselockingstate method)": [[27, "lewis.devices.chopper.devices.states.DefaultPhaseLockingState.in_state", false]], "in_state() (lewis.devices.chopper.devices.states.defaultstoppingstate method)": [[27, "lewis.devices.chopper.devices.states.DefaultStoppingState.in_state", false]], "in_state() (lewis.devices.julabo.devices.states.defaultcirculatingstate method)": [[33, "lewis.devices.julabo.devices.states.DefaultCirculatingState.in_state", false]], "in_state() (lewis.devices.linkam_t95.devices.states.defaultcoolstate method)": [[40, "lewis.devices.linkam_t95.devices.states.DefaultCoolState.in_state", false]], "in_state() (lewis.devices.linkam_t95.devices.states.defaultheatstate method)": [[40, "lewis.devices.linkam_t95.devices.states.DefaultHeatState.in_state", false]], "in_state() (lewis.examples.example_motor.defaultmovingstate method)": [[45, "lewis.examples.example_motor.DefaultMovingState.in_state", false]], "int() (lewis.utils.command_builder.cmdbuilder method)": [[54, "lewis.utils.command_builder.CmdBuilder.int", false]], "int_to_raw_bytes() (in module lewis.utils.byte_conversions)": [[53, "lewis.utils.byte_conversions.int_to_raw_bytes", false]], "interface (lewis.core.adapters.adapter property)": [[11, "lewis.core.adapters.Adapter.interface", false]], "interfacebase (class in lewis.core.devices)": [[15, "lewis.core.devices.InterfaceBase", false]], "interfaces (lewis.core.devices.devicebuilder property)": [[15, "lewis.core.devices.DeviceBuilder.interfaces", false]], "is_connected() (lewis.core.adapters.adaptercollection method)": [[11, "lewis.core.adapters.AdapterCollection.is_connected", false]], "is_device() (in module lewis.core.devices)": [[15, "lewis.core.devices.is_device", false]], "is_interface() (in module lewis.core.devices)": [[15, "lewis.core.devices.is_interface", false]], "is_paused (lewis.core.simulation.simulation property)": [[19, "lewis.core.simulation.Simulation.is_paused", false]], "is_running (lewis.adapters.epics.epicsadapter property)": [[7, "lewis.adapters.epics.EpicsAdapter.is_running", false]], "is_running (lewis.adapters.modbus.modbusadapter property)": [[8, "lewis.adapters.modbus.ModbusAdapter.is_running", false]], "is_running (lewis.adapters.stream.streamadapter property)": [[9, "lewis.adapters.stream.StreamAdapter.is_running", false]], "is_running (lewis.core.adapters.adapter property)": [[11, "lewis.core.adapters.Adapter.is_running", false]], "is_running (lewis.core.control_server.controlserver property)": [[14, "lewis.core.control_server.ControlServer.is_running", false]], "is_started (lewis.core.simulation.simulation property)": [[19, "lewis.core.simulation.Simulation.is_started", false]], "is_valid() (lewis.adapters.modbus.modbustcpframe method)": [[8, "lewis.adapters.modbus.ModbusTCPFrame.is_valid", false]], "json_rpc() (lewis.core.control_client.controlclient method)": [[13, "lewis.core.control_client.ControlClient.json_rpc", false]], "julabostreaminterfacev1 (class in lewis.devices.julabo.interfaces.julabo_stream_interface_1)": [[35, "lewis.devices.julabo.interfaces.julabo_stream_interface_1.JulaboStreamInterfaceV1", false]], "julabostreaminterfacev2 (class in lewis.devices.julabo.interfaces.julabo_stream_interface_2)": [[36, "lewis.devices.julabo.interfaces.julabo_stream_interface_2.JulaboStreamInterfaceV2", false]], "last_command (lewis.devices.chopper.interfaces.epics_interface.chopperepicsinterface property)": [[29, "lewis.devices.chopper.interfaces.epics_interface.ChopperEpicsInterface.last_command", false]], "lewis": [[5, "module-lewis", false]], "lewis.adapters": [[6, "module-lewis.adapters", false]], "lewis.adapters.epics": [[7, "module-lewis.adapters.epics", false]], "lewis.adapters.modbus": [[8, "module-lewis.adapters.modbus", false]], "lewis.adapters.stream": [[9, "module-lewis.adapters.stream", false]], "lewis.core": [[10, "module-lewis.core", false]], "lewis.core.adapters": [[11, "module-lewis.core.adapters", false]], "lewis.core.approaches": [[12, "module-lewis.core.approaches", false]], "lewis.core.control_client": [[13, "module-lewis.core.control_client", false]], "lewis.core.control_server": [[14, "module-lewis.core.control_server", false]], "lewis.core.devices": [[15, "module-lewis.core.devices", false]], "lewis.core.exceptions": [[16, "module-lewis.core.exceptions", false]], "lewis.core.logging": [[17, "module-lewis.core.logging", false]], "lewis.core.processor": [[18, "module-lewis.core.processor", false]], "lewis.core.simulation": [[19, "module-lewis.core.simulation", false]], "lewis.core.statemachine": [[20, "module-lewis.core.statemachine", false]], "lewis.core.utils": [[21, "module-lewis.core.utils", false]], "lewis.devices": [[22, "module-lewis.devices", false]], "lewis.devices.chopper": [[23, "module-lewis.devices.chopper", false]], "lewis.devices.chopper.devices": [[24, "module-lewis.devices.chopper.devices", false]], "lewis.devices.chopper.devices.bearings": [[25, "module-lewis.devices.chopper.devices.bearings", false]], "lewis.devices.chopper.devices.device": [[26, "module-lewis.devices.chopper.devices.device", false]], "lewis.devices.chopper.devices.states": [[27, "module-lewis.devices.chopper.devices.states", false]], "lewis.devices.chopper.interfaces": [[28, "module-lewis.devices.chopper.interfaces", false]], "lewis.devices.chopper.interfaces.epics_interface": [[29, "module-lewis.devices.chopper.interfaces.epics_interface", false]], "lewis.devices.julabo": [[30, "module-lewis.devices.julabo", false]], "lewis.devices.julabo.devices": [[31, "module-lewis.devices.julabo.devices", false]], "lewis.devices.julabo.devices.device": [[32, "module-lewis.devices.julabo.devices.device", false]], "lewis.devices.julabo.devices.states": [[33, "module-lewis.devices.julabo.devices.states", false]], "lewis.devices.julabo.interfaces": [[34, "module-lewis.devices.julabo.interfaces", false]], "lewis.devices.julabo.interfaces.julabo_stream_interface_1": [[35, "module-lewis.devices.julabo.interfaces.julabo_stream_interface_1", false]], "lewis.devices.julabo.interfaces.julabo_stream_interface_2": [[36, "module-lewis.devices.julabo.interfaces.julabo_stream_interface_2", false]], "lewis.devices.linkam_t95": [[37, "module-lewis.devices.linkam_t95", false]], "lewis.devices.linkam_t95.devices": [[38, "module-lewis.devices.linkam_t95.devices", false]], "lewis.devices.linkam_t95.devices.device": [[39, "module-lewis.devices.linkam_t95.devices.device", false]], "lewis.devices.linkam_t95.devices.states": [[40, "module-lewis.devices.linkam_t95.devices.states", false]], "lewis.devices.linkam_t95.interfaces": [[41, "module-lewis.devices.linkam_t95.interfaces", false]], "lewis.devices.linkam_t95.interfaces.stream_interface": [[42, "module-lewis.devices.linkam_t95.interfaces.stream_interface", false]], "lewis.examples": [[43, "module-lewis.examples", false]], "lewis.examples.dual_device": [[44, "module-lewis.examples.dual_device", false]], "lewis.examples.example_motor": [[45, "module-lewis.examples.example_motor", false]], "lewis.examples.modbus_device": [[46, "module-lewis.examples.modbus_device", false]], "lewis.examples.simple_device": [[47, "module-lewis.examples.simple_device", false]], "lewis.examples.timeout_device": [[48, "module-lewis.examples.timeout_device", false]], "lewis.scripts": [[49, "module-lewis.scripts", false]], "lewis.scripts.control": [[50, "module-lewis.scripts.control", false]], "lewis.scripts.run": [[51, "module-lewis.scripts.run", false]], "lewis.utils": [[52, "module-lewis.utils", false]], "lewis.utils.byte_conversions": [[53, "module-lewis.utils.byte_conversions", false]], "lewis.utils.command_builder": [[54, "module-lewis.utils.command_builder", false]], "lewis.utils.constants": [[55, "module-lewis.utils.constants", false]], "lewis.utils.replies": [[56, "module-lewis.utils.replies", false]], "lewisexception": [[16, "lewis.core.exceptions.LewisException", false]], "limitviolationexception": [[16, "lewis.core.exceptions.LimitViolationException", false]], "linear() (in module lewis.core.approaches)": [[12, "lewis.core.approaches.linear", false]], "linkamt95streaminterface (class in lewis.devices.linkam_t95.interfaces.stream_interface)": [[42, "lewis.devices.linkam_t95.interfaces.stream_interface.LinkamT95StreamInterface", false]], "map_arguments() (lewis.adapters.stream.func method)": [[9, "lewis.adapters.stream.Func.map_arguments", false]], "map_return_value() (lewis.adapters.stream.func method)": [[9, "lewis.adapters.stream.Func.map_return_value", false]], "match() (lewis.adapters.stream.patternmatcher method)": [[9, "lewis.adapters.stream.PatternMatcher.match", false]], "match() (lewis.adapters.stream.regex method)": [[9, "lewis.adapters.stream.regex.match", false]], "mbex (class in lewis.adapters.modbus)": [[8, "lewis.adapters.modbus.MBEX", false]], "meta (lewis.adapters.epics.boundpv property)": [[7, "lewis.adapters.epics.BoundPV.meta", false]], "modbusadapter (class in lewis.adapters.modbus)": [[8, "lewis.adapters.modbus.ModbusAdapter", false]], "modbusbasicdatabank (class in lewis.adapters.modbus)": [[8, "lewis.adapters.modbus.ModbusBasicDataBank", false]], "modbusdatabank (class in lewis.adapters.modbus)": [[8, "lewis.adapters.modbus.ModbusDataBank", false]], "modbusdatastore (class in lewis.adapters.modbus)": [[8, "lewis.adapters.modbus.ModbusDataStore", false]], "modbusdevice (class in lewis.examples.modbus_device)": [[46, "lewis.examples.modbus_device.ModbusDevice", false]], "modbusinterface (class in lewis.adapters.modbus)": [[8, "lewis.adapters.modbus.ModbusInterface", false]], "modbusprotocol (class in lewis.adapters.modbus)": [[8, "lewis.adapters.modbus.ModbusProtocol", false]], "modbustcpframe (class in lewis.adapters.modbus)": [[8, "lewis.adapters.modbus.ModbusTCPFrame", false]], "module": [[5, "module-lewis", false], [6, "module-lewis.adapters", false], [7, "module-lewis.adapters.epics", false], [8, "module-lewis.adapters.modbus", false], [9, "module-lewis.adapters.stream", false], [10, "module-lewis.core", false], [11, "module-lewis.core.adapters", false], [12, "module-lewis.core.approaches", false], [13, "module-lewis.core.control_client", false], [14, "module-lewis.core.control_server", false], [15, "module-lewis.core.devices", false], [16, "module-lewis.core.exceptions", false], [17, "module-lewis.core.logging", false], [18, "module-lewis.core.processor", false], [19, "module-lewis.core.simulation", false], [20, "module-lewis.core.statemachine", false], [21, "module-lewis.core.utils", false], [22, "module-lewis.devices", false], [23, "module-lewis.devices.chopper", false], [24, "module-lewis.devices.chopper.devices", false], [25, "module-lewis.devices.chopper.devices.bearings", false], [26, "module-lewis.devices.chopper.devices.device", false], [27, "module-lewis.devices.chopper.devices.states", false], [28, "module-lewis.devices.chopper.interfaces", false], [29, "module-lewis.devices.chopper.interfaces.epics_interface", false], [30, "module-lewis.devices.julabo", false], [31, "module-lewis.devices.julabo.devices", false], [32, "module-lewis.devices.julabo.devices.device", false], [33, "module-lewis.devices.julabo.devices.states", false], [34, "module-lewis.devices.julabo.interfaces", false], [35, "module-lewis.devices.julabo.interfaces.julabo_stream_interface_1", false], [36, "module-lewis.devices.julabo.interfaces.julabo_stream_interface_2", false], [37, "module-lewis.devices.linkam_t95", false], [38, "module-lewis.devices.linkam_t95.devices", false], [39, "module-lewis.devices.linkam_t95.devices.device", false], [40, "module-lewis.devices.linkam_t95.devices.states", false], [41, "module-lewis.devices.linkam_t95.interfaces", false], [42, "module-lewis.devices.linkam_t95.interfaces.stream_interface", false], [43, "module-lewis.examples", false], [44, "module-lewis.examples.dual_device", false], [45, "module-lewis.examples.example_motor", false], [46, "module-lewis.examples.modbus_device", false], [47, "module-lewis.examples.simple_device", false], [48, "module-lewis.examples.timeout_device", false], [49, "module-lewis.scripts", false], [50, "module-lewis.scripts.control", false], [51, "module-lewis.scripts.run", false], [52, "module-lewis.utils", false], [53, "module-lewis.utils.byte_conversions", false], [54, "module-lewis.utils.command_builder", false], [55, "module-lewis.utils.constants", false], [56, "module-lewis.utils.replies", false]], "name (lewis.core.devices.devicebuilder property)": [[15, "lewis.core.devices.DeviceBuilder.name", false]], "nolock (class in lewis.core.adapters)": [[11, "lewis.core.adapters.NoLock", false]], "objectproxy (class in lewis.core.control_client)": [[13, "lewis.core.control_client.ObjectProxy", false]], "on_entry() (lewis.core.statemachine.state method)": [[20, "lewis.core.statemachine.State.on_entry", false]], "on_entry() (lewis.devices.chopper.devices.states.defaultacceleratingstate method)": [[27, "lewis.devices.chopper.devices.states.DefaultAcceleratingState.on_entry", false]], "on_entry() (lewis.devices.chopper.devices.states.defaultinitstate method)": [[27, "lewis.devices.chopper.devices.states.DefaultInitState.on_entry", false]], "on_entry() (lewis.devices.chopper.devices.states.defaultparkingstate method)": [[27, "lewis.devices.chopper.devices.states.DefaultParkingState.on_entry", false]], "on_entry() (lewis.devices.chopper.devices.states.defaultphaselockingstate method)": [[27, "lewis.devices.chopper.devices.states.DefaultPhaseLockingState.on_entry", false]], "on_entry() (lewis.devices.chopper.devices.states.defaultstoppedstate method)": [[27, "lewis.devices.chopper.devices.states.DefaultStoppedState.on_entry", false]], "on_entry() (lewis.devices.chopper.devices.states.defaultstoppingstate method)": [[27, "lewis.devices.chopper.devices.states.DefaultStoppingState.on_entry", false]], "on_entry() (lewis.devices.linkam_t95.devices.states.defaultstartedstate method)": [[40, "lewis.devices.linkam_t95.devices.states.DefaultStartedState.on_entry", false]], "on_entry() (lewis.devices.linkam_t95.devices.states.defaultstoppedstate method)": [[40, "lewis.devices.linkam_t95.devices.states.DefaultStoppedState.on_entry", false]], "on_exit() (lewis.core.statemachine.state method)": [[20, "lewis.core.statemachine.State.on_exit", false]], "on_exit() (lewis.devices.linkam_t95.devices.states.defaultcoolstate method)": [[40, "lewis.devices.linkam_t95.devices.states.DefaultCoolState.on_exit", false]], "optional() (lewis.utils.command_builder.cmdbuilder method)": [[54, "lewis.utils.command_builder.CmdBuilder.optional", false]], "pattern (lewis.adapters.stream.patternmatcher property)": [[9, "lewis.adapters.stream.PatternMatcher.pattern", false]], "pattern (lewis.adapters.stream.scanf property)": [[9, "lewis.adapters.stream.scanf.pattern", false]], "patternmatcher (class in lewis.adapters.stream)": [[9, "lewis.adapters.stream.PatternMatcher", false]], "pause() (lewis.core.simulation.simulation method)": [[19, "lewis.core.simulation.Simulation.pause", false]], "poll_interval (lewis.adapters.epics.boundpv property)": [[7, "lewis.adapters.epics.BoundPV.poll_interval", false]], "process() (lewis.adapters.modbus.modbusprotocol method)": [[8, "lewis.adapters.modbus.ModbusProtocol.process", false]], "process() (lewis.core.control_server.controlserver method)": [[14, "lewis.core.control_server.ControlServer.process", false]], "protocolexception": [[13, "lewis.core.control_client.ProtocolException", false]], "protocols (lewis.core.adapters.adaptercollection property)": [[11, "lewis.core.adapters.AdapterCollection.protocols", false]], "protocols (lewis.core.devices.devicebuilder property)": [[15, "lewis.core.devices.DeviceBuilder.protocols", false]], "pump_command() (lewis.devices.linkam_t95.interfaces.stream_interface.linkamt95streaminterface method)": [[42, "lewis.devices.linkam_t95.interfaces.stream_interface.LinkamT95StreamInterface.pump_command", false]], "pv (class in lewis.adapters.epics)": [[7, "lewis.adapters.epics.PV", false]], "raw_bytes_to_float() (in module lewis.utils.byte_conversions)": [[53, "lewis.utils.byte_conversions.raw_bytes_to_float", false]], "raw_bytes_to_int() (in module lewis.utils.byte_conversions)": [[53, "lewis.utils.byte_conversions.raw_bytes_to_int", false]], "read_only (lewis.adapters.epics.boundpv property)": [[7, "lewis.adapters.epics.BoundPV.read_only", false]], "regex (class in lewis.adapters.stream)": [[9, "lewis.adapters.stream.regex", false]], "regex() (lewis.utils.command_builder.cmdbuilder method)": [[54, "lewis.utils.command_builder.CmdBuilder.regex", false]], "remoteexception": [[13, "lewis.core.control_client.RemoteException", false]], "remove_adapter() (lewis.core.adapters.adaptercollection method)": [[11, "lewis.core.adapters.AdapterCollection.remove_adapter", false]], "remove_object() (lewis.core.control_server.exposedobjectcollection method)": [[14, "lewis.core.control_server.ExposedObjectCollection.remove_object", false]], "reset() (lewis.core.statemachine.statemachine method)": [[20, "lewis.core.statemachine.StateMachine.reset", false]], "resume() (lewis.core.simulation.simulation method)": [[19, "lewis.core.simulation.Simulation.resume", false]], "run_simulation() (in module lewis.scripts.run)": [[51, "lewis.scripts.run.run_simulation", false]], "runtime (lewis.core.simulation.simulation property)": [[19, "lewis.core.simulation.Simulation.runtime", false]], "scanf (class in lewis.adapters.stream)": [[9, "lewis.adapters.stream.scanf", false]], "second (lewis.examples.dual_device.verysimpledevice property)": [[44, "lewis.examples.dual_device.VerySimpleDevice.second", false]], "second_int (lewis.examples.dual_device.verysimpleinterface property)": [[44, "lewis.examples.dual_device.VerySimpleInterface.second_int", false]], "seconds_since() (in module lewis.core.utils)": [[21, "lewis.core.utils.seconds_since", false]], "set() (lewis.adapters.modbus.modbusdatabank method)": [[8, "lewis.adapters.modbus.ModbusDataBank.set", false]], "set_circulating() (lewis.devices.julabo.devices.device.simulatedjulabo method)": [[32, "lewis.devices.julabo.devices.device.SimulatedJulabo.set_circulating", false]], "set_context() (lewis.core.statemachine.hascontext method)": [[20, "lewis.core.statemachine.HasContext.set_context", false]], "set_device() (lewis.core.adapters.adaptercollection method)": [[11, "lewis.core.adapters.AdapterCollection.set_device", false]], "set_device_parameters() (lewis.core.simulation.simulation method)": [[19, "lewis.core.simulation.Simulation.set_device_parameters", false]], "set_external_d() (lewis.devices.julabo.devices.device.simulatedjulabo method)": [[32, "lewis.devices.julabo.devices.device.SimulatedJulabo.set_external_d", false]], "set_external_i() (lewis.devices.julabo.devices.device.simulatedjulabo method)": [[32, "lewis.devices.julabo.devices.device.SimulatedJulabo.set_external_i", false]], "set_external_p() (lewis.devices.julabo.devices.device.simulatedjulabo method)": [[32, "lewis.devices.julabo.devices.device.SimulatedJulabo.set_external_p", false]], "set_internal_d() (lewis.devices.julabo.devices.device.simulatedjulabo method)": [[32, "lewis.devices.julabo.devices.device.SimulatedJulabo.set_internal_d", false]], "set_internal_i() (lewis.devices.julabo.devices.device.simulatedjulabo method)": [[32, "lewis.devices.julabo.devices.device.SimulatedJulabo.set_internal_i", false]], "set_internal_p() (lewis.devices.julabo.devices.device.simulatedjulabo method)": [[32, "lewis.devices.julabo.devices.device.SimulatedJulabo.set_internal_p", false]], "set_limit() (lewis.devices.linkam_t95.interfaces.stream_interface.linkamt95streaminterface method)": [[42, "lewis.devices.linkam_t95.interfaces.stream_interface.LinkamT95StreamInterface.set_limit", false]], "set_param() (lewis.examples.simple_device.verysimpleinterface method)": [[47, "lewis.examples.simple_device.VerySimpleInterface.set_param", false]], "set_rate() (lewis.devices.linkam_t95.interfaces.stream_interface.linkamt95streaminterface method)": [[42, "lewis.devices.linkam_t95.interfaces.stream_interface.LinkamT95StreamInterface.set_rate", false]], "set_set_point() (lewis.devices.julabo.devices.device.simulatedjulabo method)": [[32, "lewis.devices.julabo.devices.device.SimulatedJulabo.set_set_point", false]], "set_target() (lewis.examples.example_motor.examplemotorstreaminterface method)": [[45, "lewis.examples.example_motor.ExampleMotorStreamInterface.set_target", false]], "setups (lewis.core.devices.devicebuilder property)": [[15, "lewis.core.devices.DeviceBuilder.setups", false]], "setups (lewis.core.simulation.simulation property)": [[19, "lewis.core.simulation.Simulation.setups", false]], "simulatedbearings (class in lewis.devices.chopper.devices.device)": [[26, "lewis.devices.chopper.devices.device.SimulatedBearings", false]], "simulatedchopper (class in lewis.devices.chopper.devices.device)": [[26, "lewis.devices.chopper.devices.device.SimulatedChopper", false]], "simulatedexamplemotor (class in lewis.examples.example_motor)": [[45, "lewis.examples.example_motor.SimulatedExampleMotor", false]], "simulatedjulabo (class in lewis.devices.julabo.devices.device)": [[32, "lewis.devices.julabo.devices.device.SimulatedJulabo", false]], "simulatedlinkamt95 (class in lewis.devices.linkam_t95.devices.device)": [[39, "lewis.devices.linkam_t95.devices.device.SimulatedLinkamT95", false]], "simulation (class in lewis.core.simulation)": [[19, "lewis.core.simulation.Simulation", false]], "simulationfactory (class in lewis.core.simulation)": [[19, "lewis.core.simulation.SimulationFactory", false]], "spaces() (lewis.utils.command_builder.cmdbuilder method)": [[54, "lewis.utils.command_builder.CmdBuilder.spaces", false]], "speed (lewis.core.simulation.simulation property)": [[19, "lewis.core.simulation.Simulation.speed", false]], "start() (lewis.core.simulation.simulation method)": [[19, "lewis.core.simulation.Simulation.start", false]], "start() (lewis.devices.linkam_t95.interfaces.stream_interface.linkamt95streaminterface method)": [[42, "lewis.devices.linkam_t95.interfaces.stream_interface.LinkamT95StreamInterface.start", false]], "start_server() (lewis.adapters.epics.epicsadapter method)": [[7, "lewis.adapters.epics.EpicsAdapter.start_server", false]], "start_server() (lewis.adapters.modbus.modbusadapter method)": [[8, "lewis.adapters.modbus.ModbusAdapter.start_server", false]], "start_server() (lewis.adapters.stream.streamadapter method)": [[9, "lewis.adapters.stream.StreamAdapter.start_server", false]], "start_server() (lewis.core.adapters.adapter method)": [[11, "lewis.core.adapters.Adapter.start_server", false]], "start_server() (lewis.core.control_server.controlserver method)": [[14, "lewis.core.control_server.ControlServer.start_server", false]], "state (class in lewis.core.statemachine)": [[20, "lewis.core.statemachine.State", false]], "state (lewis.core.statemachine.statemachine property)": [[20, "lewis.core.statemachine.StateMachine.state", false]], "state (lewis.devices.chopper.devices.device.simulatedchopper property)": [[26, "lewis.devices.chopper.devices.device.SimulatedChopper.state", false]], "statemachine (class in lewis.core.statemachine)": [[20, "lewis.core.statemachine.StateMachine", false]], "statemachinedevice (class in lewis.devices)": [[22, "lewis.devices.StateMachineDevice", false]], "statemachineexception": [[20, "lewis.core.statemachine.StateMachineException", false]], "stop() (lewis.core.simulation.simulation method)": [[19, "lewis.core.simulation.Simulation.stop", false]], "stop() (lewis.devices.linkam_t95.interfaces.stream_interface.linkamt95streaminterface method)": [[42, "lewis.devices.linkam_t95.interfaces.stream_interface.LinkamT95StreamInterface.stop", false]], "stop() (lewis.examples.example_motor.simulatedexamplemotor method)": [[45, "lewis.examples.example_motor.SimulatedExampleMotor.stop", false]], "stop_server() (lewis.adapters.epics.epicsadapter method)": [[7, "lewis.adapters.epics.EpicsAdapter.stop_server", false]], "stop_server() (lewis.adapters.modbus.modbusadapter method)": [[8, "lewis.adapters.modbus.ModbusAdapter.stop_server", false]], "stop_server() (lewis.adapters.stream.streamadapter method)": [[9, "lewis.adapters.stream.StreamAdapter.stop_server", false]], "stop_server() (lewis.core.adapters.adapter method)": [[11, "lewis.core.adapters.Adapter.stop_server", false]], "streamadapter (class in lewis.adapters.stream)": [[9, "lewis.adapters.stream.StreamAdapter", false]], "streamhandler (class in lewis.adapters.stream)": [[9, "lewis.adapters.stream.StreamHandler", false]], "streaminterface (class in lewis.adapters.stream)": [[9, "lewis.adapters.stream.StreamInterface", false]], "string() (lewis.utils.command_builder.cmdbuilder method)": [[54, "lewis.utils.command_builder.CmdBuilder.string", false]], "stx() (lewis.utils.command_builder.cmdbuilder method)": [[54, "lewis.utils.command_builder.CmdBuilder.stx", false]], "switch_setup() (lewis.core.simulation.simulation method)": [[19, "lewis.core.simulation.Simulation.switch_setup", false]], "timed_reply() (in module lewis.utils.replies)": [[56, "lewis.utils.replies.timed_reply", false]], "timeterminateddevice (class in lewis.examples.timeout_device)": [[48, "lewis.examples.timeout_device.TimeTerminatedDevice", false]], "timeterminatedinterface (class in lewis.examples.timeout_device)": [[48, "lewis.examples.timeout_device.TimeTerminatedInterface", false]], "to_bytearray() (lewis.adapters.modbus.modbustcpframe method)": [[8, "lewis.adapters.modbus.ModbusTCPFrame.to_bytearray", false]], "transition (class in lewis.core.statemachine)": [[20, "lewis.core.statemachine.Transition", false]], "uptime (lewis.core.simulation.simulation property)": [[19, "lewis.core.simulation.Simulation.uptime", false]], "value (lewis.adapters.epics.boundpv property)": [[7, "lewis.adapters.epics.BoundPV.value", false]], "var (class in lewis.adapters.stream)": [[9, "lewis.adapters.stream.Var", false]], "verysimpledevice (class in lewis.examples.dual_device)": [[44, "lewis.examples.dual_device.VerySimpleDevice", false]], "verysimpledevice (class in lewis.examples.simple_device)": [[47, "lewis.examples.simple_device.VerySimpleDevice", false]], "verysimpleinterface (class in lewis.examples.dual_device)": [[44, "lewis.examples.dual_device.VerySimpleInterface", false]], "verysimpleinterface (class in lewis.examples.simple_device)": [[47, "lewis.examples.simple_device.VerySimpleInterface", false]], "verysimplestreaminterface (class in lewis.examples.dual_device)": [[44, "lewis.examples.dual_device.VerySimpleStreamInterface", false]]}, "objects": {"": [[5, 0, 0, "-", "lewis"]], "lewis": [[6, 0, 0, "-", "adapters"], [10, 0, 0, "-", "core"], [22, 0, 0, "-", "devices"], [43, 0, 0, "-", "examples"], [49, 0, 0, "-", "scripts"], [52, 0, 0, "-", "utils"]], "lewis.adapters": [[7, 0, 0, "-", "epics"], [8, 0, 0, "-", "modbus"], [9, 0, 0, "-", "stream"]], "lewis.adapters.epics": [[7, 1, 1, "", "BoundPV"], [7, 1, 1, "", "EpicsAdapter"], [7, 1, 1, "", "EpicsInterface"], [7, 1, 1, "", "PV"]], "lewis.adapters.epics.BoundPV": [[7, 2, 1, "", "config"], [7, 2, 1, "", "doc"], [7, 2, 1, "", "meta"], [7, 2, 1, "", "poll_interval"], [7, 2, 1, "", "read_only"], [7, 2, 1, "", "value"]], "lewis.adapters.epics.EpicsAdapter": [[7, 2, 1, "", "documentation"], [7, 3, 1, "", "handle"], [7, 2, 1, "", "is_running"], [7, 3, 1, "", "start_server"], [7, 3, 1, "", "stop_server"]], "lewis.adapters.epics.EpicsInterface": [[7, 2, 1, "", "adapter"]], "lewis.adapters.epics.PV": [[7, 3, 1, "", "bind"]], "lewis.adapters.modbus": [[8, 1, 1, "", "MBEX"], [8, 1, 1, "", "ModbusAdapter"], [8, 1, 1, "", "ModbusBasicDataBank"], [8, 1, 1, "", "ModbusDataBank"], [8, 1, 1, "", "ModbusDataStore"], [8, 1, 1, "", "ModbusInterface"], [8, 1, 1, "", "ModbusProtocol"], [8, 1, 1, "", "ModbusTCPFrame"]], "lewis.adapters.modbus.ModbusAdapter": [[8, 3, 1, "", "handle"], [8, 2, 1, "", "is_running"], [8, 3, 1, "", "start_server"], [8, 3, 1, "", "stop_server"]], "lewis.adapters.modbus.ModbusDataBank": [[8, 3, 1, "", "get"], [8, 3, 1, "", "set"]], "lewis.adapters.modbus.ModbusInterface": [[8, 2, 1, "", "adapter"]], "lewis.adapters.modbus.ModbusProtocol": [[8, 3, 1, "", "process"]], "lewis.adapters.modbus.ModbusTCPFrame": [[8, 3, 1, "", "create_exception"], [8, 3, 1, "", "create_response"], [8, 3, 1, "", "from_bytearray"], [8, 3, 1, "", "is_valid"], [8, 3, 1, "", "to_bytearray"]], "lewis.adapters.stream": [[9, 1, 1, "", "Cmd"], [9, 1, 1, "", "CommandBase"], [9, 1, 1, "", "Func"], [9, 1, 1, "", "PatternMatcher"], [9, 1, 1, "", "StreamAdapter"], [9, 1, 1, "", "StreamHandler"], [9, 1, 1, "", "StreamInterface"], [9, 1, 1, "", "Var"], [9, 1, 1, "", "regex"], [9, 1, 1, "", "scanf"]], "lewis.adapters.stream.Func": [[9, 3, 1, "", "map_arguments"], [9, 3, 1, "", "map_return_value"]], "lewis.adapters.stream.PatternMatcher": [[9, 2, 1, "", "arg_count"], [9, 2, 1, "", "argument_mappings"], [9, 3, 1, "", "match"], [9, 2, 1, "", "pattern"]], "lewis.adapters.stream.StreamAdapter": [[9, 2, 1, "", "documentation"], [9, 3, 1, "", "handle"], [9, 2, 1, "", "is_running"], [9, 3, 1, "", "start_server"], [9, 3, 1, "", "stop_server"]], "lewis.adapters.stream.StreamInterface": [[9, 2, 1, "", "adapter"], [9, 3, 1, "", "handle_error"]], "lewis.adapters.stream.regex": [[9, 2, 1, "", "arg_count"], [9, 2, 1, "", "argument_mappings"], [9, 3, 1, "", "match"]], "lewis.adapters.stream.scanf": [[9, 2, 1, "", "argument_mappings"], [9, 2, 1, "", "pattern"]], "lewis.core": [[11, 0, 0, "-", "adapters"], [12, 0, 0, "-", "approaches"], [13, 0, 0, "-", "control_client"], [14, 0, 0, "-", "control_server"], [15, 0, 0, "-", "devices"], [16, 0, 0, "-", "exceptions"], [17, 0, 0, "-", "logging"], [18, 0, 0, "-", "processor"], [19, 0, 0, "-", "simulation"], [20, 0, 0, "-", "statemachine"], [21, 0, 0, "-", "utils"]], "lewis.core.adapters": [[11, 1, 1, "", "Adapter"], [11, 1, 1, "", "AdapterCollection"], [11, 1, 1, "", "NoLock"]], "lewis.core.adapters.Adapter": [[11, 2, 1, "", "documentation"], [11, 3, 1, "", "handle"], [11, 2, 1, "", "interface"], [11, 2, 1, "", "is_running"], [11, 3, 1, "", "start_server"], [11, 3, 1, "", "stop_server"]], "lewis.core.adapters.AdapterCollection": [[11, 3, 1, "", "add_adapter"], [11, 3, 1, "", "configuration"], [11, 3, 1, "", "connect"], [11, 2, 1, "", "device_lock"], [11, 3, 1, "", "disconnect"], [11, 3, 1, "", "documentation"], [11, 3, 1, "", "is_connected"], [11, 2, 1, "", "protocols"], [11, 3, 1, "", "remove_adapter"], [11, 3, 1, "", "set_device"]], "lewis.core.approaches": [[12, 4, 1, "", "linear"]], "lewis.core.control_client": [[13, 1, 1, "", "ControlClient"], [13, 1, 1, "", "ObjectProxy"], [13, 5, 1, "", "ProtocolException"], [13, 5, 1, "", "RemoteException"]], "lewis.core.control_client.ControlClient": [[13, 3, 1, "", "get_object_collection"], [13, 3, 1, "", "json_rpc"]], "lewis.core.control_server": [[14, 1, 1, "", "ControlServer"], [14, 1, 1, "", "ExposedObject"], [14, 1, 1, "", "ExposedObjectCollection"]], "lewis.core.control_server.ControlServer": [[14, 2, 1, "", "exposed_object"], [14, 2, 1, "", "is_running"], [14, 3, 1, "", "process"], [14, 3, 1, "", "start_server"]], "lewis.core.control_server.ExposedObject": [[14, 3, 1, "", "get_api"]], "lewis.core.control_server.ExposedObjectCollection": [[14, 3, 1, "", "add_object"], [14, 3, 1, "", "get_objects"], [14, 3, 1, "", "remove_object"]], "lewis.core.devices": [[15, 1, 1, "", "DeviceBase"], [15, 1, 1, "", "DeviceBuilder"], [15, 1, 1, "", "DeviceRegistry"], [15, 1, 1, "", "InterfaceBase"], [15, 4, 1, "", "is_device"], [15, 4, 1, "", "is_interface"]], "lewis.core.devices.DeviceBuilder": [[15, 3, 1, "", "create_device"], [15, 3, 1, "", "create_interface"], [15, 2, 1, "", "default_device_type"], [15, 2, 1, "", "default_protocol"], [15, 2, 1, "", "device_types"], [15, 2, 1, "", "interfaces"], [15, 2, 1, "", "name"], [15, 2, 1, "", "protocols"], [15, 2, 1, "", "setups"]], "lewis.core.devices.DeviceRegistry": [[15, 3, 1, "", "device_builder"], [15, 2, 1, "", "devices"]], "lewis.core.devices.InterfaceBase": [[15, 2, 1, "", "adapter"], [15, 2, 1, "", "device"]], "lewis.core.exceptions": [[16, 5, 1, "", "AccessViolationException"], [16, 5, 1, "", "LewisException"], [16, 5, 1, "", "LimitViolationException"]], "lewis.core.logging": [[17, 1, 1, "", "HasLog"], [17, 4, 1, "", "has_log"]], "lewis.core.processor": [[18, 1, 1, "", "CanProcess"], [18, 1, 1, "", "CanProcessComposite"]], "lewis.core.simulation": [[19, 1, 1, "", "Simulation"], [19, 1, 1, "", "SimulationFactory"]], "lewis.core.simulation.Simulation": [[19, 2, 1, "", "control_server"], [19, 2, 1, "", "cycle_delay"], [19, 2, 1, "", "cycles"], [19, 2, 1, "", "is_paused"], [19, 2, 1, "", "is_started"], [19, 3, 1, "", "pause"], [19, 3, 1, "", "resume"], [19, 2, 1, "", "runtime"], [19, 3, 1, "", "set_device_parameters"], [19, 2, 1, "", "setups"], [19, 2, 1, "", "speed"], [19, 3, 1, "", "start"], [19, 3, 1, "", "stop"], [19, 3, 1, "", "switch_setup"], [19, 2, 1, "", "uptime"]], "lewis.core.simulation.SimulationFactory": [[19, 3, 1, "", "create"], [19, 2, 1, "", "devices"], [19, 3, 1, "", "get_protocols"]], "lewis.core.statemachine": [[20, 1, 1, "", "HasContext"], [20, 1, 1, "", "State"], [20, 1, 1, "", "StateMachine"], [20, 5, 1, "", "StateMachineException"], [20, 1, 1, "", "Transition"]], "lewis.core.statemachine.HasContext": [[20, 3, 1, "", "set_context"]], "lewis.core.statemachine.State": [[20, 3, 1, "", "in_state"], [20, 3, 1, "", "on_entry"], [20, 3, 1, "", "on_exit"]], "lewis.core.statemachine.StateMachine": [[20, 3, 1, "", "bind_handlers_by_name"], [20, 3, 1, "", "can"], [20, 3, 1, "", "doProcess"], [20, 3, 1, "", "reset"], [20, 2, 1, "", "state"]], "lewis.core.utils": [[21, 1, 1, "", "FromOptionalDependency"], [21, 1, 1, "", "check_limits"], [21, 4, 1, "", "dict_strict_update"], [21, 4, 1, "", "extract_module_name"], [21, 4, 1, "", "format_doc_text"], [21, 4, 1, "", "get_members"], [21, 4, 1, "", "get_submodules"], [21, 4, 1, "", "seconds_since"]], "lewis.core.utils.FromOptionalDependency": [[21, 3, 1, "", "do_import"]], "lewis.devices": [[22, 1, 1, "", "Device"], [22, 1, 1, "", "StateMachineDevice"], [23, 0, 0, "-", "chopper"], [30, 0, 0, "-", "julabo"], [37, 0, 0, "-", "linkam_t95"]], "lewis.devices.chopper": [[24, 0, 0, "-", "devices"], [28, 0, 0, "-", "interfaces"]], "lewis.devices.chopper.devices": [[25, 0, 0, "-", "bearings"], [26, 0, 0, "-", "device"], [27, 0, 0, "-", "states"]], "lewis.devices.chopper.devices.device": [[26, 1, 1, "", "SimulatedBearings"], [26, 1, 1, "", "SimulatedChopper"]], "lewis.devices.chopper.devices.device.SimulatedChopper": [[26, 2, 1, "", "state"]], "lewis.devices.chopper.devices.states": [[27, 1, 1, "", "DefaultAcceleratingState"], [27, 1, 1, "", "DefaultIdleState"], [27, 1, 1, "", "DefaultInitState"], [27, 1, 1, "", "DefaultParkedState"], [27, 1, 1, "", "DefaultParkingState"], [27, 1, 1, "", "DefaultPhaseLockedState"], [27, 1, 1, "", "DefaultPhaseLockingState"], [27, 1, 1, "", "DefaultStoppedState"], [27, 1, 1, "", "DefaultStoppingState"]], "lewis.devices.chopper.devices.states.DefaultAcceleratingState": [[27, 3, 1, "", "in_state"], [27, 3, 1, "", "on_entry"]], "lewis.devices.chopper.devices.states.DefaultIdleState": [[27, 3, 1, "", "in_state"]], "lewis.devices.chopper.devices.states.DefaultInitState": [[27, 3, 1, "", "on_entry"]], "lewis.devices.chopper.devices.states.DefaultParkingState": [[27, 3, 1, "", "in_state"], [27, 3, 1, "", "on_entry"]], "lewis.devices.chopper.devices.states.DefaultPhaseLockingState": [[27, 3, 1, "", "in_state"], [27, 3, 1, "", "on_entry"]], "lewis.devices.chopper.devices.states.DefaultStoppedState": [[27, 3, 1, "", "on_entry"]], "lewis.devices.chopper.devices.states.DefaultStoppingState": [[27, 3, 1, "", "in_state"], [27, 3, 1, "", "on_entry"]], "lewis.devices.chopper.interfaces": [[29, 0, 0, "-", "epics_interface"]], "lewis.devices.chopper.interfaces.epics_interface": [[29, 1, 1, "", "ChopperEpicsInterface"]], "lewis.devices.chopper.interfaces.epics_interface.ChopperEpicsInterface": [[29, 2, 1, "", "execute_command"], [29, 2, 1, "", "last_command"]], "lewis.devices.julabo": [[31, 0, 0, "-", "devices"], [34, 0, 0, "-", "interfaces"]], "lewis.devices.julabo.devices": [[32, 0, 0, "-", "device"], [33, 0, 0, "-", "states"]], "lewis.devices.julabo.devices.device": [[32, 1, 1, "", "SimulatedJulabo"]], "lewis.devices.julabo.devices.device.SimulatedJulabo": [[32, 3, 1, "", "set_circulating"], [32, 3, 1, "", "set_external_d"], [32, 3, 1, "", "set_external_i"], [32, 3, 1, "", "set_external_p"], [32, 3, 1, "", "set_internal_d"], [32, 3, 1, "", "set_internal_i"], [32, 3, 1, "", "set_internal_p"], [32, 3, 1, "", "set_set_point"]], "lewis.devices.julabo.devices.states": [[33, 1, 1, "", "DefaultCirculatingState"], [33, 1, 1, "", "DefaultNotCirculatingState"]], "lewis.devices.julabo.devices.states.DefaultCirculatingState": [[33, 3, 1, "", "in_state"]], "lewis.devices.julabo.interfaces": [[35, 0, 0, "-", "julabo_stream_interface_1"], [36, 0, 0, "-", "julabo_stream_interface_2"]], "lewis.devices.julabo.interfaces.julabo_stream_interface_1": [[35, 1, 1, "", "JulaboStreamInterfaceV1"]], "lewis.devices.julabo.interfaces.julabo_stream_interface_2": [[36, 1, 1, "", "JulaboStreamInterfaceV2"]], "lewis.devices.linkam_t95": [[38, 0, 0, "-", "devices"], [41, 0, 0, "-", "interfaces"]], "lewis.devices.linkam_t95.devices": [[39, 0, 0, "-", "device"], [40, 0, 0, "-", "states"]], "lewis.devices.linkam_t95.devices.device": [[39, 1, 1, "", "SimulatedLinkamT95"]], "lewis.devices.linkam_t95.devices.states": [[40, 1, 1, "", "DefaultCoolState"], [40, 1, 1, "", "DefaultHeatState"], [40, 1, 1, "", "DefaultHoldState"], [40, 1, 1, "", "DefaultInitState"], [40, 1, 1, "", "DefaultStartedState"], [40, 1, 1, "", "DefaultStoppedState"]], "lewis.devices.linkam_t95.devices.states.DefaultCoolState": [[40, 3, 1, "", "in_state"], [40, 3, 1, "", "on_exit"]], "lewis.devices.linkam_t95.devices.states.DefaultHeatState": [[40, 3, 1, "", "in_state"]], "lewis.devices.linkam_t95.devices.states.DefaultStartedState": [[40, 3, 1, "", "on_entry"]], "lewis.devices.linkam_t95.devices.states.DefaultStoppedState": [[40, 3, 1, "", "on_entry"]], "lewis.devices.linkam_t95.interfaces": [[42, 0, 0, "-", "stream_interface"]], "lewis.devices.linkam_t95.interfaces.stream_interface": [[42, 1, 1, "", "LinkamT95StreamInterface"]], "lewis.devices.linkam_t95.interfaces.stream_interface.LinkamT95StreamInterface": [[42, 3, 1, "", "cool"], [42, 3, 1, "", "get_status"], [42, 3, 1, "", "handle_error"], [42, 3, 1, "", "heat"], [42, 3, 1, "", "hold"], [42, 3, 1, "", "pump_command"], [42, 3, 1, "", "set_limit"], [42, 3, 1, "", "set_rate"], [42, 3, 1, "", "start"], [42, 3, 1, "", "stop"]], "lewis.examples": [[44, 0, 0, "-", "dual_device"], [45, 0, 0, "-", "example_motor"], [46, 0, 0, "-", "modbus_device"], [47, 0, 0, "-", "simple_device"], [48, 0, 0, "-", "timeout_device"]], "lewis.examples.dual_device": [[44, 1, 1, "", "VerySimpleDevice"], [44, 1, 1, "", "VerySimpleInterface"], [44, 1, 1, "", "VerySimpleStreamInterface"]], "lewis.examples.dual_device.VerySimpleDevice": [[44, 3, 1, "", "get_param"], [44, 2, 1, "", "second"]], "lewis.examples.dual_device.VerySimpleInterface": [[44, 2, 1, "", "second_int"]], "lewis.examples.example_motor": [[45, 1, 1, "", "DefaultMovingState"], [45, 1, 1, "", "ExampleMotorStreamInterface"], [45, 1, 1, "", "SimulatedExampleMotor"]], "lewis.examples.example_motor.DefaultMovingState": [[45, 3, 1, "", "in_state"]], "lewis.examples.example_motor.ExampleMotorStreamInterface": [[45, 3, 1, "", "get_position"], [45, 3, 1, "", "get_status"], [45, 3, 1, "", "get_target"], [45, 3, 1, "", "set_target"]], "lewis.examples.example_motor.SimulatedExampleMotor": [[45, 3, 1, "", "stop"]], "lewis.examples.modbus_device": [[46, 1, 1, "", "ExampleModbusInterface"], [46, 1, 1, "", "ModbusDevice"]], "lewis.examples.simple_device": [[47, 1, 1, "", "VerySimpleDevice"], [47, 1, 1, "", "VerySimpleInterface"]], "lewis.examples.simple_device.VerySimpleInterface": [[47, 3, 1, "", "get_param"], [47, 3, 1, "", "handle_error"], [47, 3, 1, "", "set_param"]], "lewis.examples.timeout_device": [[48, 1, 1, "", "TimeTerminatedDevice"], [48, 1, 1, "", "TimeTerminatedInterface"]], "lewis.examples.timeout_device.TimeTerminatedInterface": [[48, 3, 1, "", "handle_error"]], "lewis.scripts": [[50, 0, 0, "-", "control"], [49, 4, 1, "", "get_usage_text"], [51, 0, 0, "-", "run"]], "lewis.scripts.run": [[51, 4, 1, "", "run_simulation"]], "lewis.utils": [[53, 0, 0, "-", "byte_conversions"], [54, 0, 0, "-", "command_builder"], [55, 0, 0, "-", "constants"], [56, 0, 0, "-", "replies"]], "lewis.utils.byte_conversions": [[53, 4, 1, "", "float_to_raw_bytes"], [53, 4, 1, "", "int_to_raw_bytes"], [53, 4, 1, "", "raw_bytes_to_float"], [53, 4, 1, "", "raw_bytes_to_int"]], "lewis.utils.command_builder": [[54, 1, 1, "", "CmdBuilder"]], "lewis.utils.command_builder.CmdBuilder": [[54, 3, 1, "", "ack"], [54, 3, 1, "", "add_ascii_character"], [54, 3, 1, "", "any"], [54, 3, 1, "", "any_except"], [54, 3, 1, "", "arg"], [54, 3, 1, "", "build"], [54, 3, 1, "", "char"], [54, 3, 1, "", "digit"], [54, 3, 1, "", "enq"], [54, 3, 1, "", "enum"], [54, 3, 1, "", "eos"], [54, 3, 1, "", "eot"], [54, 3, 1, "", "escape"], [54, 3, 1, "", "etx"], [54, 3, 1, "", "float"], [54, 3, 1, "", "get_multicommands"], [54, 3, 1, "", "int"], [54, 3, 1, "", "optional"], [54, 3, 1, "", "regex"], [54, 3, 1, "", "spaces"], [54, 3, 1, "", "string"], [54, 3, 1, "", "stx"]], "lewis.utils.replies": [[56, 4, 1, "", "conditional_reply"], [56, 4, 1, "", "timed_reply"]]}, "objnames": {"0": ["py", "module", "Python module"], "1": ["py", "class", "Python class"], "2": ["py", "property", "Python property"], "3": ["py", "method", "Python method"], "4": ["py", "function", "Python function"], "5": ["py", "exception", "Python exception"]}, "objtypes": {"0": "py:module", "1": "py:class", "2": "py:property", "3": "py:method", "4": "py:function", "5": "py:exception"}, "terms": {"": [1, 4, 7, 8, 9, 11, 14, 15, 17, 18, 20, 21, 22, 42, 45, 51, 54, 58, 59, 61, 62, 63, 65, 75, 76, 77], "0": [4, 7, 8, 9, 11, 12, 13, 15, 19, 21, 27, 32, 42, 45, 51, 56, 58, 63, 64, 65, 72, 73, 75, 76], "010": 75, "05": [27, 76], "0garbag": 9, "0x01": 61, "0x06": 61, "0x0f": 61, "0x10": 61, "0x1000": 8, "0x1fff": 8, "0x2": 54, "0x3": 54, "0x4": 54, "0x5": 54, "0x6": 54, "0xdeadbeef": 75, "1": [4, 7, 8, 9, 11, 12, 13, 15, 19, 32, 58, 72, 75], "10": [4, 9, 12, 15, 42, 65, 76], "100": [7, 9, 12, 29, 42, 58, 65, 75], "10000": [13, 58, 75], "106584": 58, "12": 75, "120": 4, "123": 75, "1234": 73, "123_enhance_logic_flow": 1, "127": [4, 13, 58, 62, 75], "142721999999964": 58, "15": 21, "150": 56, "159932": 58, "17": 73, "172": 73, "2": [4, 7, 13, 19, 44, 58, 62, 63, 68, 72, 75], "20": [4, 12, 15, 58, 61, 75], "2017": [61, 62], "23e10": 75, "24": 21, "24th": 62, "250": [4, 45], "255": 73, "26th": 61, "2700": 54, "273": 21, "29": 58, "3": [13, 20, 32, 57, 63, 64, 72, 75, 77], "3000": 13, "34": 29, "4": [9, 21, 47], "40": 7, "42": 7, "45": 58, "49": 54, "5": [9, 27, 29, 44, 54, 75], "5020": 62, "555": 4, "6": [4, 9, 77], "640386": 58, "64038600000002": 58, "65535": 8, "78": 58, "8": [54, 75], "9": [9, 12, 32, 58], "99": [21, 32], "999": 32, "9998": 62, "9999": [4, 9, 32, 58, 62, 73], "A": [1, 2, 4, 7, 8, 9, 11, 14, 15, 19, 20, 21, 22, 44, 47, 48, 50, 51, 53, 54, 60, 61, 62, 77], "And": 58, "As": [2, 4, 9, 58, 65], "At": 9, "But": [4, 21, 75], "By": [7, 9, 11, 50, 62], "For": [1, 4, 7, 8, 9, 14, 17, 19, 22, 50, 54, 58, 60, 61, 62, 63, 65, 73, 75, 77], "If": [1, 3, 4, 7, 8, 9, 11, 12, 13, 14, 15, 17, 19, 20, 21, 42, 45, 46, 50, 51, 53, 54, 58, 61, 62, 63, 77], "In": [4, 7, 9, 11, 14, 15, 19, 20, 21, 58, 62, 63, 65], "It": [1, 3, 4, 7, 8, 9, 11, 14, 15, 16, 17, 19, 21, 22, 44, 54, 57, 58, 60, 61, 62, 63, 65, 75, 76], "Its": 60, "NO": [73, 77], "Not": 8, "On": [2, 4, 73, 77], "One": [46, 63], "TO": 20, "That": [8, 77], "The": [1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 26, 29, 32, 42, 44, 45, 46, 47, 48, 51, 53, 54, 56, 58, 59, 60, 61, 62, 63, 65, 73, 75, 76], "Then": [13, 29, 62], "There": [1, 2, 7, 13, 15, 17, 18, 54, 77], "These": [1, 3, 4, 8, 9, 11, 15, 59, 77], "To": [1, 4, 7, 9, 11, 13, 17, 19, 20, 21, 29, 47, 48, 50, 62, 63, 65, 75, 77], "With": [1, 9, 58, 63, 76], "_": [14, 21, 60, 61], "__": [1, 4, 21, 77], "__call__": 20, "__init__": [3, 4, 8, 15, 17, 22, 62], "__version__": 3, "_bar": 21, "_bind_devic": [11, 15], "_build": 1, "_context": [4, 20], "_csm": [4, 22], "_devic": 56, "_ex": 7, "_example_high_limit": 7, "_example_low_limit": 7, "_foo": 62, "_get_initial_st": [4, 22], "_get_state_handl": [4, 22], "_get_transition_handl": [4, 22], "_in_state_": 20, "_initialize_data": [4, 22], "_on_entry_": 20, "_on_exit_": 20, "_option": 11, "_set_logging_context": 17, "_target": 4, "_temp": 21, "a0": 42, "abil": [62, 69], "abl": [18, 21], "abort": 51, "about": [4, 7, 9, 13, 19, 42, 61, 76, 77], "abov": [2, 4, 7, 9, 15, 20, 58, 63, 75, 77], "absolut": 21, "absolute_path": 21, "abstract": [9, 59], "acceler": [27, 29], "accept": [4, 8, 9, 11, 15, 21, 62, 63, 75], "access": [4, 7, 11, 14, 16, 20, 50, 51, 57, 58, 59, 62, 63], "accessviolationexcept": 16, "accompani": 54, "accord": [4, 7, 15, 19], "account": [3, 75], "accumul": 19, "achiev": [4, 7, 11, 75], "ack": [54, 56], "acknowledge_pressur": 56, "acquir": [8, 11, 14], "across": 46, "action": [4, 16, 56], "activ": [1, 3, 21, 58, 62], "actual": [1, 4, 7, 11, 14, 17, 19, 21, 51, 61, 62, 65, 76], "ad": [9, 11, 18, 21, 51, 54, 60, 61, 62, 65, 66, 67, 68, 69], "adapt": [2, 4, 15, 19, 51, 54, 57, 58, 61, 62, 63, 65, 75, 77], "adapter_opt": 51, "adaptercollect": [11, 58], "add": [1, 9, 11, 14, 17, 51, 54, 61, 62, 66, 67, 69, 70], "add_adapt": 11, "add_ascii_charact": 54, "add_object": 14, "add_path": 51, "add_processor": [18, 62], "addit": [2, 4, 9, 15, 58, 65, 77], "addition": 4, "addr": 8, "address": [8, 46, 60, 61, 62, 73], "adher": 15, "adjust": [2, 42, 76], "adrian": 61, "advantag": [1, 4, 22], "advis": 75, "affect": [65, 75], "after": [4, 12, 13, 18, 19, 20, 29, 47, 48, 50, 59, 62, 63, 65, 75], "afterward": 14, "again": [1, 3, 15, 22, 58, 64, 76], "against": [1, 2, 3, 9, 20, 62], "aim": [58, 61], "alarm": 61, "all": [1, 2, 3, 4, 7, 8, 9, 11, 13, 14, 15, 17, 18, 19, 20, 21, 22, 42, 46, 50, 58, 61, 63, 65, 73, 75, 77], "allocate_lock": 11, "allow": [2, 4, 7, 15, 16, 19, 20, 22, 54, 58, 61, 62], "allowed_valu": 54, "alon": 7, "along": [1, 2, 4, 6, 58, 76, 77], "alreadi": [4, 11, 14, 20, 21, 45, 60], "also": [1, 3, 4, 7, 9, 11, 14, 15, 17, 20, 21, 22, 42, 58, 61, 62, 63, 75, 76, 77], "altern": [1, 21], "although": 17, "alwai": [2, 4, 9, 20, 21, 27, 33, 40, 45, 58], "amount": 2, "an": [1, 2, 3, 4, 7, 8, 9, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 32, 44, 45, 47, 49, 51, 53, 54, 56, 58, 60, 62, 63, 64, 65, 75, 76, 77], "analog": [15, 65], "ani": [2, 3, 4, 7, 8, 9, 11, 14, 17, 19, 20, 21, 47, 48, 50, 51, 54, 58, 59, 61, 62, 63, 68, 75], "anoth": [1, 3, 4, 19, 58, 62, 63, 75], "any_except": 54, "anymor": [62, 63], "anyon": [4, 14], "anystr": 54, "anyth": [7, 8, 9, 11, 21, 47, 54, 65], "anywai": 4, "api": [6, 14, 21, 50, 61, 65], "appear": 17, "append": 4, "appli": [7, 9, 11, 17], "applic": 1, "approach": [2, 4, 14, 18, 57], "appropri": [4, 11, 13, 20], "approv": 1, "approvaltest": 1, "approxim": [7, 8, 9, 11, 51], "ar": [1, 2, 3, 4, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 29, 42, 44, 45, 46, 47, 48, 50, 51, 52, 53, 54, 55, 57, 58, 61, 62, 63, 64, 65, 68, 75, 76, 77], "arbitrari": [11, 47, 61], "archiv": 77, "aren": [3, 20], "arg": [11, 13, 15, 17, 42, 54], "arg_count": 9, "arg_regex": 54, "arg_sep": 54, "argument": [4, 7, 9, 11, 13, 14, 15, 17, 19, 21, 49, 50, 51, 54, 56, 58, 61, 62, 63, 73, 75, 77], "argument_list": 51, "argument_map": [4, 9, 54], "argumentpars": 49, "around": [2, 21], "arrai": 42, "arriv": 61, "ascii": 54, "asid": 58, "ask": 19, "aspect": 19, "assign": [9, 11, 19, 20, 46, 75], "assum": [4, 15, 19, 20, 21, 58, 62, 75, 77], "ast": 75, "async_chat": 9, "asynchron": [65, 75], "at_least_on": 54, "attempt": [9, 21, 62, 75], "attribut": [7, 8, 9, 19, 20, 21, 46, 61, 65, 75], "attributeerror": 56, "authent": 14, "auto": [9, 20, 42], "autom": [2, 13, 58], "automat": [2, 4, 7, 9, 14, 20, 42, 63, 64, 65], "avail": [2, 3, 4, 9, 11, 14, 15, 19, 22, 42, 48, 51, 57, 58, 60, 61, 62, 63, 65, 75, 77], "avoid": [4, 75], "awar": [14, 77], "b": [1, 9, 21, 62, 75], "back": [1, 14, 61], "backend": 9, "bad": 61, "bar": [9, 17, 21, 48], "bar_max": 21, "bar_min": 21, "base": [1, 2, 4, 7, 8, 9, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 26, 27, 29, 32, 33, 35, 36, 39, 40, 42, 44, 45, 46, 47, 48, 54, 59, 61, 63, 65, 75, 77], "base_dict": 21, "basenam": 21, "bashwork": 8, "basi": [2, 18], "basic": [8, 14, 46, 58, 77], "baz": 17, "bdist_wheel": 3, "bear": 57, "becaus": [4, 7, 13, 14, 19, 21, 22, 65, 68, 75], "becom": [2, 4, 11, 58, 62, 64], "been": [1, 2, 3, 4, 7, 8, 9, 11, 14, 15, 19, 51, 59, 60, 61, 62, 63, 64, 65, 76, 77], "befor": [1, 2, 9, 11, 14, 18, 19, 20, 49, 51, 62, 63], "begin": [1, 8, 21], "begun": 9, "behav": [4, 63], "behavior": [4, 7, 9, 11, 12, 14, 17, 61, 62, 63, 75], "behaviour": [2, 20, 75], "being": [17, 19, 20, 65], "belong": [17, 21], "below": [4, 58, 63], "benefit": 2, "besid": [7, 63, 75], "best": [3, 4, 9], "better": [9, 16, 65], "between": [2, 4, 7, 9, 11, 15, 17, 19, 21, 22, 32, 42, 51, 54, 56, 58, 77], "bin": [3, 58], "bind": [2, 4, 7, 8, 9, 11, 14, 20, 61, 62, 65], "bind_address": [4, 9, 62, 73], "bind_handlers_by_nam": 20, "bindhandlersbynam": 2, "bit": [1, 17, 65, 77], "black": 68, "blank": 54, "block": [8, 11, 13, 14, 75], "blurb": 3, "bool": [8, 11, 22, 26, 32, 39, 45, 53, 54], "boolean": [11, 56], "both": [2, 4, 7, 9, 11, 14, 58, 59, 62, 63, 73, 75, 77], "bound": [4, 7, 9, 11, 15, 21, 60], "boundpv": [7, 16], "box": 9, "branch": [1, 3, 4], "break": [1, 4, 21], "breviti": 4, "bridg": 9, "brief": 75, "broad": [21, 58], "broadcast": 73, "broken": 15, "buffer": [8, 65], "build": [1, 52, 54, 65], "builder": [15, 54], "built": [2, 75], "builtin": 13, "bypass": [58, 62], "byte": [8, 42, 53, 69, 70], "byte_convers": 57, "bytearrai": 8, "c": [21, 32, 42, 51, 58, 75], "ca": 29, "cabl": 75, "caget": [7, 29], "calcul": [11, 12, 18, 19], "call": [2, 4, 7, 8, 9, 11, 13, 14, 15, 17, 18, 19, 20, 21, 50, 54, 56, 58, 61, 62, 65, 75, 77], "callabl": [4, 7, 8, 9, 14, 17, 20, 22, 26, 32, 39, 45, 56, 62], "callback": 2, "calld": 4, "can": [1, 2, 3, 4, 7, 8, 9, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 29, 35, 36, 42, 45, 47, 51, 54, 57, 58, 60, 61, 62, 63, 65, 73, 75, 76, 77], "cannot": [9, 75], "canprocess": [18, 20, 22, 26], "canprocesscomposit": [18, 22], "capabl": 61, "captur": [2, 4, 9, 14, 54], "caput": [7, 29], "carri": [8, 11, 29], "case": [4, 7, 8, 9, 11, 13, 14, 15, 17, 19, 20, 21, 53, 54, 58, 62, 63, 75], "cast": 54, "caught": 16, "caus": [2, 4, 7, 8, 9, 11, 17, 62, 65, 76], "cd": [1, 3], "central": [14, 20], "certain": [2, 4, 9, 11, 12, 14, 17, 19, 21, 22, 48, 63, 76, 77], "certainti": 63, "cfg": 20, "chang": [1, 4, 7, 8, 12, 15, 17, 19, 20, 21, 42, 58, 61, 63, 75], "channel": [50, 56, 59, 62, 75, 76], "channelaccess": [7, 29], "char": [48, 54], "char_numb": 54, "charact": [21, 54, 58, 62], "characterist": 4, "check": [1, 2, 3, 4, 8, 9, 20, 62, 63, 68], "check_limit": [16, 21], "checklist": 57, "checkout": 1, "chic": 59, "choic": 77, "choos": 4, "chopper": [4, 15, 57, 58, 59, 62, 73, 75, 77], "chopper_build": 15, "chopperepicsinterfac": 29, "chosen": 14, "chunk": 61, "ci": 1, "circul": 32, "circumst": [20, 65], "clark": 61, "class": [2, 4, 7, 8, 9, 11, 13, 14, 15, 17, 18, 19, 20, 21, 22, 26, 27, 29, 32, 33, 35, 36, 39, 40, 42, 44, 45, 46, 47, 48, 54, 61, 62, 63, 65], "clean": [3, 7, 9, 11, 21], "cleandoc": 21, "cleaner": 65, "cli": 58, "client": [7, 8, 9, 11, 13, 14, 20, 50, 57, 62, 63], "clone": [1, 3, 77], "close": [1, 2, 3, 7, 8, 9, 11, 61], "closer": [1, 65], "cmd": [4, 9, 29, 54, 63], "cmdbuilder": 54, "co": [8, 46, 61], "coars": 4, "code": [1, 4, 8, 13, 20, 22, 58, 61, 62, 65], "codebas": 60, "coerc": 64, "coil": 46, "collect": [4, 11, 13, 14, 18, 22], "colon": [14, 62], "com": [1, 3, 8, 51, 77], "combin": [4, 14, 19, 42], "come": [4, 14, 53], "command": [1, 4, 7, 9, 11, 21, 29, 35, 36, 42, 47, 48, 51, 54, 56, 57, 58, 59, 60, 61, 63, 65, 75, 76, 77], "command_build": 57, "command_separ": 54, "commandbas": 9, "commandlin": [9, 58], "commit": [1, 3, 68], "common": [7, 9, 15, 17, 61, 65], "commun": [2, 4, 11, 19, 51, 55, 57, 60, 61, 62, 63, 76, 77], "compar": [1, 76], "compat": [8, 61, 62, 73], "compens": 2, "compil": [9, 59], "complet": [3, 8, 9, 51, 58, 62, 63], "complex": [2, 4, 7, 15, 22, 57], "compon": [1, 8, 11], "composit": 18, "comprehens": 1, "compris": [9, 75], "comput": [19, 63, 76], "concaten": 11, "concept": [9, 18, 75], "conceptu": 4, "concret": [4, 6, 9, 11, 15, 17, 29, 42, 45], "condit": [1, 2, 20, 22, 56], "conditional_repli": 56, "conf": 3, "config": 7, "configur": [4, 7, 8, 9, 11, 14, 20, 29, 42, 51, 62, 65, 75, 77], "confirm": 35, "connect": [4, 7, 8, 9, 11, 13, 42, 47, 50, 56, 57, 61, 73, 75], "connection_str": 14, "consequ": [15, 63, 75], "consid": [4, 9, 20, 48], "consist": [4, 9, 14, 21, 22, 42, 47, 58], "constant": [9, 57], "constantli": 12, "construct": [2, 8, 9, 11, 14, 15, 19, 20, 21, 22, 51], "constructor": [9, 15, 20, 22, 54], "consult": [4, 9], "consum": 8, "contain": [2, 4, 6, 7, 8, 9, 11, 13, 14, 15, 17, 18, 19, 20, 21, 22, 29, 52, 54, 56, 61, 62, 75, 77], "content": [57, 63], "context": [4, 11, 17, 20, 56], "continu": [4, 8, 19, 60], "contribut": [61, 63], "contributor": 4, "control": [1, 2, 4, 8, 9, 11, 13, 14, 17, 19, 21, 45, 51, 57, 59, 60, 61, 62, 63, 65, 68, 76, 77], "control_cli": [14, 57, 58, 62, 75], "control_serv": [13, 19, 57, 62, 65], "controlcli": [13, 58, 62, 75], "controlserv": [13, 14, 19, 62, 65], "conveni": [4, 8, 18, 20, 58, 62, 63, 75], "convent": 20, "convers": 4, "convert": [4, 8, 9, 53, 63, 75], "cool": 42, "copi": 29, "core": [2, 4, 6, 57, 58, 61, 62, 63, 65, 75], "correct": [7, 9], "correctli": [1, 3, 11, 63, 77], "correspond": [7, 9, 14, 15, 19, 20], "could": [4, 7, 8, 17], "count": [7, 8, 9], "cover": 77, "crash_pump": 56, "creat": [1, 3, 4, 5, 7, 8, 9, 13, 15, 19, 20, 21, 45, 46, 54, 58, 65], "create_devic": 15, "create_except": 8, "create_interfac": 15, "create_request": 8, "create_respons": 8, "creation": 19, "critic": 51, "crlf": 58, "crnl": [9, 73], "csm": 22, "ctrl": 58, "current": [2, 3, 4, 8, 9, 11, 12, 15, 19, 20, 26, 42, 45, 56, 58, 61, 62, 65, 75, 77], "custom": [20, 21], "cut": 75, "cycl": [4, 8, 11, 18, 19, 20, 22, 27, 33, 40, 45, 50, 51, 58, 59, 63, 65, 76], "cycle_delai": [7, 8, 9, 11, 19, 51, 76], "d": [9, 21, 54], "data": [4, 7, 8, 9, 14, 22, 48, 61, 65], "databank": [8, 46, 61], "datastor": 8, "date": 3, "datetim": 21, "david": 60, "deactiv": 3, "debug": [2, 4, 17, 51, 58, 61, 62], "decid": [65, 77], "declar": [7, 51], "decor": [17, 21, 56], "decreas": [2, 19], "dedic": [1, 63], "def": [4, 7, 9, 17, 21, 56, 61, 62], "default": [7, 9, 11, 14, 15, 17, 20, 21, 46, 47, 48, 50, 51, 53, 54, 58, 62, 63, 65, 73, 75, 76], "default_device_typ": 15, "default_log_format": 17, "default_opt": 11, "default_protocol": 15, "default_valu": 8, "defaultacceleratingst": 27, "defaultcirculatingst": 33, "defaultcoolst": 40, "defaultheatst": 40, "defaultholdst": 40, "defaultidlest": 27, "defaultinitst": [27, 40], "defaultmovingst": [4, 45], "defaultnotcirculatingst": 33, "defaultparkedst": 27, "defaultparkingst": 27, "defaultphaselockedst": 27, "defaultphaselockingst": 27, "defaultstartedst": 40, "defaultstoppedst": [27, 40], "defaultstoppingst": 27, "defer": 21, "defin": [4, 7, 9, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 22, 54, 61, 62, 63], "definit": [4, 9, 63], "deinit": 29, "delai": [48, 51, 56, 58], "delimit": 54, "delta": [18, 19, 20, 27, 33, 40, 45], "demo": 58, "demonstr": [4, 46, 48], "depend": [4, 14, 19, 21, 29, 35, 36, 75, 77], "deposit": 62, "deprec": 51, "depth": 21, "deriv": [2, 8, 11, 15, 19, 20, 32], "describ": [4, 14, 15, 22, 42], "descript": [4, 7, 9, 29, 65, 75], "design": [2, 7, 11, 18], "desir": [1, 2, 7, 8, 11, 14, 19, 20, 56], "despit": 20, "detail": [4, 9, 15, 17, 20, 51, 57, 58, 65, 77], "detect": [4, 11], "determin": [7, 19, 26, 51, 65], "determinist": [2, 59], "dev": 1, "develop": [3, 4, 7, 59, 77], "developer_guid": [65, 77], "deviat": [8, 11], "devic": [1, 2, 3, 5, 7, 8, 9, 11, 16, 17, 19, 20, 44, 45, 46, 47, 48, 50, 51, 54, 56, 57, 58, 59, 60, 61, 62, 63, 65, 67, 76, 77], "device_1": 4, "device_2": 4, "device_build": [15, 19], "device_lock": [8, 11], "device_modul": 15, "device_nam": [15, 19, 77], "device_packag": 51, "device_typ": [4, 15], "devicebas": [11, 15, 22, 58], "devicebuild": [15, 19], "deviceinterfac": 63, "devicenam": 17, "deviceregistri": 15, "devices_packag": 19, "di": [8, 46, 61], "diagnos": [51, 62], "diagnost": 58, "dict": [4, 7, 11, 14, 15, 19, 20, 21, 22, 26, 32, 39, 45, 62], "dict_strict_upd": 21, "dict_valu": 75, "dictionari": [4, 7, 9, 11, 13, 14, 15, 19, 21, 22, 61, 62], "die": 4, "differ": [1, 4, 11, 17, 19, 21, 29, 35, 36, 44, 59, 61, 62, 63, 65, 75, 77], "digit": 54, "dir": 14, "direct": 21, "directli": [7, 8, 9, 13, 14, 15, 17, 20, 58, 63, 77], "directori": [3, 4, 21, 77], "disabl": [9, 17, 58, 64, 65], "disc": 29, "disconnect": [11, 61, 62, 75], "discov": 15, "discoveri": 15, "discret": 46, "dispatch": 14, "displai": [4, 16, 21, 58, 60, 61, 63], "dist": 3, "distinguish": [16, 17], "distribut": [4, 77], "dmsc": 51, "do": [1, 4, 7, 9, 11, 14, 15, 17, 20, 21, 22, 48, 54, 58, 62, 63, 65, 77], "do_import": 21, "doafterprocess": 18, "dobefor": 18, "dobeforeprocess": 18, "doc": [1, 3, 4, 7, 8, 9, 21, 65], "docstr": [4, 7, 9, 11], "document": [1, 3, 7, 9, 11, 17, 21, 29, 42, 45, 51, 58, 59, 60, 61, 63, 74, 75], "doe": [4, 7, 8, 9, 11, 14, 15, 18, 19, 21, 22, 29, 47, 48, 54, 56, 62, 63, 64, 65], "doesn": 1, "done": [3, 4, 18, 75, 77], "doprocess": [4, 18, 20, 22], "dot": 13, "doubl": [3, 75], "down": [7, 8, 9, 11, 58, 61], "download": 77, "draft": 3, "drive": 2, "dt": [4, 12, 18, 20, 27, 33, 40, 45], "dual_devic": [57, 58, 63], "due": [8, 9, 11, 61, 63, 64, 65], "dummi": [11, 21], "duplic": 4, "dure": [1, 2, 8, 9, 11, 19, 20, 47, 48], "dynam": [13, 29, 42, 45], "e": [13, 15, 21, 51, 54, 65], "each": [2, 4, 6, 8, 9, 11, 14, 15, 18, 19, 20, 21, 22, 46, 49, 51, 54, 62, 65], "earlier": [9, 63], "easi": [4, 9, 14, 57], "easier": [4, 7, 11, 20, 60, 61, 62, 63, 65], "easiest": 4, "easili": [17, 22, 29], "edit": [1, 65], "effect": [2, 4, 7, 19, 32, 51, 65, 75], "effort": 2, "eight": 61, "either": [1, 4, 9, 13, 14, 47], "elaps": [4, 18, 19, 21, 51], "electron": 2, "element": 21, "elig": 2, "els": [15, 21], "elsewher": 15, "empti": [4, 9, 11, 13, 14, 32, 42, 65, 73], "emul": [52, 54], "en": [4, 77], "enabl": [16, 17, 19, 20, 58, 60, 63], "encod": 54, "encourag": 63, "end": [1, 2, 8, 13, 20, 21, 54, 65], "endian": 53, "enforc": [16, 60], "enough": [4, 7, 8, 21], "enq": 54, "enquirei": 54, "ensur": [3, 11], "enter": [2, 20, 27, 40, 47, 58, 63], "entir": [4, 9, 19, 58, 65], "entri": [8, 14, 20, 22, 27, 40], "enum": [7, 54], "environ": [1, 3, 4, 21, 29, 57, 58, 65], "eo": 54, "eoferror": 8, "eot": 54, "epic": [4, 9, 11, 29, 44, 57, 59, 60, 61, 62, 63, 65, 75, 77], "epics_ca_addr_list": [73, 77], "epics_ca_auto_addr_list": [73, 77], "epics_cas_intf_addr_list": [73, 77], "epics_devic": [62, 63], "epics_interfac": 57, "epicsadapt": [7, 11, 62, 63], "epicsinterfac": [7, 9, 29, 44, 63], "equal": 45, "equival": [15, 54, 75], "err": 4, "error": [1, 4, 9, 15, 16, 19, 21, 42, 45, 47, 48, 51, 60, 62, 63, 65], "escap": [54, 58, 75], "especi": [4, 65], "ess": [29, 51, 59], "essenti": [18, 21, 75], "establish": [7, 8, 9, 11], "etc": [11, 13, 14, 22, 61, 62], "etx": 54, "evalu": 75, "even": [1, 4, 7, 20, 21, 22, 65], "event": [2, 20, 27, 33, 40, 45], "eventu": 4, "everi": [2, 20, 27, 33, 40, 45, 62], "everyth": [1, 4, 11, 14, 17, 21], "ex": 54, "exact": 9, "exact_match": 9, "exactli": [2, 7, 9, 20, 27, 33, 40, 45, 47, 63, 77], "exampl": [1, 7, 8, 9, 11, 12, 14, 15, 16, 17, 21, 29, 54, 56, 57, 59, 61, 62, 63, 64, 65, 73, 75, 76, 77], "example_meta": 7, "example_motor": [4, 57, 58], "examplemodbusinterfac": 46, "examplemotorstreaminterfac": [4, 45, 58], "exceed": 56, "except": [4, 8, 9, 13, 19, 20, 21, 47, 48, 56, 57, 61, 66], "exception_typ": 13, "exchang": 9, "exclud": 14, "exclude_inherit": 14, "exclus": 21, "execut": [4, 20, 29, 56, 58], "execute_command": 29, "exist": [1, 3, 4, 7, 9, 11, 15, 18, 19, 22, 51, 63, 75], "exit": [2, 20, 40, 50, 51, 62], "expect": [1, 3, 7, 8, 9, 11, 16, 75], "expens": 63, "experi": 4, "explain": 4, "explan": 9, "explicitli": [11, 14, 15, 60], "export": [73, 77], "expos": [4, 7, 8, 9, 11, 13, 14, 15, 19, 44, 51, 58, 61, 63, 75, 76], "exposed_object": 14, "exposedobject": 14, "exposedobjectcollect": 14, "express": [4, 7, 9, 54, 62, 63], "extend": [61, 62, 63], "extens": 21, "extern": [4, 32, 62], "extract": [9, 21, 49], "extract_module_nam": 21, "f": [4, 9, 21, 58, 63], "fact": 58, "factor": 2, "factori": [15, 19], "fail": [1, 61, 62, 64], "failur": 4, "fairli": 75, "fall": 8, "fals": [7, 8, 9, 14, 15, 20, 21, 54, 56, 73, 75], "familiar": 58, "far": 4, "fashion": [2, 75], "fast": [2, 59], "faster": 76, "faulti": 4, "featur": [4, 58], "feel": 63, "fetch": 61, "few": [1, 3, 4, 14, 15, 58, 60, 61, 77], "fidel": 2, "file": [1, 4, 9, 15, 21, 60, 65, 77], "fill": 21, "filter": 21, "final": [4, 9, 19, 54, 76], "find": [58, 65, 75], "fine": 62, "finish": 60, "finit": [4, 22, 59], "first": [1, 2, 4, 7, 8, 9, 15, 20, 22, 29, 53, 56, 60, 65, 77], "fit": 11, "five": 47, "fix": [3, 65, 69], "flag": [4, 9, 50, 51, 60, 61, 62, 63, 65], "flake8": [1, 60, 68], "flexibl": [21, 75], "float": [4, 9, 11, 12, 21, 22, 26, 32, 39, 44, 45, 53, 54, 56, 63], "float_to_raw_byt": 53, "float_valu": 75, "fluent": 54, "flush": 65, "focu": 4, "folder": 4, "follow": [1, 2, 4, 7, 8, 9, 14, 15, 20, 22, 48, 51, 58, 62, 73, 75, 77], "font": 63, "foo": [9, 17, 21, 48, 62], "foobar": 48, "foodevic": 62, "foodeviceinterfac": 62, "forc": [20, 50], "forev": 64, "fork": 4, "form": [4, 9, 18], "format": [1, 4, 9, 13, 17, 21, 49, 51, 59, 63, 68, 77], "format_doc_text": 21, "former": [7, 65], "forward": [2, 4, 7, 9, 15, 59], "found": [3, 4, 14, 15, 20, 51, 65], "four": [8, 46], "fourth": 4, "fp50": [36, 61], "fp50_mh": 35, "fragment": 8, "frame": [8, 61], "framework": [1, 11, 15, 51, 57, 61, 62, 63, 65], "framework_vers": [4, 15, 62, 63, 64], "free": [7, 9, 17, 63], "frequenc": [7, 65], "frequent": 19, "fresh": [1, 3, 4, 65], "from": [1, 2, 3, 4, 7, 8, 9, 11, 13, 14, 15, 16, 17, 19, 20, 21, 22, 49, 51, 57, 58, 61, 62, 63, 65, 75, 76], "from_bytearrai": 8, "fromoptionaldepend": 21, "front": 8, "fulfil": 8, "full": [46, 75], "fulli": 4, "func": [7, 9], "function": [2, 4, 7, 8, 9, 11, 12, 13, 14, 17, 19, 20, 21, 22, 42, 49, 50, 51, 54, 56, 58, 61, 62, 63, 67, 68, 70, 75, 76], "functool": 54, "furthermor": 14, "futur": [8, 51, 61, 62], "g": [15, 54], "gener": [1, 4, 7, 8, 9, 11, 13, 14, 29, 42, 45, 50, 54, 60, 62, 65, 75, 77], "get": [4, 7, 8, 9, 11, 14, 21, 58, 75, 77], "get_api": 14, "get_exampl": 7, "get_foo": 62, "get_memb": 21, "get_multicommand": 54, "get_object": [13, 14, 58, 75], "get_object_collect": 13, "get_param": [44, 47], "get_posit": [4, 45], "get_pr": 54, "get_protocol": 19, "get_spe": 9, "get_statu": [4, 42, 45], "get_submodul": 21, "get_target": [4, 45], "get_usage_text": 49, "getter": [7, 9, 14, 62], "git": [1, 77], "github": [1, 4, 8, 51, 57, 59, 77], "give": 58, "given": [2, 8, 12, 14, 20, 53, 54], "global": 62, "go": [1, 3, 4, 58], "goe": [63, 75], "golden": 1, "good": [1, 4, 11], "gpl": 57, "gracefulli": 70, "grain": 62, "granular": 59, "greater": [12, 19], "groundwork": [8, 62], "group": [4, 9, 54], "guarante": 19, "guid": [3, 66, 77], "guidelin": [8, 11, 19, 60], "gz": 3, "h": [4, 50, 51, 58], "ha": [1, 2, 4, 7, 8, 9, 11, 13, 14, 15, 19, 21, 22, 45, 47, 51, 56, 58, 60, 61, 62, 63, 65, 73, 75, 76, 77], "had": [20, 60, 64], "halt": 7, "handl": [2, 7, 8, 9, 11, 16, 20, 27, 33, 40, 45, 47, 48, 63, 66, 70], "handle_error": [9, 42, 47, 48, 65], "handler": [2, 4, 14, 20, 22], "hang": [11, 19, 62, 64], "happen": [1, 4, 7, 11, 15, 19, 29, 54], "hard": [11, 21], "hardwar": [5, 9, 35, 36], "has_log": 17, "hascontext": 20, "haslog": 17, "have": [1, 3, 4, 7, 8, 9, 11, 17, 18, 19, 20, 22, 29, 35, 36, 46, 48, 51, 58, 59, 60, 61, 62, 63, 65, 75, 77], "he": 36, "heart": 4, "heartbeat": 2, "heat": 42, "heater": 32, "hello": [48, 75], "hello_world": 75, "help": [14, 21, 49, 50, 51, 52, 62, 77], "helper": [21, 49], "here": [4, 11, 46, 67, 75], "high": 7, "highest": 19, "hihi": 7, "hilim": 7, "hint": 62, "hold": [8, 15, 42, 46], "hook": 1, "host": [4, 9, 13, 14, 19, 42, 45, 47, 48, 50, 51, 58, 75], "hostnam": 60, "how": [2, 4, 8, 9, 17, 48, 58, 63, 65, 75, 76], "howev": [7, 9, 13, 19, 29, 65, 75], "hr": [8, 46], "html": [1, 77], "http": [1, 3, 4, 8, 51, 77], "hypothet": 4, "i": [1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 26, 27, 29, 32, 33, 40, 42, 44, 45, 46, 48, 50, 51, 53, 54, 56, 57, 58, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 73, 75, 76, 77], "ibex": 61, "icanon": 48, "id": 13, "ideal": [3, 4], "ident": 4, "identifi": [2, 14, 62], "idl": [4, 20, 27, 33, 40, 45, 58], "iff": 20, "ignor": [4, 9, 21, 47, 48, 51, 54, 62, 63], "ignore_cas": 54, "imag": 63, "immedi": [4, 45], "implement": [2, 6, 7, 8, 9, 11, 15, 18, 20, 22, 46, 47, 48, 58, 59, 61, 63], "impli": 19, "implicit": 2, "import": [1, 4, 7, 8, 9, 11, 15, 17, 19, 21, 58, 62, 63, 66, 75], "import_devic": 4, "import_modul": 15, "importantli": [11, 16], "importerror": 21, "importlib": 15, "imposs": 61, "improv": [57, 66], "in_stat": [2, 4, 20, 27, 33, 40, 45], "in_state_new_st": 20, "in_termin": [4, 9, 65], "inbound": 9, "includ": [1, 2, 3, 8, 20, 54, 63, 65, 73, 77], "incom": [8, 9, 65], "incomplet": [8, 62], "increas": [2, 19], "increment": 65, "indent": [7, 9, 11, 21, 49], "independ": [2, 21], "index": 77, "indexerror": 8, "indic": [7, 8, 9, 11, 16, 19], "individu": 2, "infinit": [14, 63], "influenc": [4, 19, 51, 63], "info": [4, 7, 17, 51, 58], "inform": [4, 7, 9, 13, 19, 42, 49, 58, 61, 62, 75, 76], "infrastructur": [4, 8, 11, 14, 15], "inherit": [4, 7, 11, 14, 15, 20, 22, 62, 63], "inhibit": 56, "init": [2, 8, 20, 29], "initi": [2, 4, 8, 13, 15, 20, 21, 22, 29, 46, 59, 75], "initialis": 22, "inkscap": 63, "inner": 15, "input": [2, 8, 19, 21, 46, 51, 56, 62, 65], "insensit": 9, "insert": 17, "insid": [62, 77], "inspect": [7, 14, 15, 21], "instal": [1, 3, 4, 13, 21, 57, 60, 63, 65, 68, 74], "instanc": [7, 8, 13, 14, 15, 17, 19, 20, 21, 22, 42, 45, 46, 49, 58], "instanti": [8, 21], "instead": [9, 13, 19, 20, 56, 60, 61, 62, 63, 65, 75], "instruct": 77, "int": [7, 9, 21, 53, 54], "int_to_raw_byt": 53, "int_valu": 75, "integ": [9, 32, 44, 53, 54], "integr": [8, 32, 60, 63], "intend": [1, 22, 51], "intent": [7, 16], "intention": 4, "interact": [4, 8, 11, 29, 48, 50, 51, 58, 75], "interest": [4, 63], "interf": 65, "interfac": [7, 8, 9, 11, 13, 14, 15, 18, 19, 20, 44, 45, 46, 47, 51, 54, 57, 58, 60, 61, 63, 65, 77], "interfacebas": [7, 8, 9, 11, 15], "intermin": 9, "intern": [4, 9, 14, 15, 19, 22, 26, 32, 63], "interpret": [9, 14, 21, 57, 65], "interrupt": 51, "interv": [7, 9, 19, 45], "introduc": [9, 14, 60, 63], "invalid": [15, 19, 61], "invers": 9, "invoc": 60, "invok": [20, 47, 50], "involv": [2, 7, 11], "io": [11, 77], "ioc": 54, "ip": [4, 9, 60], "ir": [8, 46], "is_connect": [11, 75], "is_devic": 15, "is_interfac": 15, "is_paus": 19, "is_run": [7, 8, 9, 11, 14], "is_start": 19, "is_valid": 8, "isi": 69, "isiscomputinggroup": [1, 3, 77], "isort": 68, "issu": [1, 2, 3, 7, 9, 42, 57, 58, 61, 69], "item": 18, "item_that_implements_canprocess": 18, "iter": [9, 18], "its": [2, 4, 6, 8, 11, 14, 19, 20, 46, 54, 65, 75, 77], "itself": [7, 15, 20, 51, 58, 63, 75], "januari": 61, "job": 60, "join": 11, "joshburnett": 63, "json": [13, 14, 51, 61, 75], "json_rpc": 13, "jsonrpcresponsemanag": 14, "julabo": [57, 58, 61], "julabo_stream_interface_1": 57, "julabo_stream_interface_2": 57, "julabostreaminterfacev1": 35, "julabostreaminterfacev2": 36, "just": [1, 2, 46, 54, 58, 75, 77], "k": [4, 51, 58, 62, 63], "keep": [7, 11, 21, 59, 77], "kei": [7, 11, 14, 15, 19, 20, 21, 22, 54, 63], "keithlei": 54, "kept": 8, "keyword": 15, "kind": 9, "kindli": 61, "know": [4, 19], "known": [15, 20], "kwarg": [7, 8, 15, 17, 54], "l": [51, 62, 65], "laid": 62, "lambda": [4, 7, 9, 61, 62, 63], "languag": 4, "larg": 11, "last": [1, 2, 8, 20, 27, 29, 33, 40, 45, 56, 58], "last_addr": 8, "last_command": 29, "lastli": [9, 15], "later": [4, 11, 22, 62], "latest": 77, "latter": [4, 15], "launch": 58, "layer": 2, "lead": [65, 75], "least": [20, 21, 50, 53, 54], "leav": 20, "left": [4, 8, 9, 50, 62], "length": [4, 9, 53, 54], "less": [12, 56], "letter": 75, "level": [1, 4, 13, 17, 22, 51, 58, 61, 62, 77], "lewi": [2, 3, 4, 59, 60, 61, 62, 63, 64, 65, 68, 69, 73, 75, 76, 77], "lewis_control": 75, "lewis_test": 1, "lewisexcept": [15, 16, 21], "librari": [5, 17, 58], "licens": 57, "lifetim": [7, 8, 9, 11], "like": [1, 2, 4, 7, 9, 13, 14, 15, 18, 20, 22, 54, 58, 61, 62, 63, 75, 77], "likelihood": 4, "limit": [4, 7, 16, 21, 42, 61, 65, 75], "limitviolationexcept": [16, 21], "line": [9, 21, 29, 42, 49, 51, 57, 58, 59, 60, 75, 77], "linear": [4, 12], "linearli": 12, "linkam": [42, 59], "linkam_t95": [3, 4, 57, 58, 60, 61, 62, 73], "linkamt95streaminterfac": 42, "linux": [4, 73, 77], "list": [3, 4, 8, 9, 11, 13, 14, 19, 20, 21, 50, 51, 54, 55, 62, 71, 75, 77], "list_valu": 75, "listen": [7, 8, 9, 11, 13, 14, 42, 58, 73], "liter": 75, "literal_ev": 75, "littl": [4, 53, 63], "live": 4, "lnp": 42, "load": [7, 15, 19, 21, 51, 63, 65], "local": [1, 77], "localhost": [58, 60, 62, 73, 77], "locat": [6, 8, 15, 58, 63, 77], "lock": [8, 11, 14], "log": [15, 19, 51, 57, 61, 62, 63, 65, 75], "logger": [4, 17], "logo": 63, "lolim": 7, "lolo": 7, "long": [50, 62, 75, 76], "longer": [1, 19, 62, 64, 65], "look": [1, 4, 7, 8, 9, 11, 15, 56, 61], "loop": [14, 75], "loopback": 77, "lot": [4, 61], "low": [53, 63], "low_byte_first": 53, "low_bytes_first": 53, "lower": 21, "m": [1, 3, 9, 56, 65, 77], "m0": 42, "machin": [4, 14, 17, 19, 20, 22, 26, 58, 59, 63, 77], "machineri": 7, "made": [3, 4, 8, 9, 11, 19, 20, 60, 61, 62, 63, 65, 75], "magneticbear": 26, "mai": [2, 3, 4, 7, 8, 9, 11, 19, 20, 58, 61, 65, 75], "main": [3, 4, 16, 51, 58, 60], "mainli": [15, 22, 61], "maintain": 62, "major": [4, 63, 68], "make": [1, 3, 4, 7, 8, 9, 11, 12, 14, 17, 20, 21, 54, 57, 58, 60, 61, 62, 63, 75], "malform": 13, "man": 4, "manag": [11, 77], "mandatori": 15, "mani": [4, 8, 9, 58, 65, 76], "manipul": [13, 50], "manual": [1, 3, 21, 42, 58, 77], "map": [7, 9, 15, 54, 63], "map_argu": 9, "map_return_valu": 9, "march": 62, "markdown": 59, "master": 1, "match": [1, 4, 9, 15, 20, 35, 36, 54, 62, 63, 75], "matcher": 9, "matt": 61, "matter": [4, 7, 9, 20], "maximum": 51, "mbex": 8, "mean": [4, 11, 15, 19, 58, 73, 75, 77], "meaning": 16, "meant": [8, 15, 18, 19, 22, 58, 73], "mechan": 19, "member": [1, 4, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 25, 26, 27, 29, 32, 33, 35, 36, 39, 40, 42, 44, 45, 46, 47, 48, 49, 50, 51, 53, 54, 56, 61, 62], "memori": [8, 46, 61], "mention": 20, "merg": [4, 7, 62], "messag": [4, 13, 15, 16, 17, 21, 47, 50, 51, 60, 61, 62, 63, 65, 67], "meta": [7, 61], "meta_data_properti": [7, 62], "meta_target": 7, "metadata": [61, 65], "method": [2, 4, 7, 8, 9, 11, 13, 14, 15, 17, 18, 19, 21, 22, 47, 48, 50, 54, 56, 58, 62, 75], "method_call_with_two_string_arg": 75, "michel": 60, "might": [1, 4, 7, 11, 21, 54, 75], "millisecond": [13, 65], "mimic": 9, "min": 42, "mind": 21, "minim": [4, 11], "minimum": 56, "minimum_time_delai": 56, "minor": [63, 66, 67, 68, 69, 70, 71], "mirror": 13, "mismatch": [4, 51, 62, 63], "miss": [58, 62, 65], "mix": 70, "mixin": 20, "mm": [4, 45], "mod": 61, "modbu": [57, 61, 62], "modbus_application_protocol_v1_1b3": 8, "modbus_devic": [8, 57, 58, 61, 62], "modbus_messaging_implementation_guide_v1_0b": 8, "modbusadapt": [8, 63], "modbusbasicdatabank": 8, "modbusdatabank": [8, 46], "modbusdatastor": 8, "modbusdevic": 46, "modbusinterfac": [8, 46, 63], "modbusprotocol": 8, "modbustcpfram": 8, "mode": [32, 42, 48], "model": [2, 4, 7, 8, 12, 42, 75], "modifi": [1, 4, 9, 11, 17, 21, 51, 58, 63], "modul": [4, 7, 8, 11, 13, 14, 15, 17, 18, 20, 21, 22, 51, 58, 61, 62, 63, 66, 77], "moduletyp": 21, "moment": 19, "more": [1, 7, 8, 9, 15, 16, 17, 20, 21, 22, 48, 58, 62, 63, 65, 75, 77], "most": [4, 9, 11, 15, 19, 20, 22, 53, 61, 62, 77], "motion": [2, 59], "motor": [4, 45, 57], "move": [4, 12, 29, 45, 58, 62, 65], "movement": [4, 45, 58], "msec": 9, "much": [2, 4, 7, 8, 13, 63, 65, 75, 76], "multipl": [4, 7, 8, 9, 11, 14, 15, 18, 19, 20, 51, 54, 61, 63, 65, 75], "multipli": [19, 42, 44, 51], "must": [4, 7, 8, 9, 11, 13, 15, 21, 22, 32, 42, 48, 50, 54, 62, 63, 73, 77], "my_devic": 4, "myenv": 58, "n": [4, 13, 42, 50, 51, 61, 63], "name": [1, 2, 3, 4, 7, 9, 11, 13, 14, 15, 17, 18, 19, 20, 21, 22, 29, 51, 54, 56, 60, 61, 62, 73, 75, 76], "named_object": 14, "namespac": 62, "nanodac": 61, "nativ": 61, "natur": [2, 20], "nc": 48, "necessari": [1, 2, 4, 8, 11, 15, 62, 63, 77], "necessarili": 54, "need": [2, 3, 4, 7, 11, 15, 19, 20, 22, 54, 61, 62, 63, 77], "neg": [19, 42, 53], "neither": 44, "net": 4, "netcat": 48, "network": [9, 11, 13, 14, 19, 58, 59, 61, 63, 64, 73, 75, 76], "never": [12, 13, 20], "nevertheless": 60, "new": [1, 2, 3, 4, 9, 11, 12, 15, 17, 19, 20, 21, 32, 45, 57, 58, 75], "new_bar": 9, "new_context": 20, "new_devic": 11, "new_exampl": 7, "new_param": 47, "new_po": 12, "new_regex": 54, "new_setup": [19, 62, 75], "new_spe": 9, "new_target": [4, 45], "new_valu": 21, "newer": 4, "newli": 4, "next": [3, 8, 20, 54, 62], "node": 58, "nolock": 11, "non": 4, "none": [3, 4, 7, 8, 9, 11, 13, 14, 15, 17, 19, 20, 21, 22, 26, 27, 32, 33, 39, 40, 42, 45, 47, 49, 50, 51, 54, 56], "noreturn": [9, 15], "normal": [1, 56, 58, 61, 65], "nose": 65, "not_char": 54, "not_exact": 9, "notabl": [61, 62], "note": [4, 8, 9, 14, 58, 59, 75, 76, 77], "noth": [4, 9, 14, 15, 18, 47, 48], "notic": 4, "now": [1, 4, 21, 29, 54, 58, 60, 61, 62, 63, 64, 65, 75], "number": [1, 2, 4, 8, 9, 11, 13, 14, 19, 35, 36, 47, 49, 53, 54, 63, 75, 76], "numer": [9, 21], "o": [51, 61], "obj": [14, 15, 21], "object": [2, 4, 7, 8, 9, 11, 13, 14, 15, 17, 18, 19, 20, 21, 22, 49, 50, 54, 58, 75, 76], "object_map": 14, "object_nam": 13, "objectproxi": 13, "obtain": [4, 7, 13, 14, 15, 19, 60, 62, 75, 76], "obviou": 4, "occur": [2, 4, 8, 15, 19, 20, 21, 27, 33, 40, 45], "octal": 75, "odd": 4, "off": 8, "offer": [4, 7, 22, 44, 61], "often": [2, 9, 22], "old": [51, 62, 63], "old_posit": 4, "older": [4, 9, 63], "omit": [9, 29, 50, 51, 75], "on_entri": [2, 4, 20, 27, 40], "on_entry_init": 2, "on_entry_new_st": 20, "on_exit": [2, 4, 20, 40], "on_exit_old_st": 20, "onc": [2, 3, 4, 9, 15, 19, 20, 27, 33, 40, 42, 45, 58, 65, 75, 77], "one": [1, 2, 4, 7, 8, 9, 11, 14, 15, 17, 18, 19, 20, 21, 22, 27, 33, 40, 42, 45, 47, 50, 54, 58, 60, 63, 66, 73, 75], "ones": [3, 16, 75], "onli": [2, 4, 7, 8, 9, 11, 14, 15, 16, 18, 19, 20, 21, 22, 26, 44, 47, 51, 58, 62, 63, 65, 73, 75, 76, 77], "onlin": [51, 60], "oo": 14, "open": [1, 3, 14, 57, 58], "oper": [4, 7, 8, 11, 13, 65], "opportun": 1, "opt1": 51, "opt2": 51, "option": [2, 4, 7, 8, 9, 11, 15, 19, 20, 21, 22, 42, 50, 51, 54, 58, 59, 60, 62, 63, 73, 75, 77], "order": [3, 4, 7, 8, 11, 15, 18, 20, 21], "ordereddict": [4, 20, 22], "org": [4, 8, 77], "organ": 3, "orient": [2, 20], "origin": [1, 13, 17, 60], "orphan": 3, "os": 77, "other": [1, 2, 4, 7, 11, 15, 20, 21, 46, 51, 54, 58, 68, 77], "otherwis": [1, 4, 11, 15, 45, 53, 63], "out": [1, 3, 4, 8, 9, 11, 13, 50, 51, 61, 62, 73, 75], "out_termin": [4, 9], "outlin": [9, 63], "output": [1, 50, 51, 56, 61, 62, 75], "outsid": [4, 8, 11, 21, 45, 75], "outtermin": 9, "over": [4, 7, 8, 9, 11, 13, 14, 51, 58, 59, 62, 75, 76], "overal": [4, 68], "overlaid": [46, 61], "overlook": 64, "overrid": [4, 7, 9, 11, 20, 22, 47, 48, 73], "overridden": [4, 7, 9, 11, 20, 22, 62], "override_initial_data": [4, 15, 22, 26, 32, 39, 45], "override_initial_st": [4, 15, 22, 26, 32, 39, 45], "override_st": [22, 26, 32, 39, 45], "override_transit": [22, 26, 32, 39, 45], "overshoot": 12, "oversight": 64, "overview": 58, "overwritten": [20, 22], "own": [4, 9, 11, 14, 46, 65], "p": [4, 9, 17, 47, 48, 51, 56, 58, 61, 62, 63, 73, 75, 77], "packag": [1, 4, 6, 9, 14, 15, 51, 52, 57, 60, 63, 65, 77], "packet": 9, "page": [4, 74], "pair": [7, 11, 14, 21], "parallel": 1, "param": [32, 42, 44, 54, 61], "paramet": [2, 4, 7, 8, 9, 11, 12, 13, 14, 15, 17, 19, 20, 21, 22, 26, 27, 32, 33, 40, 42, 44, 45, 47, 48, 49, 51, 53, 54, 56, 57, 58, 61, 62, 75, 77], "park": 29, "parking_spe": 27, "pars": 51, "parser": [49, 51], "part": [4, 7, 9, 11, 13, 14, 20, 21, 29, 44, 45, 47, 62, 74, 77], "partial": [1, 7, 8, 54, 61, 63], "particular": [11, 60], "pass": [2, 4, 7, 8, 9, 11, 14, 15, 19, 20, 22, 51, 53, 54, 58, 62, 63, 75, 76], "past": 29, "patch": 63, "path": [4, 21, 51, 58, 63, 77], "pattern": [4, 9, 18, 20, 61, 63], "patternmatch": 9, "paus": [19, 76], "pcaspi": [7, 60, 77], "pdf": 8, "peopl": 52, "pep8": 1, "per": [2, 4, 20, 22, 27, 33, 40, 45, 65, 76], "perform": [1, 2, 9, 13, 14, 16, 18, 20, 56], "permiss": [3, 8, 11], "ph": 29, "phase": 29, "phase_locking_spe": 27, "pip": [1, 3, 4, 57, 58, 60, 65], "pipelin": 60, "place": [11, 17, 75], "plain": [9, 14, 22], "plankton": [59, 66], "pleas": [4, 8, 9, 11, 14, 17, 58, 62, 63, 75, 76, 77], "plu": 13, "png": 63, "po": 7, "point": [4, 11, 14, 44, 51, 53, 54, 58, 59, 63], "poll": 7, "poll_interv": [7, 65], "port": [4, 9, 13, 14, 19, 42, 45, 47, 48, 50, 51, 58, 62, 73, 75], "posit": [4, 7, 12, 15, 32, 42, 45, 50, 51, 58], "possibl": [1, 4, 7, 8, 9, 11, 13, 14, 15, 17, 18, 19, 21, 22, 29, 42, 58, 60, 61, 62, 63, 75, 76], "possibli": [9, 22], "poster": 63, "potenti": [4, 7, 20, 21, 62], "potter": 61, "power": 4, "pr": 3, "practic": 1, "pre": [1, 4, 54, 68], "precaut": 65, "preced": [4, 7, 14], "predic": 21, "pref": 62, "prefer": 4, "prefix": [7, 13, 17, 20, 29, 62, 73, 75], "preliminari": [8, 61], "prerequisit": 63, "present": [4, 9, 16, 19, 58, 63], "preserv": [8, 9, 11, 14, 21], "press": [47, 58], "pressur": 54, "pretti": 21, "previou": [3, 20, 58, 63], "previous": [19, 20, 58], "principl": 11, "print": [17, 42, 50, 51, 61, 77], "prior": [3, 14], "probabl": [15, 17], "problem": [4, 7, 8, 9, 11, 14, 42, 51, 62, 64, 65], "procedur": 9, "proceed": 3, "process": [2, 4, 7, 8, 9, 11, 14, 15, 18, 19, 20, 47, 48, 65, 75, 76], "processor": 57, "produc": [3, 4, 15, 51, 63], "program": [1, 51, 74], "progress": 19, "propag": [2, 13], "proper": [9, 11], "properli": 15, "properti": [4, 7, 8, 9, 11, 13, 14, 15, 16, 19, 20, 21, 26, 29, 44, 50, 56, 58, 61, 62, 65, 75], "property_nam": 56, "proport": 32, "protocol": [2, 4, 7, 8, 9, 11, 13, 15, 17, 19, 35, 36, 51, 54, 58, 59, 61, 63, 65, 75], "protocol1": 63, "protocol2": 63, "protocolexcept": 13, "provid": [2, 3, 4, 7, 8, 9, 11, 13, 15, 17, 19, 20, 21, 22, 51, 58, 63, 74, 75, 77], "proxi": 13, "public": 14, "pull": [1, 3, 4], "pump": 42, "pump_command": 42, "pure": 64, "purpos": [4, 9, 14, 20, 21, 58, 60], "push": 1, "put": [4, 21, 49, 53], "pv": [7, 16, 29, 44, 61, 62, 65, 73], "pvdb": 7, "pvprefix": 7, "py": [1, 3, 4, 7, 15, 21, 62, 65, 73, 75, 77], "py3": 3, "pymodbu": 8, "pymodbustcp": 8, "pypi": [58, 60, 77], "pytest": [1, 65], "python": [1, 3, 13, 14, 57, 58, 60, 61, 65, 68, 69, 73], "queri": [1, 11, 15, 62, 75, 76], "question": [8, 11], "quick": 56, "quickli": 58, "quickstart": 66, "quirk": [2, 7], "quit": [1, 44], "quot": [62, 75], "quotat": 75, "r": [1, 4, 9, 47, 50, 51, 58, 61, 62, 75, 76, 77], "raies": 15, "rais": [2, 4, 8, 9, 11, 13, 14, 15, 16, 19, 20, 21, 27, 33, 40, 45, 47, 48], "random": [9, 13], "rang": [4, 8, 21, 46, 62], "rare": 7, "rate": [4, 12, 19, 42, 51, 65], "rather": 19, "raw": [8, 53], "raw_byt": 53, "raw_bytes_to_float": 53, "raw_bytes_to_int": 53, "re": [7, 8, 9, 11, 19, 58, 61], "reach": [4, 42], "reachabl": 20, "react": 15, "read": [4, 7, 8, 9, 14, 16, 21, 26, 54, 61, 62, 75], "read_onli": 7, "read_pattern": 9, "readi": [4, 13, 59], "readthedoc": 77, "readtimeout": [9, 65], "real": [2, 4, 22, 75], "real_numb": 53, "realli": [11, 14], "reason": [9, 65], "receiv": [2, 4, 11, 13, 14, 20, 45, 48, 62, 65], "recognis": 42, "recommend": [1, 4, 58, 65, 77], "reconnect": [62, 75], "recov": 76, "refactor": 4, "refer": [4, 8, 9, 15, 17, 66, 77], "reflect": [7, 8, 9, 11], "reg": 54, "regard": 9, "regardless": [20, 63], "regex": [9, 54], "regist": [11, 14, 20, 46], "registri": 15, "regular": [4, 7, 9, 19, 54, 63], "regularli": [1, 7, 54], "relat": [1, 13, 17, 18, 51, 75], "relax": [51, 62], "releas": [4, 14, 51], "release_not": 3, "relev": [4, 17], "reliabl": 62, "remain": [20, 76], "remaind": 8, "remot": [13, 14, 19, 50, 57, 58], "remoteexcept": 13, "remov": [3, 8, 9, 11, 14, 51, 64, 65, 66, 68], "remove_adapt": 11, "remove_object": 14, "renam": [51, 62, 63], "render": 63, "rep": 14, "repeat": 63, "repeatedli": [20, 27, 33, 40, 45], "replac": [13, 19, 20, 21, 77], "replai": 48, "repli": [4, 13, 48, 57, 69], "report": 61, "repositori": [63, 77], "repres": [4, 7, 8, 13, 46, 53], "represent": [8, 53], "reproduc": 65, "req": 13, "request": [1, 3, 4, 7, 8, 9, 11, 13, 14, 15, 21, 42, 47, 48, 58, 60, 61, 62, 65], "requir": [1, 3, 4, 7, 8, 9, 11, 13, 14, 15, 20, 22, 58, 60, 61, 63, 75, 77], "resembl": 1, "reset": [20, 22], "resid": [1, 4], "resolut": [63, 65], "resolv": [3, 4], "resourc": 8, "respect": [4, 7, 9, 13, 20, 46, 58, 63], "respond": [14, 76], "respons": [2, 4, 8, 13, 54, 65, 75, 76], "rest": 62, "restart": 76, "restrict": [4, 7, 14], "result": [2, 7, 8, 9, 11, 13, 14, 21, 47, 48, 53, 62, 63, 65, 75], "resum": [19, 76], "retain": 13, "retriev": [8, 14, 58], "return": [4, 7, 8, 9, 11, 12, 13, 14, 15, 17, 19, 20, 21, 22, 32, 42, 45, 47, 48, 49, 50, 53, 54, 56, 61, 62, 75], "return_map": [4, 9], "return_valu": 9, "review": 4, "right": 4, "root": 58, "roughli": 3, "rpc": [7, 13, 14, 50, 51, 75], "rpc_host": [50, 51], "rpcobject": 14, "rr": 9, "rrr": 9, "rs232": 9, "rtd": 60, "rubik": 63, "rule": 15, "run": [1, 2, 3, 4, 7, 8, 9, 11, 13, 14, 19, 50, 57, 61, 62, 63, 65, 68, 74, 76], "run_simul": 51, "runtim": [7, 9, 11, 19, 21, 61, 62, 64, 76], "runtimeerror": [4, 9, 11, 14, 15, 19, 21], "safe": 11, "safe_load": 65, "sai": 21, "same": [2, 4, 7, 9, 11, 14, 15, 19, 22, 47, 58, 61, 62, 63, 75, 76, 77], "sampl": 4, "satisfi": 77, "scan": 58, "scanf": [4, 9, 63], "scenario": [4, 22], "schedul": 60, "scheme": 22, "script": [1, 4, 57, 58, 61, 62, 63, 68, 74, 75, 76, 77], "sdist": 3, "seamlessli": 11, "search": 20, "second": [2, 4, 7, 8, 9, 11, 14, 19, 21, 22, 44, 61, 63, 76], "second_int": 44, "seconds_sinc": 21, "section": [3, 4, 8, 58, 77], "secur": [14, 65], "see": [1, 4, 8, 9, 11, 15, 19, 20, 51, 54, 58, 61, 62, 63, 65, 67, 74, 77], "seen": 19, "segment": [46, 61], "select": [11, 51], "self": [4, 7, 9, 17, 20, 21, 22, 54, 56, 61, 62], "semant": [4, 11], "send": [8, 42, 47, 54, 67, 69], "sender": 8, "sens": [4, 14], "sensit": 58, "sent": 56, "separ": [1, 2, 4, 9, 11, 14, 22, 46, 50, 54, 61, 62, 63, 65, 75], "sequenc": 75, "serializ": 61, "serv": [8, 11, 13, 14, 19], "server": [7, 8, 9, 11, 13, 14, 19, 47, 50, 58, 60, 61, 62, 65, 75, 76], "servic": [8, 11, 14, 51, 59, 63, 64, 75], "session": 58, "set": [4, 7, 8, 9, 11, 14, 15, 17, 19, 20, 21, 29, 32, 35, 36, 42, 45, 47, 48, 50, 51, 53, 54, 58, 61, 62, 63, 75], "set_circul": 32, "set_context": 20, "set_devic": 11, "set_device_paramet": [19, 61, 75], "set_exampl": 7, "set_external_d": 32, "set_external_i": 32, "set_external_p": 32, "set_internal_d": 32, "set_internal_i": 32, "set_internal_p": 32, "set_limit": 42, "set_param": 47, "set_phas": 29, "set_pr": 54, "set_rat": 42, "set_set_point": 32, "set_spe": 9, "set_target": [4, 45], "set_temperatur": 21, "setlimit": 42, "setpoint": 29, "setrat": 42, "settabl": 62, "setter": [4, 7, 9, 14, 21, 62], "setup": [1, 3, 7, 8, 9, 11, 15, 19, 22, 51, 62, 64, 75, 77], "sever": [15, 17], "shape": 76, "share": [2, 3, 46], "shell": 75, "ship": 58, "short": [1, 22, 65], "shorter": [7, 19], "should": [1, 2, 3, 4, 7, 8, 9, 11, 12, 13, 14, 15, 19, 20, 21, 22, 29, 46, 54, 75, 76], "show": [50, 51, 58, 75], "shown": 75, "shut": [8, 11, 61], "side": [2, 13, 14, 63, 75], "sign": 53, "signatur": [7, 8, 62], "signific": [53, 62], "silent": [9, 21, 47, 48, 75], "sim": [62, 75], "sim2": 73, "similar": [4, 7, 9, 16, 21], "similarli": 17, "simpl": [4, 7, 9, 15, 22, 44, 47, 48], "simple_devic": [57, 58], "simpledeviceepicsinterfac": 7, "simpledevicestreaminterfac": 9, "simpler": 58, "simplest": [4, 7, 19], "simpli": [4, 7, 8, 9, 21], "simplifi": 63, "simul": [1, 2, 5, 8, 11, 14, 20, 22, 42, 45, 50, 51, 57, 58, 59, 61, 62, 63, 65, 75, 77], "simulatedbear": 26, "simulatedchopp": 26, "simulateddevicetyp": 15, "simulatedexamplemotor": [4, 45, 58], "simulatedjulabo": 32, "simulatedlinkamt95": 39, "simulationfactori": 19, "simultan": 19, "sinc": [2, 3, 7, 8, 9, 11, 19, 20, 21, 27, 33, 40, 45, 58, 61, 65], "singl": [4, 11, 20, 42, 54, 58], "situat": [14, 16], "skim": 58, "skip": 58, "sleep": 75, "slow": [2, 59, 63], "small": [7, 21, 49, 63, 65], "smaller": 63, "so": [1, 4, 7, 8, 9, 11, 14, 15, 17, 18, 19, 20, 21, 29, 47, 48, 54, 57, 58, 61, 62, 63, 64, 65, 75, 77], "sock": 9, "socket": [13, 14], "solv": [9, 14], "some": [4, 9, 11, 14, 17, 19, 21, 54, 56, 58, 60, 62, 63, 65, 69, 75, 76], "some_devic": 63, "some_method": 61, "someclassnam": 13, "somedevic": [7, 61], "someinterfac": [9, 63], "someth": [4, 11, 21, 47, 48], "sometim": [9, 21], "somewher": 77, "sort": 4, "sourc": [1, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 26, 27, 29, 32, 33, 35, 36, 39, 40, 42, 44, 45, 46, 47, 48, 49, 51, 53, 54, 56, 57, 58, 62, 63, 65], "sourceperl": 8, "space": [8, 21, 49, 54, 62, 63], "spd": 29, "speak": 32, "special": [9, 15, 20, 48, 54, 62], "specif": [1, 4, 6, 7, 9, 15, 16, 18, 21, 29, 57, 62, 63, 65, 75, 77], "specifi": [2, 4, 7, 9, 11, 13, 15, 19, 20, 21, 42, 48, 50, 51, 53, 54, 58, 61, 62, 63, 73, 75], "speed": [2, 4, 7, 9, 12, 19, 22, 29, 42, 51, 58, 59, 76], "spell": 65, "spend": [7, 9, 51], "spent": [7, 8, 11], "sphinx": [1, 60], "split": [4, 54], "sq": 63, "stage": 22, "standard": [1, 2, 8, 17, 21, 48, 61], "start": [1, 3, 4, 7, 8, 9, 11, 14, 19, 21, 29, 42, 45, 51, 58, 61, 62, 63, 64, 65, 75, 76], "start_addr": 8, "start_serv": [7, 8, 9, 11, 14, 19], "startup": [8, 11], "state": [2, 4, 17, 19, 20, 22, 26, 29, 32, 39, 45, 57, 58, 59, 61, 63, 75], "statemachin": [4, 17, 22, 27, 33, 40, 45, 57, 61], "statemachinedevic": [4, 15, 20, 22, 26, 32, 39, 45], "statemachineexcept": 20, "static": [9, 21], "statu": [1, 4, 11, 19, 42, 45, 58], "status": 11, "stderr": [51, 61], "stdout": 17, "step": [1, 3, 9, 29, 58, 65], "stick": [8, 11], "still": [1, 3, 9, 21, 51, 58, 59, 62, 63, 76], "stop": [4, 7, 8, 9, 11, 19, 29, 42, 45, 58, 75, 76], "stop_serv": [7, 8, 9, 11], "store": [4, 7, 8, 9, 11, 13, 14, 15, 19], "str": [11, 21, 22, 26, 29, 32, 39, 45, 54, 56, 69], "str_valu": 75, "str_value_looks_like_dict": 75, "str_value_looks_like_list": 75, "straightforward": [9, 22], "stream": [4, 8, 11, 42, 44, 45, 47, 54, 57, 58, 59, 61, 62, 63, 75, 76], "stream_interfac": 57, "stream_serv": 9, "streamadapt": [4, 9, 11, 63], "streamhandl": 9, "streaminterfac": [4, 9, 35, 36, 42, 44, 45, 47, 48, 63, 65], "streamserv": 58, "strict": [21, 63], "strict_vers": 15, "strictli": 4, "string": [4, 9, 13, 14, 17, 19, 21, 22, 32, 42, 49, 50, 51, 53, 54, 56, 62, 63, 64, 70, 73, 75], "strip": [4, 9], "strongli": [1, 65], "struct": 8, "structur": [4, 8, 65], "stty": 48, "stub": 21, "stuff": 7, "stx": 54, "style": [60, 62], "sub": [4, 7, 9, 11, 15, 18, 21, 22], "subclass": [7, 8, 9, 15, 18, 22], "subject": [8, 62], "submit": [3, 4, 13], "submodul": [5, 6, 10, 22, 23, 24, 28, 30, 31, 34, 37, 38, 41, 43, 49, 52], "subset": 11, "substitut": 7, "success": 8, "successfulli": [29, 75], "suggest": 4, "summari": 1, "super": 17, "suppli": [4, 7, 9, 11, 13, 14, 15, 19, 21, 49, 50, 51, 62, 63, 75], "support": [4, 8, 11, 20, 61, 65, 68, 71, 75], "suppos": [8, 11, 22], "sure": [1, 3, 4, 7, 8, 9, 11, 12, 21, 54, 58], "suspend": 19, "svg": 63, "switch": [19, 42, 48, 62, 64, 75], "switch_setup": [19, 62, 75], "symbol": 21, "synchron": [11, 75], "syntax": [4, 21, 57, 62], "system": [1, 65, 68, 77], "system_test": 1, "t": [1, 3, 4, 9, 14, 15, 17, 20, 27, 33, 40, 42, 45, 50, 56, 58, 61, 62], "t95": [42, 59], "t_in_kelvin": 21, "tag": [3, 13], "take": [1, 3, 9, 11, 13, 14, 15, 20, 65, 73, 75], "taken": 3, "talk": 58, "tar": 3, "target": [4, 7, 9, 12, 15, 17, 20, 32, 42, 45, 54, 58], "target_memb": 9, "target_method": 54, "target_phas": [61, 75], "target_properti": [7, 62], "target_spe": [61, 75], "targz": 3, "task": 1, "tcp": [4, 8, 9, 42, 44, 45, 47, 58, 59, 61, 62, 73, 76], "team": [1, 4, 61], "tear": [7, 8, 9, 11], "techniqu": 9, "tell": [2, 42, 58], "telnet": [4, 42, 45, 47, 48, 57, 61, 73], "telnet_mod": [9, 62, 73], "temper": 42, "temperatur": [21, 22, 32, 42, 59], "ten": 76, "term": [4, 17, 21, 75], "termin": [4, 9, 11, 42, 48, 58, 61, 65, 73, 75], "test": [1, 2, 15, 58, 61, 65, 68], "text": [9, 21, 49, 54, 63], "textwrap": 21, "than": [4, 12, 15, 17, 19, 54, 56, 63, 76], "thank": [60, 61, 63], "thei": [3, 4, 7, 9, 16, 21, 22, 63, 75, 76], "them": [1, 2, 4, 11, 20, 21, 47, 58, 62, 63], "themselv": 15, "therefor": 65, "therei": 51, "thi": [1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 26, 27, 29, 33, 35, 36, 40, 42, 44, 45, 47, 48, 49, 50, 51, 52, 54, 58, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 73, 74, 75, 76, 77], "thin": 21, "thing": [1, 3, 7, 18, 44], "think": 58, "third": [20, 22], "those": [4, 7, 14, 15, 21, 22, 29, 50, 75], "though": 7, "thread": [8, 11, 14, 63, 65], "three": [2, 4, 9, 18, 22, 64], "through": [7, 15, 19, 50, 61, 62, 63, 65, 75, 77], "throughout": 2, "thu": [11, 21], "tick": [2, 58], "time": [1, 2, 4, 7, 8, 9, 11, 12, 13, 14, 18, 19, 20, 21, 48, 51, 56, 59, 60, 63, 75, 76], "timed_repli": 56, "timeout": [9, 13, 14, 48, 50, 62, 65], "timeout_devic": [57, 58], "timeterminateddevic": 48, "timeterminatedinterfac": 48, "tn": 32, "to_bytearrai": 8, "togeth": [1, 7, 9, 11, 63], "too": [4, 56], "tool": [6, 50, 57, 58], "top": [3, 4, 13, 62, 77], "total": 19, "toward": [4, 7, 9, 12, 29], "tox": [1, 65], "track": 77, "trait": 2, "transfer": 9, "transform": 9, "transit": [2, 4, 20, 22], "translat": 9, "transmiss": 9, "transmission_control_protocol": 4, "transpar": 75, "transport": 13, "travers": 58, "treat": [1, 4, 9, 63, 65], "tree": [1, 18, 58], "tri": [4, 7, 9, 11, 14, 15, 21, 70], "trigger": [2, 4, 14, 20, 65], "trivial": 75, "true": [4, 7, 8, 9, 14, 15, 19, 20, 21, 53, 54, 56, 62, 73, 75], "trust": [14, 75, 76], "try": [4, 19, 58], "tty": 48, "tupl": [4, 7, 20, 21, 22, 26, 32, 39, 45, 62], "turn": [2, 9, 14, 15, 75], "tutori": 58, "tv": 32, "twice": 76, "twine": 3, "two": [4, 7, 9, 14, 15, 17, 18, 19, 20, 46, 51, 58, 59, 61, 63, 74, 75, 77], "txt": [1, 60, 77], "type": [4, 7, 8, 9, 13, 15, 16, 17, 20, 21, 47, 48, 54, 58, 77], "typic": [8, 12, 51], "typo": 4, "u": [58, 75], "unconfirm": 36, "under": [1, 7, 13, 14, 57, 60, 65], "underli": [13, 65], "underscor": [14, 20], "understand": 58, "unexpect": [16, 75], "unfamiliar": 60, "unicode_valu": 75, "uniform": 11, "unit": [1, 3, 42], "unknown": 13, "unless": [7, 9, 15, 53], "unlik": 20, "unlock": 29, "unmodifi": 47, "unnot": 4, "unpack": 77, "unsign": 53, "unsolicit": [67, 69], "until": [4, 13, 14, 21, 42], "up": [2, 3, 7, 9, 11, 20, 58], "updat": [2, 4, 7, 19, 21, 61, 62, 65, 71], "update_dict": 21, "upon": [11, 13, 20], "upper": 21, "upstream": 4, "uptim": [19, 76], "us": [1, 3, 4, 7, 8, 9, 11, 13, 14, 15, 16, 17, 19, 20, 21, 22, 48, 50, 51, 54, 55, 58, 59, 60, 61, 62, 63, 65, 68, 69, 75, 76, 77], "usag": [8, 50, 51, 56, 57, 61, 74], "user": [7, 8, 9, 11, 16, 22, 51, 59, 61, 62, 63, 77], "user_guid": 4, "usual": [13, 29, 58, 75], "utf": 54, "util": [3, 57, 69, 75], "uuid": 13, "uuid4": 13, "v": [9, 47, 50, 51, 62, 63, 65], "val": 51, "valid": [7, 8, 9, 14, 21, 46, 75], "valu": [1, 4, 7, 8, 9, 12, 14, 15, 19, 20, 21, 22, 29, 32, 45, 46, 47, 48, 50, 51, 54, 57, 58, 61, 62, 65], "valueerror": 4, "var": 9, "variabl": [4, 9, 12, 15, 17, 20, 22, 63, 65, 77], "variou": [54, 77], "velo": 7, "venv": 3, "verbos": 47, "veri": [2, 4, 7, 8, 11, 15, 20, 21, 22, 47, 58, 60], "verif": 1, "verifi": [51, 62, 65], "version": [1, 9, 14, 15, 35, 36, 50, 51, 57, 60, 61, 62, 63, 64, 71], "verysimpledevic": [44, 47], "verysimpleinterfac": [44, 47], "verysimplestreaminterfac": 44, "via": [1, 2, 4, 7, 8, 9, 11, 13, 14, 15, 19, 20, 21, 29, 42, 45, 47, 51, 57, 59, 60, 61, 62, 63, 75, 76], "view": 59, "violat": [4, 16, 21], "virtual": [1, 3, 4, 57, 58, 61, 65], "w": 1, "wa": [4, 9, 17, 19, 20, 21, 29, 47, 48, 61, 62, 63, 65], "wai": [1, 2, 4, 7, 8, 9, 11, 14, 18, 19, 20, 21, 58, 62, 75, 76, 77], "wait": [9, 11, 13, 48, 65, 75], "want": [22, 46, 54, 58, 77], "warn": [4, 15, 17, 51, 56, 62, 63, 75], "watch": 3, "waterbath": 61, "we": [58, 59, 61, 65, 77], "well": [1, 4, 14, 15, 60, 61, 62, 75, 76], "were": [8, 9, 59, 60, 62, 64], "what": [1, 2, 4, 9, 15, 58, 61, 62], "wheel": 3, "when": [2, 3, 4, 7, 8, 9, 11, 14, 15, 17, 19, 20, 27, 40, 42, 45, 51, 54, 56, 58, 62, 63, 64, 65, 73, 77], "whenev": [8, 15, 19], "where": [4, 7, 8, 11, 13, 14, 15, 16, 19, 20, 21, 29, 45, 48, 51, 54, 57, 62], "wherea": [4, 7, 9, 19], "whether": [4, 7, 8, 9, 11, 14, 20, 32, 53, 63], "which": [1, 2, 4, 7, 8, 9, 11, 12, 13, 14, 15, 17, 18, 19, 20, 21, 22, 29, 44, 45, 47, 50, 51, 53, 54, 55, 58, 61, 62, 63, 65, 75, 77], "while": [1, 2, 4, 7, 8, 9, 11, 19, 20, 27, 33, 40, 45, 58, 62, 75, 76], "whl": 3, "who": 65, "why": [58, 61, 75], "wide": 1, "wider": 62, "wiki": 4, "wikipedia": 4, "window": [58, 75], "within": [4, 21, 77], "without": [2, 7, 14, 20, 21, 22, 58, 63, 68, 75], "won": 62, "word": [1, 54], "work": [1, 3, 4, 8, 11, 15, 17, 19, 21, 58, 62, 63, 64, 65, 75, 77], "workaround": 21, "workflow": [65, 77], "world": [4, 48, 75], "would": [4, 7, 9, 17, 54, 58, 75, 76, 77], "wrap": [4, 9, 14, 21], "wrapper": [14, 21], "write": [7, 8, 9, 22, 57, 58, 61, 62, 75], "write_pattern": 9, "written": [4, 9, 15], "www": 8, "x": [3, 4, 63], "xp": 32, "y": 3, "yaml": 65, "yet": [4, 14, 61], "you": [4, 17, 46, 48, 54, 57, 58, 75, 77], "your": [4, 54, 58, 62, 77], "z": 3, "zero": 54, "zmq": [13, 14, 51, 75], "\u03b4t": [2, 18]}, "titles": ["API", "Developing Lewis", "Framework Details", "Release Checklist", "Writing Device Simulators", "
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ lewis", "lewis.adapters", "lewis.adapters.epics", "lewis.adapters.modbus", "lewis.adapters.stream", "lewis.core", "lewis.core.adapters", "lewis.core.approaches", "lewis.core.control_client", "lewis.core.control_server", "lewis.core.devices", "lewis.core.exceptions", "lewis.core.logging", "lewis.core.processor", "lewis.core.simulation", "lewis.core.statemachine", "lewis.core.utils", "lewis.devices", "lewis.devices.chopper", "lewis.devices.chopper.devices", "lewis.devices.chopper.devices.bearings", "lewis.devices.chopper.devices.device", "lewis.devices.chopper.devices.states", "lewis.devices.chopper.interfaces", "lewis.devices.chopper.interfaces.epics_interface", "lewis.devices.julabo", "lewis.devices.julabo.devices", "lewis.devices.julabo.devices.device", "lewis.devices.julabo.devices.states", "lewis.devices.julabo.interfaces", "lewis.devices.julabo.interfaces.julabo_stream_interface_1", "lewis.devices.julabo.interfaces.julabo_stream_interface_2", "lewis.devices.linkam_t95", "lewis.devices.linkam_t95.devices", "lewis.devices.linkam_t95.devices.device", "lewis.devices.linkam_t95.devices.states", "lewis.devices.linkam_t95.interfaces", "lewis.devices.linkam_t95.interfaces.stream_interface", "lewis.examples", "lewis.examples.dual_device", "lewis.examples.example_motor", "lewis.examples.modbus_device", "lewis.examples.simple_device", "lewis.examples.timeout_device", "lewis.scripts", "lewis.scripts.control", "lewis.scripts.run", "lewis.utils", "lewis.utils.byte_conversions", "lewis.utils.command_builder", "lewis.utils.constants", "lewis.utils.replies", "Welcome to the Lewis documentation!", "Quickstart Guide", "Release 1.0", "Release 1.0.1", "Release 1.0.2", "Release 1.0.3", "Release 1.1", "Release 1.1.1", "Release 1.2", "Release 1.2.1", "Release 1.2.2", "Release 1.3.0", "Release 1.3.1", "Release 1.3.2", "Release 1.3.3", "Release notes", "Adapter Specifics", "Command line tools", "Remote Access to Devices", "Remote Access to Simulation Parameters", "Usage with Python"], "titleterms": {"0": [59, 60, 61, 62, 68], "1": [59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71], "2": [61, 65, 66, 67, 70], "3": [62, 68, 69, 70, 71], "access": [75, 76], "ad": 4, "adapt": [6, 7, 8, 9, 11, 73], "analysi": 4, "api": [0, 57, 58, 75], "approach": 12, "bear": 25, "bug": [60, 61, 62, 63, 64, 66], "bugfix": 65, "build": 3, "byte_convers": 53, "chang": [3, 62, 65, 68, 69, 70], "checklist": 3, "chopper": [23, 24, 25, 26, 27, 28, 29], "client": [58, 75], "command": [62, 74], "command_build": 54, "commun": 75, "compat": 4, "connect": 58, "constant": 55, "control": [50, 58, 74, 75], "control_cli": 13, "control_serv": 14, "core": [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21], "cycl": 2, "detail": 2, "develop": [1, 57, 65, 68, 69, 70], "devic": [4, 15, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 75], "document": [4, 57, 66], "driven": 2, "dual_devic": 44, "environ": 77, "epic": [7, 73], "epics_interfac": 29, "exampl": [4, 43, 44, 45, 46, 47, 48, 58], "example_motor": 45, "except": 16, "face": 4, "featur": [59, 60, 61, 62, 63, 65, 67], "final": 3, "fix": [60, 61, 62, 63, 64, 66], "framework": [2, 4], "from": 77, "further": 4, "git": 3, "github": 3, "guid": [57, 58, 62, 63], "implement": 4, "improv": [60, 61, 62, 63, 65], "instal": [58, 77], "interfac": [4, 28, 29, 34, 35, 36, 41, 42, 62, 75], "interpret": 75, "julabo": [30, 31, 32, 33, 34, 35, 36], "julabo_stream_interface_1": 35, "julabo_stream_interface_2": 36, "lewi": [1, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 74], "line": [62, 74], "linkam_t95": [37, 38, 39, 40, 41, 42], "log": [4, 17], "merg": 3, "mileston": 3, "modbu": 8, "modbus_devic": 46, "more": 4, "motor": 58, "new": [60, 61, 62, 63, 65, 67], "note": [3, 57, 72], "other": [60, 61, 62, 63, 65], "packag": 3, "paramet": 76, "pip": 77, "prepar": [3, 4], "processor": 18, "pypi": 3, "python": [75, 77], "quickstart": [57, 58], "refer": 57, "releas": [3, 57, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72], "remot": [75, 76], "repli": 56, "run": [51, 58, 77], "script": [49, 50, 51], "setup": 4, "simple_devic": 47, "simul": [4, 19, 76], "sourc": 77, "specif": 73, "state": [27, 33, 40], "statemachin": [2, 20], "step": 4, "stream": [9, 73], "stream_interfac": 42, "syntax": 75, "telnet": 58, "test": [3, 4], "timeout_devic": 48, "tool": 74, "unit": 4, "updat": 3, "upgrad": [62, 63], "upload": 3, "usag": 77, "user": [4, 57], "util": [21, 52, 53, 54, 55, 56], "valu": 75, "version": [3, 4], "via": [58, 77], "virtual": 77, "welcom": 57, "write": 4}})
\ No newline at end of file
diff --git a/user_guide/adapter_specifics.html b/user_guide/adapter_specifics.html
new file mode 100644
index 00000000..186c16fa
--- /dev/null
+++ b/user_guide/adapter_specifics.html
@@ -0,0 +1,172 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/user_guide/command_line_tools.html b/user_guide/command_line_tools.html
new file mode 100644
index 00000000..538d5a0f
--- /dev/null
+++ b/user_guide/command_line_tools.html
@@ -0,0 +1,147 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Adapter Specifics
+EPICS Adapter Specifics
+The EPICS adapter takes only one optional argument:
+-
+
prefix: This string is prefixed to all PV names. Defaults to empty / no prefix.
+
Arguments meant for the adapter can be specified with the adapter options. +For example:
+$ python lewis.py chopper --adapter-options "epics: {prefix: 'SIM2:'}"
+On Linux, this means that EPICS_CA_ADDR_LIST must include this
+networks broadcast address:
$ export EPICS_CA_AUTO_ADDR_LIST=NO
+$ export EPICS_CA_ADDR_LIST=172.17.255.255
+$ export EPICS_CAS_INTF_ADDR_LIST=localhost
+Stream Adapter Specifics
+The TCP Stream adapter has the following optional arguments:
+-
+
bind_address: Address of network adapter to listen on. +Defaults to “0.0.0.0” (all network adapters).
+port: Port to listen for connections on. Defaults to 9999.
+telnet_mode: When True, overrides both in and out terminators +to CRNL for telnet compatibility. Defaults to False.
+
Arguments meant for the adapter can be specified with the adapter options. +For example:
+$ python lewis.py linkam_t95 -p "stream: {bind_address: localhost, port: 1234}"
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/user_guide/remote_access_devices.html b/user_guide/remote_access_devices.html
new file mode 100644
index 00000000..54da18f0
--- /dev/null
+++ b/user_guide/remote_access_devices.html
@@ -0,0 +1,290 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/user_guide/remote_access_simulation.html b/user_guide/remote_access_simulation.html
new file mode 100644
index 00000000..a995b0ad
--- /dev/null
+++ b/user_guide/remote_access_simulation.html
@@ -0,0 +1,170 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Remote Access to Devices
+Please note that this functionality should only be used on a trusted +network.
+Besides the device specific protocols, the device can be made accessible
+from the outside via JSON-RPC over ZMQ. This can be achieved by passing
+the -r option with a host:port string to the simulation:
$ lewis chopper -r 127.0.0.1:10000 -p "epics: {prefix: 'SIM:'}"
+Now the device can be controlled via the lewis-control.py-script
+in a different terminal window. The service can be queried to show the
+available objects by not supplying an object name:
$ lewis-control -r 127.0.0.1:10000
+The -r (or --rpc-host) option defaults to the value shown here,
+so it will be omitted in the following examples. To get information on
+the API of an object, supplying an object name without a property or
+method will list the object’s API:
$ lewis-control device
+This will output a list of properties and methods which is available for +remote access. This may not comprise the full interface of the object +depending on the server side configuration. Obtaining the value of a +property is done like this:
+$ lewis-control device state
+The same syntax is used to call methods without parameters:
+$ lewis-control device initialize
+To set a property to a new value, the value has to be supplied on the +command line:
+$ lewis-control device target_speed 100
+$ lewis-control device start
+It is possible to set multiple device parameters at once, but this goes through the simulation +itself, so that it is generic to all devices:
+$ lewis-control simulation set_device_parameters "{'target_speed': 1, 'target_phase': 20}"
+Another case of device-related access to the simulation is switching the setup. To obtain a +list of available setups, the following command is available:
+$ lewis-control simulation setups
+It is then possible to switch the setup to one from the list, assuming it is called new_setup:
$ lewis-control simulation switch_setup new_setup
+The setup switching process is logged.
+Accessing the Device Communication Interface
+Just as device model and communication interface are separate concepts in Lewis, these interfaces +can be controlled separately as well.
+To query the available communication protocols, the following command is available:
+$ lewis-control interface protocols
+This will list all communication protocols that are currently exposing device behavior. +The following methods are available for interacting with the communication interfaces:
+$ lewis-control interface disconnect
+$ lewis-control interface connect
+$ lewis-control interface is_connected
+$ lewis-control interface documentation
+Without any arguments, these methods will affect all of the device’s interfaces, but specifying
+any number of valid protocol names will limit the method to those protocols. Assuming a device
+has two interfaces, one for the stream protocol and one for epics, the following sequence
+would disconnect both, but then only reconnect the stream-adapter:
$ lewis-control interface disconnect
+$ lewis-control interface connect stream
+$ lewis-control interface is_connected stream
+True
+$ lewis-control interface is_connected
+{'stream': True, 'epics': False}
+Disconnecting is essentially the equivalent of “cutting the cable”, no new connections +will be accepted and existing ones will be terminated.
+To find out how to interact with any device via its usual communication channels a way would be:
+$ lewis-control interface protocol
+['stream', 'epics']
+$ lewis-control interface documentation epics
+[ ... long description of protocol ... ]
+Value Interpretation and Syntax
+lewis_control interprets values as built-in Python literals or containers using
+ast.literal_eval. This means any
+syntax for literal evaluation supported by Python works here as well. The following are all valid
+values which are interpreted as you might expect:
$ lewis-control device float_value 12.0
+$ lewis-control device float_value .5
+$ lewis-control device float_value 1.23e10
+$ lewis-control device int_value 123
+$ lewis-control device int_value 0xDEADBEEF
+$ lewis-control device int_value 010 # Value of 8 in base 8 (octal)
+$ lewis-control device str_value hello_world
+$ lewis-control device method_call_with_two_string_args hello world
+$ lewis-control device str_value "hello world"
+$ lewis-control device unicode_value "u'hello_world'"
+$ lewis-control device list_value "[1,2,3]"
+$ lewis-control device list_value "['a', 'b', 'c']"
+$ lewis-control device dict_value "{'a': 1, 'b': 2}"
+WARNING: Any value that cannot be successfully evaluated is silently converted into a +string literal instead! The following attempts turn into strings because the letters +are not quoted:
+$ lewis-control device str_value_looks_like_dict "{a: 1, b: 2}"
+$ lewis-control device str_value_looks_like_list "[a, b, c]"
+This is done for convenience, to avoid having to double quote and/or escape quote trivial string +values to match Python syntax while also taking shell quotation and escapes into account. But it +can lead to unexpected results at times.
+Control Client Python API
+For use cases that require more flexibility and control, it is advised to write a Python script
+using the API provided in lewis.core.control_client instead of using the command line utility.
+This makes it possible to use the remote objects in a fairly transparent fashion.
Here is a brief example using the chopper device:
from time import sleep
+from lewis.core.control_client import ControlClient
+
+client = ControlClient(host='127.0.0.1', port='10000')
+chopper = client.get_object('device')
+
+chopper.target_speed = 100
+chopper.initialize()
+
+while chopper.state != 'stopped':
+ sleep(0.1)
+
+chopper.start()
+All calls, reads and assignments are synchronous and blocking in terms of the methods and +attributes they access on the server. However, much like with real devices, the behaviour of the +simulated device is asynchronous from its interface. Consequently, depending on the specific +device, some effects of calling a method may take place long after the method is called (and +returns).
+This is why, in the above example, a loop is used to wait for chopper.state to change in
+response to the chopper.initialize() call.
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/user_guide/usage_with_python.html b/user_guide/usage_with_python.html
new file mode 100644
index 00000000..a14f9c8b
--- /dev/null
+++ b/user_guide/usage_with_python.html
@@ -0,0 +1,239 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Remote Access to Simulation Parameters
+Please note that this functionality should only be used on a trusted +network.
+Certain control over the simulation is also exposed in the shape of an
+object named simulation if Lewis is started with -r. The
+simulation can be paused and resumed using the control script:
$ lewis-control simulation pause
+$ lewis-control simulation resume
+With these commands, the simulation is paused, while the communication +with the device remains responsive. The communication channel (for +example TCP stream server) would still respond to queries and commands, +but they would not be processed by the device.
+The speed of the simulation can be adjusted as well, along with the
+number of cycles that are processed per second (via the cycle_delay
+parameter).
$ lewis-control simulation speed 10
+$ lewis-control simulation cycle_delay 0.05
+This will cause the twice as many cycles per second to be computed +compared to the default, and the simulation runs ten times faster than +actual time.
+It’s also possible to obtain some information about the simulation, for +example how long it has been running and how much simulated time has +passed:
+$ lewis-control simulation uptime
+$ lewis-control simulation runtime
+Finally, the simulation can also be stopped:
+$ lewis-control simulation stop
+It is not possible to recover from that, as the processing of remote +commands stops as well. The only way to restart the simulation is to run +Lewis again with the same parameters.
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Usage with Python
+To use Lewis directly via Python you must first install its dependencies:
+-
+
Python 3.6+
+pip (latest)
+
On most linux systems these can be installed via the distribution’s package manager.
+Virtual environments
+We recommend using a virtual environment.
+Installation via pip
+Lewis is available on the Python Package Index <https://pypi.python.org/pypi/lewis>__. That means
+it can be installed using pip:
$ pip install lewis
+This will install lewis along with its dependencies. If you would like to use EPICS based devices +and have a working EPICS environment on your machine, you can install it like this to get the +additional required dependencies:
+$ pip install lewis[epics]
+This will install two scripts in the path, lewis and lewis-control. Both scripts provide
+command line help:
$ lewis --help
+$ lewis-control --help
+To list available devices, just type lewis in the command line, a list of devices that are
+available for simulation will be printed.
All following sections of this user manual assume that Lewis has been installed via pip and that
+the lewis command is available.
Installation from source
+Clone the repository in a location of your choice, we recommend that you do it inside a virtual +environment so that you can keep track of the dependencies:
+$ git clone https://github.com/ISISComputingGroup/lewis.git
+If you do not have git available, you can
+also download this repository as an archive and unpack it somewhere. A
+few additional dependencies must be installed. This can be done through
+pip in the top level directory of Lewis, which contains the setup.py-file:
$ pip install .
+Note: There are a few optional dependencies for certain adapter types. Currently the only
+optional dependency is pcaspy for using devices with an EPICS interface, it requires a
+working installation of EPICS base. Please refer to the installation instructions <https://pcaspy.readthedocs.io/en/latest/installation.html>__ of the module.
+To include pcaspy in the installation of dependencies, use:
$ pip install ".[epics]"
+If you also want to develop Lewis, the workflow is a bit different. Please refer to the
+developer_guide for details.
If you want to use the EPICS adapter, you will also need to configure a few more +EPICS environment variables correctly. If you only want to communicate +using EPICS locally via the loopback device, you can configure it like +this:
+$ export EPICS_CA_AUTO_ADDR_LIST=NO
+$ export EPICS_CA_ADDR_LIST=localhost
+$ export EPICS_CAS_INTF_ADDR_LIST=localhost
+Once all dependencies and requirements are satisfied, Lewis can be +run using the following general format (from inside the Lewis +directory):
+$ python -m lewis device_name [arguments]
+You can then run Lewis as follows (from within the lewis +directory):
+$ python -m lewis chopper -p epics
+Details about parameters for the various adapters, and differences +between OSes are covered in the “Adapter Specifics” sections.
+If you decided to install Lewis this way, please be aware that the lewis and lewis-control
+calls in the other parts of the guide have to be replaced with python lewis.py.
Running from source
+Lewis can be run directly from source. First it is necessary to install the basic requirements:
+$ pip install -r requirements.txt
+If you would like to use EPICS based devices
+and have a working EPICS environment on your machine then it is necessary to install pcaspy like so:
$ pip install pcaspy
+There are Python scripts for running both lewis and lewis-control in the top-level scripts directory.
+These scripts work exactly the same as when Lewis is installed via pip (see above). For example:
$ python scripts/lewis.py --help
+$ python scripts/lewis-control.py --help
+