

<!DOCTYPE html>
<!--[if IE 8]><html class="no-js lt-ie9" lang="en" > <![endif]-->
<!--[if gt IE 8]><!--> <html class="no-js" lang="en" > <!--<![endif]-->
<head>
  <meta charset="utf-8">
  
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  
  <title>aria_extension_tosca.simple_v1_0.modeling &mdash; ARIA TOSCA 0.1.1 documentation</title>
  

  
  
  
  

  

  
  
    

  

  
  
    <link rel="stylesheet" href="_static/css/theme.css" type="text/css" />
  

  

  
        <link rel="index" title="Index"
              href="genindex.html"/>
        <link rel="search" title="Search" href="search.html"/>
    <link rel="top" title="ARIA TOSCA 0.1.1 documentation" href="index.html"/>
        <link rel="next" title="aria_extension_tosca.simple_v1_0.presentation" href="aria_extension_tosca.simple_v1_0.presentation.html"/>
        <link rel="prev" title="aria_extension_tosca.simple_v1_0" href="aria_extension_tosca.simple_v1_0.html"/> 

  
  <script src="_static/js/modernizr.min.js"></script>

</head>

<body class="wy-body-for-nav" role="document">

   
  <div class="wy-grid-for-nav">

    
    <nav data-toggle="wy-nav-shift" class="wy-nav-side">
      <div class="wy-side-scroll">
        <div class="wy-side-nav-search">
          

          
            <a href="index.html" class="icon icon-home"> ARIA TOSCA
          

          
          </a>

          
            
            
              <div class="version">
                0.1.1
              </div>
            
          

          
<div role="search">
  <form id="rtd-search-form" class="wy-form" action="search.html" method="get">
    <input type="text" name="q" placeholder="Search docs" />
    <input type="hidden" name="check_keywords" value="yes" />
    <input type="hidden" name="area" value="default" />
  </form>
</div>

          
        </div>

        <div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="main navigation">
          
            
            
              
            
            
              <ul>
<li class="toctree-l1"><a class="reference internal" href="cli.html">CLI</a></li>
<li class="toctree-l1"><a class="reference internal" href="rest.html">REST</a></li>
</ul>
<ul>
<li class="toctree-l1"><a class="reference internal" href="aria.html"><code class="docutils literal"><span class="pre">aria</span></code></a></li>
<li class="toctree-l1"><a class="reference internal" href="aria.cli.html"><code class="docutils literal"><span class="pre">aria.cli</span></code></a></li>
<li class="toctree-l1"><a class="reference internal" href="aria.modeling.html"><code class="docutils literal"><span class="pre">aria.modeling</span></code></a></li>
<li class="toctree-l1"><a class="reference internal" href="aria.modeling.models.html"><code class="docutils literal"><span class="pre">aria.modeling.models</span></code></a></li>
<li class="toctree-l1"><a class="reference internal" href="aria.orchestrator.html"><code class="docutils literal"><span class="pre">aria.orchestrator</span></code></a></li>
<li class="toctree-l1"><a class="reference internal" href="aria.orchestrator.context.html"><code class="docutils literal"><span class="pre">aria.orchestrator.context</span></code></a></li>
<li class="toctree-l1"><a class="reference internal" href="aria.orchestrator.execution_plugin.html"><code class="docutils literal"><span class="pre">aria.orchestrator.execution_plugin</span></code></a></li>
<li class="toctree-l1"><a class="reference internal" href="aria.orchestrator.execution_plugin.ctx_proxy.html"><code class="docutils literal"><span class="pre">aria.orchestrator.execution_plugin.ctx_proxy</span></code></a></li>
<li class="toctree-l1"><a class="reference internal" href="aria.orchestrator.execution_plugin.ssh.html"><code class="docutils literal"><span class="pre">aria.orchestrator.execution_plugin.ssh</span></code></a></li>
<li class="toctree-l1"><a class="reference internal" href="aria.orchestrator.workflows.html"><code class="docutils literal"><span class="pre">aria.orchestrator.workflows</span></code></a></li>
<li class="toctree-l1"><a class="reference internal" href="aria.orchestrator.workflows.api.html"><code class="docutils literal"><span class="pre">aria.orchestrator.workflows.api</span></code></a></li>
<li class="toctree-l1"><a class="reference internal" href="aria.orchestrator.workflows.builtin.html"><code class="docutils literal"><span class="pre">aria.orchestrator.workflows.builtin</span></code></a></li>
<li class="toctree-l1"><a class="reference internal" href="aria.orchestrator.workflows.executor.html"><code class="docutils literal"><span class="pre">aria.orchestrator.workflows.executor</span></code></a></li>
<li class="toctree-l1"><a class="reference internal" href="aria.parser.html"><code class="docutils literal"><span class="pre">aria.parser</span></code></a></li>
<li class="toctree-l1"><a class="reference internal" href="aria.parser.consumption.html"><code class="docutils literal"><span class="pre">aria.parser.consumption</span></code></a></li>
<li class="toctree-l1"><a class="reference internal" href="aria.parser.loading.html"><code class="docutils literal"><span class="pre">aria.parser.loading</span></code></a></li>
<li class="toctree-l1"><a class="reference internal" href="aria.parser.modeling.html"><code class="docutils literal"><span class="pre">aria.parser.modeling</span></code></a></li>
<li class="toctree-l1"><a class="reference internal" href="aria.parser.presentation.html"><code class="docutils literal"><span class="pre">aria.parser.presentation</span></code></a></li>
<li class="toctree-l1"><a class="reference internal" href="aria.parser.reading.html"><code class="docutils literal"><span class="pre">aria.parser.reading</span></code></a></li>
<li class="toctree-l1"><a class="reference internal" href="aria.parser.validation.html"><code class="docutils literal"><span class="pre">aria.parser.validation</span></code></a></li>
<li class="toctree-l1"><a class="reference internal" href="aria.storage.html"><code class="docutils literal"><span class="pre">aria.storage</span></code></a></li>
<li class="toctree-l1"><a class="reference internal" href="aria.utils.html"><code class="docutils literal"><span class="pre">aria.utils</span></code></a></li>
</ul>
<ul class="current">
<li class="toctree-l1"><a class="reference internal" href="aria_extension_tosca.simple_v1_0.html"><code class="docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0</span></code></a></li>
<li class="toctree-l1 current"><a class="current reference internal" href="#"><code class="docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling</span></code></a><ul>
<li class="toctree-l2"><a class="reference internal" href="#module-aria_extension_tosca.simple_v1_0.modeling.artifacts"><code class="docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.artifacts</span></code></a></li>
<li class="toctree-l2"><a class="reference internal" href="#module-aria_extension_tosca.simple_v1_0.modeling.capabilities"><code class="docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.capabilities</span></code></a></li>
<li class="toctree-l2"><a class="reference internal" href="#module-aria_extension_tosca.simple_v1_0.modeling.constraints"><code class="docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.constraints</span></code></a></li>
<li class="toctree-l2"><a class="reference internal" href="#module-aria_extension_tosca.simple_v1_0.modeling.copy"><code class="docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.copy</span></code></a></li>
<li class="toctree-l2"><a class="reference internal" href="#module-aria_extension_tosca.simple_v1_0.modeling.data_types"><code class="docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.data_types</span></code></a></li>
<li class="toctree-l2"><a class="reference internal" href="#module-aria_extension_tosca.simple_v1_0.modeling.functions"><code class="docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.functions</span></code></a></li>
<li class="toctree-l2"><a class="reference internal" href="#module-aria_extension_tosca.simple_v1_0.modeling.interfaces"><code class="docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.interfaces</span></code></a></li>
<li class="toctree-l2"><a class="reference internal" href="#module-aria_extension_tosca.simple_v1_0.modeling.parameters"><code class="docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.parameters</span></code></a></li>
<li class="toctree-l2"><a class="reference internal" href="#module-aria_extension_tosca.simple_v1_0.modeling.policies"><code class="docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.policies</span></code></a></li>
<li class="toctree-l2"><a class="reference internal" href="#module-aria_extension_tosca.simple_v1_0.modeling.requirements"><code class="docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.requirements</span></code></a></li>
<li class="toctree-l2"><a class="reference internal" href="#module-aria_extension_tosca.simple_v1_0.modeling.substitution_mappings"><code class="docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.substitution_mappings</span></code></a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html"><code class="docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation</span></code></a></li>
<li class="toctree-l1"><a class="reference internal" href="aria_extension_tosca.simple_nfv_v1_0.html"><code class="docutils literal"><span class="pre">aria_extension_tosca.simple_nfv_v1_0</span></code></a></li>
</ul>

            
          
        </div>
      </div>
    </nav>

    <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">

      
      <nav class="wy-nav-top" role="navigation" aria-label="top navigation">
        
          <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
          <a href="index.html">ARIA TOSCA</a>
        
      </nav>


      
      <div class="wy-nav-content">
        <div class="rst-content">
          















<div role="navigation" aria-label="breadcrumbs navigation">

  <ul class="wy-breadcrumbs">
    
      <li><a href="index.html">Docs</a> &raquo;</li>
        
      <li><code class="docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling</span></code></li>
    
    
      <li class="wy-breadcrumbs-aside">
        
            
            <a href="_sources/aria_extension_tosca.simple_v1_0.modeling.rst.txt" rel="nofollow"> View page source</a>
          
        
      </li>
    
  </ul>

  
  <hr/>
</div>
          <div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
           <div itemprop="articleBody">
            
  <div class="section" id="module-aria_extension_tosca.simple_v1_0.modeling">
<span id="aria-extension-tosca-simple-v1-0-modeling"></span><h1><a class="reference internal" href="#module-aria_extension_tosca.simple_v1_0.modeling" title="aria_extension_tosca.simple_v1_0.modeling"><code class="xref py py-mod docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling</span></code></a><a class="headerlink" href="#module-aria_extension_tosca.simple_v1_0.modeling" title="Permalink to this headline">¶</a></h1>
<p>Creates ARIA service template models based on the TOSCA presentation.</p>
<p>Relies on many helper methods in the presentation classes.</p>
<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.create_artifact_template_model">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.</code><code class="descname">create_artifact_template_model</code><span class="sig-paren">(</span><em>context</em>, <em>service_template</em>, <em>artifact</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.create_artifact_template_model" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.create_capability_template_model">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.</code><code class="descname">create_capability_template_model</code><span class="sig-paren">(</span><em>context</em>, <em>service_template</em>, <em>capability</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.create_capability_template_model" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.create_constraint">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.</code><code class="descname">create_constraint</code><span class="sig-paren">(</span><em>context</em>, <em>node_filter</em>, <em>constraint_clause</em>, <em>property_name</em>, <em>capability_name</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.create_constraint" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.create_group_template_model">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.</code><code class="descname">create_group_template_model</code><span class="sig-paren">(</span><em>context</em>, <em>service_template</em>, <em>group</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.create_group_template_model" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.create_interface_template_model">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.</code><code class="descname">create_interface_template_model</code><span class="sig-paren">(</span><em>context</em>, <em>service_template</em>, <em>interface</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.create_interface_template_model" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.create_interface_template_models">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.</code><code class="descname">create_interface_template_models</code><span class="sig-paren">(</span><em>context</em>, <em>service_template</em>, <em>interfaces</em>, <em>source_interfaces</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.create_interface_template_models" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.create_metadata_models">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.</code><code class="descname">create_metadata_models</code><span class="sig-paren">(</span><em>context</em>, <em>service_template</em>, <em>metadata</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.create_metadata_models" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.create_node_filter_constraints">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.</code><code class="descname">create_node_filter_constraints</code><span class="sig-paren">(</span><em>context</em>, <em>node_filter</em>, <em>target_node_template_constraints</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.create_node_filter_constraints" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.create_node_template_model">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.</code><code class="descname">create_node_template_model</code><span class="sig-paren">(</span><em>context</em>, <em>service_template</em>, <em>node_template</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.create_node_template_model" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.create_operation_template_model">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.</code><code class="descname">create_operation_template_model</code><span class="sig-paren">(</span><em>context</em>, <em>service_template</em>, <em>operation</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.create_operation_template_model" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.create_parameter_models_from_assignments">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.</code><code class="descname">create_parameter_models_from_assignments</code><span class="sig-paren">(</span><em>properties</em>, <em>source_properties</em>, <em>model_cls</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.create_parameter_models_from_assignments" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.create_parameter_models_from_values">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.</code><code class="descname">create_parameter_models_from_values</code><span class="sig-paren">(</span><em>properties</em>, <em>source_properties</em>, <em>model_cls</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.create_parameter_models_from_values" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.create_plugin_specification_model">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.</code><code class="descname">create_plugin_specification_model</code><span class="sig-paren">(</span><em>context</em>, <em>policy</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.create_plugin_specification_model" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.create_policy_template_model">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.</code><code class="descname">create_policy_template_model</code><span class="sig-paren">(</span><em>context</em>, <em>service_template</em>, <em>policy</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.create_policy_template_model" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.create_relationship_template_model">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.</code><code class="descname">create_relationship_template_model</code><span class="sig-paren">(</span><em>context</em>, <em>service_template</em>, <em>relationship</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.create_relationship_template_model" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.create_requirement_template_model">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.</code><code class="descname">create_requirement_template_model</code><span class="sig-paren">(</span><em>context</em>, <em>service_template</em>, <em>requirement</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.create_requirement_template_model" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.create_service_template_model">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.</code><code class="descname">create_service_template_model</code><span class="sig-paren">(</span><em>context</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.create_service_template_model" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.create_substitution_template_model">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.</code><code class="descname">create_substitution_template_model</code><span class="sig-paren">(</span><em>context</em>, <em>service_template</em>, <em>substitution_mappings</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.create_substitution_template_model" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.create_types">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.</code><code class="descname">create_types</code><span class="sig-paren">(</span><em>context</em>, <em>root</em>, <em>types</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.create_types" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.create_workflow_operation_template_model">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.</code><code class="descname">create_workflow_operation_template_model</code><span class="sig-paren">(</span><em>context</em>, <em>service_template</em>, <em>policy</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.create_workflow_operation_template_model" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.extract_implementation_primary">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.</code><code class="descname">extract_implementation_primary</code><span class="sig-paren">(</span><em>context</em>, <em>service_template</em>, <em>presentation</em>, <em>model</em>, <em>primary</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.extract_implementation_primary" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.fix_node_template_model">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.</code><code class="descname">fix_node_template_model</code><span class="sig-paren">(</span><em>context</em>, <em>service_template</em>, <em>node_template</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.fix_node_template_model" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.set_nested">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.</code><code class="descname">set_nested</code><span class="sig-paren">(</span><em>the_dict</em>, <em>keys</em>, <em>value</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.set_nested" title="Permalink to this definition">¶</a></dt>
<dd><p>If the <code class="docutils literal"><span class="pre">keys</span></code> list has just one item, puts the value in the the dict. If there are more items,
puts the value in a sub-dict, creating sub-dicts as necessary for each key.</p>
<p>For example, if <code class="docutils literal"><span class="pre">the_dict</span></code> is an empty dict, keys is <code class="docutils literal"><span class="pre">['first',</span> <span class="pre">'second',</span> <span class="pre">'third']</span></code> and
value is <code class="docutils literal"><span class="pre">'value'</span></code>, then the_dict will be: <code class="docutils literal"><span class="pre">{'first':{'second':{'third':'value'}}}</span></code>.</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 last simple">
<li><strong>the_dict</strong> (<em>{}</em>) – Dict to change</li>
<li><strong>keys</strong> (<em>[</em><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><em>basestring</em></a><em>]</em>) – Keys</li>
<li><strong>value</strong> – Value</li>
</ul>
</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.split_prefix">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.</code><code class="descname">split_prefix</code><span class="sig-paren">(</span><em>string</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.split_prefix" title="Permalink to this definition">¶</a></dt>
<dd><p>Splits the prefix on the first non-escaped “&gt;”.</p>
</dd></dl>

<div class="section" id="module-aria_extension_tosca.simple_v1_0.modeling.artifacts">
<span id="aria-extension-tosca-simple-v1-0-modeling-artifacts"></span><h2><a class="reference internal" href="#module-aria_extension_tosca.simple_v1_0.modeling.artifacts" title="aria_extension_tosca.simple_v1_0.modeling.artifacts"><code class="xref py py-mod docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.artifacts</span></code></a><a class="headerlink" href="#module-aria_extension_tosca.simple_v1_0.modeling.artifacts" title="Permalink to this headline">¶</a></h2>
<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.artifacts.get_inherited_artifact_definitions">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.artifacts.</code><code class="descname">get_inherited_artifact_definitions</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>for_presentation=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.artifacts.get_inherited_artifact_definitions" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</div>
<div class="section" id="module-aria_extension_tosca.simple_v1_0.modeling.capabilities">
<span id="aria-extension-tosca-simple-v1-0-modeling-capabilities"></span><h2><a class="reference internal" href="#module-aria_extension_tosca.simple_v1_0.modeling.capabilities" title="aria_extension_tosca.simple_v1_0.modeling.capabilities"><code class="xref py py-mod docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.capabilities</span></code></a><a class="headerlink" href="#module-aria_extension_tosca.simple_v1_0.modeling.capabilities" title="Permalink to this headline">¶</a></h2>
<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.capabilities.convert_capability_from_definition_to_assignment">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.capabilities.</code><code class="descname">convert_capability_from_definition_to_assignment</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>container</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.capabilities.convert_capability_from_definition_to_assignment" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.capabilities.get_inherited_capability_definitions">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.capabilities.</code><code class="descname">get_inherited_capability_definitions</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>for_presentation=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.capabilities.get_inherited_capability_definitions" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns our capability capability definitions added on top of those of our parent, if we have
one (recursively).</p>
<p>Allows overriding all aspects of parent capability properties except data type.</p>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.capabilities.get_inherited_valid_source_types">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.capabilities.</code><code class="descname">get_inherited_valid_source_types</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.capabilities.get_inherited_valid_source_types" title="Permalink to this definition">¶</a></dt>
<dd><p>If we haven’t set the <code class="docutils literal"><span class="pre">valid_source_types</span></code> fields, uses that value from our parent, if we have
one (recursively).</p>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.capabilities.get_template_capabilities">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.capabilities.</code><code class="descname">get_template_capabilities</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.capabilities.get_template_capabilities" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the node type’s capabilities with our assignments to properties and attributes merged
in.</p>
<p>Capability properties’ default values, if available, will be used if we did not assign them.</p>
<p>Makes sure that required properties indeed end up with a value.</p>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.capabilities.merge_capability_definition_from_type">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.capabilities.</code><code class="descname">merge_capability_definition_from_type</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>capability_definition</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.capabilities.merge_capability_definition_from_type" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</div>
<div class="section" id="module-aria_extension_tosca.simple_v1_0.modeling.constraints">
<span id="aria-extension-tosca-simple-v1-0-modeling-constraints"></span><h2><a class="reference internal" href="#module-aria_extension_tosca.simple_v1_0.modeling.constraints" title="aria_extension_tosca.simple_v1_0.modeling.constraints"><code class="xref py py-mod docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.constraints</span></code></a><a class="headerlink" href="#module-aria_extension_tosca.simple_v1_0.modeling.constraints" title="Permalink to this headline">¶</a></h2>
<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.modeling.constraints.Equal">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.constraints.</code><code class="descname">Equal</code><span class="sig-paren">(</span><em>property_name</em>, <em>capability_name</em>, <em>constraint</em>, <em>as_list=False</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.Equal" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint" title="aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint</span></code></a></p>
<dl class="method">
<dt id="aria_extension_tosca.simple_v1_0.modeling.constraints.Equal.matches_evaluated">
<code class="descname">matches_evaluated</code><span class="sig-paren">(</span><em>value</em>, <em>constraint</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.Equal.matches_evaluated" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.constraints.</code><code class="descname">EvaluatingNodeTemplateConstraint</code><span class="sig-paren">(</span><em>property_name</em>, <em>capability_name</em>, <em>constraint</em>, <em>as_list=False</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria.modeling.html#aria.modeling.constraints.NodeTemplateConstraint" title="aria.modeling.constraints.NodeTemplateConstraint"><code class="xref py py-class docutils literal"><span class="pre">aria.modeling.constraints.NodeTemplateConstraint</span></code></a></p>
<p>A version of <code class="xref py py-class docutils literal"><span class="pre">NodeTemplateConstraint</span></code> with boilerplate initialization for TOSCA
constraints.</p>
<dl class="method">
<dt id="aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint.matches">
<code class="descname">matches</code><span class="sig-paren">(</span><em>source_node_template</em>, <em>target_node_template</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint.matches" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="method">
<dt id="aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint.matches_evaluated">
<code class="descname">matches_evaluated</code><span class="sig-paren">(</span><em>value</em>, <em>constraint</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint.matches_evaluated" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.modeling.constraints.GreaterOrEqual">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.constraints.</code><code class="descname">GreaterOrEqual</code><span class="sig-paren">(</span><em>property_name</em>, <em>capability_name</em>, <em>constraint</em>, <em>as_list=False</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.GreaterOrEqual" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint" title="aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint</span></code></a></p>
<dl class="method">
<dt id="aria_extension_tosca.simple_v1_0.modeling.constraints.GreaterOrEqual.matches_evaluated">
<code class="descname">matches_evaluated</code><span class="sig-paren">(</span><em>value</em>, <em>constraint</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.GreaterOrEqual.matches_evaluated" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.modeling.constraints.GreaterThan">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.constraints.</code><code class="descname">GreaterThan</code><span class="sig-paren">(</span><em>property_name</em>, <em>capability_name</em>, <em>constraint</em>, <em>as_list=False</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.GreaterThan" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint" title="aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint</span></code></a></p>
<dl class="method">
<dt id="aria_extension_tosca.simple_v1_0.modeling.constraints.GreaterThan.matches_evaluated">
<code class="descname">matches_evaluated</code><span class="sig-paren">(</span><em>value</em>, <em>constraint</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.GreaterThan.matches_evaluated" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.modeling.constraints.InRange">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.constraints.</code><code class="descname">InRange</code><span class="sig-paren">(</span><em>property_name</em>, <em>capability_name</em>, <em>constraint</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.InRange" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint" title="aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint</span></code></a></p>
<dl class="method">
<dt id="aria_extension_tosca.simple_v1_0.modeling.constraints.InRange.matches_evaluated">
<code class="descname">matches_evaluated</code><span class="sig-paren">(</span><em>value</em>, <em>constraints</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.InRange.matches_evaluated" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.modeling.constraints.Length">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.constraints.</code><code class="descname">Length</code><span class="sig-paren">(</span><em>property_name</em>, <em>capability_name</em>, <em>constraint</em>, <em>as_list=False</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.Length" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint" title="aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint</span></code></a></p>
<dl class="method">
<dt id="aria_extension_tosca.simple_v1_0.modeling.constraints.Length.matches_evaluated">
<code class="descname">matches_evaluated</code><span class="sig-paren">(</span><em>value</em>, <em>constraint</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.Length.matches_evaluated" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.modeling.constraints.LessOrEqual">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.constraints.</code><code class="descname">LessOrEqual</code><span class="sig-paren">(</span><em>property_name</em>, <em>capability_name</em>, <em>constraint</em>, <em>as_list=False</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.LessOrEqual" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint" title="aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint</span></code></a></p>
<dl class="method">
<dt id="aria_extension_tosca.simple_v1_0.modeling.constraints.LessOrEqual.matches_evaluated">
<code class="descname">matches_evaluated</code><span class="sig-paren">(</span><em>value</em>, <em>constraint</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.LessOrEqual.matches_evaluated" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.modeling.constraints.LessThan">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.constraints.</code><code class="descname">LessThan</code><span class="sig-paren">(</span><em>property_name</em>, <em>capability_name</em>, <em>constraint</em>, <em>as_list=False</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.LessThan" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint" title="aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint</span></code></a></p>
<dl class="method">
<dt id="aria_extension_tosca.simple_v1_0.modeling.constraints.LessThan.matches_evaluated">
<code class="descname">matches_evaluated</code><span class="sig-paren">(</span><em>value</em>, <em>constraint</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.LessThan.matches_evaluated" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.modeling.constraints.MaxLength">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.constraints.</code><code class="descname">MaxLength</code><span class="sig-paren">(</span><em>property_name</em>, <em>capability_name</em>, <em>constraint</em>, <em>as_list=False</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.MaxLength" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint" title="aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint</span></code></a></p>
<dl class="method">
<dt id="aria_extension_tosca.simple_v1_0.modeling.constraints.MaxLength.matches_evaluated">
<code class="descname">matches_evaluated</code><span class="sig-paren">(</span><em>value</em>, <em>constraint</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.MaxLength.matches_evaluated" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.modeling.constraints.MinLength">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.constraints.</code><code class="descname">MinLength</code><span class="sig-paren">(</span><em>property_name</em>, <em>capability_name</em>, <em>constraint</em>, <em>as_list=False</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.MinLength" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint" title="aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint</span></code></a></p>
<dl class="method">
<dt id="aria_extension_tosca.simple_v1_0.modeling.constraints.MinLength.matches_evaluated">
<code class="descname">matches_evaluated</code><span class="sig-paren">(</span><em>value</em>, <em>constraint</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.MinLength.matches_evaluated" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.modeling.constraints.Pattern">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.constraints.</code><code class="descname">Pattern</code><span class="sig-paren">(</span><em>property_name</em>, <em>capability_name</em>, <em>constraint</em>, <em>as_list=False</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.Pattern" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint" title="aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint</span></code></a></p>
<dl class="method">
<dt id="aria_extension_tosca.simple_v1_0.modeling.constraints.Pattern.matches_evaluated">
<code class="descname">matches_evaluated</code><span class="sig-paren">(</span><em>value</em>, <em>constraint</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.Pattern.matches_evaluated" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.modeling.constraints.ValidValues">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.constraints.</code><code class="descname">ValidValues</code><span class="sig-paren">(</span><em>property_name</em>, <em>capability_name</em>, <em>constraint</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.ValidValues" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint" title="aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.constraints.EvaluatingNodeTemplateConstraint</span></code></a></p>
<dl class="method">
<dt id="aria_extension_tosca.simple_v1_0.modeling.constraints.ValidValues.matches_evaluated">
<code class="descname">matches_evaluated</code><span class="sig-paren">(</span><em>value</em>, <em>constraints</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.constraints.ValidValues.matches_evaluated" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

</div>
<div class="section" id="module-aria_extension_tosca.simple_v1_0.modeling.copy">
<span id="aria-extension-tosca-simple-v1-0-modeling-copy"></span><h2><a class="reference internal" href="#module-aria_extension_tosca.simple_v1_0.modeling.copy" title="aria_extension_tosca.simple_v1_0.modeling.copy"><code class="xref py py-mod docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.copy</span></code></a><a class="headerlink" href="#module-aria_extension_tosca.simple_v1_0.modeling.copy" title="Permalink to this headline">¶</a></h2>
<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.copy.get_default_raw_from_copy">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.copy.</code><code class="descname">get_default_raw_from_copy</code><span class="sig-paren">(</span><em>presentation</em>, <em>field_name</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.copy.get_default_raw_from_copy" title="Permalink to this definition">¶</a></dt>
<dd><p>Used for the <code class="docutils literal"><span class="pre">_get_default_raw</span></code> field hook.</p>
</dd></dl>

</div>
<div class="section" id="module-aria_extension_tosca.simple_v1_0.modeling.data_types">
<span id="aria-extension-tosca-simple-v1-0-modeling-data-types"></span><h2><a class="reference internal" href="#module-aria_extension_tosca.simple_v1_0.modeling.data_types" title="aria_extension_tosca.simple_v1_0.modeling.data_types"><code class="xref py py-mod docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.data_types</span></code></a><a class="headerlink" href="#module-aria_extension_tosca.simple_v1_0.modeling.data_types" title="Permalink to this headline">¶</a></h2>
<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.data_types.apply_constraint_to_value">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.data_types.</code><code class="descname">apply_constraint_to_value</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>constraint_clause</em>, <em>value</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.data_types.apply_constraint_to_value" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns false if the value does not conform to the constraint.</p>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.data_types.apply_constraints_to_value">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.data_types.</code><code class="descname">apply_constraints_to_value</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>constraints</em>, <em>value</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.data_types.apply_constraints_to_value" title="Permalink to this definition">¶</a></dt>
<dd><p>Applies all constraints to the value. If the value conforms, returns the value. If it does not
conform, returns None.</p>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.data_types.coerce_data_type_value">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.data_types.</code><code class="descname">coerce_data_type_value</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>data_type</em>, <em>entry_schema</em>, <em>constraints</em>, <em>value</em>, <em>aspect</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.data_types.coerce_data_type_value" title="Permalink to this definition">¶</a></dt>
<dd><p>Handles the <code class="docutils literal"><span class="pre">_coerce_data()</span></code> hook for complex data types.</p>
<p>There are two kinds of handling:</p>
<ol class="arabic simple">
<li>If we have a primitive type as our great ancestor, then we do primitive type coersion, and
just check for constraints.</li>
<li>Otherwise, for normal complex data types we return the assigned property values while making
sure they are defined in our type. The property definition’s default value, if available,
will be used if we did not assign it. We also make sure that required definitions indeed end
up with a value.</li>
</ol>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.data_types.coerce_to_data_type_class">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.data_types.</code><code class="descname">coerce_to_data_type_class</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>cls</em>, <em>entry_schema</em>, <em>constraints</em>, <em>value</em>, <em>aspect=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.data_types.coerce_to_data_type_class" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the value after it’s coerced to a data type class, reporting validation errors if it
cannot be coerced. Constraints will be applied after coersion.</p>
<p>Will either call a <code class="docutils literal"><span class="pre">_create</span></code> static function in the class, or instantiate it using a
constructor if <code class="docutils literal"><span class="pre">_create</span></code> is not available.</p>
<p>This will usually be called by a <code class="docutils literal"><span class="pre">coerce_value</span></code> extension hook in a <code class="xref py py-class docutils literal"><span class="pre">DataType</span></code>.</p>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.data_types.coerce_to_primitive">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.data_types.</code><code class="descname">coerce_to_primitive</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>primitive_type</em>, <em>constraints</em>, <em>value</em>, <em>aspect=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.data_types.coerce_to_primitive" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the value after it’s coerced to a primitive type, translating exceptions to validation
errors if it cannot be coerced.</p>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.data_types.coerce_value">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.data_types.</code><code class="descname">coerce_value</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>the_type</em>, <em>entry_schema</em>, <em>constraints</em>, <em>value</em>, <em>aspect=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.data_types.coerce_value" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the value after it’s coerced to its type, reporting validation errors if it cannot be
coerced.</p>
<p>Supports both complex data types and primitives.</p>
<p>Data types can use the <code class="docutils literal"><span class="pre">coerce_value</span></code> extension to hook their own specialized function.
If the extension is present, we will delegate to that hook.</p>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.data_types.get_container_data_type">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.data_types.</code><code class="descname">get_container_data_type</code><span class="sig-paren">(</span><em>presentation</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.data_types.get_container_data_type" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.data_types.get_data_type">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.data_types.</code><code class="descname">get_data_type</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>field_name</em>, <em>allow_none=False</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.data_types.get_data_type" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the type, whether it’s a complex data type (a DataType instance) or a primitive (a
Python primitive type class).</p>
<p>If the type is not specified, defaults to <a class="reference external" href="https://docs.python.org/2.7/library/functions.html#str" title="(in Python v2.7)"><code class="xref py py-class docutils literal"><span class="pre">str</span></code></a>, per note in section 3.2.1.1 of the
<a class="reference external" href="http://docs.oasis-open.org/tosca/TOSCA-Simple-Profile-YAML/v1.0/cos01/TOSCA-Simple-Profile-YAML-v1.0-cos01.html#_Toc379455072">TOSCA Simple Profile v1.0 cos01 specification</a></p>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.data_types.get_data_type_name">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.data_types.</code><code class="descname">get_data_type_name</code><span class="sig-paren">(</span><em>the_type</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.data_types.get_data_type_name" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the name of the type, whether it’s a DataType, a primitive type, or another class.</p>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.data_types.get_data_type_value">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.data_types.</code><code class="descname">get_data_type_value</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>field_name</em>, <em>type_name</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.data_types.get_data_type_value" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.data_types.get_inherited_constraints">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.data_types.</code><code class="descname">get_inherited_constraints</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.data_types.get_inherited_constraints" title="Permalink to this definition">¶</a></dt>
<dd><p>If we don’t have constraints, will return our parent’s constraints (if we have one),
recursively.</p>
<p>Implication: if we define even one constraint, the parent’s constraints will not be inherited.</p>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.data_types.get_primitive_data_type">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.data_types.</code><code class="descname">get_primitive_data_type</code><span class="sig-paren">(</span><em>type_name</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.data_types.get_primitive_data_type" title="Permalink to this definition">¶</a></dt>
<dd><p>Many of the types we use in this profile are built-in types from the YAML 1.2 specification
(i.e., those identified by the “<a class="reference external" href="tag:yaml.org,2002">tag:yaml.org,2002</a>” version tag) [YAML-1.2].</p>
<p>See the <a class="reference external" href="http://docs.oasis-open.org/tosca/TOSCA-Simple-Profile-YAML/v1.0/cos01/TOSCA-Simple-Profile-YAML-v1.0-cos01.html#_Toc373867862">TOSCA Simple Profile v1.0 cos01 specification</a></p>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.data_types.get_property_constraints">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.data_types.</code><code class="descname">get_property_constraints</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.data_types.get_property_constraints" title="Permalink to this definition">¶</a></dt>
<dd><p>If we don’t have constraints, will return our type’s constraints (if we have one), recursively.</p>
<p>Implication: if we define even one constraint, the type’s constraints will not be inherited.</p>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.data_types.report_issue_for_bad_format">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.data_types.</code><code class="descname">report_issue_for_bad_format</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>the_type</em>, <em>value</em>, <em>aspect</em>, <em>e</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.data_types.report_issue_for_bad_format" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.data_types.validate_data_type_name">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.data_types.</code><code class="descname">validate_data_type_name</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.data_types.validate_data_type_name" title="Permalink to this definition">¶</a></dt>
<dd><p>Makes sure the complex data type’s name is not that of a built-in type.</p>
</dd></dl>

</div>
<div class="section" id="module-aria_extension_tosca.simple_v1_0.modeling.functions">
<span id="aria-extension-tosca-simple-v1-0-modeling-functions"></span><h2><a class="reference internal" href="#module-aria_extension_tosca.simple_v1_0.modeling.functions" title="aria_extension_tosca.simple_v1_0.modeling.functions"><code class="xref py py-mod docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.functions</span></code></a><a class="headerlink" href="#module-aria_extension_tosca.simple_v1_0.modeling.functions" title="Permalink to this headline">¶</a></h2>
<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.Concat">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.functions.</code><code class="descname">Concat</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>argument</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.Concat" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria.modeling.html#aria.modeling.functions.Function" title="aria.modeling.functions.Function"><code class="xref py py-class docutils literal"><span class="pre">aria.modeling.functions.Function</span></code></a></p>
<p>The <code class="docutils literal"><span class="pre">concat</span></code> function is used to concatenate two or more string values within a TOSCA
service template.</p>
<dl class="method">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.Concat.__evaluate__">
<code class="descname">__evaluate__</code><span class="sig-paren">(</span><em>container_holder</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.Concat.__evaluate__" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.Concat.as_raw">
<code class="descname">as_raw</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.Concat.as_raw" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.GetArtifact">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.functions.</code><code class="descname">GetArtifact</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>argument</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.GetArtifact" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria.modeling.html#aria.modeling.functions.Function" title="aria.modeling.functions.Function"><code class="xref py py-class docutils literal"><span class="pre">aria.modeling.functions.Function</span></code></a></p>
<p>The <code class="docutils literal"><span class="pre">get_artifact</span></code> function is used to retrieve artifact location between modelable
entities defined in the same service template.</p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.GetArtifact.as_raw">
<code class="descname">as_raw</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.GetArtifact.as_raw" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.GetAttribute">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.functions.</code><code class="descname">GetAttribute</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>argument</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.GetAttribute" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria.modeling.html#aria.modeling.functions.Function" title="aria.modeling.functions.Function"><code class="xref py py-class docutils literal"><span class="pre">aria.modeling.functions.Function</span></code></a></p>
<p>The <code class="docutils literal"><span class="pre">get_attribute</span></code> function is used to retrieve the values of named attributes declared
by the referenced node or relationship template name.</p>
<dl class="method">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.GetAttribute.__evaluate__">
<code class="descname">__evaluate__</code><span class="sig-paren">(</span><em>container_holder</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.GetAttribute.__evaluate__" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.GetAttribute.as_raw">
<code class="descname">as_raw</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.GetAttribute.as_raw" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.GetInput">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.functions.</code><code class="descname">GetInput</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>argument</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.GetInput" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria.modeling.html#aria.modeling.functions.Function" title="aria.modeling.functions.Function"><code class="xref py py-class docutils literal"><span class="pre">aria.modeling.functions.Function</span></code></a></p>
<p>The <code class="docutils literal"><span class="pre">get_input</span></code> function is used to retrieve the values of properties declared within the
inputs section of a TOSCA Service Template.</p>
<dl class="method">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.GetInput.__evaluate__">
<code class="descname">__evaluate__</code><span class="sig-paren">(</span><em>container_holder</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.GetInput.__evaluate__" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.GetInput.as_raw">
<code class="descname">as_raw</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.GetInput.as_raw" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.GetNodesOfType">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.functions.</code><code class="descname">GetNodesOfType</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>argument</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.GetNodesOfType" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria.modeling.html#aria.modeling.functions.Function" title="aria.modeling.functions.Function"><code class="xref py py-class docutils literal"><span class="pre">aria.modeling.functions.Function</span></code></a></p>
<p>The <code class="docutils literal"><span class="pre">get_nodes_of_type</span></code> function can be used to retrieve a list of all known instances of
nodes of the declared Node Type.</p>
<dl class="method">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.GetNodesOfType.__evaluate__">
<code class="descname">__evaluate__</code><span class="sig-paren">(</span><em>container</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.GetNodesOfType.__evaluate__" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.GetNodesOfType.as_raw">
<code class="descname">as_raw</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.GetNodesOfType.as_raw" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.GetOperationOutput">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.functions.</code><code class="descname">GetOperationOutput</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>argument</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.GetOperationOutput" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria.modeling.html#aria.modeling.functions.Function" title="aria.modeling.functions.Function"><code class="xref py py-class docutils literal"><span class="pre">aria.modeling.functions.Function</span></code></a></p>
<p>The <code class="docutils literal"><span class="pre">get_operation_output</span></code> function is used to retrieve the values of variables exposed /
exported from an interface operation.</p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.GetOperationOutput.as_raw">
<code class="descname">as_raw</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.GetOperationOutput.as_raw" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.GetProperty">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.functions.</code><code class="descname">GetProperty</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>argument</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.GetProperty" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria.modeling.html#aria.modeling.functions.Function" title="aria.modeling.functions.Function"><code class="xref py py-class docutils literal"><span class="pre">aria.modeling.functions.Function</span></code></a></p>
<p>The <code class="docutils literal"><span class="pre">get_property</span></code> function is used to retrieve property values between modelable entities
defined in the same service template.</p>
<dl class="method">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.GetProperty.__evaluate__">
<code class="descname">__evaluate__</code><span class="sig-paren">(</span><em>container_holder</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.GetProperty.__evaluate__" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.GetProperty.as_raw">
<code class="descname">as_raw</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.GetProperty.as_raw" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.Token">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.functions.</code><code class="descname">Token</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>argument</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.Token" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria.modeling.html#aria.modeling.functions.Function" title="aria.modeling.functions.Function"><code class="xref py py-class docutils literal"><span class="pre">aria.modeling.functions.Function</span></code></a></p>
<p>The <code class="docutils literal"><span class="pre">token</span></code> function is used within a TOSCA service template on a string to parse out
(tokenize) substrings separated by one or more token characters within a larger string.</p>
<dl class="method">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.Token.__evaluate__">
<code class="descname">__evaluate__</code><span class="sig-paren">(</span><em>container_holder</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.Token.__evaluate__" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.Token.as_raw">
<code class="descname">as_raw</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.Token.as_raw" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.evaluate">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.functions.</code><code class="descname">evaluate</code><span class="sig-paren">(</span><em>value</em>, <em>final</em>, <em>container_holder</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.evaluate" title="Permalink to this definition">¶</a></dt>
<dd><p>Calls <code class="docutils literal"><span class="pre">__evaluate__</span></code> and passes on <code class="docutils literal"><span class="pre">final</span></code> state.</p>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.get_function">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.functions.</code><code class="descname">get_function</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>value</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.get_function" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.get_hosts">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.functions.</code><code class="descname">get_hosts</code><span class="sig-paren">(</span><em>container_holder</em>, <em>name</em>, <em>locator</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.get_hosts" title="Permalink to this definition">¶</a></dt>
<dd><p>A TOSCA orchestrator will interpret this keyword to refer to the all nodes that “host” the node
using this reference (i.e., as identified by its HostedOn relationship).</p>
<p>Specifically, TOSCA orchestrators that encounter this keyword when evaluating the get_attribute
or <code class="docutils literal"><span class="pre">get_property</span></code> functions SHALL search each node along the “HostedOn” relationship chain
starting at the immediate node that hosts the node where the function was evaluated (and then
that node’s host node, and so forth) until a match is found or the “HostedOn” relationship chain
ends.</p>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.get_modelable_entities">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.functions.</code><code class="descname">get_modelable_entities</code><span class="sig-paren">(</span><em>container_holder</em>, <em>name</em>, <em>locator</em>, <em>modelable_entity_name</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.get_modelable_entities" title="Permalink to this definition">¶</a></dt>
<dd><p>The following keywords MAY be used in some TOSCA function in place of a TOSCA Node or
Relationship Template name.</p>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.get_modelable_entity_parameter">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.functions.</code><code class="descname">get_modelable_entity_parameter</code><span class="sig-paren">(</span><em>modelable_entity</em>, <em>parameters</em>, <em>nested_parameter_name_or_index</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.get_modelable_entity_parameter" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.get_self">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.functions.</code><code class="descname">get_self</code><span class="sig-paren">(</span><em>container_holder</em>, <em>name</em>, <em>locator</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.get_self" title="Permalink to this definition">¶</a></dt>
<dd><p>A TOSCA orchestrator will interpret this keyword as the Node or Relationship Template instance
that contains the function at the time the function is evaluated.</p>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.get_source">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.functions.</code><code class="descname">get_source</code><span class="sig-paren">(</span><em>container_holder</em>, <em>name</em>, <em>locator</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.get_source" title="Permalink to this definition">¶</a></dt>
<dd><p>A TOSCA orchestrator will interpret this keyword as the Node Template instance that is at the
source end of the relationship that contains the referencing function.</p>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.get_target">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.functions.</code><code class="descname">get_target</code><span class="sig-paren">(</span><em>container_holder</em>, <em>name</em>, <em>locator</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.get_target" title="Permalink to this definition">¶</a></dt>
<dd><p>A TOSCA orchestrator will interpret this keyword as the Node Template instance that is at the
target end of the relationship that contains the referencing function.</p>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.invalid_modelable_entity_name">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.functions.</code><code class="descname">invalid_modelable_entity_name</code><span class="sig-paren">(</span><em>name</em>, <em>index</em>, <em>value</em>, <em>locator</em>, <em>contexts</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.invalid_modelable_entity_name" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.invalid_value">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.functions.</code><code class="descname">invalid_value</code><span class="sig-paren">(</span><em>name</em>, <em>index</em>, <em>the_type</em>, <em>explanation</em>, <em>value</em>, <em>locator</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.invalid_value" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.parse_bool">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.functions.</code><code class="descname">parse_bool</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>name</em>, <em>index</em>, <em>explanation</em>, <em>value</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.parse_bool" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.parse_int">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.functions.</code><code class="descname">parse_int</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>name</em>, <em>index</em>, <em>explanation</em>, <em>value</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.parse_int" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.parse_modelable_entity_name">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.functions.</code><code class="descname">parse_modelable_entity_name</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>name</em>, <em>index</em>, <em>value</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.parse_modelable_entity_name" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.parse_self">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.functions.</code><code class="descname">parse_self</code><span class="sig-paren">(</span><em>presentation</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.parse_self" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.functions.parse_string_expression">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.functions.</code><code class="descname">parse_string_expression</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>name</em>, <em>index</em>, <em>explanation</em>, <em>value</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.functions.parse_string_expression" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</div>
<div class="section" id="module-aria_extension_tosca.simple_v1_0.modeling.interfaces">
<span id="aria-extension-tosca-simple-v1-0-modeling-interfaces"></span><h2><a class="reference internal" href="#module-aria_extension_tosca.simple_v1_0.modeling.interfaces" title="aria_extension_tosca.simple_v1_0.modeling.interfaces"><code class="xref py py-mod docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.interfaces</span></code></a><a class="headerlink" href="#module-aria_extension_tosca.simple_v1_0.modeling.interfaces" title="Permalink to this headline">¶</a></h2>
<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.interfaces.assign_raw_inputs">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.interfaces.</code><code class="descname">assign_raw_inputs</code><span class="sig-paren">(</span><em>context</em>, <em>values</em>, <em>assignments</em>, <em>definitions</em>, <em>interface_name</em>, <em>operation_name</em>, <em>presentation</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.interfaces.assign_raw_inputs" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.interfaces.convert_interface_definition_from_type_to_raw_template">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.interfaces.</code><code class="descname">convert_interface_definition_from_type_to_raw_template</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.interfaces.convert_interface_definition_from_type_to_raw_template" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.interfaces.convert_interface_definition_from_type_to_template">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.interfaces.</code><code class="descname">convert_interface_definition_from_type_to_template</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>container</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.interfaces.convert_interface_definition_from_type_to_template" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.interfaces.convert_requirement_interface_definitions_from_type_to_raw_template">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.interfaces.</code><code class="descname">convert_requirement_interface_definitions_from_type_to_raw_template</code><span class="sig-paren">(</span><em>context</em>, <em>raw_requirement</em>, <em>interface_definitions</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.interfaces.convert_requirement_interface_definitions_from_type_to_raw_template" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.interfaces.get_and_override_input_definitions_from_type">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.interfaces.</code><code class="descname">get_and_override_input_definitions_from_type</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.interfaces.get_and_override_input_definitions_from_type" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns our input definitions added on top of those of the interface type, if specified.</p>
<p>Allows overriding all aspects of parent interface type inputs except data types.</p>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.interfaces.get_and_override_operation_definitions_from_type">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.interfaces.</code><code class="descname">get_and_override_operation_definitions_from_type</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.interfaces.get_and_override_operation_definitions_from_type" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns our operation definitions added on top of those of the interface type, if specified.</p>
<p>Allows overriding all aspects of parent interface type inputs except data types.</p>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.interfaces.get_inherited_interface_definitions">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.interfaces.</code><code class="descname">get_inherited_interface_definitions</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>type_name</em>, <em>for_presentation=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.interfaces.get_inherited_interface_definitions" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns our interface definitions added on top of those of our parent, if we have one
(recursively).</p>
<p>Allows overriding all aspects of parent interfaces except interface and operation input data
types.</p>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.interfaces.get_inherited_operations">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.interfaces.</code><code class="descname">get_inherited_operations</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.interfaces.get_inherited_operations" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns our operation definitions added on top of those of our parent, if we have one
(recursively).</p>
<p>Allows overriding all aspects of parent operations except input data types.</p>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.interfaces.get_template_interfaces">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.interfaces.</code><code class="descname">get_template_interfaces</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>type_name</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.interfaces.get_template_interfaces" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the assigned interface_template values while making sure they are defined in the type.
This includes the interfaces themselves, their operations, and inputs for interfaces and
operations.</p>
<p>Interface and operation inputs’ default values, if available, will be used if we did not assign
them.</p>
<p>Makes sure that required inputs indeed end up with a value.</p>
<p>This code is especially complex due to the many levels of nesting involved.</p>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.interfaces.merge_input_definitions">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.interfaces.</code><code class="descname">merge_input_definitions</code><span class="sig-paren">(</span><em>context</em>, <em>inputs</em>, <em>our_inputs</em>, <em>interface_name</em>, <em>operation_name</em>, <em>presentation</em>, <em>type_name</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.interfaces.merge_input_definitions" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.interfaces.merge_interface">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.interfaces.</code><code class="descname">merge_interface</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>interface_assignment</em>, <em>our_interface_assignment</em>, <em>interface_definition</em>, <em>interface_name</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.interfaces.merge_interface" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.interfaces.merge_interface_definition">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.interfaces.</code><code class="descname">merge_interface_definition</code><span class="sig-paren">(</span><em>context</em>, <em>interface</em>, <em>our_source</em>, <em>presentation</em>, <em>type_name</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.interfaces.merge_interface_definition" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.interfaces.merge_interface_definitions">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.interfaces.</code><code class="descname">merge_interface_definitions</code><span class="sig-paren">(</span><em>context</em>, <em>interfaces</em>, <em>our_interfaces</em>, <em>presentation</em>, <em>for_presentation=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.interfaces.merge_interface_definitions" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.interfaces.merge_interface_definitions_from_their_types">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.interfaces.</code><code class="descname">merge_interface_definitions_from_their_types</code><span class="sig-paren">(</span><em>context</em>, <em>interfaces</em>, <em>presentation</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.interfaces.merge_interface_definitions_from_their_types" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.interfaces.merge_operation_definitions">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.interfaces.</code><code class="descname">merge_operation_definitions</code><span class="sig-paren">(</span><em>context</em>, <em>operations</em>, <em>our_operations</em>, <em>interface_name</em>, <em>presentation</em>, <em>type_name</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.interfaces.merge_operation_definitions" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.interfaces.merge_raw_input_definition">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.interfaces.</code><code class="descname">merge_raw_input_definition</code><span class="sig-paren">(</span><em>context</em>, <em>the_raw_input</em>, <em>our_input</em>, <em>interface_name</em>, <em>operation_name</em>, <em>presentation</em>, <em>type_name</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.interfaces.merge_raw_input_definition" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.interfaces.merge_raw_input_definitions">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.interfaces.</code><code class="descname">merge_raw_input_definitions</code><span class="sig-paren">(</span><em>context</em>, <em>raw_inputs</em>, <em>our_inputs</em>, <em>interface_name</em>, <em>operation_name</em>, <em>presentation</em>, <em>type_name</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.interfaces.merge_raw_input_definitions" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.interfaces.merge_raw_operation_definition">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.interfaces.</code><code class="descname">merge_raw_operation_definition</code><span class="sig-paren">(</span><em>context</em>, <em>raw_operation</em>, <em>our_operation</em>, <em>interface_name</em>, <em>presentation</em>, <em>type_name</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.interfaces.merge_raw_operation_definition" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.interfaces.merge_raw_operation_definitions">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.interfaces.</code><code class="descname">merge_raw_operation_definitions</code><span class="sig-paren">(</span><em>context</em>, <em>raw_operations</em>, <em>our_operations</em>, <em>interface_name</em>, <em>presentation</em>, <em>type_name</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.interfaces.merge_raw_operation_definitions" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.interfaces.validate_required_inputs">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.interfaces.</code><code class="descname">validate_required_inputs</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>assignment</em>, <em>definition</em>, <em>original_assignment</em>, <em>interface_name</em>, <em>operation_name=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.interfaces.validate_required_inputs" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</div>
<div class="section" id="module-aria_extension_tosca.simple_v1_0.modeling.parameters">
<span id="aria-extension-tosca-simple-v1-0-modeling-parameters"></span><h2><a class="reference internal" href="#module-aria_extension_tosca.simple_v1_0.modeling.parameters" title="aria_extension_tosca.simple_v1_0.modeling.parameters"><code class="xref py py-mod docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.parameters</span></code></a><a class="headerlink" href="#module-aria_extension_tosca.simple_v1_0.modeling.parameters" title="Permalink to this headline">¶</a></h2>
<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.parameters.coerce_parameter_value">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.parameters.</code><code class="descname">coerce_parameter_value</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>definition</em>, <em>value</em>, <em>aspect=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.parameters.coerce_parameter_value" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.parameters.convert_parameter_definitions_to_values">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.parameters.</code><code class="descname">convert_parameter_definitions_to_values</code><span class="sig-paren">(</span><em>context</em>, <em>definitions</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.parameters.convert_parameter_definitions_to_values" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.parameters.get_assigned_and_defined_parameter_values">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.parameters.</code><code class="descname">get_assigned_and_defined_parameter_values</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>field_name</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.parameters.get_assigned_and_defined_parameter_values" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the assigned property values while making sure they are defined in our type.</p>
<p>The property definition’s default value, if available, will be used if we did not assign it.</p>
<p>Makes sure that required properties indeed end up with a value.</p>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.parameters.get_inherited_parameter_definitions">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.parameters.</code><code class="descname">get_inherited_parameter_definitions</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>field_name</em>, <em>for_presentation=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.parameters.get_inherited_parameter_definitions" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns our parameter definitions added on top of those of our parent, if we have one
(recursively).</p>
<p>Allows overriding all aspects of parent properties except data type.</p>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.parameters.get_parameter_values">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.parameters.</code><code class="descname">get_parameter_values</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>field_name</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.parameters.get_parameter_values" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.parameters.merge_parameter_definitions">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.parameters.</code><code class="descname">merge_parameter_definitions</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>property_definitions</em>, <em>our_property_definitions</em>, <em>field_name</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.parameters.merge_parameter_definitions" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.parameters.merge_raw_parameter_definition">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.parameters.</code><code class="descname">merge_raw_parameter_definition</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>raw_property_definition</em>, <em>our_property_definition</em>, <em>field_name</em>, <em>property_name</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.parameters.merge_raw_parameter_definition" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.parameters.merge_raw_parameter_definitions">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.parameters.</code><code class="descname">merge_raw_parameter_definitions</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>raw_property_definitions</em>, <em>our_property_definitions</em>, <em>field_name</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.parameters.merge_raw_parameter_definitions" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.parameters.validate_required_values">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.parameters.</code><code class="descname">validate_required_values</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>values</em>, <em>definitions</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.parameters.validate_required_values" title="Permalink to this definition">¶</a></dt>
<dd><p>Check if required properties have not been assigned.</p>
</dd></dl>

</div>
<div class="section" id="module-aria_extension_tosca.simple_v1_0.modeling.policies">
<span id="aria-extension-tosca-simple-v1-0-modeling-policies"></span><h2><a class="reference internal" href="#module-aria_extension_tosca.simple_v1_0.modeling.policies" title="aria_extension_tosca.simple_v1_0.modeling.policies"><code class="xref py py-mod docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.policies</span></code></a><a class="headerlink" href="#module-aria_extension_tosca.simple_v1_0.modeling.policies" title="Permalink to this headline">¶</a></h2>
<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.policies.get_inherited_targets">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.policies.</code><code class="descname">get_inherited_targets</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.policies.get_inherited_targets" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns our target node types and group types if we have them or those of our parent, if we have
one (recursively).</p>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.policies.get_policy_targets">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.policies.</code><code class="descname">get_policy_targets</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.policies.get_policy_targets" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns our target node templates and groups if we have them.</p>
</dd></dl>

</div>
<div class="section" id="module-aria_extension_tosca.simple_v1_0.modeling.requirements">
<span id="aria-extension-tosca-simple-v1-0-modeling-requirements"></span><h2><a class="reference internal" href="#module-aria_extension_tosca.simple_v1_0.modeling.requirements" title="aria_extension_tosca.simple_v1_0.modeling.requirements"><code class="xref py py-mod docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.requirements</span></code></a><a class="headerlink" href="#module-aria_extension_tosca.simple_v1_0.modeling.requirements" title="Permalink to this headline">¶</a></h2>
<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.requirements.add_requirement_assignments">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.requirements.</code><code class="descname">add_requirement_assignments</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>requirement_assignments</em>, <em>requirement_definitions</em>, <em>our_requirement_assignments</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.requirements.add_requirement_assignments" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.requirements.convert_requirement_from_definition_to_assignment">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.requirements.</code><code class="descname">convert_requirement_from_definition_to_assignment</code><span class="sig-paren">(</span><em>context</em>, <em>requirement_definition</em>, <em>our_requirement_assignment</em>, <em>container</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.requirements.convert_requirement_from_definition_to_assignment" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.requirements.get_first_requirement">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.requirements.</code><code class="descname">get_first_requirement</code><span class="sig-paren">(</span><em>requirement_definitions</em>, <em>name</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.requirements.get_first_requirement" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.requirements.get_inherited_requirement_definitions">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.requirements.</code><code class="descname">get_inherited_requirement_definitions</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.requirements.get_inherited_requirement_definitions" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns our requirement definitions added on top of those of our parent, if we have one
(recursively).</p>
<p>Allows overriding requirement definitions if they have the same name.</p>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.requirements.get_template_requirements">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.requirements.</code><code class="descname">get_template_requirements</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.requirements.get_template_requirements" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns our requirements added on top of those of the node type if they exist there.</p>
<p>If the requirement has a relationship, the relationship properties and interfaces are assigned.</p>
<p>Returns the assigned property, interface input, and interface operation input values while
making sure they are defined in our type. Default values, if available, will be used if we did
not assign them. Also makes sure that required properties and inputs indeed end up with a value.</p>
</dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.requirements.merge_requirement_assignment">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.requirements.</code><code class="descname">merge_requirement_assignment</code><span class="sig-paren">(</span><em>context</em>, <em>relationship_property_definitions</em>, <em>relationship_interface_definitions</em>, <em>requirement</em>, <em>our_requirement</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.requirements.merge_requirement_assignment" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.requirements.merge_requirement_assignment_relationship">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.requirements.</code><code class="descname">merge_requirement_assignment_relationship</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>property_definitions</em>, <em>interface_definitions</em>, <em>requirement</em>, <em>our_relationship</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.requirements.merge_requirement_assignment_relationship" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.requirements.validate_requirement_assignment">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.requirements.</code><code class="descname">validate_requirement_assignment</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>requirement_assignment</em>, <em>relationship_property_definitions</em>, <em>relationship_interface_definitions</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.requirements.validate_requirement_assignment" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</div>
<div class="section" id="module-aria_extension_tosca.simple_v1_0.modeling.substitution_mappings">
<span id="aria-extension-tosca-simple-v1-0-modeling-substitution-mappings"></span><h2><a class="reference internal" href="#module-aria_extension_tosca.simple_v1_0.modeling.substitution_mappings" title="aria_extension_tosca.simple_v1_0.modeling.substitution_mappings"><code class="xref py py-mod docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling.substitution_mappings</span></code></a><a class="headerlink" href="#module-aria_extension_tosca.simple_v1_0.modeling.substitution_mappings" title="Permalink to this headline">¶</a></h2>
<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.substitution_mappings.get_node_template">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.substitution_mappings.</code><code class="descname">get_node_template</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>name</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.substitution_mappings.get_node_template" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.substitution_mappings.validate_format">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.substitution_mappings.</code><code class="descname">validate_format</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em>, <em>name</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.substitution_mappings.validate_format" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.substitution_mappings.validate_subtitution_mappings_capability">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.substitution_mappings.</code><code class="descname">validate_subtitution_mappings_capability</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.substitution_mappings.validate_subtitution_mappings_capability" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="aria_extension_tosca.simple_v1_0.modeling.substitution_mappings.validate_subtitution_mappings_requirement">
<code class="descclassname">aria_extension_tosca.simple_v1_0.modeling.substitution_mappings.</code><code class="descname">validate_subtitution_mappings_requirement</code><span class="sig-paren">(</span><em>context</em>, <em>presentation</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.modeling.substitution_mappings.validate_subtitution_mappings_requirement" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</div>
</div>


           </div>
           <div class="articleComments">
            
           </div>
          </div>
          <footer>
  
    <div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
      
        <a href="aria_extension_tosca.simple_v1_0.presentation.html" class="btn btn-neutral float-right" title="aria_extension_tosca.simple_v1_0.presentation" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right"></span></a>
      
      
        <a href="aria_extension_tosca.simple_v1_0.html" class="btn btn-neutral" title="aria_extension_tosca.simple_v1_0" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left"></span> Previous</a>
      
    </div>
  

  <hr/>

  <div role="contentinfo">
    <p>
        &copy; Copyright 2016-2017, Apache Software Foundation.

    </p>
  </div>
  Built with <a href="http://sphinx-doc.org/">Sphinx</a> using a <a href="https://github.com/snide/sphinx_rtd_theme">theme</a> provided by <a href="https://readthedocs.org">Read the Docs</a>. 

</footer>

        </div>
      </div>

    </section>

  </div>
  


  

    <script type="text/javascript">
        var DOCUMENTATION_OPTIONS = {
            URL_ROOT:'./',
            VERSION:'0.1.1',
            COLLAPSE_INDEX:false,
            FILE_SUFFIX:'.html',
            HAS_SOURCE:  true,
            SOURCELINK_SUFFIX: '.txt'
        };
    </script>
      <script type="text/javascript" src="_static/jquery.js"></script>
      <script type="text/javascript" src="_static/underscore.js"></script>
      <script type="text/javascript" src="_static/doctools.js"></script>

  

  
  
    <script type="text/javascript" src="_static/js/theme.js"></script>
  

  
  
  <script type="text/javascript">
      jQuery(function () {
          SphinxRtdTheme.StickyNav.enable();
      });
  </script>
   

</body>
</html>