diff --git a/MANIFEST.in b/MANIFEST.in
index effeba85e50cc66b09c0064947452882e11229dc..0fcf6da91e58b2c84d3c7d1d73c12df6c785b429 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -11,17 +11,16 @@ graft kadmos/utilities/cmdows
graft kadmos/cmdows/schemas
# Include current vispack templates
-graft kadmos/vispack/KADMOS_VisualizationPackage_170419
-graft kadmos/vispack/KADMOS_VisualizationPackage_170523
-graft kadmos/vispack/KADMOS_VisualizationPackage_170530
+graft kadmos/vispack/VISTOMS_170803
+graft kadmos/vispack/VISTOMS_170814
+graft kadmos/vispack/VISTOMS_170817
# Include XDSM templates
include kadmos/external/XDSM_writer/*.tex
# Include examples (except VISPACK dirs)
graft examples
-prune examples/scripts/tu_delft_wing_design/VISPACK
-prune examples/scripts/tu_delft_wing_design/VISPACK_RCG
+prune examples/scripts/tu_delft_wing_design/VISTOMS
# Include documentation
graft doc
diff --git a/dist/kadmos-0.6.dev0-py2-none-any.whl b/dist/kadmos-0.6.dev0-py2-none-any.whl
deleted file mode 100644
index 29aa48eff678a5788e57af4224b3b0946a0a28fa..0000000000000000000000000000000000000000
Binary files a/dist/kadmos-0.6.dev0-py2-none-any.whl and /dev/null differ
diff --git a/dist/kadmos-0.6.dev0.tar.gz.REMOVED.git-id b/dist/kadmos-0.6.dev0.tar.gz.REMOVED.git-id
deleted file mode 100644
index a767b03b82519bb8db075db4472d93f5e04228e4..0000000000000000000000000000000000000000
--- a/dist/kadmos-0.6.dev0.tar.gz.REMOVED.git-id
+++ /dev/null
@@ -1 +0,0 @@
-fc56ae87a8b345c34011af239679634e2e4b155a
\ No newline at end of file
diff --git a/dist/kadmos-0.7.dev0-py2-none-any.whl b/dist/kadmos-0.7.dev0-py2-none-any.whl
new file mode 100644
index 0000000000000000000000000000000000000000..b85d737628a236aaa330e621c95039977f9de5f1
Binary files /dev/null and b/dist/kadmos-0.7.dev0-py2-none-any.whl differ
diff --git a/dist/kadmos-0.7.dev0.tar.gz.REMOVED.git-id b/dist/kadmos-0.7.dev0.tar.gz.REMOVED.git-id
new file mode 100644
index 0000000000000000000000000000000000000000..d880aabc4c83e9518d48219ede7542c5582b3144
--- /dev/null
+++ b/dist/kadmos-0.7.dev0.tar.gz.REMOVED.git-id
@@ -0,0 +1 @@
+4e6214bd905b3a3a1f82fa803626f29336b60136
\ No newline at end of file
diff --git a/doc/.buildinfo b/doc/.buildinfo
index d369398ec4b4b04c32728c71fe29a2bed5ab9322..cc852529641ecf50bcf9511f921a483c72310e37 100644
--- a/doc/.buildinfo
+++ b/doc/.buildinfo
@@ -1,4 +1,4 @@
# Sphinx build info version 1
# This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
-config: 929c4db299fcb874e42fef4fa5014a8b
+config: 2c86b0e15511d484dfbeb893e27a3cae
tags: 645f666f9bcd5a90fca523b33c5a78b7
diff --git a/doc/.doctrees/KADMOS.doctree b/doc/.doctrees/KADMOS.doctree
index 7d921b932e4c3ae8c8e8ff37d351fd137ba04b02..d2bb63de5a3d12c3732c593637bbbd72bd8c055a 100644
Binary files a/doc/.doctrees/KADMOS.doctree and b/doc/.doctrees/KADMOS.doctree differ
diff --git a/doc/.doctrees/environment.pickle b/doc/.doctrees/environment.pickle
index a11734ecb05aec103d6b2c31c067118d5ed57251..d376d79fbf72530a94ac87ebdb2a051749cb06e9 100644
Binary files a/doc/.doctrees/environment.pickle and b/doc/.doctrees/environment.pickle differ
diff --git a/doc/KADMOS.html b/doc/KADMOS.html
index 6791e961ac8c17d9804a55d0fb18839e2150afad..d25b266d6a047556e2dd910a86ab7939539b937b 100644
--- a/doc/KADMOS.html
+++ b/doc/KADMOS.html
@@ -48,14 +48,14 @@
<h1>Welcome to KADMOS’s documentation!<a class="headerlink" href="#welcome-to-kadmos-s-documentation" title="Permalink to this headline">¶</a></h1>
<p>See sidebar on the right for the table of contents.</p>
<ul class="simple">
-<li><a class="reference internal" href="genindex.html"><span>Index</span></a></li>
-<li><a class="reference internal" href="py-modindex.html"><span>Module Index</span></a></li>
-<li><a class="reference internal" href="search.html"><span>Search Page</span></a></li>
+<li><a class="reference internal" href="genindex.html"><span class="std std-ref">Index</span></a></li>
+<li><a class="reference internal" href="py-modindex.html"><span class="std std-ref">Module Index</span></a></li>
+<li><a class="reference internal" href="search.html"><span class="std std-ref">Search Page</span></a></li>
</ul>
</div>
<div class="section" id="module-kadmos">
<span id="documentation-for-the-code"></span><h1>Documentation for the Code<a class="headerlink" href="#module-kadmos" title="Permalink to this headline">¶</a></h1>
-<p>Below the simplified class diagram of the KADMOS package is shown (not all methods are included for clarity). The UML can als be downloaded as PDF <a class="reference download internal" href="_downloads/KADMOS_UML.pdf"><code class="xref download docutils literal"><span class="pre">here</span></code></a>.</p>
+<p>Below the simplified class diagram of the KADMOS package is shown (not all methods are included for clarity). The UML can als be downloaded as PDF <a class="reference download internal" href="_downloads/KADMOS_UML.pdf" download=""><code class="xref download docutils literal"><span class="pre">here</span></code></a>.</p>
<a class="reference internal image-reference" href="_images/KADMOS_UML.png"><img alt="_images/KADMOS_UML.png" class="align-center" src="_images/KADMOS_UML.png" style="width: 90%;" /></a>
<p>Example scripts for using KADMOS are available in the examples/scripts folder. The following scripts are available there:</p>
<ul class="simple">
@@ -82,11 +82,11 @@
<dt>nodes: iterable container</dt>
<dd>A container of nodes. A cycle will be constructed from
the nodes (in order) and added to the graph.</dd>
-<dt>attr <span class="classifier-delimiter">:</span> <span class="classifier">keyword arguments, optional (default= no attributes)</span></dt>
-<dd>Attributes to add to every edge in cycle.</dd>
+<dt>attr</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">keyword arguments, optional (default= no attributes)</span><dd>Attributes to add to every edge in cycle.</dd>
</dl>
<p>add_path, add_star</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span><span class="o">=</span><span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span><span class="o">=</span><span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_cycle</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_cycle</span><span class="p">([</span><span class="mi">10</span><span class="p">,</span><span class="mi">11</span><span class="p">,</span><span class="mi">12</span><span class="p">],</span><span class="n">weight</span><span class="o">=</span><span class="mi">7</span><span class="p">)</span>
</pre></div>
@@ -134,14 +134,14 @@ not already in the graph.</p>
<p>Edge attributes can be specified with keywords or by providing
a dictionary with key/value pairs. See examples below.</p>
<dl class="docutils">
-<dt>u, v <span class="classifier-delimiter">:</span> <span class="classifier">nodes</span></dt>
-<dd>Nodes can be, for example, strings or numbers.
+<dt>u, v</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">nodes</span><dd>Nodes can be, for example, strings or numbers.
Nodes must be hashable (and not None) Python objects.</dd>
-<dt>attr_dict <span class="classifier-delimiter">:</span> <span class="classifier">dictionary, optional (default= no attributes)</span></dt>
-<dd>Dictionary of edge attributes. Key/value pairs will
+<dt>attr_dict</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">dictionary, optional (default= no attributes)</span><dd>Dictionary of edge attributes. Key/value pairs will
update existing data associated with the edge.</dd>
-<dt>attr <span class="classifier-delimiter">:</span> <span class="classifier">keyword arguments, optional</span></dt>
-<dd>Edge data (or labels or objects) can be assigned using
+<dt>attr</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">keyword arguments, optional</span><dd>Edge data (or labels or objects) can be assigned using
keyword arguments.</dd>
</dl>
<p>add_edges_from : add a collection of edges</p>
@@ -150,7 +150,7 @@ keyword arguments.</dd>
the edge weight a numerical value assigned to a keyword
which by default is ‘weight’.</p>
<p>The following all add the edge e=(1,2) to graph G:</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">e</span> <span class="o">=</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_edge</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span> <span class="c1"># explicit two-node form</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_edge</span><span class="p">(</span><span class="o">*</span><span class="n">e</span><span class="p">)</span> <span class="c1"># single edge as tuple of two nodes</span>
@@ -158,7 +158,7 @@ which by default is ‘weight’.</p>
</pre></div>
</div>
<p>Associate data to edges using keywords:</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_edge</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="n">weight</span><span class="o">=</span><span class="mi">3</span><span class="p">)</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_edge</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="n">weight</span><span class="o">=</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_edge</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="n">weight</span><span class="o">=</span><span class="mi">7</span><span class="p">,</span> <span class="n">capacity</span><span class="o">=</span><span class="mi">15</span><span class="p">,</span> <span class="n">length</span><span class="o">=</span><span class="mf">342.7</span><span class="p">)</span>
</pre></div>
</div>
@@ -169,16 +169,16 @@ which by default is ‘weight’.</p>
<code class="descname">add_edges_from</code><span class="sig-paren">(</span><em>ebunch</em>, <em>attr_dict=None</em>, <em>**attr</em><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.graph.KadmosGraph.add_edges_from" title="Permalink to this definition">¶</a></dt>
<dd><p>Add all the edges in ebunch.</p>
<dl class="docutils">
-<dt>ebunch <span class="classifier-delimiter">:</span> <span class="classifier">container of edges</span></dt>
-<dd>Each edge given in the container will be added to the
+<dt>ebunch</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">container of edges</span><dd>Each edge given in the container will be added to the
graph. The edges must be given as as 2-tuples (u,v) or
3-tuples (u,v,d) where d is a dictionary containing edge
data.</dd>
-<dt>attr_dict <span class="classifier-delimiter">:</span> <span class="classifier">dictionary, optional (default= no attributes)</span></dt>
-<dd>Dictionary of edge attributes. Key/value pairs will
+<dt>attr_dict</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">dictionary, optional (default= no attributes)</span><dd>Dictionary of edge attributes. Key/value pairs will
update existing data associated with each edge.</dd>
-<dt>attr <span class="classifier-delimiter">:</span> <span class="classifier">keyword arguments, optional</span></dt>
-<dd>Edge data (or labels or objects) can be assigned using
+<dt>attr</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">keyword arguments, optional</span><dd>Edge data (or labels or objects) can be assigned using
keyword arguments.</dd>
</dl>
<p>add_edge : add a single edge
@@ -187,14 +187,14 @@ add_weighted_edges_from : convenient way to add weighted edges</p>
will be updated when each duplicate edge is added.</p>
<p>Edge attributes specified in edges take precedence
over attributes specified generally.</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_edges_from</span><span class="p">([(</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">),(</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">)])</span> <span class="c1"># using a list of edge tuples</span>
<span class="gp">>>> </span><span class="n">e</span> <span class="o">=</span> <span class="nb">zip</span><span class="p">(</span><span class="nb">range</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">3</span><span class="p">),</span><span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">4</span><span class="p">))</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_edges_from</span><span class="p">(</span><span class="n">e</span><span class="p">)</span> <span class="c1"># Add the path graph 0-1-2-3</span>
</pre></div>
</div>
<p>Associate data to edges</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_edges_from</span><span class="p">([(</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">),(</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">)],</span> <span class="n">weight</span><span class="o">=</span><span class="mi">3</span><span class="p">)</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_edges_from</span><span class="p">([(</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">),(</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">)],</span> <span class="n">weight</span><span class="o">=</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_edges_from</span><span class="p">([(</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">),(</span><span class="mi">1</span><span class="p">,</span><span class="mi">4</span><span class="p">)],</span> <span class="n">label</span><span class="o">=</span><span class="s1">'WN2898'</span><span class="p">)</span>
</pre></div>
</div>
@@ -262,59 +262,23 @@ over attributes specified generally.</p>
</table>
</dd></dl>
-<dl class="method">
-<dt id="kadmos.graph.KadmosGraph.add_node">
-<code class="descname">add_node</code><span class="sig-paren">(</span><em>n</em>, <em>attr_dict=None</em>, <em>**attr</em><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.graph.KadmosGraph.add_node" title="Permalink to this definition">¶</a></dt>
-<dd><p>Add a single node n and update node attributes.</p>
-<dl class="docutils">
-<dt>n <span class="classifier-delimiter">:</span> <span class="classifier">node</span></dt>
-<dd>A node can be any hashable Python object except None.</dd>
-<dt>attr_dict <span class="classifier-delimiter">:</span> <span class="classifier">dictionary, optional (default= no attributes)</span></dt>
-<dd>Dictionary of node attributes. Key/value pairs will
-update existing data associated with the node.</dd>
-<dt>attr <span class="classifier-delimiter">:</span> <span class="classifier">keyword arguments, optional</span></dt>
-<dd>Set or change attributes using key=value.</dd>
-</dl>
-<p>add_nodes_from</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
-<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_node</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
-<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_node</span><span class="p">(</span><span class="s1">'Hello'</span><span class="p">)</span>
-<span class="gp">>>> </span><span class="n">K3</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">([(</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">),(</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">),(</span><span class="mi">2</span><span class="p">,</span><span class="mi">0</span><span class="p">)])</span>
-<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_node</span><span class="p">(</span><span class="n">K3</span><span class="p">)</span>
-<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">number_of_nodes</span><span class="p">()</span>
-<span class="go">3</span>
-</pre></div>
-</div>
-<p>Use keywords set/change node attributes:</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_node</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="n">size</span><span class="o">=</span><span class="mi">10</span><span class="p">)</span>
-<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_node</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span><span class="n">weight</span><span class="o">=</span><span class="mf">0.4</span><span class="p">,</span><span class="n">UTM</span><span class="o">=</span><span class="p">(</span><span class="s1">'13S'</span><span class="p">,</span><span class="mi">382871</span><span class="p">,</span><span class="mi">3972649</span><span class="p">))</span>
-</pre></div>
-</div>
-<p>A hashable object is one that can be used as a key in a Python
-dictionary. This includes strings, numbers, tuples of strings
-and numbers, etc.</p>
-<p>On many platforms hashable items also include mutables such as
-NetworkX Graphs, though one should be careful that the hash
-doesn’t change on mutables.</p>
-</dd></dl>
-
<dl class="method">
<dt id="kadmos.graph.KadmosGraph.add_nodes_from">
<code class="descname">add_nodes_from</code><span class="sig-paren">(</span><em>nodes</em>, <em>**attr</em><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.graph.KadmosGraph.add_nodes_from" title="Permalink to this definition">¶</a></dt>
<dd><p>Add multiple nodes.</p>
<dl class="docutils">
-<dt>nodes <span class="classifier-delimiter">:</span> <span class="classifier">iterable container</span></dt>
-<dd>A container of nodes (list, dict, set, etc.).
+<dt>nodes</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">iterable container</span><dd>A container of nodes (list, dict, set, etc.).
OR
A container of (node, attribute dict) tuples.
Node attributes are updated using the attribute dict.</dd>
-<dt>attr <span class="classifier-delimiter">:</span> <span class="classifier">keyword arguments, optional (default= no attributes)</span></dt>
-<dd>Update attributes for all nodes in nodes.
+<dt>attr</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">keyword arguments, optional (default= no attributes)</span><dd>Update attributes for all nodes in nodes.
Node attributes specified in nodes as a tuple
take precedence over attributes specified generally.</dd>
</dl>
<p>add_node</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_nodes_from</span><span class="p">(</span><span class="s1">'Hello'</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">K3</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">([(</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">),(</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">),(</span><span class="mi">2</span><span class="p">,</span><span class="mi">0</span><span class="p">)])</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_nodes_from</span><span class="p">(</span><span class="n">K3</span><span class="p">)</span>
@@ -323,17 +287,17 @@ take precedence over attributes specified generally.</dd>
</pre></div>
</div>
<p>Use keywords to update specific node attributes for every node.</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_nodes_from</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">],</span> <span class="n">size</span><span class="o">=</span><span class="mi">10</span><span class="p">)</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_nodes_from</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">],</span> <span class="n">size</span><span class="o">=</span><span class="mi">10</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_nodes_from</span><span class="p">([</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">],</span> <span class="n">weight</span><span class="o">=</span><span class="mf">0.4</span><span class="p">)</span>
</pre></div>
</div>
<p>Use (node, attrdict) tuples to update attributes for specific
nodes.</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_nodes_from</span><span class="p">([(</span><span class="mi">1</span><span class="p">,</span><span class="nb">dict</span><span class="p">(</span><span class="n">size</span><span class="o">=</span><span class="mi">11</span><span class="p">)),</span> <span class="p">(</span><span class="mi">2</span><span class="p">,{</span><span class="s1">'color'</span><span class="p">:</span><span class="s1">'blue'</span><span class="p">})])</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_nodes_from</span><span class="p">([(</span><span class="mi">1</span><span class="p">,</span><span class="nb">dict</span><span class="p">(</span><span class="n">size</span><span class="o">=</span><span class="mi">11</span><span class="p">)),</span> <span class="p">(</span><span class="mi">2</span><span class="p">,{</span><span class="s1">'color'</span><span class="p">:</span><span class="s1">'blue'</span><span class="p">})])</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">node</span><span class="p">[</span><span class="mi">1</span><span class="p">][</span><span class="s1">'size'</span><span class="p">]</span>
<span class="go">11</span>
<span class="gp">>>> </span><span class="n">H</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span>
-<span class="gp">>>> </span><span class="n">H</span><span class="o">.</span><span class="n">add_nodes_from</span><span class="p">(</span><span class="n">G</span><span class="o">.</span><span class="n">nodes</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="bp">True</span><span class="p">))</span>
+<span class="gp">>>> </span><span class="n">H</span><span class="o">.</span><span class="n">add_nodes_from</span><span class="p">(</span><span class="n">G</span><span class="o">.</span><span class="n">nodes</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="kc">True</span><span class="p">))</span>
<span class="gp">>>> </span><span class="n">H</span><span class="o">.</span><span class="n">node</span><span class="p">[</span><span class="mi">1</span><span class="p">][</span><span class="s1">'size'</span><span class="p">]</span>
<span class="go">11</span>
</pre></div>
@@ -380,14 +344,14 @@ MyGraph.add_objective_function_by_nodes(unnamed_function, My_obj_fcn_name = name
<code class="descname">add_path</code><span class="sig-paren">(</span><em>nodes</em>, <em>**attr</em><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.graph.KadmosGraph.add_path" title="Permalink to this definition">¶</a></dt>
<dd><p>Add a path.</p>
<dl class="docutils">
-<dt>nodes <span class="classifier-delimiter">:</span> <span class="classifier">iterable container</span></dt>
-<dd>A container of nodes. A path will be constructed from
+<dt>nodes</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">iterable container</span><dd>A container of nodes. A path will be constructed from
the nodes (in order) and added to the graph.</dd>
-<dt>attr <span class="classifier-delimiter">:</span> <span class="classifier">keyword arguments, optional (default= no attributes)</span></dt>
-<dd>Attributes to add to every edge in path.</dd>
+<dt>attr</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">keyword arguments, optional (default= no attributes)</span><dd>Attributes to add to every edge in path.</dd>
</dl>
<p>add_star, add_cycle</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span><span class="o">=</span><span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span><span class="o">=</span><span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">10</span><span class="p">,</span><span class="mi">11</span><span class="p">,</span><span class="mi">12</span><span class="p">],</span><span class="n">weight</span><span class="o">=</span><span class="mi">7</span><span class="p">)</span>
</pre></div>
@@ -401,13 +365,13 @@ the nodes (in order) and added to the graph.</dd>
<p>The first node in nodes is the middle of the star. It is connected
to all other nodes.</p>
<dl class="docutils">
-<dt>nodes <span class="classifier-delimiter">:</span> <span class="classifier">iterable container</span></dt>
-<dd>A container of nodes.</dd>
-<dt>attr <span class="classifier-delimiter">:</span> <span class="classifier">keyword arguments, optional (default= no attributes)</span></dt>
-<dd>Attributes to add to every edge in star.</dd>
+<dt>nodes</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">iterable container</span><dd>A container of nodes.</dd>
+<dt>attr</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">keyword arguments, optional (default= no attributes)</span><dd>Attributes to add to every edge in star.</dd>
</dl>
<p>add_path, add_cycle</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_star</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_star</span><span class="p">([</span><span class="mi">10</span><span class="p">,</span><span class="mi">11</span><span class="p">,</span><span class="mi">12</span><span class="p">],</span><span class="n">weight</span><span class="o">=</span><span class="mi">2</span><span class="p">)</span>
</pre></div>
@@ -420,21 +384,21 @@ to all other nodes.</p>
<dd><p>Add all the edges in ebunch as weighted edges with specified
weights.</p>
<dl class="docutils">
-<dt>ebunch <span class="classifier-delimiter">:</span> <span class="classifier">container of edges</span></dt>
-<dd>Each edge given in the list or container will be added
+<dt>ebunch</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">container of edges</span><dd>Each edge given in the list or container will be added
to the graph. The edges must be given as 3-tuples (u,v,w)
where w is a number.</dd>
-<dt>weight <span class="classifier-delimiter">:</span> <span class="classifier">string, optional (default= ‘weight’)</span></dt>
-<dd>The attribute name for the edge weights to be added.</dd>
-<dt>attr <span class="classifier-delimiter">:</span> <span class="classifier">keyword arguments, optional (default= no attributes)</span></dt>
-<dd>Edge attributes to add/update for all edges.</dd>
+<dt>weight</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">string, optional (default= ‘weight’)</span><dd>The attribute name for the edge weights to be added.</dd>
+<dt>attr</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">keyword arguments, optional (default= no attributes)</span><dd>Edge attributes to add/update for all edges.</dd>
</dl>
<p>add_edge : add a single edge
add_edges_from : add multiple edges</p>
<p>Adding the same edge twice for Graph/DiGraph simply updates
the edge data. For MultiGraph/MultiDiGraph, duplicate edges
are stored.</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_weighted_edges_from</span><span class="p">([(</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mf">3.0</span><span class="p">),(</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mf">7.5</span><span class="p">)])</span>
</pre></div>
</div>
@@ -447,12 +411,12 @@ are stored.</p>
<p>This is the fastest way to look at every edge.
For directed graphs, only outgoing adjacencies are included.</p>
<dl class="docutils">
-<dt>adj_iter <span class="classifier-delimiter">:</span> <span class="classifier">iterator</span></dt>
-<dd>An iterator of (node, adjacency dictionary) for all nodes in
+<dt>adj_iter</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">iterator</span><dd>An iterator of (node, adjacency dictionary) for all nodes in
the graph.</dd>
</dl>
<p>adjacency_list</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">])</span>
<span class="gp">>>> </span><span class="p">[(</span><span class="n">n</span><span class="p">,</span><span class="n">nbrdict</span><span class="p">)</span> <span class="k">for</span> <span class="n">n</span><span class="p">,</span><span class="n">nbrdict</span> <span class="ow">in</span> <span class="n">G</span><span class="o">.</span><span class="n">adjacency_iter</span><span class="p">()]</span>
<span class="go">[(0, {1: {}}), (1, {0: {}, 2: {}}), (2, {1: {}, 3: {}}), (3, {2: {}})]</span>
@@ -467,11 +431,11 @@ the graph.</dd>
<p>The output adjacency list is in the order of G.nodes().
For directed graphs, only outgoing adjacencies are included.</p>
<dl class="docutils">
-<dt>adj_list <span class="classifier-delimiter">:</span> <span class="classifier">lists of lists</span></dt>
-<dd>The adjacency structure of the graph as a list of lists.</dd>
+<dt>adj_list</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">lists of lists</span><dd>The adjacency structure of the graph as a list of lists.</dd>
</dl>
<p>adjacency_iter</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">adjacency_list</span><span class="p">()</span> <span class="c1"># in order given by G.nodes()</span>
<span class="go">[[1], [0, 2], [1, 3], [2]]</span>
@@ -509,7 +473,7 @@ defined below and are then further refined in child classes.</p>
<dl class="method">
<dt id="kadmos.graph.KadmosGraph.check_cmdows_integrity">
-<code class="descname">check_cmdows_integrity</code><span class="sig-paren">(</span><em>mpg=None</em><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.graph.KadmosGraph.check_cmdows_integrity" title="Permalink to this definition">¶</a></dt>
+<code class="descname">check_cmdows_integrity</code><span class="sig-paren">(</span><em>convention=True</em>, <em>mpg=None</em><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.graph.KadmosGraph.check_cmdows_integrity" title="Permalink to this definition">¶</a></dt>
<dd><p>Method to check the integrity of the CMDOWS file that can be created with the save method.</p>
<p>The integrity check is graph specific and thus needs to be executed for every graph before saving as CMDOWS if
one wants to be sure that the CMDOWS file is integer. Due to its relative long runtime this check is however not
@@ -518,11 +482,17 @@ performed automatically when using the save method.</p>
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
-<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>mpg</strong> (<a class="reference internal" href="#kadmos.graph.MdaoProcessGraph" title="kadmos.graph.MdaoProcessGraph"><em>MdaoProcessGraph</em></a>) – MPG to be saved together with graph</td>
+<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
+<li><strong>convention</strong> (<em>bool</em>) – option for applying a UID convention</li>
+<li><strong>mpg</strong> (<a class="reference internal" href="#kadmos.graph.MdaoProcessGraph" title="kadmos.graph.MdaoProcessGraph"><em>MdaoProcessGraph</em></a>) – MPG to be saved together with graph</li>
+</ul>
+</td>
</tr>
-<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body">check result</td>
+<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">check result</p>
+</td>
</tr>
-<tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body">bool</td>
+<tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last">bool</p>
+</td>
</tr>
</tbody>
</table>
@@ -577,7 +547,7 @@ The graph class is kept.</p>
<code class="descname">clear</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.graph.KadmosGraph.clear" title="Permalink to this definition">¶</a></dt>
<dd><p>Remove all nodes and edges from the graph.</p>
<p>This also removes the name, and all graph, node, and edge attributes.</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">clear</span><span class="p">()</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">nodes</span><span class="p">()</span>
@@ -593,13 +563,13 @@ The graph class is kept.</p>
<code class="descname">copy</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.graph.KadmosGraph.copy" title="Permalink to this definition">¶</a></dt>
<dd><p>Return a copy of the graph.</p>
<dl class="docutils">
-<dt>G <span class="classifier-delimiter">:</span> <span class="classifier">Graph</span></dt>
-<dd>A copy of the graph.</dd>
+<dt>G</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">Graph</span><dd>A copy of the graph.</dd>
</dl>
<p>to_directed: return a directed copy of the graph.</p>
<p>This makes a complete copy of the graph including all of the
node or edge attributes.</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">H</span> <span class="o">=</span> <span class="n">G</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span>
</pre></div>
@@ -678,20 +648,20 @@ node or edge attributes.</p>
<dd><p>Return the degree of a node or nodes.</p>
<p>The node degree is the number of edges adjacent to that node.</p>
<dl class="docutils">
-<dt>nbunch <span class="classifier-delimiter">:</span> <span class="classifier">iterable container, optional (default=all nodes)</span></dt>
-<dd>A container of nodes. The container will be iterated
+<dt>nbunch</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">iterable container, optional (default=all nodes)</span><dd>A container of nodes. The container will be iterated
through once.</dd>
-<dt>weight <span class="classifier-delimiter">:</span> <span class="classifier">string or None, optional (default=None)</span></dt>
-<dd>The edge attribute that holds the numerical value used
+<dt>weight</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">string or None, optional (default=None)</span><dd>The edge attribute that holds the numerical value used
as a weight. If None, then each edge has weight 1.
The degree is the sum of the edge weights adjacent to the node.</dd>
</dl>
<dl class="docutils">
-<dt>nd <span class="classifier-delimiter">:</span> <span class="classifier">dictionary, or number</span></dt>
-<dd>A dictionary with nodes as keys and degree as values or
+<dt>nd</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">dictionary, or number</span><dd>A dictionary with nodes as keys and degree as values or
a number if a single node is specified.</dd>
</dl>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">degree</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="go">1</span>
@@ -709,20 +679,20 @@ a number if a single node is specified.</dd>
<dd><p>Return an iterator for (node, degree).</p>
<p>The node degree is the number of edges adjacent to the node.</p>
<dl class="docutils">
-<dt>nbunch <span class="classifier-delimiter">:</span> <span class="classifier">iterable container, optional (default=all nodes)</span></dt>
-<dd>A container of nodes. The container will be iterated
+<dt>nbunch</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">iterable container, optional (default=all nodes)</span><dd>A container of nodes. The container will be iterated
through once.</dd>
-<dt>weight <span class="classifier-delimiter">:</span> <span class="classifier">string or None, optional (default=None)</span></dt>
-<dd>The edge attribute that holds the numerical value used
+<dt>weight</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">string or None, optional (default=None)</span><dd>The edge attribute that holds the numerical value used
as a weight. If None, then each edge has weight 1.
The degree is the sum of the edge weights adjacent to the node.</dd>
</dl>
<dl class="docutils">
-<dt>nd_iter <span class="classifier-delimiter">:</span> <span class="classifier">an iterator</span></dt>
-<dd>The iterator returns two-tuples of (node, degree).</dd>
+<dt>nd_iter</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">an iterator</span><dd>The iterator returns two-tuples of (node, degree).</dd>
</dl>
<p>degree, in_degree, out_degree, in_degree_iter, out_degree_iter</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">DiGraph</span><span class="p">()</span> <span class="c1"># or MultiDiGraph</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">DiGraph</span><span class="p">()</span> <span class="c1"># or MultiDiGraph</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">])</span>
<span class="gp">>>> </span><span class="nb">list</span><span class="p">(</span><span class="n">G</span><span class="o">.</span><span class="n">degree_iter</span><span class="p">(</span><span class="mi">0</span><span class="p">))</span> <span class="c1"># node 0 with degree 1</span>
<span class="go">[(0, 1)]</span>
@@ -766,15 +736,15 @@ function. Also, if given as setting (disconnect_shared_sources=True), shared sou
<p>Edges are returned as tuples with optional data
in the order (node, neighbor, data).</p>
<dl class="docutils">
-<dt>nbunch <span class="classifier-delimiter">:</span> <span class="classifier">iterable container, optional (default= all nodes)</span></dt>
-<dd>A container of nodes. The container will be iterated
+<dt>nbunch</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">iterable container, optional (default= all nodes)</span><dd>A container of nodes. The container will be iterated
through once.</dd>
-<dt>data <span class="classifier-delimiter">:</span> <span class="classifier">string or bool, optional (default=False)</span></dt>
-<dd>The edge attribute returned in 3-tuple (u,v,ddict[data]).
+<dt>data</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">string or bool, optional (default=False)</span><dd>The edge attribute returned in 3-tuple (u,v,ddict[data]).
If True, return edge attribute dict in 3-tuple (u,v,ddict).
If False, return 2-tuple (u,v).</dd>
-<dt>default <span class="classifier-delimiter">:</span> <span class="classifier">value, optional (default=None)</span></dt>
-<dd>Value used for edges that dont have the requested attribute.
+<dt>default</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">value, optional (default=None)</span><dd>Value used for edges that dont have the requested attribute.
Only relevant if data is not True or False.</dd>
</dl>
<dl class="docutils">
@@ -785,12 +755,12 @@ of all edges if nbunch is not specified.</dd>
<p>edges_iter : return an iterator over the edges</p>
<p>Nodes in nbunch that are not in the graph will be (quietly) ignored.
For directed graphs this returns the out-edges.</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_edge</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="n">weight</span><span class="o">=</span><span class="mi">5</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">edges</span><span class="p">()</span>
<span class="go">[(0, 1), (1, 2), (2, 3)]</span>
-<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">edges</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span> <span class="c1"># default edge data is {} (empty dictionary)</span>
+<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">edges</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span> <span class="c1"># default edge data is {} (empty dictionary)</span>
<span class="go">[(0, 1, {}), (1, 2, {}), (2, 3, {'weight': 5})]</span>
<span class="gp">>>> </span><span class="nb">list</span><span class="p">(</span><span class="n">G</span><span class="o">.</span><span class="n">edges_iter</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="s1">'weight'</span><span class="p">,</span> <span class="n">default</span><span class="o">=</span><span class="mi">1</span><span class="p">))</span>
<span class="go">[(0, 1, 1), (1, 2, 1), (2, 3, 5)]</span>
@@ -809,30 +779,30 @@ For directed graphs this returns the out-edges.</p>
<p>Edges are returned as tuples with optional data
in the order (node, neighbor, data).</p>
<dl class="docutils">
-<dt>nbunch <span class="classifier-delimiter">:</span> <span class="classifier">iterable container, optional (default= all nodes)</span></dt>
-<dd>A container of nodes. The container will be iterated
+<dt>nbunch</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">iterable container, optional (default= all nodes)</span><dd>A container of nodes. The container will be iterated
through once.</dd>
-<dt>data <span class="classifier-delimiter">:</span> <span class="classifier">string or bool, optional (default=False)</span></dt>
-<dd>The edge attribute returned in 3-tuple (u,v,ddict[data]).
+<dt>data</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">string or bool, optional (default=False)</span><dd>The edge attribute returned in 3-tuple (u,v,ddict[data]).
If True, return edge attribute dict in 3-tuple (u,v,ddict).
If False, return 2-tuple (u,v).</dd>
-<dt>default <span class="classifier-delimiter">:</span> <span class="classifier">value, optional (default=None)</span></dt>
-<dd>Value used for edges that dont have the requested attribute.
+<dt>default</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">value, optional (default=None)</span><dd>Value used for edges that dont have the requested attribute.
Only relevant if data is not True or False.</dd>
</dl>
<dl class="docutils">
-<dt>edge_iter <span class="classifier-delimiter">:</span> <span class="classifier">iterator</span></dt>
-<dd>An iterator of (u,v) or (u,v,d) tuples of edges.</dd>
+<dt>edge_iter</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">iterator</span><dd>An iterator of (u,v) or (u,v,d) tuples of edges.</dd>
</dl>
<p>edges : return a list of edges</p>
<p>Nodes in nbunch that are not in the graph will be (quietly) ignored.
For directed graphs this returns the out-edges.</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">DiGraph</span><span class="p">()</span> <span class="c1"># or MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">DiGraph</span><span class="p">()</span> <span class="c1"># or MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_edge</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="n">weight</span><span class="o">=</span><span class="mi">5</span><span class="p">)</span>
<span class="gp">>>> </span><span class="p">[</span><span class="n">e</span> <span class="k">for</span> <span class="n">e</span> <span class="ow">in</span> <span class="n">G</span><span class="o">.</span><span class="n">edges_iter</span><span class="p">()]</span>
<span class="go">[(0, 1), (1, 2), (2, 3)]</span>
-<span class="gp">>>> </span><span class="nb">list</span><span class="p">(</span><span class="n">G</span><span class="o">.</span><span class="n">edges_iter</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="bp">True</span><span class="p">))</span> <span class="c1"># default data is {} (empty dict)</span>
+<span class="gp">>>> </span><span class="nb">list</span><span class="p">(</span><span class="n">G</span><span class="o">.</span><span class="n">edges_iter</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="kc">True</span><span class="p">))</span> <span class="c1"># default data is {} (empty dict)</span>
<span class="go">[(0, 1, {}), (1, 2, {}), (2, 3, {'weight': 5})]</span>
<span class="gp">>>> </span><span class="nb">list</span><span class="p">(</span><span class="n">G</span><span class="o">.</span><span class="n">edges_iter</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="s1">'weight'</span><span class="p">,</span> <span class="n">default</span><span class="o">=</span><span class="mi">1</span><span class="p">))</span>
<span class="go">[(0, 1, 1), (1, 2, 1), (2, 3, 5)]</span>
@@ -844,29 +814,6 @@ For directed graphs this returns the out-edges.</p>
</div>
</dd></dl>
-<dl class="method">
-<dt id="kadmos.graph.KadmosGraph.expand_node">
-<code class="descname">expand_node</code><span class="sig-paren">(</span><em>node_name</em>, <em>elements</em><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.graph.KadmosGraph.expand_node" title="Permalink to this definition">¶</a></dt>
-<dd><p>Method to crete a note from temporary node(s) created by the load function</p>
-<p>Used to expand and clean-up nodes read in by the load functions when _ui_d is given in the dictionary. Only
-used for loading from CMDOWS files. The node is then automatically added to the graph.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
-<li><strong>node_name</strong> (<em>str</em>) – name of the node to be expanded</li>
-<li><strong>elements</strong> (<em>list</em>) – structure of the node</li>
-</ul>
-</td>
-</tr>
-<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last">expanded and cleaned-up node</p>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
<dl class="method">
<dt id="kadmos.graph.KadmosGraph.find_all_nodes">
<code class="descname">find_all_nodes</code><span class="sig-paren">(</span><em>category='all'</em>, <em>subcategory='all'</em>, <em>attr_cond=None</em>, <em>attr_include=None</em>, <em>attr_exclude=None</em>, <em>print_in_log=False</em>, <em>print_attributes='all'</em><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.graph.KadmosGraph.find_all_nodes" title="Permalink to this definition">¶</a></dt>
@@ -985,16 +932,16 @@ used for loading from CMDOWS files. The node is then automatically added to the
</div>
<p>Example usage:
Just get all nodes of a graph in a list:</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">all_nodes</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">find_all_nodes</span><span class="p">()</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">all_nodes</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">find_all_nodes</span><span class="p">()</span>
</pre></div>
</div>
<p>Get all input nodes in a list and print them in the log as well:</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">all_nodes</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">find_all_nodes</span><span class="p">(</span><span class="n">category</span><span class="o">=</span><span class="s1">'all'</span><span class="p">,</span> <span class="n">subcategory</span><span class="o">=</span><span class="s1">'all inputs'</span><span class="p">,</span> <span class="n">print_in_log</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">all_nodes</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">find_all_nodes</span><span class="p">(</span><span class="n">category</span><span class="o">=</span><span class="s1">'all'</span><span class="p">,</span> <span class="n">subcategory</span><span class="o">=</span><span class="s1">'all inputs'</span><span class="p">,</span> <span class="n">print_in_log</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
</pre></div>
</div>
<p>Get all input nodes with a certain attribute value:</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">all_nodes</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">find_all_nodes</span><span class="p">(</span><span class="n">category</span><span class="o">=</span><span class="s1">'all'</span><span class="p">,</span> <span class="n">subcategory</span><span class="o">=</span><span class="s1">'all inputs'</span><span class="p">,</span>
-<span class="gp">>>> </span> <span class="n">attr_cond</span><span class="o">=</span><span class="p">[</span><span class="s1">'execution time'</span><span class="p">,</span> <span class="s1">'>'</span><span class="p">,</span> <span class="mi">5</span><span class="p">],</span> <span class="n">print_in_log</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">all_nodes</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">find_all_nodes</span><span class="p">(</span><span class="n">category</span><span class="o">=</span><span class="s1">'all'</span><span class="p">,</span> <span class="n">subcategory</span><span class="o">=</span><span class="s1">'all inputs'</span><span class="p">,</span>
+<span class="gp">>>> </span> <span class="n">attr_cond</span><span class="o">=</span><span class="p">[</span><span class="s1">'execution time'</span><span class="p">,</span> <span class="s1">'>'</span><span class="p">,</span> <span class="mi">5</span><span class="p">],</span> <span class="n">print_in_log</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
</pre></div>
</div>
</dd></dl>
@@ -1106,11 +1053,11 @@ default: any Python object (default=None)</p>
<blockquote>
<div>Value to return if the edge (u,v) is not found.</div></blockquote>
<dl class="docutils">
-<dt>edge_dict <span class="classifier-delimiter">:</span> <span class="classifier">dictionary</span></dt>
-<dd>The edge attribute dictionary.</dd>
+<dt>edge_dict</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">dictionary</span><dd>The edge attribute dictionary.</dd>
</dl>
<p>It is faster to use G[u][v].</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">G</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="mi">1</span><span class="p">]</span>
<span class="go">{}</span>
@@ -1118,14 +1065,14 @@ default: any Python object (default=None)</p>
</div>
<p>Warning: Assigning G[u][v] corrupts the graph data structure.
But it is safe to assign attributes to that dictionary,</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="mi">1</span><span class="p">][</span><span class="s1">'weight'</span><span class="p">]</span> <span class="o">=</span> <span class="mi">7</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="mi">1</span><span class="p">][</span><span class="s1">'weight'</span><span class="p">]</span> <span class="o">=</span> <span class="mi">7</span>
<span class="gp">>>> </span><span class="n">G</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="mi">1</span><span class="p">][</span><span class="s1">'weight'</span><span class="p">]</span>
<span class="go">7</span>
<span class="gp">>>> </span><span class="n">G</span><span class="p">[</span><span class="mi">1</span><span class="p">][</span><span class="mi">0</span><span class="p">][</span><span class="s1">'weight'</span><span class="p">]</span>
<span class="go">7</span>
</pre></div>
</div>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">get_edge_data</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">)</span> <span class="c1"># default edge data is {}</span>
<span class="go">{}</span>
@@ -1531,16 +1478,16 @@ into an undirected graph.</p>
<code class="descname">has_edge</code><span class="sig-paren">(</span><em>u</em>, <em>v</em><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.graph.KadmosGraph.has_edge" title="Permalink to this definition">¶</a></dt>
<dd><p>Return True if the edge (u,v) is in the graph.</p>
<dl class="docutils">
-<dt>u, v <span class="classifier-delimiter">:</span> <span class="classifier">nodes</span></dt>
-<dd>Nodes can be, for example, strings or numbers.
+<dt>u, v</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">nodes</span><dd>Nodes can be, for example, strings or numbers.
Nodes must be hashable (and not None) Python objects.</dd>
</dl>
<dl class="docutils">
-<dt>edge_ind <span class="classifier-delimiter">:</span> <span class="classifier">bool</span></dt>
-<dd>True if edge is in the graph, False otherwise.</dd>
+<dt>edge_ind</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">bool</span><dd>True if edge is in the graph, False otherwise.</dd>
</dl>
<p>Can be called either using two nodes u,v or edge tuple (u,v)</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">has_edge</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">)</span> <span class="c1"># using two nodes</span>
<span class="go">True</span>
@@ -1553,7 +1500,7 @@ Nodes must be hashable (and not None) Python objects.</dd>
</pre></div>
</div>
<p>The following syntax are all equivalent:</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">has_edge</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">)</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">has_edge</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">)</span>
<span class="go">True</span>
<span class="gp">>>> </span><span class="mi">1</span> <span class="ow">in</span> <span class="n">G</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="c1"># though this gives KeyError if 0 not in G</span>
<span class="go">True</span>
@@ -1566,14 +1513,14 @@ Nodes must be hashable (and not None) Python objects.</dd>
<code class="descname">has_node</code><span class="sig-paren">(</span><em>n</em><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.graph.KadmosGraph.has_node" title="Permalink to this definition">¶</a></dt>
<dd><p>Return True if the graph contains the node n.</p>
<p>n : node</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">has_node</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="go">True</span>
</pre></div>
</div>
<p>It is more readable and simpler to use</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="mi">0</span> <span class="ow">in</span> <span class="n">G</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="mi">0</span> <span class="ow">in</span> <span class="n">G</span>
<span class="go">True</span>
</pre></div>
</div>
@@ -1617,21 +1564,21 @@ Nodes must be hashable (and not None) Python objects.</dd>
<dd><p>Return the in-degree of a node or nodes.</p>
<p>The node in-degree is the number of edges pointing in to the node.</p>
<dl class="docutils">
-<dt>nbunch <span class="classifier-delimiter">:</span> <span class="classifier">iterable container, optional (default=all nodes)</span></dt>
-<dd>A container of nodes. The container will be iterated
+<dt>nbunch</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">iterable container, optional (default=all nodes)</span><dd>A container of nodes. The container will be iterated
through once.</dd>
-<dt>weight <span class="classifier-delimiter">:</span> <span class="classifier">string or None, optional (default=None)</span></dt>
-<dd>The edge attribute that holds the numerical value used
+<dt>weight</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">string or None, optional (default=None)</span><dd>The edge attribute that holds the numerical value used
as a weight. If None, then each edge has weight 1.
The degree is the sum of the edge weights adjacent to the node.</dd>
</dl>
<dl class="docutils">
-<dt>nd <span class="classifier-delimiter">:</span> <span class="classifier">dictionary, or number</span></dt>
-<dd>A dictionary with nodes as keys and in-degree as values or
+<dt>nd</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">dictionary, or number</span><dd>A dictionary with nodes as keys and in-degree as values or
a number if a single node is specified.</dd>
</dl>
<p>degree, out_degree, in_degree_iter</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">DiGraph</span><span class="p">()</span> <span class="c1"># or MultiDiGraph</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">DiGraph</span><span class="p">()</span> <span class="c1"># or MultiDiGraph</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">in_degree</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="go">0</span>
@@ -1649,20 +1596,20 @@ a number if a single node is specified.</dd>
<dd><p>Return an iterator for (node, in-degree).</p>
<p>The node in-degree is the number of edges pointing in to the node.</p>
<dl class="docutils">
-<dt>nbunch <span class="classifier-delimiter">:</span> <span class="classifier">iterable container, optional (default=all nodes)</span></dt>
-<dd>A container of nodes. The container will be iterated
+<dt>nbunch</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">iterable container, optional (default=all nodes)</span><dd>A container of nodes. The container will be iterated
through once.</dd>
-<dt>weight <span class="classifier-delimiter">:</span> <span class="classifier">string or None, optional (default=None)</span></dt>
-<dd>The edge attribute that holds the numerical value used
+<dt>weight</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">string or None, optional (default=None)</span><dd>The edge attribute that holds the numerical value used
as a weight. If None, then each edge has weight 1.
The degree is the sum of the edge weights adjacent to the node.</dd>
</dl>
<dl class="docutils">
-<dt>nd_iter <span class="classifier-delimiter">:</span> <span class="classifier">an iterator</span></dt>
-<dd>The iterator returns two-tuples of (node, in-degree).</dd>
+<dt>nd_iter</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">an iterator</span><dd>The iterator returns two-tuples of (node, in-degree).</dd>
</dl>
<p>degree, in_degree, out_degree, out_degree_iter</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">DiGraph</span><span class="p">()</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">DiGraph</span><span class="p">()</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">])</span>
<span class="gp">>>> </span><span class="nb">list</span><span class="p">(</span><span class="n">G</span><span class="o">.</span><span class="n">in_degree_iter</span><span class="p">(</span><span class="mi">0</span><span class="p">))</span> <span class="c1"># node 0 with degree 0</span>
<span class="go">[(0, 0)]</span>
@@ -1684,15 +1631,15 @@ The degree is the sum of the edge weights adjacent to the node.</dd>
<code class="descname">in_edges_iter</code><span class="sig-paren">(</span><em>nbunch=None</em>, <em>data=False</em><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.graph.KadmosGraph.in_edges_iter" title="Permalink to this definition">¶</a></dt>
<dd><p>Return an iterator over the incoming edges.</p>
<dl class="docutils">
-<dt>nbunch <span class="classifier-delimiter">:</span> <span class="classifier">iterable container, optional (default= all nodes)</span></dt>
-<dd>A container of nodes. The container will be iterated
+<dt>nbunch</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">iterable container, optional (default= all nodes)</span><dd>A container of nodes. The container will be iterated
through once.</dd>
-<dt>data <span class="classifier-delimiter">:</span> <span class="classifier">bool, optional (default=False)</span></dt>
-<dd>If True, return edge attribute dict in 3-tuple (u,v,data).</dd>
+<dt>data</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">bool, optional (default=False)</span><dd>If True, return edge attribute dict in 3-tuple (u,v,data).</dd>
</dl>
<dl class="docutils">
-<dt>in_edge_iter <span class="classifier-delimiter">:</span> <span class="classifier">iterator</span></dt>
-<dd>An iterator of (u,v) or (u,v,d) tuples of incoming edges.</dd>
+<dt>in_edge_iter</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">iterator</span><dd>An iterator of (u,v) or (u,v,d) tuples of incoming edges.</dd>
</dl>
<p>edges_iter : return an iterator of edges</p>
</dd></dl>
@@ -1838,13 +1785,13 @@ also in the graph.</p>
<p>The nodes in nbunch are checked for membership in the graph
and if not are silently ignored.</p>
<dl class="docutils">
-<dt>nbunch <span class="classifier-delimiter">:</span> <span class="classifier">iterable container, optional (default=all nodes)</span></dt>
-<dd>A container of nodes. The container will be iterated
+<dt>nbunch</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">iterable container, optional (default=all nodes)</span><dd>A container of nodes. The container will be iterated
through once.</dd>
</dl>
<dl class="docutils">
-<dt>niter <span class="classifier-delimiter">:</span> <span class="classifier">iterator</span></dt>
-<dd>An iterator over nodes in nbunch that are also in the graph.
+<dt>niter</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">iterator</span><dd>An iterator over nodes in nbunch that are also in the graph.
If nbunch is None, iterate over all nodes in the graph.</dd>
</dl>
<dl class="docutils">
@@ -1988,21 +1935,21 @@ nbunch is not hashable, a NetworkXError is raised.</p>
<code class="descname">nodes</code><span class="sig-paren">(</span><em>data=False</em><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.graph.KadmosGraph.nodes" title="Permalink to this definition">¶</a></dt>
<dd><p>Return a list of the nodes in the graph.</p>
<dl class="docutils">
-<dt>data <span class="classifier-delimiter">:</span> <span class="classifier">boolean, optional (default=False)</span></dt>
-<dd>If False return a list of nodes. If True return a
+<dt>data</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">boolean, optional (default=False)</span><dd>If False return a list of nodes. If True return a
two-tuple of node and node data dictionary</dd>
</dl>
<dl class="docutils">
-<dt>nlist <span class="classifier-delimiter">:</span> <span class="classifier">list</span></dt>
-<dd>A list of nodes. If data=True a list of two-tuples containing
+<dt>nlist</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">list</span><dd>A list of nodes. If data=True a list of two-tuples containing
(node, node data dictionary).</dd>
</dl>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">nodes</span><span class="p">()</span>
<span class="go">[0, 1, 2]</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_node</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="n">time</span><span class="o">=</span><span class="s1">'5pm'</span><span class="p">)</span>
-<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">nodes</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span>
+<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">nodes</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
<span class="go">[(0, {}), (1, {'time': '5pm'}), (2, {})]</span>
</pre></div>
</div>
@@ -2013,26 +1960,26 @@ two-tuple of node and node data dictionary</dd>
<code class="descname">nodes_iter</code><span class="sig-paren">(</span><em>data=False</em><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.graph.KadmosGraph.nodes_iter" title="Permalink to this definition">¶</a></dt>
<dd><p>Return an iterator over the nodes.</p>
<dl class="docutils">
-<dt>data <span class="classifier-delimiter">:</span> <span class="classifier">boolean, optional (default=False)</span></dt>
-<dd>If False the iterator returns nodes. If True
+<dt>data</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">boolean, optional (default=False)</span><dd>If False the iterator returns nodes. If True
return a two-tuple of node and node data dictionary</dd>
</dl>
<dl class="docutils">
-<dt>niter <span class="classifier-delimiter">:</span> <span class="classifier">iterator</span></dt>
-<dd>An iterator over nodes. If data=True the iterator gives
+<dt>niter</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">iterator</span><dd>An iterator over nodes. If data=True the iterator gives
two-tuples containing (node, node data, dictionary)</dd>
</dl>
<p>If the node data is not required it is simpler and equivalent
to use the expression ‘for n in G’.</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">])</span>
</pre></div>
</div>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">])</span>
</pre></div>
</div>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="p">[</span><span class="n">d</span> <span class="k">for</span> <span class="n">n</span><span class="p">,</span><span class="n">d</span> <span class="ow">in</span> <span class="n">G</span><span class="o">.</span><span class="n">nodes_iter</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="bp">True</span><span class="p">)]</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="p">[</span><span class="n">d</span> <span class="k">for</span> <span class="n">n</span><span class="p">,</span><span class="n">d</span> <span class="ow">in</span> <span class="n">G</span><span class="o">.</span><span class="n">nodes_iter</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="kc">True</span><span class="p">)]</span>
<span class="go">[{}, {}, {}]</span>
</pre></div>
</div>
@@ -2045,11 +1992,11 @@ to use the expression ‘for n in G’.</p>
<p>A node with a self loop has an edge with both ends adjacent
to that node.</p>
<dl class="docutils">
-<dt>nodelist <span class="classifier-delimiter">:</span> <span class="classifier">list</span></dt>
-<dd>A list of nodes with self loops.</dd>
+<dt>nodelist</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">list</span><dd>A list of nodes with self loops.</dd>
</dl>
<p>selfloop_edges, number_of_selfloops</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_edge</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_edge</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">nodes_with_selfloops</span><span class="p">()</span>
@@ -2063,17 +2010,17 @@ to that node.</p>
<code class="descname">number_of_edges</code><span class="sig-paren">(</span><em>u=None</em>, <em>v=None</em><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.graph.KadmosGraph.number_of_edges" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the number of edges between two nodes.</p>
<dl class="docutils">
-<dt>u, v <span class="classifier-delimiter">:</span> <span class="classifier">nodes, optional (default=all edges)</span></dt>
-<dd>If u and v are specified, return the number of edges between
+<dt>u, v</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">nodes, optional (default=all edges)</span><dd>If u and v are specified, return the number of edges between
u and v. Otherwise return the total number of all edges.</dd>
</dl>
<dl class="docutils">
-<dt>nedges <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
-<dd>The number of edges in the graph. If nodes u and v are specified
+<dt>nedges</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">int</span><dd>The number of edges in the graph. If nodes u and v are specified
return the number of edges between those nodes.</dd>
</dl>
<p>size</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">number_of_edges</span><span class="p">()</span>
<span class="go">3</span>
@@ -2091,11 +2038,11 @@ return the number of edges between those nodes.</dd>
<code class="descname">number_of_nodes</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.graph.KadmosGraph.number_of_nodes" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the number of nodes in the graph.</p>
<dl class="docutils">
-<dt>nnodes <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
-<dd>The number of nodes in the graph.</dd>
+<dt>nnodes</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">int</span><dd>The number of nodes in the graph.</dd>
</dl>
<p>order, __len__ which are identical</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">])</span>
<span class="gp">>>> </span><span class="nb">len</span><span class="p">(</span><span class="n">G</span><span class="p">)</span>
<span class="go">3</span>
@@ -2109,11 +2056,11 @@ return the number of edges between those nodes.</dd>
<dd><p>Return the number of selfloop edges.</p>
<p>A selfloop edge has the same node at both ends.</p>
<dl class="docutils">
-<dt>nloops <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
-<dd>The number of selfloops.</dd>
+<dt>nloops</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">int</span><dd>The number of selfloops.</dd>
</dl>
<p>nodes_with_selfloops, selfloop_edges</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span><span class="o">=</span><span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span><span class="o">=</span><span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_edge</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_edge</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">number_of_selfloops</span><span class="p">()</span>
@@ -2127,8 +2074,8 @@ return the number of edges between those nodes.</dd>
<code class="descname">order</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.graph.KadmosGraph.order" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the number of nodes in the graph.</p>
<dl class="docutils">
-<dt>nnodes <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
-<dd>The number of nodes in the graph.</dd>
+<dt>nnodes</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">int</span><dd>The number of nodes in the graph.</dd>
</dl>
<p>number_of_nodes, __len__ which are identical</p>
</dd></dl>
@@ -2139,20 +2086,20 @@ return the number of edges between those nodes.</dd>
<dd><p>Return the out-degree of a node or nodes.</p>
<p>The node out-degree is the number of edges pointing out of the node.</p>
<dl class="docutils">
-<dt>nbunch <span class="classifier-delimiter">:</span> <span class="classifier">iterable container, optional (default=all nodes)</span></dt>
-<dd>A container of nodes. The container will be iterated
+<dt>nbunch</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">iterable container, optional (default=all nodes)</span><dd>A container of nodes. The container will be iterated
through once.</dd>
-<dt>weight <span class="classifier-delimiter">:</span> <span class="classifier">string or None, optional (default=None)</span></dt>
-<dd>The edge attribute that holds the numerical value used
+<dt>weight</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">string or None, optional (default=None)</span><dd>The edge attribute that holds the numerical value used
as a weight. If None, then each edge has weight 1.
The degree is the sum of the edge weights adjacent to the node.</dd>
</dl>
<dl class="docutils">
-<dt>nd <span class="classifier-delimiter">:</span> <span class="classifier">dictionary, or number</span></dt>
-<dd>A dictionary with nodes as keys and out-degree as values or
+<dt>nd</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">dictionary, or number</span><dd>A dictionary with nodes as keys and out-degree as values or
a number if a single node is specified.</dd>
</dl>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">DiGraph</span><span class="p">()</span> <span class="c1"># or MultiDiGraph</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">DiGraph</span><span class="p">()</span> <span class="c1"># or MultiDiGraph</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">out_degree</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="go">1</span>
@@ -2170,20 +2117,20 @@ a number if a single node is specified.</dd>
<dd><p>Return an iterator for (node, out-degree).</p>
<p>The node out-degree is the number of edges pointing out of the node.</p>
<dl class="docutils">
-<dt>nbunch <span class="classifier-delimiter">:</span> <span class="classifier">iterable container, optional (default=all nodes)</span></dt>
-<dd>A container of nodes. The container will be iterated
+<dt>nbunch</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">iterable container, optional (default=all nodes)</span><dd>A container of nodes. The container will be iterated
through once.</dd>
-<dt>weight <span class="classifier-delimiter">:</span> <span class="classifier">string or None, optional (default=None)</span></dt>
-<dd>The edge attribute that holds the numerical value used
+<dt>weight</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">string or None, optional (default=None)</span><dd>The edge attribute that holds the numerical value used
as a weight. If None, then each edge has weight 1.
The degree is the sum of the edge weights adjacent to the node.</dd>
</dl>
<dl class="docutils">
-<dt>nd_iter <span class="classifier-delimiter">:</span> <span class="classifier">an iterator</span></dt>
-<dd>The iterator returns two-tuples of (node, out-degree).</dd>
+<dt>nd_iter</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">an iterator</span><dd>The iterator returns two-tuples of (node, out-degree).</dd>
</dl>
<p>degree, in_degree, out_degree, in_degree_iter</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">DiGraph</span><span class="p">()</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">DiGraph</span><span class="p">()</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">])</span>
<span class="gp">>>> </span><span class="nb">list</span><span class="p">(</span><span class="n">G</span><span class="o">.</span><span class="n">out_degree_iter</span><span class="p">(</span><span class="mi">0</span><span class="p">))</span> <span class="c1"># node 0 with degree 1</span>
<span class="go">[(0, 1)]</span>
@@ -2200,15 +2147,15 @@ The degree is the sum of the edge weights adjacent to the node.</dd>
<p>Edges are returned as tuples with optional data
in the order (node, neighbor, data).</p>
<dl class="docutils">
-<dt>nbunch <span class="classifier-delimiter">:</span> <span class="classifier">iterable container, optional (default= all nodes)</span></dt>
-<dd>A container of nodes. The container will be iterated
+<dt>nbunch</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">iterable container, optional (default= all nodes)</span><dd>A container of nodes. The container will be iterated
through once.</dd>
-<dt>data <span class="classifier-delimiter">:</span> <span class="classifier">string or bool, optional (default=False)</span></dt>
-<dd>The edge attribute returned in 3-tuple (u,v,ddict[data]).
+<dt>data</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">string or bool, optional (default=False)</span><dd>The edge attribute returned in 3-tuple (u,v,ddict[data]).
If True, return edge attribute dict in 3-tuple (u,v,ddict).
If False, return 2-tuple (u,v).</dd>
-<dt>default <span class="classifier-delimiter">:</span> <span class="classifier">value, optional (default=None)</span></dt>
-<dd>Value used for edges that dont have the requested attribute.
+<dt>default</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">value, optional (default=None)</span><dd>Value used for edges that dont have the requested attribute.
Only relevant if data is not True or False.</dd>
</dl>
<dl class="docutils">
@@ -2219,12 +2166,12 @@ of all edges if nbunch is not specified.</dd>
<p>edges_iter : return an iterator over the edges</p>
<p>Nodes in nbunch that are not in the graph will be (quietly) ignored.
For directed graphs this returns the out-edges.</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_edge</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="n">weight</span><span class="o">=</span><span class="mi">5</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">edges</span><span class="p">()</span>
<span class="go">[(0, 1), (1, 2), (2, 3)]</span>
-<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">edges</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span> <span class="c1"># default edge data is {} (empty dictionary)</span>
+<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">edges</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span> <span class="c1"># default edge data is {} (empty dictionary)</span>
<span class="go">[(0, 1, {}), (1, 2, {}), (2, 3, {'weight': 5})]</span>
<span class="gp">>>> </span><span class="nb">list</span><span class="p">(</span><span class="n">G</span><span class="o">.</span><span class="n">edges_iter</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="s1">'weight'</span><span class="p">,</span> <span class="n">default</span><span class="o">=</span><span class="mi">1</span><span class="p">))</span>
<span class="go">[(0, 1, 1), (1, 2, 1), (2, 3, 5)]</span>
@@ -2243,30 +2190,30 @@ For directed graphs this returns the out-edges.</p>
<p>Edges are returned as tuples with optional data
in the order (node, neighbor, data).</p>
<dl class="docutils">
-<dt>nbunch <span class="classifier-delimiter">:</span> <span class="classifier">iterable container, optional (default= all nodes)</span></dt>
-<dd>A container of nodes. The container will be iterated
+<dt>nbunch</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">iterable container, optional (default= all nodes)</span><dd>A container of nodes. The container will be iterated
through once.</dd>
-<dt>data <span class="classifier-delimiter">:</span> <span class="classifier">string or bool, optional (default=False)</span></dt>
-<dd>The edge attribute returned in 3-tuple (u,v,ddict[data]).
+<dt>data</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">string or bool, optional (default=False)</span><dd>The edge attribute returned in 3-tuple (u,v,ddict[data]).
If True, return edge attribute dict in 3-tuple (u,v,ddict).
If False, return 2-tuple (u,v).</dd>
-<dt>default <span class="classifier-delimiter">:</span> <span class="classifier">value, optional (default=None)</span></dt>
-<dd>Value used for edges that dont have the requested attribute.
+<dt>default</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">value, optional (default=None)</span><dd>Value used for edges that dont have the requested attribute.
Only relevant if data is not True or False.</dd>
</dl>
<dl class="docutils">
-<dt>edge_iter <span class="classifier-delimiter">:</span> <span class="classifier">iterator</span></dt>
-<dd>An iterator of (u,v) or (u,v,d) tuples of edges.</dd>
+<dt>edge_iter</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">iterator</span><dd>An iterator of (u,v) or (u,v,d) tuples of edges.</dd>
</dl>
<p>edges : return a list of edges</p>
<p>Nodes in nbunch that are not in the graph will be (quietly) ignored.
For directed graphs this returns the out-edges.</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">DiGraph</span><span class="p">()</span> <span class="c1"># or MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">DiGraph</span><span class="p">()</span> <span class="c1"># or MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_edge</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="n">weight</span><span class="o">=</span><span class="mi">5</span><span class="p">)</span>
<span class="gp">>>> </span><span class="p">[</span><span class="n">e</span> <span class="k">for</span> <span class="n">e</span> <span class="ow">in</span> <span class="n">G</span><span class="o">.</span><span class="n">edges_iter</span><span class="p">()]</span>
<span class="go">[(0, 1), (1, 2), (2, 3)]</span>
-<span class="gp">>>> </span><span class="nb">list</span><span class="p">(</span><span class="n">G</span><span class="o">.</span><span class="n">edges_iter</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="bp">True</span><span class="p">))</span> <span class="c1"># default data is {} (empty dict)</span>
+<span class="gp">>>> </span><span class="nb">list</span><span class="p">(</span><span class="n">G</span><span class="o">.</span><span class="n">edges_iter</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="kc">True</span><span class="p">))</span> <span class="c1"># default data is {} (empty dict)</span>
<span class="go">[(0, 1, {}), (1, 2, {}), (2, 3, {'weight': 5})]</span>
<span class="gp">>>> </span><span class="nb">list</span><span class="p">(</span><span class="n">G</span><span class="o">.</span><span class="n">edges_iter</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="s1">'weight'</span><span class="p">,</span> <span class="n">default</span><span class="o">=</span><span class="mi">1</span><span class="p">))</span>
<span class="go">[(0, 1, 1), (1, 2, 1), (2, 3, 5)]</span>
@@ -2362,15 +2309,15 @@ convention ID[modeID][instanceID][version]</p>
<code class="descname">remove_edge</code><span class="sig-paren">(</span><em>u</em>, <em>v</em><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.graph.KadmosGraph.remove_edge" title="Permalink to this definition">¶</a></dt>
<dd><p>Remove the edge between u and v.</p>
<dl class="docutils">
-<dt>u, v <span class="classifier-delimiter">:</span> <span class="classifier">nodes</span></dt>
-<dd>Remove the edge between nodes u and v.</dd>
+<dt>u, v</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">nodes</span><dd>Remove the edge between nodes u and v.</dd>
</dl>
<dl class="docutils">
<dt>NetworkXError</dt>
<dd>If there is not an edge between u and v.</dd>
</dl>
<p>remove_edges_from : remove a collection of edges</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">remove_edge</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">e</span> <span class="o">=</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span>
@@ -2399,7 +2346,7 @@ from the graph. The edges can be:</p>
</dl>
<p>remove_edge : remove a single edge</p>
<p>Will fail silently if an edge in ebunch is not in the graph.</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">ebunch</span><span class="o">=</span><span class="p">[(</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">),(</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">)]</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">remove_edges_from</span><span class="p">(</span><span class="n">ebunch</span><span class="p">)</span>
@@ -2430,15 +2377,15 @@ remove_node of a function node might lead to unconnected variables in the graph.
<p>Removes the node n and all adjacent edges.
Attempting to remove a non-existent node will raise an exception.</p>
<dl class="docutils">
-<dt>n <span class="classifier-delimiter">:</span> <span class="classifier">node</span></dt>
-<dd>A node in the graph</dd>
+<dt>n</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">node</span><dd>A node in the graph</dd>
</dl>
<dl class="docutils">
<dt>NetworkXError</dt>
<dd>If n is not in the graph.</dd>
</dl>
<p>remove_nodes_from</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">edges</span><span class="p">()</span>
<span class="go">[(0, 1), (1, 2)]</span>
@@ -2454,13 +2401,13 @@ Attempting to remove a non-existent node will raise an exception.</p>
<code class="descname">remove_nodes_from</code><span class="sig-paren">(</span><em>nbunch</em><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.graph.KadmosGraph.remove_nodes_from" title="Permalink to this definition">¶</a></dt>
<dd><p>Remove multiple nodes.</p>
<dl class="docutils">
-<dt>nodes <span class="classifier-delimiter">:</span> <span class="classifier">iterable container</span></dt>
-<dd>A container of nodes (list, dict, set, etc.). If a node
+<dt>nodes</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">iterable container</span><dd>A container of nodes (list, dict, set, etc.). If a node
in the container is not in the graph it is silently
ignored.</dd>
</dl>
<p>remove_node</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">e</span> <span class="o">=</span> <span class="n">G</span><span class="o">.</span><span class="n">nodes</span><span class="p">()</span>
<span class="gp">>>> </span><span class="n">e</span>
@@ -2479,8 +2426,8 @@ ignored.</dd>
<p>The reverse is a graph with the same nodes and edges
but with the directions of the edges reversed.</p>
<dl class="docutils">
-<dt>copy <span class="classifier-delimiter">:</span> <span class="classifier">bool optional (default=True)</span></dt>
-<dd>If True, return a new DiGraph holding the reversed edges.
+<dt>copy</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">bool optional (default=True)</span><dd>If True, return a new DiGraph holding the reversed edges.
If False, reverse the reverse graph is created using
the original graph (this changes the original graph).</dd>
</dl>
@@ -2488,7 +2435,7 @@ the original graph (this changes the original graph).</dd>
<dl class="method">
<dt id="kadmos.graph.KadmosGraph.save">
-<code class="descname">save</code><span class="sig-paren">(</span><em>file_name</em>, <em>file_type='kdms'</em>, <em>graph_check_critical=True</em>, <em>destination_folder=None</em>, <em>mpg=None</em>, <em>description=''</em>, <em>creator=''</em>, <em>version='1.0'</em>, <em>timestamp=datetime.datetime(2017</em>, <em>8</em>, <em>21</em>, <em>12</em>, <em>30</em>, <em>9</em>, <em>511000)</em>, <em>keep_empty_elements=False</em>, <em>pretty_print=False</em>, <em>convention=True</em><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.graph.KadmosGraph.save" title="Permalink to this definition">¶</a></dt>
+<code class="descname">save</code><span class="sig-paren">(</span><em>file_name</em>, <em>file_type='kdms'</em>, <em>graph_check_critical=True</em>, <em>destination_folder=None</em>, <em>mpg=None</em>, <em>description=''</em>, <em>creator=''</em>, <em>version='1.0'</em>, <em>timestamp=datetime.datetime(2017</em>, <em>9</em>, <em>5</em>, <em>16</em>, <em>41</em>, <em>58</em>, <em>881401)</em>, <em>keep_empty_elements=False</em>, <em>pretty_print=False</em>, <em>convention=True</em>, <em>integrity=False</em><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.graph.KadmosGraph.save" title="Permalink to this definition">¶</a></dt>
<dd><p>Method to save the graph.</p>
<p>Different output file types are implemented for saving graphs. They are listed in the following.
kdms: the most simple file type which makes use of pickling
@@ -2511,6 +2458,7 @@ graphml: another file type especially suited for file exchange with other tools
<li><strong>keep_empty_elements</strong> (<em>bool</em>) – option for keeping empty XML elements (only applicable for the cmdows file type)</li>
<li><strong>pretty_print</strong> (<em>bool</em>) – option for pretty XML printing (only applicable for the cmdows file type)</li>
<li><strong>convention</strong> (<em>bool</em>) – option for appyling a UID convention (only applicable for the cmdows file type)</li>
+<li><strong>integrity</strong> (<em>bool</em>) – option for doing an integrity file check (only applicable for the cmdows file type)</li>
</ul>
</td>
</tr>
@@ -2542,25 +2490,25 @@ objective from all functions in graph.</p>
<dd><p>Return a list of selfloop edges.</p>
<p>A selfloop edge has the same node at both ends.</p>
<dl class="docutils">
-<dt>data <span class="classifier-delimiter">:</span> <span class="classifier">string or bool, optional (default=False)</span></dt>
-<dd>Return selfloop edges as two tuples (u,v) (data=False)
+<dt>data</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">string or bool, optional (default=False)</span><dd>Return selfloop edges as two tuples (u,v) (data=False)
or three-tuples (u,v,datadict) (data=True)
or three-tuples (u,v,datavalue) (data=’attrname’)</dd>
-<dt>default <span class="classifier-delimiter">:</span> <span class="classifier">value, optional (default=None)</span></dt>
-<dd>Value used for edges that dont have the requested attribute.
+<dt>default</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">value, optional (default=None)</span><dd>Value used for edges that dont have the requested attribute.
Only relevant if data is not True or False.</dd>
</dl>
<dl class="docutils">
-<dt>edgelist <span class="classifier-delimiter">:</span> <span class="classifier">list of edge tuples</span></dt>
-<dd>A list of all selfloop edges.</dd>
+<dt>edgelist</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">list of edge tuples</span><dd>A list of all selfloop edges.</dd>
</dl>
<p>nodes_with_selfloops, number_of_selfloops</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_edge</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_edge</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">selfloop_edges</span><span class="p">()</span>
<span class="go">[(1, 1)]</span>
-<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">selfloop_edges</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span>
+<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">selfloop_edges</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
<span class="go">[(1, 1, {})]</span>
</pre></div>
</div>
@@ -2571,22 +2519,22 @@ Only relevant if data is not True or False.</dd>
<code class="descname">size</code><span class="sig-paren">(</span><em>weight=None</em><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.graph.KadmosGraph.size" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the number of edges.</p>
<dl class="docutils">
-<dt>weight <span class="classifier-delimiter">:</span> <span class="classifier">string or None, optional (default=None)</span></dt>
-<dd>The edge attribute that holds the numerical value used
+<dt>weight</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">string or None, optional (default=None)</span><dd>The edge attribute that holds the numerical value used
as a weight. If None, then each edge has weight 1.</dd>
</dl>
<dl class="docutils">
-<dt>nedges <span class="classifier-delimiter">:</span> <span class="classifier">int</span></dt>
-<dd>The number of edges or sum of edge weights in the graph.</dd>
+<dt>nedges</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">int</span><dd>The number of edges or sum of edge weights in the graph.</dd>
</dl>
<p>number_of_edges</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">size</span><span class="p">()</span>
<span class="go">3</span>
</pre></div>
</div>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_edge</span><span class="p">(</span><span class="s1">'a'</span><span class="p">,</span><span class="s1">'b'</span><span class="p">,</span><span class="n">weight</span><span class="o">=</span><span class="mi">2</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_edge</span><span class="p">(</span><span class="s1">'b'</span><span class="p">,</span><span class="s1">'c'</span><span class="p">,</span><span class="n">weight</span><span class="o">=</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">size</span><span class="p">()</span>
@@ -2667,12 +2615,12 @@ x1/variableInstance4 ====> F6</p>
<p>The induced subgraph of the graph contains the nodes in nbunch
and the edges between those nodes.</p>
<dl class="docutils">
-<dt>nbunch <span class="classifier-delimiter">:</span> <span class="classifier">list, iterable</span></dt>
-<dd>A container of nodes which will be iterated through once.</dd>
+<dt>nbunch</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">list, iterable</span><dd>A container of nodes which will be iterated through once.</dd>
</dl>
<dl class="docutils">
-<dt>G <span class="classifier-delimiter">:</span> <span class="classifier">Graph</span></dt>
-<dd>A subgraph of the graph with the same edge attributes.</dd>
+<dt>G</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">Graph</span><dd>A subgraph of the graph with the same edge attributes.</dd>
</dl>
<p>The graph, edge or node attributes just point to the original graph.
So changes to the node or edge structure will not be reflected in
@@ -2683,7 +2631,7 @@ nx.Graph(G.subgraph(nbunch))</p>
G.subgraph(nbunch).copy()</p>
<p>For an inplace reduction of a graph to a subgraph you can remove nodes:
G.remove_nodes_from([ n in G if n not in set(nbunch)])</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or DiGraph, MultiGraph, MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">H</span> <span class="o">=</span> <span class="n">G</span><span class="o">.</span><span class="n">subgraph</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">H</span><span class="o">.</span><span class="n">edges</span><span class="p">()</span>
@@ -2711,8 +2659,8 @@ G.remove_nodes_from([ n in G if n not in set(nbunch)])</p>
<code class="descname">to_directed</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.graph.KadmosGraph.to_directed" title="Permalink to this definition">¶</a></dt>
<dd><p>Return a directed copy of the graph.</p>
<dl class="docutils">
-<dt>G <span class="classifier-delimiter">:</span> <span class="classifier">DiGraph</span></dt>
-<dd>A deepcopy of the graph.</dd>
+<dt>G</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">DiGraph</span><dd>A deepcopy of the graph.</dd>
</dl>
<p>This returns a “deepcopy” of the edge, node, and
graph attributes which attempts to completely copy
@@ -2721,7 +2669,7 @@ all of the data and references.</p>
shallow copy of the data.</p>
<p>See the Python copy module for more information on shallow
and deep copies, <a class="reference external" href="http://docs.python.org/library/copy.html">http://docs.python.org/library/copy.html</a>.</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or MultiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span> <span class="c1"># or MultiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">H</span> <span class="o">=</span> <span class="n">G</span><span class="o">.</span><span class="n">to_directed</span><span class="p">()</span>
<span class="gp">>>> </span><span class="n">H</span><span class="o">.</span><span class="n">edges</span><span class="p">()</span>
@@ -2729,7 +2677,7 @@ and deep copies, <a class="reference external" href="http://docs.python.org/libr
</pre></div>
</div>
<p>If already directed, return a (deep) copy</p>
-<div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">DiGraph</span><span class="p">()</span> <span class="c1"># or MultiDiGraph, etc</span>
+<div class="highlight-default"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">DiGraph</span><span class="p">()</span> <span class="c1"># or MultiDiGraph, etc</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_path</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">H</span> <span class="o">=</span> <span class="n">G</span><span class="o">.</span><span class="n">to_directed</span><span class="p">()</span>
<span class="gp">>>> </span><span class="n">H</span><span class="o">.</span><span class="n">edges</span><span class="p">()</span>
@@ -2743,13 +2691,13 @@ and deep copies, <a class="reference external" href="http://docs.python.org/libr
<code class="descname">to_undirected</code><span class="sig-paren">(</span><em>reciprocal=False</em><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.graph.KadmosGraph.to_undirected" title="Permalink to this definition">¶</a></dt>
<dd><p>Return an undirected representation of the digraph.</p>
<dl class="docutils">
-<dt>reciprocal <span class="classifier-delimiter">:</span> <span class="classifier">bool (optional)</span></dt>
-<dd>If True only keep edges that appear in both directions
+<dt>reciprocal</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">bool (optional)</span><dd>If True only keep edges that appear in both directions
in the original digraph.</dd>
</dl>
<dl class="docutils">
-<dt>G <span class="classifier-delimiter">:</span> <span class="classifier">Graph</span></dt>
-<dd>An undirected graph with the same name and nodes and
+<dt>G</dt>
+ <span class="classifier-delimiter">:</span> <span class="classifier">Graph</span><dd>An undirected graph with the same name and nodes and
with edge (u,v,data) if either (u,v,data) or (v,u,data)
is in the digraph. If both edges exist in digraph and
their edge data is different, only one edge is created
@@ -3702,6 +3650,30 @@ The graph class is kept.</p>
</table>
</dd></dl>
+<dl class="function">
+<dt id="kadmos.utilities.general.get_uid">
+<code class="descclassname">kadmos.utilities.general.</code><code class="descname">get_uid</code><span class="sig-paren">(</span><em>preference</em>, <em>uids</em><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.utilities.general.get_uid" title="Permalink to this definition">¶</a></dt>
+<dd><p>Simple function to determine a valid uid which is not part of the uids list</p>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
+<li><strong>preference</strong> (<em>str</em>) – preferred name for the uid</li>
+<li><strong>uids</strong> (<em>list</em>) – list of existing uids</li>
+</ul>
+</td>
+</tr>
+<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">a valid uid which</p>
+</td>
+</tr>
+<tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last">str</p>
+</td>
+</tr>
+</tbody>
+</table>
+</dd></dl>
+
<dl class="function">
<dt id="kadmos.utilities.general.get_unique_friendly_id">
<code class="descclassname">kadmos.utilities.general.</code><code class="descname">get_unique_friendly_id</code><span class="sig-paren">(</span><em>used_ids</em>, <em>uid_length</em><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.utilities.general.get_unique_friendly_id" title="Permalink to this definition">¶</a></dt>
@@ -3768,6 +3740,24 @@ The graph class is kept.</p>
</table>
</dd></dl>
+<dl class="function">
+<dt id="kadmos.utilities.general.make_singular">
+<code class="descclassname">kadmos.utilities.general.</code><code class="descname">make_singular</code><span class="sig-paren">(</span><em>string</em><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.utilities.general.make_singular" title="Permalink to this definition">¶</a></dt>
+<dd><p>Function to convert a string to its singular form.</p>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>string</strong> (<em>str</em>) – initial string</td>
+</tr>
+<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body">singular string</td>
+</tr>
+<tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body">str</td>
+</tr>
+</tbody>
+</table>
+</dd></dl>
+
<dl class="function">
<dt id="kadmos.utilities.general.open_file">
<code class="descclassname">kadmos.utilities.general.</code><code class="descname">open_file</code><span class="sig-paren">(</span><em>filename</em><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.utilities.general.open_file" title="Permalink to this definition">¶</a></dt>
@@ -3808,22 +3798,6 @@ The graph class is kept.</p>
</table>
</dd></dl>
-<dl class="function">
-<dt id="kadmos.utilities.general.string_eval">
-<code class="descclassname">kadmos.utilities.general.</code><code class="descname">string_eval</code><span class="sig-paren">(</span><em>string</em><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.utilities.general.string_eval" title="Permalink to this definition">¶</a></dt>
-<dd><p>Utility function to check if a string contains a float or integer and also convert if this is the case.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>string</strong> – string to be checked and converted</td>
-</tr>
-<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body">(converted) string</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
<dl class="function">
<dt id="kadmos.utilities.general.test_attr_cond">
<code class="descclassname">kadmos.utilities.general.</code><code class="descname">test_attr_cond</code><span class="sig-paren">(</span><em>attr_value</em>, <em>operator</em>, <em>test_value</em><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.utilities.general.test_attr_cond" title="Permalink to this definition">¶</a></dt>
@@ -3897,6 +3871,27 @@ The graph class is kept.</p>
</table>
</dd></dl>
+<dl class="function">
+<dt id="kadmos.utilities.general.translate_dict_keys">
+<code class="descclassname">kadmos.utilities.general.</code><code class="descname">translate_dict_keys</code><span class="sig-paren">(</span><em>dictionary</em>, <em>translations</em><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.utilities.general.translate_dict_keys" title="Permalink to this definition">¶</a></dt>
+<dd><p>Utility to (recursively) translate all keys in a dictionary with a translation dictionary.</p>
+<table class="docutils field-list" frame="void" rules="none">
+<col class="field-name" />
+<col class="field-body" />
+<tbody valign="top">
+<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
+<li><strong>dictionary</strong> – dictionary to be translated</li>
+<li><strong>translations</strong> – dictionary used for the translation</li>
+</ul>
+</td>
+</tr>
+<tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last">translated dictionary</p>
+</td>
+</tr>
+</tbody>
+</table>
+</dd></dl>
+
<dl class="function">
<dt id="kadmos.utilities.general.translate_list">
<code class="descclassname">kadmos.utilities.general.</code><code class="descname">translate_list</code><span class="sig-paren">(</span><em>l</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="headerlink" href="#kadmos.utilities.general.translate_list" title="Permalink to this definition">¶</a></dt>
@@ -3979,14 +3974,11 @@ The graph class is kept.</p>
<div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3>
<form class="search" action="search.html" method="get">
- <input type="text" name="q" />
- <input type="submit" value="Go" />
+ <div><input type="text" name="q" /></div>
+ <div><input type="submit" value="Go" /></div>
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
- <p class="searchtip" style="font-size: 90%">
- Enter search terms or a module, class or function name.
- </p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
@@ -4007,7 +3999,7 @@ The graph class is kept.</p>
</div>
<div class="footer" role="contentinfo">
© Copyright 2017, Imco van Gent.
- Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.5.
+ Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.4.4.
</div>
</body>
</html>
\ No newline at end of file
diff --git a/doc/_static/basic.css b/doc/_static/basic.css
index c89fc7e920b41365e5fb89c104b35fbd18179b89..2b513f0c9643dcd7e671013a2507badf2efb3040 100644
--- a/doc/_static/basic.css
+++ b/doc/_static/basic.css
@@ -52,6 +52,8 @@ div.sphinxsidebar {
width: 230px;
margin-left: -100%;
font-size: 90%;
+ word-wrap: break-word;
+ overflow-wrap : break-word;
}
div.sphinxsidebar ul {
@@ -83,10 +85,6 @@ div.sphinxsidebar #searchbox input[type="text"] {
width: 170px;
}
-div.sphinxsidebar #searchbox input[type="submit"] {
- width: 30px;
-}
-
img {
border: 0;
max-width: 100%;
@@ -187,6 +185,13 @@ div.genindex-jumpbox {
/* -- general body styles --------------------------------------------------- */
+div.body p, div.body dd, div.body li, div.body blockquote {
+ -moz-hyphens: auto;
+ -ms-hyphens: auto;
+ -webkit-hyphens: auto;
+ hyphens: auto;
+}
+
a.headerlink {
visibility: hidden;
}
diff --git a/doc/_static/doctools.js b/doc/_static/doctools.js
index e2e70cc287e06e4af0b8ce70f28a65b44079cdae..816349563588e87ca99c7cf2d6e54268e52e761d 100644
--- a/doc/_static/doctools.js
+++ b/doc/_static/doctools.js
@@ -124,6 +124,7 @@ var Documentation = {
this.fixFirefoxAnchorBug();
this.highlightSearchWords();
this.initIndexTable();
+
},
/**
@@ -252,6 +253,29 @@ var Documentation = {
});
var url = parts.join('/');
return path.substring(url.lastIndexOf('/') + 1, path.length - 1);
+ },
+
+ initOnKeyListeners: function() {
+ $(document).keyup(function(event) {
+ var activeElementType = document.activeElement.tagName;
+ // don't navigate when in search box or textarea
+ if (activeElementType !== 'TEXTAREA' && activeElementType !== 'INPUT' && activeElementType !== 'SELECT') {
+ switch (event.keyCode) {
+ case 37: // left
+ var prevHref = $('link[rel="prev"]').prop('href');
+ if (prevHref) {
+ window.location.href = prevHref;
+ return false;
+ }
+ case 39: // right
+ var nextHref = $('link[rel="next"]').prop('href');
+ if (nextHref) {
+ window.location.href = nextHref;
+ return false;
+ }
+ }
+ }
+ });
}
};
@@ -260,4 +284,4 @@ _ = Documentation.gettext;
$(document).ready(function() {
Documentation.init();
-});
+});
\ No newline at end of file
diff --git a/doc/_static/searchtools.js b/doc/_static/searchtools.js
index cb7446728a2f4217a74dea81a69bbb10c12c6621..066857ce21b1b4b055f9a9308eb351237260fcca 100644
--- a/doc/_static/searchtools.js
+++ b/doc/_static/searchtools.js
@@ -2,7 +2,7 @@
* searchtools.js_t
* ~~~~~~~~~~~~~~~~
*
- * Sphinx JavaScript utilties for the full-text search.
+ * Sphinx JavaScript utilities for the full-text search.
*
* :copyright: Copyright 2007-2016 by the Sphinx team, see AUTHORS.
* :license: BSD, see LICENSE for details.
@@ -623,7 +623,7 @@ var Search = {
* helper function to return a node containing the
* search summary for a given text. keywords is a list
* of stemmed words, hlwords is the list of normal, unstemmed
- * words. the first one is used to find the occurance, the
+ * words. the first one is used to find the occurrence, the
* latter for highlighting it.
*/
makeSearchSummary : function(text, keywords, hlwords) {
diff --git a/doc/_static/websupport.js b/doc/_static/websupport.js
index ffd9b2bfdcb71401f4f84b5eaa74ed2e7b306c1f..98e7f40b6327e673e382068cdfb3bf3674a06cca 100644
--- a/doc/_static/websupport.js
+++ b/doc/_static/websupport.js
@@ -2,7 +2,7 @@
* websupport.js
* ~~~~~~~~~~~~~
*
- * sphinx.websupport utilties for all documentation.
+ * sphinx.websupport utilities for all documentation.
*
* :copyright: Copyright 2007-2016 by the Sphinx team, see AUTHORS.
* :license: BSD, see LICENSE for details.
diff --git a/doc/genindex.html b/doc/genindex.html
index bd83c4621efae1eca86e3e20c3d7a02e7d9b52e3..6ac01eda8a7c5460ef630ef3fb4fa56522793437 100644
--- a/doc/genindex.html
+++ b/doc/genindex.html
@@ -109,16 +109,12 @@
</dt>
- <dt><a href="KADMOS.html#kadmos.graph.KadmosGraph.add_node">add_node() (kadmos.graph.KadmosGraph method)</a>
+ <dt><a href="KADMOS.html#kadmos.graph.KadmosGraph.add_nodes_from">add_nodes_from() (kadmos.graph.KadmosGraph method)</a>
</dt>
</dl></td>
<td style="width: 33%" valign="top"><dl>
- <dt><a href="KADMOS.html#kadmos.graph.KadmosGraph.add_nodes_from">add_nodes_from() (kadmos.graph.KadmosGraph method)</a>
- </dt>
-
-
<dt><a href="KADMOS.html#kadmos.graph.KadmosGraph.add_objective_function_by_nodes">add_objective_function_by_nodes() (kadmos.graph.KadmosGraph method)</a>
</dt>
@@ -294,14 +290,10 @@
<dt><a href="KADMOS.html#kadmos.graph.KadmosGraph.edges">edges() (kadmos.graph.KadmosGraph method)</a>
</dt>
-
- <dt><a href="KADMOS.html#kadmos.graph.KadmosGraph.edges_iter">edges_iter() (kadmos.graph.KadmosGraph method)</a>
- </dt>
-
</dl></td>
<td style="width: 33%" valign="top"><dl>
- <dt><a href="KADMOS.html#kadmos.graph.KadmosGraph.expand_node">expand_node() (kadmos.graph.KadmosGraph method)</a>
+ <dt><a href="KADMOS.html#kadmos.graph.KadmosGraph.edges_iter">edges_iter() (kadmos.graph.KadmosGraph method)</a>
</dt>
@@ -489,6 +481,10 @@
</dt>
+ <dt><a href="KADMOS.html#kadmos.utilities.general.get_uid">get_uid() (in module kadmos.utilities.general)</a>
+ </dt>
+
+
<dt><a href="KADMOS.html#kadmos.utilities.general.get_unique_friendly_id">get_unique_friendly_id() (in module kadmos.utilities.general)</a>
</dt>
@@ -611,6 +607,10 @@
</dt>
+ <dt><a href="KADMOS.html#kadmos.utilities.general.make_singular">make_singular() (in module kadmos.utilities.general)</a>
+ </dt>
+
+
<dt><a href="KADMOS.html#kadmos.graph.MdaoDataGraph.manipulate_coupling_nodes">manipulate_coupling_nodes() (kadmos.graph.MdaoDataGraph method)</a>
</dt>
@@ -861,10 +861,6 @@
</dt>
- <dt><a href="KADMOS.html#kadmos.utilities.general.string_eval">string_eval() (in module kadmos.utilities.general)</a>
- </dt>
-
-
<dt><a href="KADMOS.html#kadmos.graph.KadmosGraph.subgraph">subgraph() (kadmos.graph.KadmosGraph method)</a>
</dt>
@@ -894,17 +890,21 @@
<dt><a href="KADMOS.html#kadmos.graph.KadmosGraph.to_undirected">to_undirected() (kadmos.graph.KadmosGraph method)</a>
</dt>
- </dl></td>
- <td style="width: 33%" valign="top"><dl>
<dt><a href="KADMOS.html#kadmos.utilities.general.transform_data_into_strings">transform_data_into_strings() (in module kadmos.utilities.general)</a>
</dt>
+ </dl></td>
+ <td style="width: 33%" valign="top"><dl>
<dt><a href="KADMOS.html#kadmos.utilities.general.transform_string_into_format">transform_string_into_format() (in module kadmos.utilities.general)</a>
</dt>
+ <dt><a href="KADMOS.html#kadmos.utilities.general.translate_dict_keys">translate_dict_keys() (in module kadmos.utilities.general)</a>
+ </dt>
+
+
<dt><a href="KADMOS.html#kadmos.utilities.general.translate_list">translate_list() (in module kadmos.utilities.general)</a>
</dt>
@@ -950,14 +950,11 @@
<div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3>
<form class="search" action="search.html" method="get">
- <input type="text" name="q" />
- <input type="submit" value="Go" />
+ <div><input type="text" name="q" /></div>
+ <div><input type="submit" value="Go" /></div>
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
- <p class="searchtip" style="font-size: 90%">
- Enter search terms or a module, class or function name.
- </p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
@@ -978,7 +975,7 @@
</div>
<div class="footer" role="contentinfo">
© Copyright 2017, Imco van Gent.
- Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.5.
+ Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.4.4.
</div>
</body>
</html>
\ No newline at end of file
diff --git a/doc/objects.inv b/doc/objects.inv
index 06f1792004174c74928d8f02660f9524d4c2ff75..b1948b92fcc16de5d18d98fc7ffb8a1ac42f910f 100644
Binary files a/doc/objects.inv and b/doc/objects.inv differ
diff --git a/doc/py-modindex.html b/doc/py-modindex.html
index fa50c23b8c23dcf32a391f81dc17843e26f1c8ae..ae80a463c2be1fd64d09d2689b862d95e5af13ec 100644
--- a/doc/py-modindex.html
+++ b/doc/py-modindex.html
@@ -80,14 +80,11 @@
<div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3>
<form class="search" action="search.html" method="get">
- <input type="text" name="q" />
- <input type="submit" value="Go" />
+ <div><input type="text" name="q" /></div>
+ <div><input type="submit" value="Go" /></div>
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
- <p class="searchtip" style="font-size: 90%">
- Enter search terms or a module, class or function name.
- </p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
@@ -108,7 +105,7 @@
</div>
<div class="footer" role="contentinfo">
© Copyright 2017, Imco van Gent.
- Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.5.
+ Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.4.4.
</div>
</body>
</html>
\ No newline at end of file
diff --git a/doc/search.html b/doc/search.html
index 2f561eba1ead7337f7af9c82acf349a2f18ceb01..d012f248ee251835823ab6c35d9cffb6779c212b 100644
--- a/doc/search.html
+++ b/doc/search.html
@@ -99,7 +99,7 @@
</div>
<div class="footer" role="contentinfo">
© Copyright 2017, Imco van Gent.
- Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.3.5.
+ Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.4.4.
</div>
</body>
</html>
\ No newline at end of file
diff --git a/doc/searchindex.js b/doc/searchindex.js
index b913dac892be16754fc8a150307636f9e32c27b2..0516f1d435b6aadd4c9fe4bc1e36508435e49e30 100644
--- a/doc/searchindex.js
+++ b/doc/searchindex.js
@@ -1 +1 @@
-Search.setIndex({envversion:46,filenames:["KADMOS"],objects:{"":{kadmos:[0,0,0,"-"]},"kadmos.graph":{FundamentalProblemGraph:[0,3,1,""],KadmosGraph:[0,3,1,""],MdaoDataGraph:[0,3,1,""],MdaoProcessGraph:[0,3,1,""],RepositoryConnectivityGraph:[0,3,1,""]},"kadmos.graph.FundamentalProblemGraph":{add_function_problem_roles:[0,1,1,""],cleancopy:[0,1,1,""],create_mdg:[0,1,1,""],create_mpg:[0,1,1,""],get_coupling_matrix:[0,1,1,""],get_mdg:[0,1,1,""],get_mg_function_ordering:[0,1,1,""],get_mpg:[0,1,1,""],mark_as_constraint:[0,1,1,""],mark_as_design_variable:[0,1,1,""],mark_as_objective:[0,1,1,""],mark_as_qoi:[0,1,1,""]},"kadmos.graph.KadmosGraph":{add_cycle:[0,1,1,""],add_default_description:[0,1,1,""],add_default_name:[0,1,1,""],add_edge:[0,1,1,""],add_edges_from:[0,1,1,""],add_equation:[0,1,1,""],add_equation_label:[0,1,1,""],add_equation_labels:[0,1,1,""],add_node:[0,1,1,""],add_nodes_from:[0,1,1,""],add_objective_function_by_nodes:[0,1,1,""],add_path:[0,1,1,""],add_star:[0,1,1,""],add_weighted_edges_from:[0,1,1,""],adjacency_iter:[0,1,1,""],adjacency_list:[0,1,1,""],adjlist_dict_factory:[0,4,1,""],check:[0,1,1,""],check_cmdows_integrity:[0,1,1,""],check_for_coupling:[0,1,1,""],cleancopy:[0,1,1,""],clear:[0,1,1,""],copy:[0,1,1,""],copy_node_with_suffix:[0,1,1,""],count_function_nodes:[0,1,1,""],create_dsm:[0,1,1,""],degree:[0,1,1,""],degree_iter:[0,1,1,""],disconnect_problematic_variables_from:[0,1,1,""],edge_attr_dict_factory:[0,4,1,""],edges:[0,1,1,""],edges_iter:[0,1,1,""],expand_node:[0,1,1,""],find_all_nodes:[0,1,1,""],get_adjacency_matrix:[0,1,1,""],get_categorized_nodes:[0,1,1,""],get_contracted_graph:[0,1,1,""],get_direct_coupling_nodes:[0,1,1,""],get_edge_data:[0,1,1,""],get_function_graph:[0,1,1,""],get_function_metadata:[0,1,1,""],get_function_nodes:[0,1,1,""],get_graph_properties:[0,1,1,""],get_node_attributes:[0,1,1,""],get_node_subcategory:[0,1,1,""],get_nodes_based_on_strings:[0,1,1,""],get_nodes_indegree:[0,1,1,""],get_nodes_outdegree:[0,1,1,""],get_nodes_subcategory:[0,1,1,""],get_number_of_couplings:[0,1,1,""],get_partitioned_graph:[0,1,1,""],get_sources:[0,1,1,""],get_subgraph_by_function_nodes:[0,1,1,""],get_system_inputs:[0,1,1,""],get_targets:[0,1,1,""],has_edge:[0,1,1,""],has_node:[0,1,1,""],has_nodes:[0,1,1,""],has_predecessor:[0,1,1,""],has_successor:[0,1,1,""],in_degree:[0,1,1,""],in_degree_iter:[0,1,1,""],in_edges:[0,1,1,""],in_edges_iter:[0,1,1,""],inspect:[0,1,1,""],inspect_node:[0,1,1,""],inspect_nodes:[0,1,1,""],is_directed:[0,1,1,""],is_multigraph:[0,1,1,""],make_all_variables_valid:[0,1,1,""],merge_function_modes:[0,1,1,""],merge_function_nodes_based_on_modes:[0,1,1,""],merge_parallel_functions:[0,1,1,""],merge_sequential_functions:[0,1,1,""],nbunch_iter:[0,1,1,""],neighbors:[0,1,1,""],neighbors_iter:[0,1,1,""],node_dict_factory:[0,4,1,""],node_is_function:[0,1,1,""],node_is_hole:[0,1,1,""],node_is_objective_function:[0,1,1,""],node_is_output:[0,1,1,""],node_is_variable:[0,1,1,""],nodes:[0,1,1,""],nodes_iter:[0,1,1,""],nodes_with_selfloops:[0,1,1,""],number_of_edges:[0,1,1,""],number_of_nodes:[0,1,1,""],number_of_selfloops:[0,1,1,""],order:[0,1,1,""],out_degree:[0,1,1,""],out_degree_iter:[0,1,1,""],out_edges:[0,1,1,""],out_edges_iter:[0,1,1,""],plot_adjacency_matrix:[0,1,1,""],plot_graph:[0,1,1,""],predecessors:[0,1,1,""],predecessors_iter:[0,1,1,""],print_graph:[0,1,1,""],relabel_function_nodes:[0,1,1,""],remove_edge:[0,1,1,""],remove_edges_from:[0,1,1,""],remove_function_nodes:[0,1,1,""],remove_node:[0,1,1,""],remove_nodes_from:[0,1,1,""],reverse:[0,1,1,""],save:[0,1,1,""],select_objectives_from_graph:[0,1,1,""],selfloop_edges:[0,1,1,""],size:[0,1,1,""],split_variables:[0,1,1,""],subgraph:[0,1,1,""],successors:[0,1,1,""],successors_iter:[0,1,1,""],to_directed:[0,1,1,""],to_undirected:[0,1,1,""],vistoms_add:[0,1,1,""],vistoms_create:[0,1,1,""]},"kadmos.graph.MdaoDataGraph":{cleancopy:[0,1,1,""],connect_converger:[0,1,1,""],connect_coordinator:[0,1,1,""],connect_doe_block:[0,1,1,""],connect_nodes_as_output:[0,1,1,""],connect_optimizer:[0,1,1,""],connect_qoi_nodes_as_input:[0,1,1,""],copy_node_as:[0,1,1,""],manipulate_coupling_nodes:[0,1,1,""]},"kadmos.graph.MdaoProcessGraph":{add_parallel_process:[0,1,1,""],add_simple_sequential_process:[0,1,1,""],cleancopy:[0,1,1,""],connect_nested_iterators:[0,1,1,""],get_nested_process_ordering:[0,1,1,""],get_node_text:[0,1,1,""],get_process_list:[0,1,1,""],inspect_process:[0,1,1,""]},"kadmos.graph.RepositoryConnectivityGraph":{cleancopy:[0,1,1,""],get_fpg_based_on_function_nodes:[0,1,1,""],get_fpg_based_on_list_functions:[0,1,1,""],get_fpg_based_on_sinks:[0,1,1,""],get_fpg_by_function_nodes:[0,1,1,""],get_function_paths_by_objective:[0,1,1,""],get_path_combinations:[0,1,1,""],select_function_combination_from:[0,1,1,""]},"kadmos.utilities":{general:[0,0,0,"-"]},"kadmos.utilities.general":{color_list:[0,2,1,""],export_as_json:[0,2,1,""],format_string_for_d3js:[0,2,1,""],get_element_dict:[0,2,1,""],get_friendly_id:[0,2,1,""],get_list_entries:[0,2,1,""],get_mdao_setup:[0,2,1,""],get_unique_friendly_id:[0,2,1,""],hex_to_rgb:[0,2,1,""],make_camel_case:[0,2,1,""],make_plural:[0,2,1,""],open_file:[0,2,1,""],remove_if_exists:[0,2,1,""],string_eval:[0,2,1,""],test_attr_cond:[0,2,1,""],transform_data_into_strings:[0,2,1,""],transform_string_into_format:[0,2,1,""],translate_list:[0,2,1,""],unmake_camel_case:[0,2,1,""]}},objnames:{"0":["py","module","Python module"],"1":["py","method","Python method"],"2":["py","function","Python function"],"3":["py","class","Python class"],"4":["py","attribute","Python attribute"]},objtypes:{"0":"py:module","1":"py:method","2":"py:function","3":"py:class","4":"py:attribute"},terms:{"1e4":0,"5pm":0,"__iter__":0,"__len__":0,"_check_category_a":0,"_check_category_b":0,"_check_category_c":0,"_ui_d":0,"boolean":0,"case":0,"class":0,"default":0,"export":0,"final":0,"float":0,"function":0,"int":0,"long":0,"new":0,"return":0,"true":0,"while":0,abl:0,abov:0,accord:0,account:0,action:0,actual:0,add:0,add_cycl:0,add_default_descript:0,add_default_nam:0,add_edg:0,add_edges_from:0,add_equ:0,add_equation_label:0,add_function_problem_rol:0,add_nod:0,add_nodes_from:0,add_nodes_subcategori:[],add_objective_function_by_nod:0,add_parallel_process:0,add_path:0,add_simple_sequential_process:0,add_star:0,add_to_visualization_packag:[],add_weighted_edges_from:0,addit:0,adj_it:0,adj_list:0,adjac:0,adjacency_it:0,adjacency_list:0,adjlist_dict_factori:0,adjust:0,advanc:0,after:0,agile_ey01_demo:[],aircraft:0,algorithm:0,alia:0,all:0,all_nod:0,allow:0,allow_unconverged_coupl:0,alreadi:0,also:0,alwai:0,american:0,amount:0,analys:0,analysi:0,analyz:0,ani:0,anoth:0,appear:0,append:0,appli:0,applic:0,appyl:0,arbitrari:0,architectur:0,architecture_rol:0,arg:0,argument:0,around:0,ask:0,assess:0,assign:0,associ:0,assum:0,attempt:0,attr:0,attr_cond:0,attr_dict:0,attr_exclud:0,attr_includ:0,attr_list:0,attr_valu:0,attrdict:0,attribut:0,attrnam:0,automat:0,avail:0,avoid:0,back:0,base:0,baselin:0,basestr:0,becaus:0,becom:0,been:0,befor:0,begin:[],belong:0,below:0,between:0,bitbucket:[],block:0,blue:0,bool:0,both:0,bound:0,box:0,build:[],call:0,camelcas:0,can:0,capac:0,care:0,categori:0,certain:0,chang:0,characterist:0,check:0,check_cmdows_integr:0,check_for_coupl:0,child:0,choic:0,choos:0,circular:0,clariti:0,clean:0,cleancopi:0,clear:0,close:0,clutter:0,cmdow:0,collect:0,collid:0,collis:0,color:0,color_list:0,color_set:0,combin:0,common:0,compar:0,complet:0,compon:0,compress:0,comput:0,condit:0,config:0,configur:0,connect:0,connect_converg:0,connect_coordin:0,connect_doe_block:0,connect_nested_iter:0,connect_nodes_as_output:0,connect_optim:0,connect_qoi_nodes_as_input:0,consid:0,consider:0,consist:0,constraint:0,constraint_nod:0,construct:0,contain:0,content:0,contig:0,continu:0,contract:0,contracted_graph:0,contraction_level:0,contrast:0,control:0,conv_typ:0,conveni:0,convent:0,converg:0,convert:0,coordin:0,copi:0,copy_node_a:0,copy_node_with_suffix:0,copy_typ:0,correct:0,corrupt:0,count:0,count_function_nod:0,coupl:0,coupling_funct:0,cpac:0,creat:0,create_dsm:0,create_mdg:0,create_mpg:0,create_visualization_packag:[],creation:[],creator:0,crete:0,criteria:0,cross:0,current:0,custom:0,cut:0,cwd:0,cycl:0,d3j:0,data:0,data_dictionari:0,databas:[],datadict:0,datavalu:0,datetim:0,ddict:0,deep:0,deepcopi:0,defin:0,degre:0,degree_it:0,delet:0,delft:0,descend:0,descirb:[],describ:0,descript:0,design:0,design_variable_nod:0,desir:0,destin:0,destination_fold:0,detail:0,determin:0,develop:0,diagon:0,diagram:0,diciplin:[],dict:0,dictionari:0,differ:0,digraph:0,dimens:0,direct:0,directli:0,directori:0,disciplin:0,disciplinari:0,disconnect:0,disconnect_collided_target:0,disconnect_problematic_variables_from:0,disconnect_shared_sourc:0,disregard:0,distinguis:0,divid:0,doc:0,doe:0,doe_block:0,doesn:0,done:0,dont:0,download:0,draw:0,dsm:0,dtc:0,due:0,duplic:0,dynam:0,each:0,ebunch:0,edg:0,edge_attr_dict_factori:0,edge_dict:0,edge_ind:0,edge_it:0,edge_label:0,edge_list:0,edge_or_nod:0,edgelist:0,edges_it:0,edu:0,effect:0,either:0,element:0,empti:0,enabl:0,encount:0,end:0,end_in_converg:0,end_in_iterative_nod:0,end_nod:0,enrich:0,ensur:0,entri:0,entries_to_remov:0,equat:0,equival:0,error:0,especi:0,etc:0,etre:[],evalu:0,even:0,everi:0,exampl:0,examplegraph:[],exce:0,except:0,exchang:0,exclud:0,exclus:0,execut:0,exhaust:0,exist:0,expand:0,expand_nod:0,expect:0,explicit:0,export_as_json:0,export_d3js_fil:[],express:0,extend:[],extend_list_uniqu:[],extens:0,extension_list:[],extract:0,fail:0,fals:0,faster:0,fastest:0,feedback:0,feedforward:0,fig_num:0,fig_siz:0,figur:0,file:0,file_nam:0,file_path:[],file_ref:0,file_typ:0,filenam:0,filter:0,find:0,find_all_nod:0,finish:0,first:0,folder:0,follow:0,form:0,format:0,format_string_for_d3j:0,found:0,fpg:0,from:0,front:0,full:0,func_ord:0,function_ord:0,function_order_method:0,fundament:0,further:0,gauss:0,gener:0,get:0,get_adjacency_matrix:0,get_categorized_nod:0,get_contracted_graph:0,get_coupling_matrix:0,get_direct_coupling_nod:0,get_edge_data:0,get_element_dict:0,get_fpg_based_on_function_nod:0,get_fpg_based_on_list_funct:0,get_fpg_based_on_sink:0,get_fpg_by_function_nod:0,get_friendly_id:0,get_function_graph:0,get_function_metadata:0,get_function_nod:0,get_function_paths_by_object:0,get_graph_nodes_indegre:[],get_graph_nodes_outdegre:[],get_graph_properti:0,get_list_entri:0,get_mdao_setup:0,get_mdg:0,get_mg_function_ord:0,get_mpg:0,get_nested_process_ord:0,get_node_attribut:0,get_node_subcategori:0,get_node_text:0,get_nodes_based_on_str:0,get_nodes_indegre:0,get_nodes_outdegre:0,get_nodes_subcategori:0,get_number_of_coupl:0,get_partitioned_graph:0,get_path_combin:0,get_process_list:0,get_schema:[],get_sourc:0,get_subgraph_by_function_nod:0,get_system_input:0,get_target:0,get_unique_friendly_id:0,give:0,given:0,gkhome:0,glaro:0,graph_check_crit:0,graph_id:0,graph_properti:0,graphml:0,group:0,guarante:0,guess:0,handl:0,has_edg:0,has_nod:0,has_predecessor:0,has_successor:0,hash:0,hashabl:0,have:0,hello:0,here:0,hex:0,hex_to_rgb:0,highest:0,hold:0,hole:0,how:0,howev:0,html:0,http:0,ident:0,identifi:0,idf:0,ignor:0,ignore_func:0,illustr:0,implement:0,in_degre:0,in_degree_it:0,in_edg:0,in_edge_it:0,in_edges_it:0,includ:0,include_al:0,include_couplings_as_final_output:0,include_reference_data:0,include_system_var:0,incom:0,indegre:0,indent:0,indentifi:0,independ:0,index:0,indic:0,induc:0,inform:0,initi:0,inplac:0,input:0,input_list:0,inputless:0,insid:0,inspect:0,inspect_nod:0,inspect_process:0,inspir:[],instanc:0,instanceid:0,instead:0,integ:0,integr:0,interest:0,interfac:[],invalid:0,is_direct:0,is_multigraph:0,italian:0,item:0,iter:0,iterative_nod:0,itertool:0,itself:0,jacobi:0,japanes:0,json:0,just:0,kdm:0,keep:0,keep_empty_el:0,keep_objective_vari:0,keep_tex_fil:0,kei:0,kept:0,keyerror:0,keys_to_be_remov:0,keyword:0,kwarg:0,label:0,label_extens:0,languag:0,larg:0,last:0,lead:0,least:0,len:0,length:0,less:0,let:0,level:0,librari:0,like:0,limit:0,link:0,list:0,list_of_funct:0,list_of_nod:0,list_of_sink:0,literatur:0,load:0,local:0,log:0,look:0,loop:0,lost:0,lower:0,lower_bound:0,lowest:0,main:[],mainli:0,make:0,make_all_variables_valid:0,make_camel_cas:0,make_plur:0,make_plural_opt:0,mani:0,manipul:0,manipulate_coupling_nod:0,manual:0,map:0,mark:0,mark_as_constraint:0,mark_as_design_vari:0,mark_as_object:0,mark_as_qoi:0,master:0,match:0,mathproblem:[],matplotlib:0,matrix:0,max_func:0,maximum:0,mda:0,mda_typ:0,mdao:0,mdao_setup:0,mdf:0,mdg:0,mdo:0,mdo_architectur:0,meet:0,membership:0,merg:0,merge_func:0,merge_function_mod:0,merge_function_nodes_based_on_mod:0,merge_parallel_funct:0,merge_sequential_funct:0,merger:0,metadata:0,method:0,meti:0,mg_function_ord:0,middl:0,might:0,min_func:0,mind:0,minimum:0,mode:0,modeid:0,modifi:0,modul:0,more:0,most:0,move:[],move_and_open:[],mpg:0,multidigraph:0,multigraph:0,multipl:0,must:0,mutabl:0,my_obj_fcn_nam:0,mygraph:0,n_part:0,name:0,named_obj_fcn:0,nativ:0,nbrdict:0,nbunch:0,nbunch_it:0,nd_iter:0,nedg:0,need:0,neighbor:0,neighbors_it:0,nest:0,nested_funct:0,networkx:0,networkxerror:0,new_label:0,niter:0,nlist:0,nloop:0,nnode:0,no_circleview_variables_data:[],node:0,node_dict_factori:0,node_id:0,node_is_funct:0,node_is_hol:0,node_is_objective_funct:0,node_is_output:0,node_is_vari:0,node_nam:0,nodelist:0,nodes_it:0,nodes_with_selfloop:0,nomin:0,nominal_valu:0,non:0,none:0,nonetyp:0,normal:0,notat:0,note:0,number:0,number_of_edg:0,number_of_nod:0,number_of_selfloop:0,numer:0,obj_vars_cov:0,object:0,objective_nod:0,obtain:0,off:0,onc:0,onli:0,only_feedback:0,open:0,open_fil:0,open_pdf:0,oper:0,optim:0,option:0,order:0,org:0,origin:0,original_list:[],other:0,otherwis:0,our:0,out:0,out_degre:0,out_degree_it:0,out_edg:0,out_edges_it:0,outdegre:0,outgo:0,output:0,outputless:0,over:0,overal:0,overrid:0,override_with_final_output:0,overview:0,own:0,packag:0,page:0,pair:0,parallel:0,parallel_funct:0,param:0,paramet:0,part:0,partit:0,pass:0,path:0,paus:0,pdf:0,perform:0,pickl:0,place:0,platform:0,plot:0,plot_adjacency_matrix:0,plot_graph:0,plural:0,png:0,point:0,posit:0,possibl:0,post:0,pre:0,preced:0,predecessor:0,predecessors_it:0,prefix:0,presenc:0,present:0,pretti:0,pretty_print:0,print:0,print_attribut:0,print_coupl:0,print_graph:0,print_in_log:0,problem:0,problemat:0,process:0,process_info:0,produc:0,product:0,progress_path:[],prompt:0,properti:0,provid:0,psg:0,pull:0,pure:0,purpos:0,pymerg:0,pyplot:0,python:0,qoi:0,qoi_nod:0,quantiti:0,queri:0,quickli:0,quietli:0,rais:0,raise_error:0,raise_error_if_tru:0,rang:0,rce:0,read:0,readabl:0,reciproc:0,recognis:0,recurs:0,reduc:0,reduct:0,refer:0,reference_fil:0,refin:0,reflect:0,rel:0,relabel:0,relabel_function_nod:0,relev:0,remain:0,remov:0,remove_after_compress:0,remove_edg:0,remove_edges_from:0,remove_feedback:0,remove_feedforward:0,remove_function_nod:0,remove_if_exist:0,remove_nod:0,remove_nodes_from:0,replac:0,replacement_id:0,replacement_index:[],repres:0,represent:0,request:0,requir:0,resolv:0,resourc:0,respect:0,result:0,retriev:0,revers:0,rgb:0,right:0,role:0,routin:0,run:0,runtim:0,safe:0,same:0,sampl:0,sampledir:0,samplefil:0,satisfi:0,save:0,save_a:0,schema:0,script:0,search:0,second:0,see:0,seidel:0,select:0,select_function_combination_from:0,select_objectives_from_graph:0,self:0,selfloop:0,selfloop_edg:0,sellar:0,sellarproblem:[],separ:0,sequenc:0,sequenti:0,server:0,set:0,sever:0,shallow:0,share:0,should:0,show:0,show_now:0,shown:0,sidebar:0,signific:0,silent:0,similar:0,simpl:0,simpler:0,simpli:0,simplifi:0,sinc:0,singl:0,sink:0,size:0,slash:[],slave:0,small:0,some:0,sort:0,sort_bi:0,sort_kei:0,sourc:0,space:0,specif:0,specifi:0,split:0,split_all_vari:[],split_vari:0,splittabl:0,standard:0,star:0,start:0,start_nod:0,start_step:0,statement:0,step:0,still:0,store:0,str:0,strength:[],string:0,string_ev:0,structur:0,sub:0,subcategori:0,subclass:0,subdirectori:[],subfold:[],subgraph:0,subset:0,successor:0,successors_it:0,suffix:0,suit:0,sum:0,summar:0,summarize_var:0,suppli:0,sure:0,svg:0,symbol:0,syntax:0,system:0,system_input:0,tabl:0,take:0,taken:0,target:0,temporari:0,test:0,test_attr_cond:0,test_valu:0,tex:0,text:0,thei:0,them:0,therefor:0,thi:0,think:0,third:0,those:0,though:0,three:0,through:0,thu:0,time:0,timestamp:0,titl:0,to_direct:0,to_undirect:0,todo:0,togeth:0,tool:0,total:0,tpwgt:0,transfer:0,transform:0,transform_data_into_str:0,transform_string_into_format:0,translat:0,translate_list:0,tree:0,tupl:0,twice:0,two:0,type:0,uid:0,uid_length:0,uml:0,umn:0,unconnect:0,under:0,underscor:0,undirect:0,uniqu:0,unmake_camel_cas:0,unnamed_funct:0,unpack:0,until:0,unwant:0,updat:0,upper:0,upper_bound:0,usag:0,use_d3js_node_id:0,use_data_graph:0,use_png_fig:0,use_pretty_print:0,used_id:0,user:0,utm:0,valid:0,valu:0,var_dim:0,var_valu:0,variabl:0,variableinstance1:0,variableinstance2:0,variableinstance3:0,variableinstance4:0,varieti:0,versatil:0,version:0,vispack_add:[],vispack_cr:[],vispack_fold:[],vispack_vers:0,vistom:0,vistoms_add:0,vistoms_cr:0,vistoms_dir:0,vistoms_vers:0,visual:0,wai:0,want:0,warn:0,weight:0,well:0,when:0,where:0,whether:0,which:0,window:0,wing:0,without:0,wn2898:0,work:0,workflow:0,written:0,wrong:0,xdsm:0,xml:0,xmlschema:[],xpath:0,yet:0,yield:0,you:0,your:0,zero:0,zip:0},titles:["Welcome to KADMOS’s documentation!"],titleterms:{code:0,document:0,fundamentalproblemgraph:0,graph:0,kadmo:0,kadmosgraph:0,knowledgebas:0,mdaodatagraph:0,mdaoprocessgraph:0,repositoryconnectivitygraph:0,util:0,welcom:0,xmlutil:[]}})
\ No newline at end of file
+Search.setIndex({envversion:49,filenames:["KADMOS"],objects:{"":{kadmos:[0,0,0,"-"]},"kadmos.graph":{FundamentalProblemGraph:[0,1,1,""],KadmosGraph:[0,1,1,""],MdaoDataGraph:[0,1,1,""],MdaoProcessGraph:[0,1,1,""],RepositoryConnectivityGraph:[0,1,1,""]},"kadmos.graph.FundamentalProblemGraph":{add_function_problem_roles:[0,2,1,""],cleancopy:[0,2,1,""],create_mdg:[0,2,1,""],create_mpg:[0,2,1,""],get_coupling_matrix:[0,2,1,""],get_mdg:[0,2,1,""],get_mg_function_ordering:[0,2,1,""],get_mpg:[0,2,1,""],mark_as_constraint:[0,2,1,""],mark_as_design_variable:[0,2,1,""],mark_as_objective:[0,2,1,""],mark_as_qoi:[0,2,1,""]},"kadmos.graph.KadmosGraph":{add_cycle:[0,2,1,""],add_default_description:[0,2,1,""],add_default_name:[0,2,1,""],add_edge:[0,2,1,""],add_edges_from:[0,2,1,""],add_equation:[0,2,1,""],add_equation_label:[0,2,1,""],add_equation_labels:[0,2,1,""],add_nodes_from:[0,2,1,""],add_objective_function_by_nodes:[0,2,1,""],add_path:[0,2,1,""],add_star:[0,2,1,""],add_weighted_edges_from:[0,2,1,""],adjacency_iter:[0,2,1,""],adjacency_list:[0,2,1,""],adjlist_dict_factory:[0,3,1,""],check:[0,2,1,""],check_cmdows_integrity:[0,2,1,""],check_for_coupling:[0,2,1,""],cleancopy:[0,2,1,""],clear:[0,2,1,""],copy:[0,2,1,""],copy_node_with_suffix:[0,2,1,""],count_function_nodes:[0,2,1,""],create_dsm:[0,2,1,""],degree:[0,2,1,""],degree_iter:[0,2,1,""],disconnect_problematic_variables_from:[0,2,1,""],edge_attr_dict_factory:[0,3,1,""],edges:[0,2,1,""],edges_iter:[0,2,1,""],find_all_nodes:[0,2,1,""],get_adjacency_matrix:[0,2,1,""],get_categorized_nodes:[0,2,1,""],get_contracted_graph:[0,2,1,""],get_direct_coupling_nodes:[0,2,1,""],get_edge_data:[0,2,1,""],get_function_graph:[0,2,1,""],get_function_metadata:[0,2,1,""],get_function_nodes:[0,2,1,""],get_graph_properties:[0,2,1,""],get_node_attributes:[0,2,1,""],get_node_subcategory:[0,2,1,""],get_nodes_based_on_strings:[0,2,1,""],get_nodes_indegree:[0,2,1,""],get_nodes_outdegree:[0,2,1,""],get_nodes_subcategory:[0,2,1,""],get_number_of_couplings:[0,2,1,""],get_partitioned_graph:[0,2,1,""],get_sources:[0,2,1,""],get_subgraph_by_function_nodes:[0,2,1,""],get_system_inputs:[0,2,1,""],get_targets:[0,2,1,""],has_edge:[0,2,1,""],has_node:[0,2,1,""],has_nodes:[0,2,1,""],has_predecessor:[0,2,1,""],has_successor:[0,2,1,""],in_degree:[0,2,1,""],in_degree_iter:[0,2,1,""],in_edges:[0,2,1,""],in_edges_iter:[0,2,1,""],inspect:[0,2,1,""],inspect_node:[0,2,1,""],inspect_nodes:[0,2,1,""],is_directed:[0,2,1,""],is_multigraph:[0,2,1,""],make_all_variables_valid:[0,2,1,""],merge_function_modes:[0,2,1,""],merge_function_nodes_based_on_modes:[0,2,1,""],merge_parallel_functions:[0,2,1,""],merge_sequential_functions:[0,2,1,""],nbunch_iter:[0,2,1,""],neighbors:[0,2,1,""],neighbors_iter:[0,2,1,""],node_dict_factory:[0,3,1,""],node_is_function:[0,2,1,""],node_is_hole:[0,2,1,""],node_is_objective_function:[0,2,1,""],node_is_output:[0,2,1,""],node_is_variable:[0,2,1,""],nodes:[0,2,1,""],nodes_iter:[0,2,1,""],nodes_with_selfloops:[0,2,1,""],number_of_edges:[0,2,1,""],number_of_nodes:[0,2,1,""],number_of_selfloops:[0,2,1,""],order:[0,2,1,""],out_degree:[0,2,1,""],out_degree_iter:[0,2,1,""],out_edges:[0,2,1,""],out_edges_iter:[0,2,1,""],plot_adjacency_matrix:[0,2,1,""],plot_graph:[0,2,1,""],predecessors:[0,2,1,""],predecessors_iter:[0,2,1,""],print_graph:[0,2,1,""],relabel_function_nodes:[0,2,1,""],remove_edge:[0,2,1,""],remove_edges_from:[0,2,1,""],remove_function_nodes:[0,2,1,""],remove_node:[0,2,1,""],remove_nodes_from:[0,2,1,""],reverse:[0,2,1,""],save:[0,2,1,""],select_objectives_from_graph:[0,2,1,""],selfloop_edges:[0,2,1,""],size:[0,2,1,""],split_variables:[0,2,1,""],subgraph:[0,2,1,""],successors:[0,2,1,""],successors_iter:[0,2,1,""],to_directed:[0,2,1,""],to_undirected:[0,2,1,""],vistoms_add:[0,2,1,""],vistoms_create:[0,2,1,""]},"kadmos.graph.MdaoDataGraph":{cleancopy:[0,2,1,""],connect_converger:[0,2,1,""],connect_coordinator:[0,2,1,""],connect_doe_block:[0,2,1,""],connect_nodes_as_output:[0,2,1,""],connect_optimizer:[0,2,1,""],connect_qoi_nodes_as_input:[0,2,1,""],copy_node_as:[0,2,1,""],manipulate_coupling_nodes:[0,2,1,""]},"kadmos.graph.MdaoProcessGraph":{add_parallel_process:[0,2,1,""],add_simple_sequential_process:[0,2,1,""],cleancopy:[0,2,1,""],connect_nested_iterators:[0,2,1,""],get_nested_process_ordering:[0,2,1,""],get_node_text:[0,2,1,""],get_process_list:[0,2,1,""],inspect_process:[0,2,1,""]},"kadmos.graph.RepositoryConnectivityGraph":{cleancopy:[0,2,1,""],get_fpg_based_on_function_nodes:[0,2,1,""],get_fpg_based_on_list_functions:[0,2,1,""],get_fpg_based_on_sinks:[0,2,1,""],get_fpg_by_function_nodes:[0,2,1,""],get_function_paths_by_objective:[0,2,1,""],get_path_combinations:[0,2,1,""],select_function_combination_from:[0,2,1,""]},"kadmos.utilities":{general:[0,0,0,"-"]},"kadmos.utilities.general":{color_list:[0,4,1,""],export_as_json:[0,4,1,""],format_string_for_d3js:[0,4,1,""],get_element_dict:[0,4,1,""],get_friendly_id:[0,4,1,""],get_list_entries:[0,4,1,""],get_mdao_setup:[0,4,1,""],get_uid:[0,4,1,""],get_unique_friendly_id:[0,4,1,""],hex_to_rgb:[0,4,1,""],make_camel_case:[0,4,1,""],make_plural:[0,4,1,""],make_singular:[0,4,1,""],open_file:[0,4,1,""],remove_if_exists:[0,4,1,""],test_attr_cond:[0,4,1,""],transform_data_into_strings:[0,4,1,""],transform_string_into_format:[0,4,1,""],translate_dict_keys:[0,4,1,""],translate_list:[0,4,1,""],unmake_camel_case:[0,4,1,""]}},objnames:{"0":["py","module","Python module"],"1":["py","class","Python class"],"2":["py","method","Python method"],"3":["py","attribute","Python attribute"],"4":["py","function","Python function"]},objtypes:{"0":"py:module","1":"py:class","2":"py:method","3":"py:attribute","4":"py:function"},terms:{"1e4":0,"5pm":0,"__iter__":0,"__len__":0,"_check_category_a":0,"_check_category_b":0,"_check_category_c":0,"boolean":0,"case":0,"class":0,"default":0,"export":0,"final":0,"float":0,"function":0,"int":0,"long":0,"new":0,"return":0,"true":0,"while":0,abl:0,abov:0,accord:0,account:0,action:0,actual:0,add:0,add_cycl:0,add_default_descript:0,add_default_nam:0,add_edg:0,add_edges_from:0,add_equ:0,add_equation_label:0,add_function_problem_rol:0,add_nod:0,add_nodes_from:0,add_objective_function_by_nod:0,add_parallel_process:0,add_path:0,add_simple_sequential_process:0,add_star:0,add_weighted_edges_from:0,adding:0,addit:0,adj_it:0,adj_list:0,adjac:0,adjacency_it:0,adjacency_list:0,adjlist_dict_factori:0,adjust:0,advanc:0,after:0,aircraft:0,algorithm:0,alia:0,all:0,all_nod:0,allow:0,allow_unconverged_coupl:0,alreadi:0,also:0,alwai:0,american:0,amount:0,analys:0,analysi:0,analyz:0,ani:0,anoth:0,appear:0,append:0,appli:0,applic:0,appyl:0,arbitrari:0,architectur:0,architecture:0,architecture_rol:0,arg:0,argument:0,around:0,ask:0,assess:0,assign:0,associ:0,associat:0,assum:0,attempt:0,attr:0,attr_cond:0,attr_dict:0,attr_exclud:0,attr_includ:0,attr_list:0,attr_valu:0,attrdict:0,attribut:0,attrnam:0,automat:0,avail:0,avoid:0,back:0,base:0,baselin:0,basestr:0,becaus:0,becom:0,been:0,befor:0,belong:0,below:0,between:0,block:0,blue:0,bool:0,both:0,bound:0,box:0,call:0,camelcas:0,can:0,capac:0,categori:0,category:0,certain:0,chang:0,characterist:0,check:0,check_cmdows_integr:0,check_for_coupl:0,child:0,choic:0,choos:0,circular:0,clariti:0,clean:0,cleancopi:0,clear:0,close:0,clutter:0,cmdow:0,cmdows:0,collect:0,collid:0,collided:0,collis:0,collision:0,color:0,color_list:0,color_set:0,combin:0,common:0,compar:0,complet:0,compon:0,components:0,compress:0,comput:0,condit:0,config:0,configur:0,connect:0,connect_converg:0,connect_coordin:0,connect_doe_block:0,connect_nested_iter:0,connect_nodes_as_output:0,connect_optim:0,connect_qoi_nodes_as_input:0,consid:0,consider:0,consist:0,constraint:0,constraint_nod:0,construct:0,contain:0,content:0,contig:0,continu:0,contract:0,contracted_graph:0,contraction_level:0,contrast:0,control:0,conv_typ:0,conveni:0,convent:0,converg:0,convert:0,coordin:0,copi:0,copy_node_a:0,copy_node_with_suffix:0,copy_typ:0,correct:0,corrupt:0,count:0,count_function_nod:0,coupl:0,coupling:0,coupling_funct:0,cpac:0,cpacs:0,creat:0,create_dsm:0,create_mdg:0,create_mpg:0,creator:0,criteria:0,cross:0,current:0,custom:0,cut:0,cwd:0,cycl:0,d3j:0,data:0,data_dictionari:0,datadict:0,datavalu:0,datetim:0,ddict:0,deep:0,deepcopi:0,defin:0,degre:0,degree_it:0,delet:0,delft:0,descend:0,describ:0,descript:0,design:0,design_variable_nod:0,desir:0,destin:0,destination_fold:0,detail:0,determin:0,develop:0,diagon:0,diagram:0,dict:0,dictionari:0,differ:0,digraph:0,dimens:0,direct:0,directli:0,directori:0,disciplin:0,disciplinari:0,disconnect:0,disconnect_collided_target:0,disconnect_problematic_variables_from:0,disconnect_shared_sourc:0,disregard:0,distinguis:0,divid:0,doc:0,doe:0,doe_block:0,done:0,dont:0,download:0,draw:0,dsm:0,dtc:0,due:0,duplic:0,dynam:0,each:0,ebunch:0,edg:0,edge:0,edge_attr_dict_factori:0,edge_dict:0,edge_ind:0,edge_it:0,edge_label:0,edge_list:0,edge_or_nod:0,edgelist:0,edges_it:0,edu:0,effect:0,either:0,element:0,elements:0,empti:0,enabl:0,encount:0,end:0,end_in_converg:0,end_in_iterative_nod:0,end_nod:0,enrich:0,ensur:0,entri:0,entries_to_remov:0,equat:0,equival:0,error:0,especi:0,etc:0,evalu:0,even:0,everi:0,exampl:0,exce:0,except:0,exchang:0,exclud:0,exclus:0,execut:0,exhaust:0,exist:0,expect:0,explicit:0,export_as_json:0,express:0,extens:0,extract:0,fail:0,fals:0,faster:0,fastest:0,feedback:0,feedforward:0,fig_num:0,fig_siz:0,figur:0,file:0,file_nam:0,file_ref:0,file_typ:0,filenam:0,filter:0,find:0,find_all_nod:0,finish:0,first:0,folder:0,follow:0,form:0,format:0,format_string_for_d3j:0,found:0,fpg:0,from:0,front:0,full:0,func_ord:0,function_ord:0,function_order_method:0,functions:0,fundament:0,further:0,gauss:0,gener:0,get:0,get_adjacency_matrix:0,get_categorized_nod:0,get_contracted_graph:0,get_coupling_matrix:0,get_direct_coupling_nod:0,get_edge_data:0,get_element_dict:0,get_fpg_based_on_function_nod:0,get_fpg_based_on_list_funct:0,get_fpg_based_on_sink:0,get_fpg_by_function_nod:0,get_friendly_id:0,get_function_graph:0,get_function_metadata:0,get_function_nod:0,get_function_paths_by_object:0,get_graph_properti:0,get_list_entri:0,get_mdao_setup:0,get_mdg:0,get_mg_function_ord:0,get_mpg:0,get_nested_process_ord:0,get_node_attribut:0,get_node_subcategori:0,get_node_text:0,get_nodes_based_on_str:0,get_nodes_indegre:0,get_nodes_outdegre:0,get_nodes_subcategori:0,get_number_of_coupl:0,get_partitioned_graph:0,get_path_combin:0,get_process_list:0,get_sourc:0,get_subgraph_by_function_nod:0,get_system_input:0,get_target:0,get_uid:0,get_unique_friendly_id:0,give:0,given:0,gkhome:0,glaro:0,graph_check_crit:0,graph_id:0,graph_properties:0,graphml:0,group:0,groups:0,guarante:0,guess:0,handl:0,has_edg:0,has_nod:0,has_predecessor:0,has_successor:0,hashabl:0,have:0,hello:0,here:0,hex:0,hex_to_rgb:0,highest:0,hold:0,hole:0,how:0,howev:0,html:0,http:0,ident:0,identifi:0,idf:0,ignor:0,ignore_func:0,illustr:0,implement:0,in_degre:0,in_degree_it:0,in_edg:0,in_edge_it:0,in_edges_it:0,includ:0,include_al:0,include_couplings_as_final_output:0,include_reference_data:0,include_system_var:0,incom:0,indegre:0,indegree:0,indent:0,indentifi:0,independ:0,index:0,indic:0,induc:0,inform:0,initi:0,inplac:0,input:0,input_list:0,inputless:0,insid:0,inspect:0,inspect_nod:0,inspect_process:0,instanc:0,instanceid:0,instead:0,integ:0,integr:0,interest:0,invalid:0,is_direct:0,is_multigraph:0,italian:0,iter:0,iterative_nod:0,itertool:0,itself:0,jacobi:0,japanes:0,json:0,just:0,kadmo:0,kdm:0,keep:0,keep_empty_el:0,keep_objective_vari:0,keep_tex_fil:0,kei:0,kept:0,keyerror:0,keys_to_be_remov:0,keyword:0,kwarg:0,label:0,label_extens:0,languag:0,larg:0,last:0,lead:0,least:0,len:0,length:0,less:0,let:0,level:0,librari:0,like:0,limit:0,link:0,list:0,list_of_funct:0,list_of_nod:0,list_of_sink:0,literatur:0,local:0,log:0,look:0,loop:0,lost:0,lower:0,lower_bound:0,lowest:0,mainli:0,make:0,make_all_variables_valid:0,make_camel_cas:0,make_plur:0,make_plural_opt:0,make_singular:0,mani:0,manipul:0,manipulate_coupling_nod:0,manual:0,map:0,mark:0,mark_as_constraint:0,mark_as_design_vari:0,mark_as_object:0,mark_as_qoi:0,master:0,match:0,matplotlib:0,matrix:0,max_func:0,maximum:0,mda:0,mda_typ:0,mdao:0,mdao_setup:0,mdf:0,mdg:0,mdo:0,mdo_architectur:0,meet:0,membership:0,merg:0,merge_func:0,merge_function_mod:0,merge_function_nodes_based_on_mod:0,merge_parallel_funct:0,merge_sequential_funct:0,merger:0,metadata:0,method:0,meti:0,mg_function_ord:0,middl:0,might:0,min_func:0,mind:0,minimum:0,mode:0,modeid:0,modifi:0,modul:0,more:0,most:0,mpg:0,multidigraph:0,multigraph:0,multipl:0,must:0,my_obj_fcn_nam:0,mygraph:0,n_part:0,name:0,named_obj_fcn:0,nativ:0,nbrdict:0,nbunch:0,nbunch_it:0,nd_iter:0,nedg:0,need:0,neighbor:0,neighbors_it:0,nest:0,nested_funct:0,networkx:0,networkxerror:0,new_label:0,niter:0,nlist:0,nloop:0,nnode:0,node:0,node_dict_factori:0,node_id:0,node_is_funct:0,node_is_hol:0,node_is_objective_funct:0,node_is_output:0,node_is_vari:0,nodelist:0,nodes_it:0,nodes_with_selfloop:0,nomin:0,nominal_valu:0,non:0,none:0,nonetyp:0,normal:0,notat:0,note:0,number:0,number_of_edg:0,number_of_nod:0,number_of_selfloop:0,numer:0,obj_vars_cov:0,object:0,objectiv:0,objective_nod:0,obtain:0,off:0,onc:0,onli:0,only:0,only_feedback:0,open:0,open_fil:0,open_pdf:0,oper:0,optim:0,optimiz:0,option:0,optional:0,order:0,org:0,origin:0,other:0,otherwis:0,our:0,out:0,out_degre:0,out_degree_it:0,out_edg:0,out_edges_it:0,outdegre:0,outdegree:0,outgo:0,output:0,outputless:0,over:0,overal:0,overrid:0,override_with_final_output:0,overview:0,own:0,packag:0,page:0,pair:0,parallel:0,parallel_funct:0,param:0,paramet:0,part:0,partit:0,pass:0,path:0,paus:0,pdf:0,perform:0,pickl:0,place:0,platform:0,plot:0,plot_adjacency_matrix:0,plot_graph:0,plural:0,png:0,point:0,posit:0,possibl:0,post:0,pre:0,preced:0,predecessor:0,predecessors_it:0,prefer:0,prefix:0,presenc:0,present:0,pretti:0,pretty_print:0,print:0,print_attribut:0,print_coupl:0,print_graph:0,print_in_log:0,problem:0,problemat:0,process:0,process_info:0,produc:0,product:0,prompt:0,properti:0,provid:0,psg:0,pull:0,pure:0,purpos:0,pymerg:0,pyplot:0,python:0,qoi:0,qoi_nod:0,quantiti:0,queri:0,quickli:0,quietli:0,rais:0,raise_error:0,raise_error_if_tru:0,rang:0,rce:0,readabl:0,reciproc:0,recognis:0,recurs:0,reduc:0,reduct:0,refer:0,reference_fil:0,refin:0,reflect:0,rel:0,relabel:0,relabel_function_nod:0,relev:0,remain:0,remov:0,remove_after_compress:0,remove_edg:0,remove_edges_from:0,remove_feedback:0,remove_feedforward:0,remove_function_nod:0,remove_if_exist:0,remove_nod:0,remove_nodes_from:0,replac:0,replacement_id:0,repres:0,represent:0,request:0,requir:0,resolv:0,resourc:0,respect:0,result:0,retriev:0,revers:0,rgb:0,right:0,role:0,routin:0,run:0,runtim:0,safe:0,same:0,sampl:0,sampledir:0,samplefil:0,satisfi:0,save:0,save_a:0,schema:0,script:0,search:0,second:0,see:0,seidel:0,select:0,select_function_combination_from:0,select_objectives_from_graph:0,self:0,selfloop:0,selfloop_edg:0,sellar:0,separ:0,sequenc:0,sequenti:0,server:0,set:0,sever:0,shallow:0,share:0,shared:0,should:0,show:0,show_now:0,shown:0,sidebar:0,signific:0,silent:0,similar:0,simpl:0,simpler:0,simpli:0,simplifi:0,sinc:0,singl:0,singular:0,sink:0,size:0,slave:0,small:0,some:0,sort:0,sort_bi:0,sort_kei:0,sourc:0,space:0,specif:0,specifi:0,split:0,split_vari:0,splittabl:0,standard:0,star:0,start:0,start_nod:0,start_step:0,statement:0,step:0,still:0,store:0,str:0,string:0,structur:0,sub:0,subcategori:0,subcategory:0,subclass:0,subgraph:0,subset:0,successor:0,successors_it:0,suffix:0,suit:0,sum:0,summar:0,summarize_var:0,suppli:0,sure:0,svg:0,symbol:0,syntax:0,system:0,system_input:0,tabl:0,take:0,taken:0,target:0,test:0,test_attr_cond:0,test_valu:0,tex:0,text:0,thei:0,them:0,therefor:0,thi:0,think:0,third:0,those:0,though:0,three:0,through:0,thu:0,time:0,timestamp:0,titl:0,to_direct:0,to_undirect:0,todo:0,togeth:0,tool:0,total:0,tpwgt:0,transfer:0,transform:0,transform_data_into_str:0,transform_string_into_format:0,translat:0,translate_dict_kei:0,translate_list:0,tree:0,tupl:0,twice:0,two:0,type:0,uid:0,uid_length:0,uml:0,umn:0,unconnect:0,under:0,underscor:0,undirect:0,uniqu:0,unmake_camel_cas:0,unnamed_funct:0,unpack:0,until:0,unwant:0,updat:0,update:0,upper:0,upper_bound:0,usag:0,use:0,use_d3js_node_id:0,use_data_graph:0,use_png_fig:0,use_pretty_print:0,used_id:0,user:0,util:0,valid:0,valu:0,var_dim:0,var_valu:0,variabl:0,variable:0,variableinstance1:0,variableinstance2:0,variableinstance3:0,variableinstance4:0,variables:0,varieti:0,versatil:0,version:0,vispack_vers:0,vistoms:0,vistoms_add:0,vistoms_cr:0,vistoms_dir:0,vistoms_vers:0,visual:0,wai:0,want:0,warn:0,weight:0,well:0,when:0,where:0,whether:0,which:0,window:0,wing:0,without:0,wn2898:0,work:0,workflow:0,written:0,wrong:0,xdsm:0,xml:0,xpath:0,yet:0,yield:0,you:0,your:0,zero:0,zip:0},titles:["Welcome to KADMOS’s documentation!"],titleterms:{code:0,document:0,fundamentalproblemgraph:0,graph:0,kadmos:0,kadmosgraph:0,knowledgebas:0,mdaodatagraph:0,mdaoprocessgraph:0,repositoryconnectivitygraph:0,utiliti:0,welcom:0}})
\ No newline at end of file
diff --git a/kadmos/rce.py b/kadmos/rce.py
deleted file mode 100644
index c324181ab37d887511e4d6776a65892340759ead..0000000000000000000000000000000000000000
--- a/kadmos/rce.py
+++ /dev/null
@@ -1,831 +0,0 @@
-import collections
-import uuid
-import json
-
-from collections import OrderedDict as OrdDict
-from shutil import move
-
-class RceWorkflow(collections.OrderedDict):
- """
- The RCE workflow object is an ordered dictionary in which the RCE workflow file is stored. This class provides
- methods to enrich, adjust, and export the ordered dictionary.
- """
-
- # Static variables
- # TODO: Import from KadmosGraph?!
- RCE_ROLES_FUNS = ['Input Provider', # 0
- 'XML Merger', # 1
- 'XML Loader', # 2
- 'XML PyMerger', # 3
- 'CPACS Tool', # 4
- 'Converger', # 5
- 'Optimizer', # 6
- 'Consistency constraint function', # 7
- 'UXPath Filter', # 8
- 'DOE'] # 9
-
- def __init__(self, *args, **kwargs):
- super(RceWorkflow, self).__init__(*args, **kwargs)
-
- def add_rce_node(self, rce_role, node_name, location, metadata=None):
- """
- Function to add a node to the RCE workflow.
-
- :param rce_role: type of RCE node (e.g. "CPACS-tool", "Input provider", "XML merger", etc.)
- :type rce_role: str
- :param node_name: name of the node
- :type node_name: str
- :param location: location of the node in the RCE GUI
- :type location: tuple
- :param metadata: any node metadata that is required (e.g. for CPACS tools)
- :type location: tuple
- :return: new entry in RCE workflow object
- :rtype: OrderedDict
- """
-
- # Input assertions
- assert rce_role in self.RCE_ROLES_FUNS
- assert type(node_name) is str or type(node_name) is unicode
- assert len(location) == 2
- assert type(location[0]) is int
- assert type(location[1]) is int
- assert location[0] >= 0
- assert location[1] >= 0
- assert type(metadata) is dict or metadata is None
-
- # Check if nodes key already exists, otherwise add it.
- if "nodes" not in self:
- self["nodes"] = []
-
- node_identifier = str(uuid.uuid4())
- node_location = str(location[0]) + ":" + str(location[1])
- if rce_role == self.RCE_ROLES_FUNS[0]: # Input Provider
- new_node = OrdDict((
- ("identifier", node_identifier),
- ("name", node_name),
- ("location", node_location),
- ("active", "true"),
- ("component", OrdDict(
- (("identifier", "de.rcenvironment.inputprovider"),
- ("version", "3.2"),
- ("name", "Input Provider")
- ))
- ),
- ("configuration", OrdDict(
- (("storeComponentHistoryData", "true"),
- ))
- ),
- ))
- elif rce_role == self.RCE_ROLES_FUNS[4]: # CPACS Tool
- assert type(metadata) is dict, 'Metadata dictionary is required for this node.'
- new_node = OrdDict((
- ("identifier", node_identifier),
- ("name", node_name),
- ("location", node_location),
- ("active", "true"),
- ("platform", metadata['platform']),
- ("component", OrdDict(
- (("identifier", metadata['component']['identifier']),
- ("version", metadata['component']['version']),
- ("name", metadata['component']['name'])
- ))
- ),
- ("configuration", OrdDict(
- (("chosenDeleteTempDirBehavior", "deleteWorkingDirectoriesAfterWorkflowExecution"),
- ("executionMode", metadata['executionMode']),
- ("storeComponentHistoryData", "true")
- ))
- ),
- ("staticInputs", [OrdDict(
- (("identifier", str(uuid.uuid4())),
- ("name", metadata['staticInputName']),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "FileReference")
- ))]
- ),
- ("staticOutputs", [OrdDict(
- (("identifier", str(uuid.uuid4())),
- ("name", metadata['staticOutputName']),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "FileReference")
- ))]
- )
- ))
- elif rce_role == self.RCE_ROLES_FUNS[8]: # UXPath Filter
- assert type(metadata) is dict, 'Metadata dictionary is required for this node.'
- new_node = OrdDict((
- ("identifier", node_identifier),
- ("name", node_name),
- ("location", node_location),
- ("active", "true"),
- ("platform", metadata['platform']),
- ("component", OrdDict((
- ("identifier", metadata['component']['identifier']),
- ("version", metadata['component']['version']),
- ("name", metadata['component']['name'])
- ))
- ),
- ("configuration", OrdDict((
- ("chosenDeleteTempDirBehavior", "deleteWorkingDirectoriesAfterWorkflowExecution"),
- ("storeComponentHistoryData", "true")
- ))
- ),
- ("staticInputs", [OrdDict((
- ("identifier", str(uuid.uuid4())),
- ("name", metadata['staticInputNames'][0]),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "FileReference"),
- )), OrdDict((
- ("identifier", str(uuid.uuid4())),
- ("name", metadata['staticInputNames'][1]),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "FileReference")
- ))]
- ),
- ("staticOutputs", [OrdDict((
- ("identifier", str(uuid.uuid4())),
- ("name", metadata['staticOutputName']),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "FileReference")))]
- )
- ))
-
- elif rce_role == self.RCE_ROLES_FUNS[7]: # Consistency constraint function
- assert type(metadata) is dict, 'Metadata dictionary is required for this node.'
- new_node = OrdDict((
- ("identifier", node_identifier),
- ("name", node_name),
- ("location", node_location),
- ("active", "true"),
- ("platform", metadata['platform']),
- ("component", OrdDict(
- (("identifier", metadata['component']['identifier']),
- ("version", metadata['component']['version']),
- ("name", metadata['component']['name'])
- ))
- ),
- ("configuration", OrdDict(
- (("chosenDeleteTempDirBehavior", "deleteWorkingDirectoriesNever"),
- ("storeComponentHistoryData", "true")
- ))
- ),
- ("staticInputs", [OrdDict(
- (("identifier", str(uuid.uuid4())),
- ("name", metadata['staticInputNames'][0]),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "FileReference")
- )),
- OrdDict(
- (("identifier", str(uuid.uuid4())),
- ("name", metadata['staticInputNames'][1]),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "FileReference")
- ))
- ]
- ),
- ("staticOutputs", [OrdDict(
- (("identifier", str(uuid.uuid4())),
- ("name", metadata['staticOutputName']),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "FileReference")
- ))]
- )
- ))
- elif rce_role == self.RCE_ROLES_FUNS[1]: # XML Merger
- assert type(metadata) is dict, 'Metadata dictionary is required for this node.'
- new_node = OrdDict((
- ("identifier", node_identifier),
- ("name", node_name),
- ("location", node_location),
- ("active", "true"),
- ("platform", "98737cdd4b424ab9af8f6bb636382176"),
- ("component", OrdDict(
- (("identifier", "de.rcenvironment.xmlmerger"),
- ("version", "3.2"),
- ("name", "XML Merger")
- ))),
- ("configuration", OrdDict(
- (("mappingType", "Classic"),
- ("storeComponentHistoryData", "true"),
- ("xmlContent", "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<map:mappings xmlns:map=\"http://www.rcenvironment.de/2015/mapping\"\r\n xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\">\r\n\r\n <map:mapping>\r\n <map:source>/"+metadata['root_name']+"</map:source>\r\n <map:target>/"+metadata['root_name']+"</map:target>\r\n </map:mapping>\r\n\r\n</map:mappings>")
- ))),
- ("staticInputs", [OrdDict(
- (("identifier", str(uuid.uuid4())),
- ("name", "XML"),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "FileReference")
- )),
- OrdDict(
- (("identifier", str(uuid.uuid4())),
- ("name", "XML to integrate"),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "FileReference")
- ))]),
- ("staticOutputs", [OrdDict(
- (("identifier", str(uuid.uuid4())),
- ("name", "XML"),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "FileReference")
- ))]),
- ))
- elif rce_role == self.RCE_ROLES_FUNS[2]: # XML Loader
- assert type(metadata) is dict, 'Metadata XML string in dictionary is required for this node.'
- new_node = OrdDict((
- ("identifier", node_identifier),
- ("name", node_name),
- ("location", node_location),
- ("active", "true"),
- ("platform", "98737cdd4b424ab9af8f6bb636382176"),
- ("component", OrdDict((
- ("identifier", "de.rcenvironment.xmlloader"),
- ("version", "3.2"),
- ("name", "XML Loader")
- ))),
- ("configuration", OrdDict((
- ("storeComponentHistoryData", "true"),
- ("xmlContent", metadata['data_schema'])
- ))),
- ("staticOutputs", [OrdDict((
- ("identifier", str(uuid.uuid4())),
- ("name", "XML"),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "FileReference")
- ))])
- ))
- elif rce_role == self.RCE_ROLES_FUNS[3]: # XML PyMerger
- assert type(metadata) is dict, 'Metadata dictionary is required for this node.'
- assert 'number_of_xmls' in metadata, 'Number of xmls (key: number_of_xmls) should be defined in metadata ' \
- 'for this node.'
- new_node = OrdDict((
- ("identifier", node_identifier),
- ("name", node_name),
- ("location", node_location),
- ("active", "true"),
- ("platform", "98737cdd4b424ab9af8f6bb636382176"),
- ("component", OrdDict((
- ("identifier", "de.rcenvironment.integration.cpacs.CPACS-XML-merger"),
- ("version", "0.1"),
- ("name", "CPACS-XML-merger")
- ))),
- ("configuration", OrdDict((
- ("chosenDeleteTempDirBehavior", "deleteWorkingDirectoriesAfterWorkflowExecution"),
- ("n_xmls", str(metadata['number_of_xmls'])),
- ("storeComponentHistoryData", "true")
- ))),
- ("staticInputs", [OrdDict((
- ("identifier", str(uuid.uuid4())),
- ("name", "xml_in_01"),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "FileReference"),
- ("metadata", OrdDict((
- ("endpointFileName", ""),
- ))
- ))),
- OrdDict((
- ("identifier", str(uuid.uuid4())),
- ("name", "xml_in_02"),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "FileReference"),
- ("metadata", OrdDict((
- ("endpointFileName", ""),
- ))
- ))),
- OrdDict((
- ("identifier", str(uuid.uuid4())),
- ("name", "xml_in_03"),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "FileReference"),
- ("metadata", OrdDict((
- ("endpointFileName", ""),
- ))
- ))),
- OrdDict((
- ("identifier", str(uuid.uuid4())),
- ("name", "xml_in_04"),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "FileReference"),
- ("metadata", OrdDict((
- ("endpointFileName", ""),
- ))
- ))),
- OrdDict((
- ("identifier", str(uuid.uuid4())),
- ("name", "xml_in_05"),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "FileReference"),
- ("metadata", OrdDict((
- ("endpointFileName", ""),
- ))
- ))),
- OrdDict((
- ("identifier", str(uuid.uuid4())),
- ("name", "xml_in_06"),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "FileReference"),
- ("metadata", OrdDict((
- ("endpointFileName", ""),
- ))
- ))),
- OrdDict((
- ("identifier", str(uuid.uuid4())),
- ("name", "xml_in_07"),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "FileReference"),
- ("metadata", OrdDict((
- ("endpointFileName", ""),
- ))
- ))),
- OrdDict((
- ("identifier", str(uuid.uuid4())),
- ("name", "xml_in_08"),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "FileReference"),
- ("metadata", OrdDict((
- ("endpointFileName", ""),
- ))
- ))),
- OrdDict((
- ("identifier", str(uuid.uuid4())),
- ("name", "xml_in_09"),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "FileReference"),
- ("metadata", OrdDict((
- ("endpointFileName", ""),
- ))
- ))),
- OrdDict((
- ("identifier", str(uuid.uuid4())),
- ("name", "xml_in_10"),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "FileReference"),
- ("metadata", OrdDict((
- ("endpointFileName", ""),
- ))
- )))
- ]),
- ("staticOutputs", [OrdDict((
- ("identifier", str(uuid.uuid4())),
- ("name", "xml_file"),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "FileReference")
- ))])
- ))
- elif rce_role == self.RCE_ROLES_FUNS[5]: # Converger
- assert type(metadata) is dict, 'Metadata dictionary is required for this node.'
- new_node = OrdDict((
- ("identifier", node_identifier),
- ("name", node_name),
- ("location", node_location),
- ("active", "true"),
- ("platform", "98737cdd4b424ab9af8f6bb636382176"),
- ("component", OrdDict((
- ("identifier", "de.rcenvironment.converger"),
- ("version", "5"),
- ("name", "Converger")
- ))),
- ("configuration", OrdDict((
- ("epsA", metadata['configuration']['epsA']),
- ("epsR", metadata['configuration']['epsR']),
- ("isNestedLoop_5e0ed1cd", metadata['configuration']['isNestedLoop_5e0ed1cd']),
- ("iterationsToConsider", metadata['configuration']["iterationsToConsider"]),
- ("loopRerunAndFail_5e0ed1cd", metadata['configuration']["loopRerunAndFail_5e0ed1cd"]),
- ("storeComponentHistoryData", metadata['configuration']["storeComponentHistoryData"])
- ))),
- ("staticOutputs", [OrdDict((
- ("identifier", str(uuid.uuid4())),
- ("name", "Converged"),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "Boolean"),
- ("metadata", OrdDict((
- ("loopEndpointType_5e0ed1cd", "OuterLoopEndpoint"),
- ))
- ))), OrdDict((
- ("identifier", str(uuid.uuid4())),
- ("name", "Converged absolute"),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "Boolean"),
- ("metadata", OrdDict((
- ("loopEndpointType_5e0ed1cd", "OuterLoopEndpoint"),
- ))
- ))), OrdDict((
- ("identifier", str(uuid.uuid4())),
- ("name", "Converged relative"),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "Boolean"),
- ("metadata", OrdDict((
- ("loopEndpointType_5e0ed1cd", "OuterLoopEndpoint"),
- ))
- ))), OrdDict((
- ("identifier", str(uuid.uuid4())),
- ("name", "Done"),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "Boolean"),
- ("metadata", OrdDict((
- ("loopEndpointType_5e0ed1cd", "OuterLoopEndpoint"),
- ))
- ))), OrdDict((
- ("identifier", str(uuid.uuid4())),
- ("name", "Outer loop done"),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "Boolean"),
- ("metadata", OrdDict((
- ("loopEndpointType_5e0ed1cd", "InnerLoopEndpoint"),
- ))
- )))])))
- elif rce_role == self.RCE_ROLES_FUNS[6]: # Optimizer
- assert type(metadata) is dict, 'Metadata dictionary is required for this node.'
- new_node = OrdDict((
- ("identifier", node_identifier),
- ("name", node_name),
- ("location", node_location),
- ("active", "true"),
- ("platform", "98737cdd4b424ab9af8f6bb636382176"),
- ("component", OrdDict((
- ("identifier", "de.rcenvironment.optimizer"),
- ("version", "7.0"),
- ("name", "Optimizer")
- ))),
- ("configuration", OrdDict((
- ("CustomDakotaPath", metadata['configuration']['CustomDakotaPath']),
- ("algorithm", metadata['configuration']['algorithm']),
- ("dakotaExecPath", metadata['configuration']['dakotaExecPath']),
- ("loopFaultTolerance_5e0ed1cd", metadata['configuration']['loopFaultTolerance_5e0ed1cd']),
- ("loopRerunAndDiscard_5e0ed1cd", metadata['configuration']['loopRerunAndDiscard_5e0ed1cd']),
- ("loopRerunAndFail_5e0ed1cd", metadata['configuration']['loopRerunAndFail_5e0ed1cd']),
- ("methodConfigurations", metadata['configuration']['methodConfigurations']),
- ("optimizerPackageCode", metadata['configuration']['optimizerPackageCode']),
- ("preCalcFilePath", metadata['configuration']['preCalcFilePath']),
- ("storeComponentHistoryData", metadata['configuration']['storeComponentHistoryData']),
- ("usePrecalculation", metadata['configuration']['usePrecalculation'])
- ))),
- ("staticOutputs", [ OrdDict((
- ("identifier", "8be25e2b-b6f2-40fb-bbb7-b7c6971dce1a"),
- ("name", "Done"),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "Boolean"),
- ("metadata", OrdDict((
- ("loopEndpointType_5e0ed1cd", "OuterLoopEndpoint"),
- )))
- )), OrdDict((
- ("identifier", "95a93c87-d984-442b-86ce-0a6d3220a29b"),
- ("name", "Gradient request"),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "Boolean"),
- ("metadata", OrdDict((
- ("loopEndpointType_5e0ed1cd", "SelfLoopEndpoint"),
- )))
- )), OrdDict((
- ("identifier", "32cb964e-4c4f-435a-bb40-f99ff485f6f1"),
- ("name", "Iteration"),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "Integer"),
- ("metadata", OrdDict((
- ("loopEndpointType_5e0ed1cd", "SelfLoopEndpoint"),
- )))
- )), OrdDict((
- ("identifier", "71c7e2d7-bd9c-4f20-af2a-c066b53a4ec9"),
- ("name", "Outer loop done"),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "Boolean"),
- ("metadata", OrdDict((
- ("loopEndpointType_5e0ed1cd", "InnerLoopEndpoint"),
- )))
- ))])
- ))
- elif rce_role == self.RCE_ROLES_FUNS[9]: # DOE
- assert type(metadata) is dict, 'Metadata dictionary is required for this node.'
- new_node = OrdDict((
- ("identifier", node_identifier),
- ("name", node_name),
- ("location", node_location),
- ("active", "true"),
- ("platform", "98737cdd4b424ab9af8f6bb636382176"),
- ("component", OrdDict((
- ("identifier", "de.rcenvironment.doe.v2"),
- ("version", "3.3"),
- ("name", "Design of Experiments")))),
- ("configuration", OrdDict((
- ("behaviourFailedRun", metadata['configuration']['behaviourFailedRun']),
- ("endSample", metadata['configuration']['endSample']),
- ("isNestedLoop_5e0ed1cd", metadata['configuration']['isNestedLoop_5e0ed1cd']),
- ("loopFaultTolerance_5e0ed1cd", metadata['configuration']['loopFaultTolerance_5e0ed1cd']),
- ("loopRerunAndDiscard_5e0ed1cd", metadata['configuration']['loopRerunAndDiscard_5e0ed1cd']),
- ("loopRerunAndFail_5e0ed1cd", metadata['configuration']['loopRerunAndFail_5e0ed1cd']),
- ("method", metadata['configuration']['method']),
- ("runNumber", metadata['configuration']['runNumber']),
- ("seedNumber", metadata['configuration']['seedNumber']),
- ("startSample", metadata['configuration']['startSample']),
- ("storeComponentHistoryData", metadata['configuration']['storeComponentHistoryData']),
- ("table", metadata['configuration']['table'])))),
- ("staticOutputs", [OrdDict((
- ("identifier", "8b4e2040-44fb-4779-a772-ac68116e947b"),
- ("name", "Done"),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "Boolean"),
- ("metadata", OrdDict((
- ("loopEndpointType_5e0ed1cd", "OuterLoopEndpoint"),
- ))))),
- OrdDict((
- ("identifier", "edc0b70f-1d80-42cc-b3c3-1730ce51ddc0"),
- ("name", "Outer loop done"),
- ("epIdentifier", None),
- ("group", None),
- ("datatype", "Boolean"),
- ("metadata", OrdDict((
- ("loopEndpointType_5e0ed1cd", "InnerLoopEndpoint"),
- )))
- ))])
- ))
- self["nodes"].append(new_node)
-
- def add_dynamic_output(self, node_idx, name, datatype, epIdentifier='default', group=None, metadata=None):
- """
- Function to add a dynamic output entry to a given node.
-
- :param node_idx: index of the node to which a dynamic output should be added.
- :type node_idx: int
- :param name: name of the dynamic output.
- :type name:
- :param datatype:
- :type datatype:
- :param metadata:
- :type metadata:
- :return: new entry in RCE workflow object at indicated node
- :rtype: OrderedDict
- """
-
- # Input assertions
- assert type(name) is str or type(name) is unicode
- assert type(datatype) is str
- assert datatype in ["FileReference", "Float"]
- assert type(metadata) is OrdDict
-
- # Check if node already has dynamicOutputs, otherwise add it.
- if "dynamicOutputs" not in self["nodes"][node_idx]:
- self["nodes"][node_idx]["dynamicOutputs"] = []
-
- new_output = OrdDict((
- ("identifier", str(uuid.uuid4())),
- ("name", name),
- ("epIdentifier", epIdentifier),
- ("group", group),
- ("datatype", datatype),
- ("metadata", metadata)))
- self["nodes"][node_idx]["dynamicOutputs"].append(new_output)
-
- def add_dynamic_input(self, node_idx, name, datatype, epIdentifier='default', group=None, metadata=None):
- """
- Function to add dynamic input entry to a given node.
-
- :param node_idx: index of the node to which a dynamic output should be added.
- :type node_idx: int
- :param name: name of the dynamic input.
- :type name:
- :param datatype:
- :type datatype:
- :param metadata:
- :type metadata:
- :return: new entry in RCE workflow object at indicated node
- :rtype: OrderedDict
- """
-
- # Input assertions
- assert type(name) is str or type(name) is unicode
- assert type(datatype) is str
- assert datatype in ["Float", "Boolean", "FileReference"]
- assert type(metadata) is OrdDict
-
- # Check if node already has dynamicInputs, otherwise add it.
- if "dynamicInputs" not in self["nodes"][node_idx]:
- self["nodes"][node_idx]["dynamicInputs"] = []
-
- new_input = OrdDict((
- ("identifier", str(uuid.uuid4())),
- ("name", name),
- ("epIdentifier", epIdentifier),
- ("group", group),
- ("datatype", datatype),
- ("metadata", metadata)))
- self["nodes"][node_idx]["dynamicInputs"].append(new_input)
-
- def adjust_static_input(self, node_idx, stat_inp_idx, new_metadata):
- """
- Function to add dynamic input entry to a given node.
-
- :param node_idx: index of the node to which a dynamic output should be added.
- :type node_idx: int
- :param stat_inp_idx: index of the static input list entry
- :type stat_inp_idx: int
- :param new_metadata: ordered dictionary with updated metadata
- :type new_metadata: OrderedDict
- :return: new entry in RCE workflow object at indicated node
- :rtype: OrderedDict
- """
-
- # Input assertions
- assert type(node_idx) is int
- assert type(stat_inp_idx) is int
- assert type(new_metadata) is OrdDict
-
- self["nodes"][node_idx]["staticInputs"][stat_inp_idx]["metadata"] = new_metadata
-
- def add_rce_connection(self, source_id, output_id, target_id, input_id):
- """
- Function to add a connection between an input and output of two nodes in the RCE workflow object.
-
- :param source_id: identifier of the source node
- :type source_id: str
- :param output_id: identifier of the output entry of the source node
- :type output_id: str
- :param target_id: identifier of the target node
- :type target_id: str
- :param input_id: identifier of the input entry of the target node
- :type input_id: str
- :return: new entry in the RCE workflow object
- :rtype: OrderedDict
- """
-
- # Input assertions
- assert type(source_id) is str
- assert type(output_id) is str
- assert type(target_id) is str
- assert type(input_id) is str
-
- # Check if connections key already exists, otherwise add it.
- if "connections" not in self:
- self["connections"] = []
-
- new_connection = OrdDict((
- ("source", source_id),
- ("output", output_id),
- ("target", target_id),
- ("input", input_id)
- ))
- self["connections"].append(new_connection)
-
- def add_label(self, text, location, size, colorBackground, colorText = (0,0,0), alpha = 127,
- alignmentType = "TOPRIGHT", border = "false", textSize=9):
- """
- Function to add a label to the RCE workflow. A label is a rectangular box with text that is used as annotation.
-
- :param text: text to be placed in the box
- :type text: str
- :param location: location of the box in the RCE GUI (horizontal, vertical)
- :type location: tuple
- :param size: size of the box
- :type size: tuple
- :param colorBackground: background color of the box in RGB
- :type colorBackground: tuple
- :param colorText: text color of the box text in RGB
- :type colorText: tuple
- :param alpha: transparency of the annotation box
- :type alpha: int
- :param alignmentType: alignment of the text in the box (e.g. "TOPRIGHT", "CENTER", "BOTTOMLEFT", etc.)
- :type alignmentType: str
- :param border: Boolean string on whether to use a border (e.g. "true", "false")
- :type border: str
- :param textSize: size of the text in the box (e.g. 9,10,11)
- :type textSize: int
- :return: new label entry in RCE workflow object
- :rtype: OrderedDict
- """
-
- # Input assertions
- assert type(text) is str
- assert type(location) is tuple
- assert len(location) is 2
- assert type(size) is tuple
- assert len(size) is 2
- assert type(alpha) is int
- assert alpha >= 0
- assert alpha <= 255
- assert type(colorText) is tuple
- assert len(colorText) is 3
- assert type(colorBackground) is tuple
- assert len(colorBackground) is 3
- assert type(alignmentType) is str
- assert alignmentType in ["TOPRIGHT", "TOPCENTER", "TOPLEFT", "CENTERLEFT", "CENTER", "CENTERRIGHT",
- "BOTTOMLEFT", "BOTTOMCENTER", "BOTTOMRIGHT"]
- assert type(border) is str
- assert border in ["true","false"]
- assert type(textSize) is int
-
- # Check if labels key already exists, otherwise add it.
- if "labels" not in self:
- self["labels"] = []
-
- new_label = OrdDict((("identifier", str(uuid.uuid4())),
- ("text", text),
- ("location", str(location[0]) + ":" + str(location[1])),
- ("size", str(size[0]) + ":" + str(size[1])),
- ("alpha", str(alpha)),
- ("colorText", str(colorText[0]) + ":" + str(colorText[1]) + ":" + str(colorText[2])),
- ("colorBackground", str(colorBackground[0]) + ":" + str(colorBackground[1]) + ":"
- + str(colorBackground[2])),
- ("alignmentType", alignmentType),
- ("border", border),
- ("textSize", str(textSize))))
- self["labels"].append(new_label)
-
- def add_bendpoint(self, source_id, target_id, coordinates):
- """
- Function to add a bendpoint on a connection.
-
- :param source_id: identifier of the source node
- :type source_id: str
- :param target_id: identifier of the target node
- :type target_id: str
- :param coordinates: coordinates of the bend in the RCE GUI
- :type coordinates: tuple
- :return: new bendpoint entry in the RCE workflow object
- :rtype: OrderedDict
- """
-
- # Input assertions
- assert type(source_id) is str
- assert type(target_id) is str
- assert type(coordinates) is tuple
- assert len(coordinates) is 2
-
- # Check if bendpoints key already exists, otherwise add it.
- if "bendpoints" not in self:
- self["bendpoints"] = []
-
- new_bendpoint = OrdDict((("source",source_id),
- ("target",target_id),
- ("coordinates",str(coordinates[0]) + ":" + str(coordinates[1]))))
- self["bendpoints"].append(new_bendpoint)
-
- def export_to_wf_file(self, rce_wf_filename, rce_working_directory=None):
- """
- Function to export the RCE workflow object to a .wf-file.
-
- :param rce_wf_filename: name of the wf-file (e.g. 'MDA', 'MDA.wf', 'RCE_workflow')
- :type rce_wf_filename: str
- :param rce_working_directory: (optional) directory to which the workflow should be copied.
- :type rce_working_directory: str
- :return: RCE workflow file
- :rtype: file
- """
-
- # Input assertions
- assert type(rce_wf_filename) is str
- if rce_working_directory is not None:
- assert type(rce_working_directory) is str or type(rce_working_directory)
- if not rce_wf_filename[-3:] == '.wf':
- rce_wf_filename += '.wf'
-
- # Bendpoints entry in the wf-file should be double encoded.
- if "bendpoints" in self:
- encoded_bendpoints = json.dumps(self["bendpoints"])
- self["bendpoints"] = encoded_bendpoints
-
- # Labels entry in the wf-file should be double encoded.
- if "labels" in self:
- encoded_labels = json.dumps(self["labels"])
- self["labels"] = encoded_labels
-
- # Write wf-file
- with open(rce_wf_filename, 'w') as fp:
- json.dump(self, fp, indent=2)
-
- # Copy wf-file to requested folder
- if rce_working_directory is not None:
- assert rce_working_directory[-1] == '/', "Invalid RCE working directory ('%s') specified. " \
- "Last character should be a '/'." % rce_working_directory
- move(rce_wf_filename, rce_working_directory + rce_wf_filename)
-
- return 'Exporting finished...'
diff --git a/setup.py b/setup.py
index cad88bd028e2c0986c5d456a4da9d034cf6475c3..01626d1b50196b652e8ef09b05e9cb89501cd860 100644
--- a/setup.py
+++ b/setup.py
@@ -1,7 +1,7 @@
from setuptools import setup, find_packages
-version = '0.6dev'
+version = '0.7dev'
def readme():
diff --git a/submit.md b/submit.md
index 015f738a60ccea55bce39035053b9d273d0cd5f3..f9e75f53f3971aba8c1b51e8ad0635b80feecc6b 100644
--- a/submit.md
+++ b/submit.md
@@ -7,7 +7,9 @@ Instructions for submitting a new version of KADMOS to PyPi
- Adapt the [MANIFEST.in](MANIFEST.in) file (this file specifies what should be included in the distribution, by default only .py or .pyc files are included in the distribution). Normally you only need to adapt the included visualization packages here.
-- Run the release.bat file. This creates a wheel distribution in the [dist](dist) directory which should be installable with pip. Test this out.
+- Adapt the [requirements.txt](requirements.txt) file and the setup.py file w.r.t. new dependencies.
+
+- Run the release.bat file (or the three commands from the file in a terminal). This creates a wheel distribution in the [dist](dist) directory which should be installable with pip. Test this out.
- Remove intermediate distributions from the [dist](dist) directory (for example version '0.6dev').