

<!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 &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.modeling" href="aria_extension_tosca.simple_v1_0.modeling.html"/>
        <link rel="prev" title="aria.utils" href="aria.utils.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 current"><a class="current reference internal" href="#"><code class="docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0</span></code></a><ul>
<li class="toctree-l2"><a class="reference internal" href="#assignments">Assignments</a></li>
<li class="toctree-l2"><a class="reference internal" href="#definitions">Definitions</a></li>
<li class="toctree-l2"><a class="reference internal" href="#filters">Filters</a></li>
<li class="toctree-l2"><a class="reference internal" href="#miscellaneous">Miscellaneous</a></li>
<li class="toctree-l2"><a class="reference internal" href="#templates">Templates</a></li>
<li class="toctree-l2"><a class="reference internal" href="#types">Types</a></li>
<li class="toctree-l2"><a class="reference internal" href="#data-types">Data types</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="aria_extension_tosca.simple_v1_0.modeling.html"><code class="docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.modeling</span></code></a></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</span></code></li>
    
    
      <li class="wy-breadcrumbs-aside">
        
            
            <a href="_sources/aria_extension_tosca.simple_v1_0.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">
<span id="aria-extension-tosca-simple-v1-0"></span><h1><a class="reference internal" href="#module-aria_extension_tosca.simple_v1_0" title="aria_extension_tosca.simple_v1_0"><code class="xref py py-mod docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0</span></code></a><a class="headerlink" href="#module-aria_extension_tosca.simple_v1_0" title="Permalink to this headline">¶</a></h1>
<p>Parser implementation of <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">TOSCA Simple Profile v1.0 cos01</a>.</p>
<table border="1" class="longtable docutils">
<colgroup>
<col width="10%" />
<col width="90%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.ToscaSimplePresenter1_0" title="aria_extension_tosca.simple_v1_0.ToscaSimplePresenter1_0"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.ToscaSimplePresenter1_0</span></code></a></td>
<td>ARIA presenter for 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">TOSCA Simple Profile v1.0 cos01</a>.</td>
</tr>
</tbody>
</table>
<div class="section" id="assignments">
<h2>Assignments<a class="headerlink" href="#assignments" title="Permalink to this headline">¶</a></h2>
<table border="1" class="longtable docutils">
<colgroup>
<col width="10%" />
<col width="90%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.PropertyAssignment" title="aria_extension_tosca.simple_v1_0.PropertyAssignment"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.PropertyAssignment</span></code></a></td>
<td>This section defines the grammar for assigning values to named properties within TOSCA Node and Relationship templates that are defined in their corresponding named types.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.OperationAssignment" title="aria_extension_tosca.simple_v1_0.OperationAssignment"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.OperationAssignment</span></code></a></td>
<td>An operation definition defines a named function or procedure that can be bound to an implementation artifact (e.g., a script).</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.InterfaceAssignment" title="aria_extension_tosca.simple_v1_0.InterfaceAssignment"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.InterfaceAssignment</span></code></a></td>
<td>An interface definition defines a named interface that can be associated with a Node or Relationship Type.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.RelationshipAssignment" title="aria_extension_tosca.simple_v1_0.RelationshipAssignment"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.RelationshipAssignment</span></code></a></td>
<td>Relationship assignment.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.RequirementAssignment" title="aria_extension_tosca.simple_v1_0.RequirementAssignment"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.RequirementAssignment</span></code></a></td>
<td>A Requirement assignment allows template authors to provide either concrete names of TOSCA templates or provide abstract selection criteria for providers to use to find matching TOSCA templates that are used to fulfill a named requirement’s declared TOSCA Node Type.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.AttributeAssignment" title="aria_extension_tosca.simple_v1_0.AttributeAssignment"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.AttributeAssignment</span></code></a></td>
<td>This section defines the grammar for assigning values to named attributes within TOSCA Node and Relationship templates which are defined in their corresponding named types.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.CapabilityAssignment" title="aria_extension_tosca.simple_v1_0.CapabilityAssignment"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.CapabilityAssignment</span></code></a></td>
<td>A capability assignment allows node template authors to assign values to properties and attributes for a named capability definition that is part of a Node Template’s type definition.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.ArtifactAssignment" title="aria_extension_tosca.simple_v1_0.ArtifactAssignment"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.ArtifactAssignment</span></code></a></td>
<td>An artifact definition defines a named, typed file that can be associated with Node Type or Node Template and used by orchestration engine to facilitate deployment and implementation of interface operations.</td>
</tr>
</tbody>
</table>
</div>
<div class="section" id="definitions">
<h2>Definitions<a class="headerlink" href="#definitions" title="Permalink to this headline">¶</a></h2>
<table border="1" class="longtable docutils">
<colgroup>
<col width="10%" />
<col width="90%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.PropertyDefinition" title="aria_extension_tosca.simple_v1_0.PropertyDefinition"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.PropertyDefinition</span></code></a></td>
<td>A property definition defines a named, typed value and related data that can be associated with an entity defined in this specification (e.g., Node Types, Relationship Types, Capability Types, etc.).</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.AttributeDefinition" title="aria_extension_tosca.simple_v1_0.AttributeDefinition"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.AttributeDefinition</span></code></a></td>
<td>An attribute definition defines a named, typed value that can be associated with an entity defined in this specification (e.g., a Node, Relationship or Capability Type).</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.ParameterDefinition" title="aria_extension_tosca.simple_v1_0.ParameterDefinition"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.ParameterDefinition</span></code></a></td>
<td>A parameter definition is essentially a TOSCA property definition; however, it also allows a value to be assigned to it (as for a TOSCA property assignment).</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.OperationDefinition" title="aria_extension_tosca.simple_v1_0.OperationDefinition"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.OperationDefinition</span></code></a></td>
<td>An operation definition defines a named function or procedure that can be bound to an implementation artifact (e.g., a script).</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.InterfaceDefinition" title="aria_extension_tosca.simple_v1_0.InterfaceDefinition"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.InterfaceDefinition</span></code></a></td>
<td>An interface definition defines a named interface that can be associated with a Node or Relationship Type.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.RelationshipDefinition" title="aria_extension_tosca.simple_v1_0.RelationshipDefinition"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.RelationshipDefinition</span></code></a></td>
<td>Relationship definition.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.RequirementDefinition" title="aria_extension_tosca.simple_v1_0.RequirementDefinition"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.RequirementDefinition</span></code></a></td>
<td>The Requirement definition describes a named requirement (dependencies) of a TOSCA Node Type or Node template which needs to be fulfilled by a matching Capability definition declared by another TOSCA modelable entity.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.CapabilityDefinition" title="aria_extension_tosca.simple_v1_0.CapabilityDefinition"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.CapabilityDefinition</span></code></a></td>
<td>A capability definition defines a named, typed set of data that can be associated with Node Type or Node Template to describe a transparent capability or feature of the software component the node describes.</td>
</tr>
</tbody>
</table>
</div>
<div class="section" id="filters">
<h2>Filters<a class="headerlink" href="#filters" title="Permalink to this headline">¶</a></h2>
<table border="1" class="longtable docutils">
<colgroup>
<col width="10%" />
<col width="90%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.CapabilityFilter" title="aria_extension_tosca.simple_v1_0.CapabilityFilter"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.CapabilityFilter</span></code></a></td>
<td>Capability filter.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.NodeFilter" title="aria_extension_tosca.simple_v1_0.NodeFilter"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.NodeFilter</span></code></a></td>
<td>A node filter definition defines criteria for selection of a TOSCA Node Template based upon the template’s property values, capabilities and capability properties.</td>
</tr>
</tbody>
</table>
</div>
<div class="section" id="miscellaneous">
<h2>Miscellaneous<a class="headerlink" href="#miscellaneous" title="Permalink to this headline">¶</a></h2>
<table border="1" class="longtable docutils">
<colgroup>
<col width="10%" />
<col width="90%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Description" title="aria_extension_tosca.simple_v1_0.Description"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.Description</span></code></a></td>
<td>Human-readable description.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.MetaData" title="aria_extension_tosca.simple_v1_0.MetaData"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.MetaData</span></code></a></td>
<td>Meta data.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Repository" title="aria_extension_tosca.simple_v1_0.Repository"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.Repository</span></code></a></td>
<td>A repository definition defines a named external repository which contains deployment and implementation artifacts that are referenced within the TOSCA Service Template.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Import" title="aria_extension_tosca.simple_v1_0.Import"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.Import</span></code></a></td>
<td>An import definition is used within a TOSCA Service Template to locate and uniquely name another TOSCA Service Template file which has type and template definitions to be imported (included) and referenced within another Service Template.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.ConstraintClause" title="aria_extension_tosca.simple_v1_0.ConstraintClause"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.ConstraintClause</span></code></a></td>
<td>A constraint clause defines an operation along with one or more compatible values that can be used to define a constraint on a property or parameter’s allowed values when it is defined in a TOSCA Service Template or one of its entities.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.EntrySchema" title="aria_extension_tosca.simple_v1_0.EntrySchema"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.EntrySchema</span></code></a></td>
<td>ARIA NOTE: The specification does not properly explain this type, however it is implied by examples.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.OperationImplementation" title="aria_extension_tosca.simple_v1_0.OperationImplementation"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.OperationImplementation</span></code></a></td>
<td>Operation implementation.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.SubstitutionMappingsRequirement" title="aria_extension_tosca.simple_v1_0.SubstitutionMappingsRequirement"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.SubstitutionMappingsRequirement</span></code></a></td>
<td>Substitution mapping for requirement.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.SubstitutionMappingsCapability" title="aria_extension_tosca.simple_v1_0.SubstitutionMappingsCapability"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.SubstitutionMappingsCapability</span></code></a></td>
<td>Substitution mapping for capability.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.SubstitutionMappings" title="aria_extension_tosca.simple_v1_0.SubstitutionMappings"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.SubstitutionMappings</span></code></a></td>
<td>Substitution mappings.</td>
</tr>
</tbody>
</table>
</div>
<div class="section" id="templates">
<h2>Templates<a class="headerlink" href="#templates" title="Permalink to this headline">¶</a></h2>
<table border="1" class="longtable docutils">
<colgroup>
<col width="10%" />
<col width="90%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.NodeTemplate" title="aria_extension_tosca.simple_v1_0.NodeTemplate"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.NodeTemplate</span></code></a></td>
<td>A Node Template specifies the occurrence of a manageable software component as part of an application’s topology model which is defined in a TOSCA Service Template.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.RelationshipTemplate" title="aria_extension_tosca.simple_v1_0.RelationshipTemplate"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.RelationshipTemplate</span></code></a></td>
<td>A Relationship Template specifies the occurrence of a manageable relationship between node templates as part of an application’s topology model that is defined in a TOSCA Service Template.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.GroupTemplate" title="aria_extension_tosca.simple_v1_0.GroupTemplate"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.GroupTemplate</span></code></a></td>
<td>A group definition defines a logical grouping of node templates, typically for management purposes, but is separate from the application’s topology template.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.PolicyTemplate" title="aria_extension_tosca.simple_v1_0.PolicyTemplate"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.PolicyTemplate</span></code></a></td>
<td>A policy definition defines a policy that can be associated with a TOSCA topology or top-level entity definition (e.g., group definition, node template, etc.).</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.TopologyTemplate" title="aria_extension_tosca.simple_v1_0.TopologyTemplate"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.TopologyTemplate</span></code></a></td>
<td>This section defines the topology template of a cloud application.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.ServiceTemplate" title="aria_extension_tosca.simple_v1_0.ServiceTemplate"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.ServiceTemplate</span></code></a></td>
<td>Servicate template.</td>
</tr>
</tbody>
</table>
</div>
<div class="section" id="types">
<h2>Types<a class="headerlink" href="#types" title="Permalink to this headline">¶</a></h2>
<table border="1" class="longtable docutils">
<colgroup>
<col width="10%" />
<col width="90%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.ArtifactType" title="aria_extension_tosca.simple_v1_0.ArtifactType"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.ArtifactType</span></code></a></td>
<td>An Artifact Type is a reusable entity that defines the type of one or more files that are used to define implementation or deployment artifacts that are referenced by nodes or relationships on their operations.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.DataType" title="aria_extension_tosca.simple_v1_0.DataType"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.DataType</span></code></a></td>
<td>A Data Type definition defines the schema for new named datatypes in TOSCA.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.CapabilityType" title="aria_extension_tosca.simple_v1_0.CapabilityType"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.CapabilityType</span></code></a></td>
<td>A Capability Type is a reusable entity that describes a kind of capability that a Node Type can declare to expose.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.InterfaceType" title="aria_extension_tosca.simple_v1_0.InterfaceType"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.InterfaceType</span></code></a></td>
<td>An Interface Type is a reusable entity that describes a set of operations that can be used to interact with or manage a node or relationship in a TOSCA topology.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.RelationshipType" title="aria_extension_tosca.simple_v1_0.RelationshipType"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.RelationshipType</span></code></a></td>
<td>A Relationship Type is a reusable entity that defines the type of one or more relationships between Node Types or Node Templates.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.NodeType" title="aria_extension_tosca.simple_v1_0.NodeType"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.NodeType</span></code></a></td>
<td>A Node Type is a reusable entity that defines the type of one or more Node Templates.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.GroupType" title="aria_extension_tosca.simple_v1_0.GroupType"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.GroupType</span></code></a></td>
<td>A Group Type defines logical grouping types for nodes, typically for different management purposes.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.PolicyType" title="aria_extension_tosca.simple_v1_0.PolicyType"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.PolicyType</span></code></a></td>
<td>A Policy Type defines a type of requirement that affects or governs an application or service’s topology at some stage of its lifecycle, but is not explicitly part of the topology itself (i.e., it does not prevent the application or service from being deployed or run if it did not exist).</td>
</tr>
</tbody>
</table>
</div>
<div class="section" id="data-types">
<h2>Data types<a class="headerlink" href="#data-types" title="Permalink to this headline">¶</a></h2>
<table border="1" class="longtable docutils">
<colgroup>
<col width="10%" />
<col width="90%" />
</colgroup>
<tbody valign="top">
<tr class="row-odd"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Timestamp" title="aria_extension_tosca.simple_v1_0.Timestamp"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.Timestamp</span></code></a></td>
<td>TOSCA timestamps follow the YAML specification, which in turn is a variant of ISO8601.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Version" title="aria_extension_tosca.simple_v1_0.Version"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.Version</span></code></a></td>
<td>TOSCA supports the concept of “reuse” of type definitions, as well as template definitions which could be version and change over time.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Range" title="aria_extension_tosca.simple_v1_0.Range"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.Range</span></code></a></td>
<td>The range type can be used to define numeric ranges with a lower and upper boundary.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.List" title="aria_extension_tosca.simple_v1_0.List"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.List</span></code></a></td>
<td>The list type allows for specifying multiple values for a parameter of property.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Map" title="aria_extension_tosca.simple_v1_0.Map"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.Map</span></code></a></td>
<td>The map type allows for specifying multiple values for a parameter of property as a map.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.ScalarSize" title="aria_extension_tosca.simple_v1_0.ScalarSize"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.ScalarSize</span></code></a></td>
<td>Integer scalar for counting bytes.</td>
</tr>
<tr class="row-odd"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.ScalarTime" title="aria_extension_tosca.simple_v1_0.ScalarTime"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.ScalarTime</span></code></a></td>
<td>Floating point scalar for counting seconds.</td>
</tr>
<tr class="row-even"><td><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.ScalarFrequency" title="aria_extension_tosca.simple_v1_0.ScalarFrequency"><code class="xref py py-obj docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.ScalarFrequency</span></code></a></td>
<td>Floating point scalar for counting cycles per second (Hz).</td>
</tr>
</tbody>
</table>
<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.ToscaSimplePresenter1_0">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">ToscaSimplePresenter1_0</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ToscaSimplePresenter1_0" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">aria.parser.presentation.presenter.Presenter</span></code></p>
<p>ARIA presenter for 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">TOSCA Simple Profile v1.0 cos01</a>.</p>
<p>Supported <code class="docutils literal"><span class="pre">tosca_definitions_version</span></code> values:</p>
<ul class="simple">
<li><code class="docutils literal"><span class="pre">tosca_simple_yaml_1_0</span></code></li>
</ul>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ToscaSimplePresenter1_0.ALLOWED_IMPORTED_DSL_VERSIONS">
<code class="descname">ALLOWED_IMPORTED_DSL_VERSIONS</code><em class="property"> = ('tosca_simple_yaml_1_0',)</em><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ToscaSimplePresenter1_0.ALLOWED_IMPORTED_DSL_VERSIONS" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ToscaSimplePresenter1_0.DSL_VERSIONS">
<code class="descname">DSL_VERSIONS</code><em class="property"> = ('tosca_simple_yaml_1_0',)</em><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ToscaSimplePresenter1_0.DSL_VERSIONS" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ToscaSimplePresenter1_0.SIMPLE_PROFILE_LOCATION">
<code class="descname">SIMPLE_PROFILE_LOCATION</code><em class="property"> = 'tosca-simple-1.0/tosca-simple-1.0.yaml'</em><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ToscaSimplePresenter1_0.SIMPLE_PROFILE_LOCATION" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ToscaSimplePresenter1_0.SPECIAL_IMPORTS">
<code class="descname">SPECIAL_IMPORTS</code><em class="property"> = {'aria-1.0': 'aria-1.0/aria-1.0.yaml'}</em><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ToscaSimplePresenter1_0.SPECIAL_IMPORTS" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

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

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

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.PropertyAssignment">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">PropertyAssignment</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em>, <em>cls=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.PropertyAssignment" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">aria.parser.presentation.presentation.AsIsPresentation</span></code></p>
<p>This section defines the grammar for assigning values to named properties within TOSCA Node and
Relationship templates that are defined in their corresponding named types.</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#DEFN_ELEMENT_PROPERTY_VALUE_ASSIGNMENT">TOSCA Simple Profile v1.0 cos01 specification</a></p>
</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.OperationAssignment">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">OperationAssignment</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.OperationAssignment" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>An operation definition defines a named function or procedure that can be bound to an
implementation artifact (e.g., a script).</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#DEFN_ELEMENT_OPERATION_DEF">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.OperationAssignment.description">
<code class="descname">description</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.OperationAssignment.description" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional description string for the associated named operation.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Description" title="aria_extension_tosca.simple_v1_0.Description"><code class="xref py py-class docutils literal"><span class="pre">Description</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.OperationAssignment.implementation">
<code class="descname">implementation</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.OperationAssignment.implementation" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional implementation artifact name (e.g., a script file name within a TOSCA CSAR
file).</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.OperationImplementation" title="aria_extension_tosca.simple_v1_0.OperationImplementation"><code class="xref py py-class docutils literal"><span class="pre">OperationImplementation</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.OperationAssignment.inputs">
<code class="descname">inputs</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.OperationAssignment.inputs" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional list of input property assignments (i.e., parameters assignments) for operation
definitions that are within TOSCA Node or Relationship Template definitions. This includes
when operation definitions are included as part of a Requirement assignment in a Node
Template.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.PropertyAssignment" title="aria_extension_tosca.simple_v1_0.PropertyAssignment"><code class="xref py py-class docutils literal"><span class="pre">PropertyAssignment</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.InterfaceAssignment">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">InterfaceAssignment</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.InterfaceAssignment" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>An interface definition defines a named interface that can be associated with a Node or
Relationship Type.</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#DEFN_ELEMENT_INTERFACE_DEF">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.InterfaceAssignment.inputs">
<code class="descname">inputs</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.InterfaceAssignment.inputs" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional list of input property assignments (i.e., parameters assignments) for interface
definitions that are within TOSCA Node or Relationship Template definitions. This includes
when interface definitions are referenced as part of a Requirement assignment in a Node
Template.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.PropertyAssignment" title="aria_extension_tosca.simple_v1_0.PropertyAssignment"><code class="xref py py-class docutils literal"><span class="pre">PropertyAssignment</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.InterfaceAssignment.operations">
<code class="descname">operations</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.InterfaceAssignment.operations" title="Permalink to this definition">¶</a></dt>
<dd><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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.OperationAssignment" title="aria_extension_tosca.simple_v1_0.OperationAssignment"><code class="xref py py-class docutils literal"><span class="pre">OperationAssignment</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.RelationshipAssignment">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">RelationshipAssignment</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RelationshipAssignment" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>Relationship assignment.</p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.RelationshipAssignment.interfaces">
<code class="descname">interfaces</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RelationshipAssignment.interfaces" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional reserved keyname used to reference declared (named) interface definitions of
the corresponding Relationship Type in order to provide Property assignments for these
interfaces or operations of these interfaces.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.InterfaceAssignment" title="aria_extension_tosca.simple_v1_0.InterfaceAssignment"><code class="xref py py-class docutils literal"><span class="pre">InterfaceAssignment</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.RelationshipAssignment.properties">
<code class="descname">properties</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RelationshipAssignment.properties" title="Permalink to this definition">¶</a></dt>
<dd><p>ARIA NOTE: This field is not mentioned in the spec, but is implied.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.PropertyAssignment" title="aria_extension_tosca.simple_v1_0.PropertyAssignment"><code class="xref py py-class docutils literal"><span class="pre">PropertyAssignment</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.RelationshipAssignment.type">
<code class="descname">type</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RelationshipAssignment.type" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional reserved keyname used to provide the name of the Relationship Type for the
requirement assignment’s relationship keyname.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.RequirementAssignment">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">RequirementAssignment</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RequirementAssignment" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>A Requirement assignment allows template authors to provide either concrete names of TOSCA
templates or provide abstract selection criteria for providers to use to find matching TOSCA
templates that are used to fulfill a named requirement’s declared TOSCA Node Type.</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#DEFN_ELEMENT_REQUIREMENT_ASSIGNMENT">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.RequirementAssignment.capability">
<code class="descname">capability</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RequirementAssignment.capability" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional reserved keyname used to provide the name of either a:</p>
<ul class="simple">
<li>Capability definition within a target node template that can fulfill the requirement.</li>
<li>Capability Type that the provider will use to select a type-compatible target node
template to fulfill the requirement at runtime.</li>
</ul>
<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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.RequirementAssignment.node">
<code class="descname">node</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RequirementAssignment.node" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional reserved keyname used to identify the target node of a relationship.
Specifically, it is used to provide either a:</p>
<ul class="simple">
<li>Node Template name that can fulfill the target node requirement.</li>
<li>Node Type name that the provider will use to select a type-compatible node template to
fulfill the requirement at runtime.</li>
</ul>
<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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.RequirementAssignment.node_filter">
<code class="descname">node_filter</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RequirementAssignment.node_filter" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional filter definition that TOSCA orchestrators or providers would use to select a
type-compatible target node that can fulfill the associated abstract requirement at runtime.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.NodeFilter" title="aria_extension_tosca.simple_v1_0.NodeFilter"><code class="xref py py-class docutils literal"><span class="pre">NodeFilter</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.RequirementAssignment.relationship">
<code class="descname">relationship</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RequirementAssignment.relationship" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional reserved keyname used to provide the name of either a:</p>
<ul class="simple">
<li>Relationship Template to use to relate the source node to the (capability in the) target
node when fulfilling the requirement.</li>
<li>Relationship Type that the provider will use to select a type-compatible relationship
template to relate the source node to the target node at runtime.</li>
</ul>
<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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.RelationshipAssignment" title="aria_extension_tosca.simple_v1_0.RelationshipAssignment"><code class="xref py py-class docutils literal"><span class="pre">RelationshipAssignment</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.AttributeAssignment">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">AttributeAssignment</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em>, <em>cls=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.AttributeAssignment" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">aria.parser.presentation.presentation.AsIsPresentation</span></code></p>
<p>This section defines the grammar for assigning values to named attributes within TOSCA Node and
Relationship templates which are defined in their corresponding named types.</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#DEFN_ELEMENT_ATTRIBUTE_VALUE_ASSIGNMENT">TOSCA Simple Profile v1.0 cos01 specification</a></p>
</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.CapabilityAssignment">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">CapabilityAssignment</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.CapabilityAssignment" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>A capability assignment allows node template authors to assign values to properties and
attributes for a named capability definition that is part of a Node Template’s type definition.</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#DEFN_ELEMENT_CAPABILITY_ASSIGNMENT">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.CapabilityAssignment.attributes">
<code class="descname">attributes</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.CapabilityAssignment.attributes" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of attribute definitions for the Capability definition.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.AttributeAssignment" title="aria_extension_tosca.simple_v1_0.AttributeAssignment"><code class="xref py py-class docutils literal"><span class="pre">AttributeAssignment</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.CapabilityAssignment.properties">
<code class="descname">properties</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.CapabilityAssignment.properties" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of property definitions for the Capability definition.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.PropertyAssignment" title="aria_extension_tosca.simple_v1_0.PropertyAssignment"><code class="xref py py-class docutils literal"><span class="pre">PropertyAssignment</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.ArtifactAssignment">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">ArtifactAssignment</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ArtifactAssignment" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>An artifact definition defines a named, typed file that can be associated with Node Type or Node
Template and used by orchestration engine to facilitate deployment and implementation of
interface operations.</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#DEFN_ENTITY_ARTIFACT_DEF">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ArtifactAssignment.deploy_path">
<code class="descname">deploy_path</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ArtifactAssignment.deploy_path" title="Permalink to this definition">¶</a></dt>
<dd><p>The file path the associated file would be deployed into within the target node’s container.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ArtifactAssignment.description">
<code class="descname">description</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ArtifactAssignment.description" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional description for the artifact definition.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Description" title="aria_extension_tosca.simple_v1_0.Description"><code class="xref py py-class docutils literal"><span class="pre">Description</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ArtifactAssignment.file">
<code class="descname">file</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ArtifactAssignment.file" title="Permalink to this definition">¶</a></dt>
<dd><p>The required URI string (relative or absolute) which can be used to locate the artifact’s
file.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ArtifactAssignment.properties">
<code class="descname">properties</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ArtifactAssignment.properties" title="Permalink to this definition">¶</a></dt>
<dd><p>ARIA NOTE: This field is not mentioned in the spec, but is implied.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.PropertyAssignment" title="aria_extension_tosca.simple_v1_0.PropertyAssignment"><code class="xref py py-class docutils literal"><span class="pre">PropertyAssignment</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ArtifactAssignment.repository">
<code class="descname">repository</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ArtifactAssignment.repository" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional name of the repository definition which contains the location of the external
repository that contains the artifact. The artifact is expected to be referenceable by its
file URI within the repository.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ArtifactAssignment.type">
<code class="descname">type</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ArtifactAssignment.type" title="Permalink to this definition">¶</a></dt>
<dd><p>The required artifact type for the artifact definition.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.PropertyDefinition">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">PropertyDefinition</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.PropertyDefinition" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>A property definition defines a named, typed value and related data that can be associated with
an entity defined in this specification (e.g., Node Types, Relationship Types, Capability Types,
etc.). Properties are used by template authors to provide input values to TOSCA entities which
indicate their “desired state” when they are instantiated. The value of a property can be
retrieved using the <code class="docutils literal"><span class="pre">get_property</span></code> function within TOSCA Service Templates.</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#DEFN_ELEMENT_PROPERTY_DEFN">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.PropertyDefinition.constraints">
<code class="descname">constraints</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.PropertyDefinition.constraints" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional list of sequenced constraint clauses for the property.</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">Type:</th><td class="field-body">list of (str, <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.ConstraintClause" title="aria_extension_tosca.simple_v1_0.ConstraintClause"><code class="xref py py-class docutils literal"><span class="pre">ConstraintClause</span></code></a>)</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.PropertyDefinition.default">
<code class="descname">default</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.PropertyDefinition.default" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional key that may provide a value to be used as a default if not provided by another
means.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.PropertyDefinition.description">
<code class="descname">description</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.PropertyDefinition.description" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional description for the property.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Description" title="aria_extension_tosca.simple_v1_0.Description"><code class="xref py py-class docutils literal"><span class="pre">Description</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.PropertyDefinition.entry_schema">
<code class="descname">entry_schema</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.PropertyDefinition.entry_schema" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional key that is used to declare the name of the Datatype definition for entries of
set types such as the TOSCA list or map.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.PropertyDefinition.required">
<code class="descname">required</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.PropertyDefinition.required" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional key that declares a property as required (true) or not (false).</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">Type:</th><td class="field-body">bool</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.PropertyDefinition.status">
<code class="descname">status</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.PropertyDefinition.status" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional status of the property relative to the specification or implementation.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.PropertyDefinition.type">
<code class="descname">type</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.PropertyDefinition.type" title="Permalink to this definition">¶</a></dt>
<dd><p>The required data type for the property.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.AttributeDefinition">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">AttributeDefinition</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.AttributeDefinition" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>An attribute definition defines a named, typed value that can be associated with an entity
defined in this specification (e.g., a Node, Relationship or Capability Type). Specifically, it
is used to expose the “actual state” of some property of a TOSCA entity after it has been
deployed and instantiated (as set by the TOSCA orchestrator). Attribute values can be retrieved
via the <code class="docutils literal"><span class="pre">get_attribute</span></code> function from the instance model and used as values to other
entities within TOSCA Service Templates.</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#DEFN_ELEMENT_ATTRIBUTE_DEFN">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.AttributeDefinition.default">
<code class="descname">default</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.AttributeDefinition.default" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional key that may provide a value to be used as a default if not provided by another
means.</p>
<p>This value SHALL be type compatible with the type declared by the property definition’s type
keyname.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.AttributeDefinition.description">
<code class="descname">description</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.AttributeDefinition.description" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional description for the attribute.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Description" title="aria_extension_tosca.simple_v1_0.Description"><code class="xref py py-class docutils literal"><span class="pre">Description</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.AttributeDefinition.entry_schema">
<code class="descname">entry_schema</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.AttributeDefinition.entry_schema" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional key that is used to declare the name of the Datatype definition for entries of
set types such as the TOSCA list or map.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.AttributeDefinition.status">
<code class="descname">status</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.AttributeDefinition.status" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional status of the attribute relative to the specification or implementation.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.AttributeDefinition.type">
<code class="descname">type</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.AttributeDefinition.type" title="Permalink to this definition">¶</a></dt>
<dd><p>The required data type for the attribute.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.ParameterDefinition">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">ParameterDefinition</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ParameterDefinition" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.definitions.PropertyDefinition</span></code></p>
<p>A parameter definition is essentially a TOSCA property definition; however, it also allows a
value to be assigned to it (as for a TOSCA property assignment). In addition, in the case of
output parameters, it can optionally inherit the data type of the value assigned to it rather
than have an explicit data type defined for it.</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#DEFN_ELEMENT_PARAMETER_DEF">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ParameterDefinition.type">
<code class="descname">type</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ParameterDefinition.type" title="Permalink to this definition">¶</a></dt>
<dd><p>The required data type for the parameter.</p>
<p>Note: This keyname is required for a TOSCA Property definition, but is not for a TOSCA
Parameter definition.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ParameterDefinition.value">
<code class="descname">value</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ParameterDefinition.value" title="Permalink to this definition">¶</a></dt>
<dd><p>The type-compatible value to assign to the named parameter. Parameter values may be provided
as the result from the evaluation of an expression or a function.</p>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.OperationDefinition">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">OperationDefinition</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.OperationDefinition" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>An operation definition defines a named function or procedure that can be bound to an
implementation artifact (e.g., a script).</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#DEFN_ELEMENT_OPERATION_DEF">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.OperationDefinition.description">
<code class="descname">description</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.OperationDefinition.description" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional description string for the associated named operation.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Description" title="aria_extension_tosca.simple_v1_0.Description"><code class="xref py py-class docutils literal"><span class="pre">Description</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.OperationDefinition.implementation">
<code class="descname">implementation</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.OperationDefinition.implementation" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional implementation artifact name (e.g., a script file name within a TOSCA CSAR
file).</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.OperationImplementation" title="aria_extension_tosca.simple_v1_0.OperationImplementation"><code class="xref py py-class docutils literal"><span class="pre">OperationImplementation</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.OperationDefinition.inputs">
<code class="descname">inputs</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.OperationDefinition.inputs" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional list of input property definitions available to all defined operations for
interface definitions that are within TOSCA Node or Relationship Type definitions. This
includes when interface definitions are included as part of a Requirement definition in a
Node Type.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.PropertyDefinition" title="aria_extension_tosca.simple_v1_0.PropertyDefinition"><code class="xref py py-class docutils literal"><span class="pre">PropertyDefinition</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.InterfaceDefinition">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">InterfaceDefinition</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.InterfaceDefinition" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>An interface definition defines a named interface that can be associated with a Node or
Relationship Type.</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#DEFN_ELEMENT_INTERFACE_DEF">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.InterfaceDefinition.inputs">
<code class="descname">inputs</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.InterfaceDefinition.inputs" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional list of input property definitions available to all defined operations for
interface definitions that are within TOSCA Node or Relationship Type definitions. This
includes when interface definitions are included as part of a Requirement definition in a
Node Type.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.PropertyDefinition" title="aria_extension_tosca.simple_v1_0.PropertyDefinition"><code class="xref py py-class docutils literal"><span class="pre">PropertyDefinition</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.InterfaceDefinition.operations">
<code class="descname">operations</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.InterfaceDefinition.operations" title="Permalink to this definition">¶</a></dt>
<dd><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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.OperationDefinition" title="aria_extension_tosca.simple_v1_0.OperationDefinition"><code class="xref py py-class docutils literal"><span class="pre">OperationDefinition</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.InterfaceDefinition.type">
<code class="descname">type</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.InterfaceDefinition.type" title="Permalink to this definition">¶</a></dt>
<dd><p>ARIA NOTE: This field is not mentioned in the spec, but is implied.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.RelationshipDefinition">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">RelationshipDefinition</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RelationshipDefinition" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>Relationship definition.</p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.RelationshipDefinition.interfaces">
<code class="descname">interfaces</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RelationshipDefinition.interfaces" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional reserved keyname used to reference declared (named) interface definitions of
the corresponding Relationship Type in order to declare additional Property definitions for
these interfaces or operations of these interfaces.</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">Type:</th><td class="field-body">list of <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.InterfaceDefinition" title="aria_extension_tosca.simple_v1_0.InterfaceDefinition"><code class="xref py py-class docutils literal"><span class="pre">InterfaceDefinition</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.RelationshipDefinition.type">
<code class="descname">type</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RelationshipDefinition.type" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional reserved keyname used to provide the name of the Relationship Type for the
requirement definition’s relationship keyname.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.RequirementDefinition">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">RequirementDefinition</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RequirementDefinition" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>The Requirement definition describes a named requirement (dependencies) of a TOSCA Node Type or
Node template which needs to be fulfilled by a matching Capability definition declared by
another TOSCA modelable entity. The requirement definition may itself include the specific name
of the fulfilling entity (explicitly) or provide an abstract type, along with additional
filtering characteristics, that a TOSCA orchestrator can use to fulfill the capability at
runtime (implicitly).</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#DEFN_ELEMENT_REQUIREMENT_DEF">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.RequirementDefinition.capability">
<code class="descname">capability</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RequirementDefinition.capability" title="Permalink to this definition">¶</a></dt>
<dd><p>The required reserved keyname used that can be used to provide the name of a valid
Capability Type that can fulfill the requirement.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.RequirementDefinition.node">
<code class="descname">node</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RequirementDefinition.node" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional reserved keyname used to provide the name of a valid Node Type that contains
the capability definition that can be used to fulfill the requirement.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.RequirementDefinition.occurrences">
<code class="descname">occurrences</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RequirementDefinition.occurrences" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional minimum and maximum occurrences for the requirement.</p>
<p>Note: the keyword UNBOUNDED is also supported to represent any positive integer.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Range" title="aria_extension_tosca.simple_v1_0.Range"><code class="xref py py-class docutils literal"><span class="pre">Range</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.RequirementDefinition.relationship">
<code class="descname">relationship</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RequirementDefinition.relationship" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional reserved keyname used to provide the name of a valid Relationship Type to
construct when fulfilling the requirement.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.RelationshipDefinition" title="aria_extension_tosca.simple_v1_0.RelationshipDefinition"><code class="xref py py-class docutils literal"><span class="pre">RelationshipDefinition</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.CapabilityDefinition">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">CapabilityDefinition</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.CapabilityDefinition" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>A capability definition defines a named, typed set of data that can be associated with Node Type
or Node Template to describe a transparent capability or feature of the software component the
node describes.</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#DEFN_ELEMENT_CAPABILITY_DEFN">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.CapabilityDefinition.attributes">
<code class="descname">attributes</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.CapabilityDefinition.attributes" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of attribute definitions for the Capability definition.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.AttributeDefinition" title="aria_extension_tosca.simple_v1_0.AttributeDefinition"><code class="xref py py-class docutils literal"><span class="pre">AttributeDefinition</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.CapabilityDefinition.description">
<code class="descname">description</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.CapabilityDefinition.description" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional description of the Capability definition.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Description" title="aria_extension_tosca.simple_v1_0.Description"><code class="xref py py-class docutils literal"><span class="pre">Description</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.CapabilityDefinition.occurrences">
<code class="descname">occurrences</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.CapabilityDefinition.occurrences" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional minimum and maximum occurrences for the capability. By default, an exported
Capability should allow at least one relationship to be formed with it with a maximum of
<code class="docutils literal"><span class="pre">UNBOUNDED</span></code> relationships.</p>
<p>Note: the keyword <code class="docutils literal"><span class="pre">UNBOUNDED</span></code> is also supported to represent any positive integer.</p>
<p>ARIA NOTE: The spec seems wrong here: the implied default should be <code class="docutils literal"><span class="pre">[0,UNBOUNDED]</span></code>, not
<code class="docutils literal"><span class="pre">[1,UNBOUNDED]</span></code>, otherwise it would imply that at 1 least one relationship <em>must</em> be
formed.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Range" title="aria_extension_tosca.simple_v1_0.Range"><code class="xref py py-class docutils literal"><span class="pre">Range</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.CapabilityDefinition.properties">
<code class="descname">properties</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.CapabilityDefinition.properties" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of property definitions for the Capability definition.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.PropertyDefinition" title="aria_extension_tosca.simple_v1_0.PropertyDefinition"><code class="xref py py-class docutils literal"><span class="pre">PropertyDefinition</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.CapabilityDefinition.type">
<code class="descname">type</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.CapabilityDefinition.type" title="Permalink to this definition">¶</a></dt>
<dd><p>The required name of the Capability Type the capability definition is based upon.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.CapabilityDefinition.valid_source_types">
<code class="descname">valid_source_types</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.CapabilityDefinition.valid_source_types" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of one or more valid names of Node Types that are supported as valid
sources of any relationship established to the declared Capability Type.</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">Type:</th><td class="field-body">[<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>]</td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.CapabilityFilter">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">CapabilityFilter</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.CapabilityFilter" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>Capability filter.</p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.CapabilityFilter.properties">
<code class="descname">properties</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.CapabilityFilter.properties" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.NodeFilter">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">NodeFilter</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.NodeFilter" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>A node filter definition defines criteria for selection of a TOSCA Node Template based upon the
template’s property values, capabilities and capability properties.</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#DEFN_ELEMENT_NODE_FILTER_DEFN">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.NodeFilter.capabilities">
<code class="descname">capabilities</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.NodeFilter.capabilities" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional sequenced list of property filters that would be used to select (filter)
matching TOSCA entities (e.g., Node Template, Node Type, Capability Types, etc.) based upon
their capabilities’ property definitions’ values.</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">Type:</th><td class="field-body">list of (str, <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.CapabilityDefinition" title="aria_extension_tosca.simple_v1_0.CapabilityDefinition"><code class="xref py py-class docutils literal"><span class="pre">CapabilityDefinition</span></code></a>)</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.NodeFilter.properties">
<code class="descname">properties</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.NodeFilter.properties" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional sequenced list of property filters that would be used to select (filter)
matching TOSCA entities (e.g., Node Template, Node Type, Capability Types, etc.) based upon
their property definitions’ values.</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#DEFN_ELEMENT_PROPERTY_FILTER_DEFN">TOSCA Simple Profile v1.0 cos01 specification</a></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">Type:</th><td class="field-body">list of (str, <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.ConstraintClause" title="aria_extension_tosca.simple_v1_0.ConstraintClause"><code class="xref py py-class docutils literal"><span class="pre">ConstraintClause</span></code></a>)</td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.Description">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">Description</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em>, <em>cls=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.Description" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">aria.parser.presentation.presentation.AsIsPresentation</span></code></p>
<p>Human-readable description.</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#DEFN_ELEMENT_DESCRIPTION">TOSCA Simple Profile v1.0 cos01 specification</a></p>
</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.MetaData">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">MetaData</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.MetaData" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>Meta data.</p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.MetaData.custom">
<code class="descname">custom</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.MetaData.custom" title="Permalink to this definition">¶</a></dt>
<dd><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">Type:</th><td class="field-body">dict</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.MetaData.template_author">
<code class="descname">template_author</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.MetaData.template_author" title="Permalink to this definition">¶</a></dt>
<dd><p>This optional metadata keyname can be used to declare the author(s) of the service template
as a single-line string value.</p>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.MetaData.template_name">
<code class="descname">template_name</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.MetaData.template_name" title="Permalink to this definition">¶</a></dt>
<dd><p>This optional metadata keyname can be used to declare the name of service template as a
single-line string value.</p>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.MetaData.template_version">
<code class="descname">template_version</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.MetaData.template_version" title="Permalink to this definition">¶</a></dt>
<dd><p>This optional metadata keyname can be used to declare a domain specific version of the
service template as a single-line string value.</p>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.Repository">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">Repository</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.Repository" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>A repository definition defines a named external repository which contains deployment and
implementation artifacts that are referenced within the TOSCA Service Template.</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#DEFN_ELEMENT_REPOSITORY_DEF">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.Repository.credential">
<code class="descname">credential</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.Repository.credential" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional Credential used to authorize access to the repository.</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">Type:</th><td class="field-body">tosca.datatypes.Credential</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.Repository.description">
<code class="descname">description</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.Repository.description" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional description for the repository.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Description" title="aria_extension_tosca.simple_v1_0.Description"><code class="xref py py-class docutils literal"><span class="pre">Description</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.Repository.url">
<code class="descname">url</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.Repository.url" title="Permalink to this definition">¶</a></dt>
<dd><p>The required URL or network address used to access the repository.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.Import">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">Import</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.Import" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>An import definition is used within a TOSCA Service Template to locate and uniquely name another
TOSCA Service Template file which has type and template definitions to be imported (included)
and referenced within another Service Template.</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#DEFN_ELEMENT_IMPORT_DEF">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.Import.file">
<code class="descname">file</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.Import.file" title="Permalink to this definition">¶</a></dt>
<dd><p>The required symbolic name for the imported file.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.Import.namespace_prefix">
<code class="descname">namespace_prefix</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.Import.namespace_prefix" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional namespace prefix (alias) that will be used to indicate the namespace_uri when
forming a qualified name (i.e., qname) when referencing type definitions from the imported
file.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.Import.namespace_uri">
<code class="descname">namespace_uri</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.Import.namespace_uri" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional namespace URI to that will be applied to type definitions found within the
imported file as a string.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.Import.repository">
<code class="descname">repository</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.Import.repository" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional symbolic name of the repository definition where the imported file can be found
as a string.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.ConstraintClause">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">ConstraintClause</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ConstraintClause" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>A constraint clause defines an operation along with one or more compatible values that can be
used to define a constraint on a property or parameter’s allowed values when it is defined in a
TOSCA Service Template or one of its entities.</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#DEFN_ELEMENT_CONSTRAINTS_CLAUSE">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ConstraintClause.equal">
<code class="descname">equal</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ConstraintClause.equal" title="Permalink to this definition">¶</a></dt>
<dd><p>Constrains a property or parameter to a value equal to (‘=’) the value declared.</p>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ConstraintClause.greater_or_equal">
<code class="descname">greater_or_equal</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ConstraintClause.greater_or_equal" title="Permalink to this definition">¶</a></dt>
<dd><p>Constrains a property or parameter to a value greater than or equal to (‘&gt;=’) the value
declared.</p>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ConstraintClause.greater_than">
<code class="descname">greater_than</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ConstraintClause.greater_than" title="Permalink to this definition">¶</a></dt>
<dd><p>Constrains a property or parameter to a value greater than (‘&gt;’) the value declared.</p>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ConstraintClause.in_range">
<code class="descname">in_range</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ConstraintClause.in_range" title="Permalink to this definition">¶</a></dt>
<dd><p>Constrains a property or parameter to a value in range of (inclusive) the two values
declared.</p>
<p>Note: subclasses or templates of types that declare a property with the <code class="docutils literal"><span class="pre">in_range</span></code>
constraint MAY only further restrict the range specified by the parent type.</p>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ConstraintClause.length">
<code class="descname">length</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ConstraintClause.length" title="Permalink to this definition">¶</a></dt>
<dd><p>Constrains the property or parameter to a value of a given length.</p>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ConstraintClause.less_or_equal">
<code class="descname">less_or_equal</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ConstraintClause.less_or_equal" title="Permalink to this definition">¶</a></dt>
<dd><p>Constrains a property or parameter to a value less than or equal to (‘&lt;=’) the value
declared.</p>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ConstraintClause.less_than">
<code class="descname">less_than</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ConstraintClause.less_than" title="Permalink to this definition">¶</a></dt>
<dd><p>Constrains a property or parameter to a value less than (‘&lt;’) the value declared.</p>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ConstraintClause.max_length">
<code class="descname">max_length</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ConstraintClause.max_length" title="Permalink to this definition">¶</a></dt>
<dd><p>Constrains the property or parameter to a value to a maximum length.</p>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ConstraintClause.min_length">
<code class="descname">min_length</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ConstraintClause.min_length" title="Permalink to this definition">¶</a></dt>
<dd><p>Constrains the property or parameter to a value to a minimum length.</p>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ConstraintClause.pattern">
<code class="descname">pattern</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ConstraintClause.pattern" title="Permalink to this definition">¶</a></dt>
<dd><p>Constrains the property or parameter to a value that is allowed by the provided regular
expression.</p>
<p>Note: Future drafts of this specification will detail the use of regular expressions and
reference an appropriate standardized grammar.</p>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ConstraintClause.valid_values">
<code class="descname">valid_values</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ConstraintClause.valid_values" title="Permalink to this definition">¶</a></dt>
<dd><p>Constrains a property or parameter to a value that is in the list of declared values.</p>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.EntrySchema">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">EntrySchema</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.EntrySchema" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>ARIA NOTE: The specification does not properly explain this type, however it is implied by
examples.</p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.EntrySchema.constraints">
<code class="descname">constraints</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.EntrySchema.constraints" title="Permalink to this definition">¶</a></dt>
<dd><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">Type:</th><td class="field-body">list of (str, <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.ConstraintClause" title="aria_extension_tosca.simple_v1_0.ConstraintClause"><code class="xref py py-class docutils literal"><span class="pre">ConstraintClause</span></code></a>)</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.EntrySchema.description">
<code class="descname">description</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.EntrySchema.description" title="Permalink to this definition">¶</a></dt>
<dd><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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Description" title="aria_extension_tosca.simple_v1_0.Description"><code class="xref py py-class docutils literal"><span class="pre">Description</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.EntrySchema.type">
<code class="descname">type</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.EntrySchema.type" title="Permalink to this definition">¶</a></dt>
<dd><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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.OperationImplementation">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">OperationImplementation</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.OperationImplementation" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>Operation implementation.</p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.OperationImplementation.dependencies">
<code class="descname">dependencies</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.OperationImplementation.dependencies" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional ordered list of one or more dependent or secondary implementation artifact name
which are referenced by the primary implementation artifact (e.g., a library the script
installs or a secondary script).</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">Type:</th><td class="field-body">[<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>]</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.OperationImplementation.primary">
<code class="descname">primary</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.OperationImplementation.primary" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional implementation artifact name (i.e., the primary script file name within a
TOSCA CSAR file).</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.SubstitutionMappingsRequirement">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">SubstitutionMappingsRequirement</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em>, <em>cls=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.SubstitutionMappingsRequirement" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">aria.parser.presentation.presentation.AsIsPresentation</span></code></p>
<p>Substitution mapping for requirement.</p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.SubstitutionMappingsRequirement.node_template">
<code class="descname">node_template</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.SubstitutionMappingsRequirement.node_template" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

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

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.SubstitutionMappingsCapability">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">SubstitutionMappingsCapability</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em>, <em>cls=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.SubstitutionMappingsCapability" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">aria.parser.presentation.presentation.AsIsPresentation</span></code></p>
<p>Substitution mapping for capability.</p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.SubstitutionMappingsCapability.capability">
<code class="descname">capability</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.SubstitutionMappingsCapability.capability" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

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

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.SubstitutionMappings">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">SubstitutionMappings</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.SubstitutionMappings" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>Substitution mappings.</p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.SubstitutionMappings.capabilities">
<code class="descname">capabilities</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.SubstitutionMappings.capabilities" title="Permalink to this definition">¶</a></dt>
<dd><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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.SubstitutionMappingsCapability" title="aria_extension_tosca.simple_v1_0.SubstitutionMappingsCapability"><code class="xref py py-class docutils literal"><span class="pre">SubstitutionMappingsCapability</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.SubstitutionMappings.node_type">
<code class="descname">node_type</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.SubstitutionMappings.node_type" title="Permalink to this definition">¶</a></dt>
<dd><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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.SubstitutionMappings.requirements">
<code class="descname">requirements</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.SubstitutionMappings.requirements" title="Permalink to this definition">¶</a></dt>
<dd><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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.SubstitutionMappingsRequirement" title="aria_extension_tosca.simple_v1_0.SubstitutionMappingsRequirement"><code class="xref py py-class docutils literal"><span class="pre">SubstitutionMappingsRequirement</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.NodeTemplate">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">NodeTemplate</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.NodeTemplate" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>A Node Template specifies the occurrence of a manageable software component as part of an
application’s topology model which is defined in a TOSCA Service Template. A Node template is an
instance of a specified Node Type and can provide customized properties, constraints or
operations which override the defaults provided by its Node Type and its implementations.</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#DEFN_ENTITY_NODE_TEMPLATE">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.NodeTemplate.artifacts">
<code class="descname">artifacts</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.NodeTemplate.artifacts" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of named artifact definitions for the Node Template.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.ArtifactAssignment" title="aria_extension_tosca.simple_v1_0.ArtifactAssignment"><code class="xref py py-class docutils literal"><span class="pre">ArtifactAssignment</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.NodeTemplate.attributes">
<code class="descname">attributes</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.NodeTemplate.attributes" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of attribute value assignments for the Node Template.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.AttributeAssignment" title="aria_extension_tosca.simple_v1_0.AttributeAssignment"><code class="xref py py-class docutils literal"><span class="pre">AttributeAssignment</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.NodeTemplate.capabilities">
<code class="descname">capabilities</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.NodeTemplate.capabilities" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of capability assignments for the Node Template.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.CapabilityAssignment" title="aria_extension_tosca.simple_v1_0.CapabilityAssignment"><code class="xref py py-class docutils literal"><span class="pre">CapabilityAssignment</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.NodeTemplate.copy">
<code class="descname">copy</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.NodeTemplate.copy" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional (symbolic) name of another node template to copy into (all keynames and values)
and use as a basis for this node template.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.NodeTemplate.description">
<code class="descname">description</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.NodeTemplate.description" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional description for the Node Template.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Description" title="aria_extension_tosca.simple_v1_0.Description"><code class="xref py py-class docutils literal"><span class="pre">Description</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.NodeTemplate.directives">
<code class="descname">directives</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.NodeTemplate.directives" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of directive values to provide processing instructions to orchestrators and
tooling.</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">Type:</th><td class="field-body">[<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>]</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.NodeTemplate.interfaces">
<code class="descname">interfaces</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.NodeTemplate.interfaces" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of named interface definitions for the Node Template.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.InterfaceAssignment" title="aria_extension_tosca.simple_v1_0.InterfaceAssignment"><code class="xref py py-class docutils literal"><span class="pre">InterfaceAssignment</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.NodeTemplate.node_filter">
<code class="descname">node_filter</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.NodeTemplate.node_filter" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional filter definition that TOSCA orchestrators would use to select the correct
target node. This keyname is only valid if the directive has the value of “selectable” set.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.NodeFilter" title="aria_extension_tosca.simple_v1_0.NodeFilter"><code class="xref py py-class docutils literal"><span class="pre">NodeFilter</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.NodeTemplate.properties">
<code class="descname">properties</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.NodeTemplate.properties" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of property value assignments for the Node Template.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.PropertyAssignment" title="aria_extension_tosca.simple_v1_0.PropertyAssignment"><code class="xref py py-class docutils literal"><span class="pre">PropertyAssignment</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.NodeTemplate.requirements">
<code class="descname">requirements</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.NodeTemplate.requirements" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional sequenced list of requirement assignments for the Node Template.</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">Type:</th><td class="field-body">list of (str, <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.RequirementAssignment" title="aria_extension_tosca.simple_v1_0.RequirementAssignment"><code class="xref py py-class docutils literal"><span class="pre">RequirementAssignment</span></code></a>)</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.NodeTemplate.type">
<code class="descname">type</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.NodeTemplate.type" title="Permalink to this definition">¶</a></dt>
<dd><p>The required name of the Node Type the Node Template is based upon.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.RelationshipTemplate">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">RelationshipTemplate</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RelationshipTemplate" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>A Relationship Template specifies the occurrence of a manageable relationship between node
templates as part of an application’s topology model that is defined in a TOSCA Service
Template. A Relationship template is an instance of a specified Relationship Type and can
provide customized properties, constraints or operations which override the defaults provided by
its Relationship Type and its implementations.</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#DEFN_ENTITY_RELATIONSHIP_TEMPLATE">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.RelationshipTemplate.attributes">
<code class="descname">attributes</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RelationshipTemplate.attributes" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of attribute assignments for the Relationship Template.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.AttributeAssignment" title="aria_extension_tosca.simple_v1_0.AttributeAssignment"><code class="xref py py-class docutils literal"><span class="pre">AttributeAssignment</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.RelationshipTemplate.copy">
<code class="descname">copy</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RelationshipTemplate.copy" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional (symbolic) name of another relationship template to copy into (all keynames and
values) and use as a basis for this relationship template.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.RelationshipTemplate.description">
<code class="descname">description</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RelationshipTemplate.description" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional description for the Relationship Template.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Description" title="aria_extension_tosca.simple_v1_0.Description"><code class="xref py py-class docutils literal"><span class="pre">Description</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.RelationshipTemplate.interfaces">
<code class="descname">interfaces</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RelationshipTemplate.interfaces" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of named interface definitions for the Node Template.</p>
<p>ARIA NOTE: Spec is wrong here, should be Relationship Template.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.InterfaceAssignment" title="aria_extension_tosca.simple_v1_0.InterfaceAssignment"><code class="xref py py-class docutils literal"><span class="pre">InterfaceAssignment</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.RelationshipTemplate.properties">
<code class="descname">properties</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RelationshipTemplate.properties" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of property assignments for the Relationship Template.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.PropertyAssignment" title="aria_extension_tosca.simple_v1_0.PropertyAssignment"><code class="xref py py-class docutils literal"><span class="pre">PropertyAssignment</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.RelationshipTemplate.type">
<code class="descname">type</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RelationshipTemplate.type" title="Permalink to this definition">¶</a></dt>
<dd><p>The required name of the Relationship Type the Relationship Template is based upon.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.GroupTemplate">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">GroupTemplate</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.GroupTemplate" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>A group definition defines a logical grouping of node templates, typically for management
purposes, but is separate from the application’s topology template.</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#DEFN_ELEMENT_GROUP_DEF">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.GroupTemplate.description">
<code class="descname">description</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.GroupTemplate.description" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional description for the group definition.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Description" title="aria_extension_tosca.simple_v1_0.Description"><code class="xref py py-class docutils literal"><span class="pre">Description</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.GroupTemplate.interfaces">
<code class="descname">interfaces</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.GroupTemplate.interfaces" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of named interface definitions for the group definition.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.InterfaceDefinition" title="aria_extension_tosca.simple_v1_0.InterfaceDefinition"><code class="xref py py-class docutils literal"><span class="pre">InterfaceDefinition</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.GroupTemplate.members">
<code class="descname">members</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.GroupTemplate.members" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional list of one or more node template names that are members of this group
definition.</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">Type:</th><td class="field-body">[<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>]</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.GroupTemplate.properties">
<code class="descname">properties</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.GroupTemplate.properties" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of property value assignments for the group definition.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.PropertyAssignment" title="aria_extension_tosca.simple_v1_0.PropertyAssignment"><code class="xref py py-class docutils literal"><span class="pre">PropertyAssignment</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.GroupTemplate.type">
<code class="descname">type</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.GroupTemplate.type" title="Permalink to this definition">¶</a></dt>
<dd><p>The required name of the group type the group definition is based upon.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.PolicyTemplate">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">PolicyTemplate</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.PolicyTemplate" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>A policy definition defines a policy that can be associated with a TOSCA topology or top-level
entity definition (e.g., group definition, node template, etc.).</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#DEFN_ELEMENT_POLICY_DEF">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.PolicyTemplate.description">
<code class="descname">description</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.PolicyTemplate.description" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional description for the policy definition.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Description" title="aria_extension_tosca.simple_v1_0.Description"><code class="xref py py-class docutils literal"><span class="pre">Description</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.PolicyTemplate.properties">
<code class="descname">properties</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.PolicyTemplate.properties" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of property value assignments for the policy definition.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.PropertyAssignment" title="aria_extension_tosca.simple_v1_0.PropertyAssignment"><code class="xref py py-class docutils literal"><span class="pre">PropertyAssignment</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.PolicyTemplate.targets">
<code class="descname">targets</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.PolicyTemplate.targets" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of valid Node Templates or Groups the Policy can be applied to.</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">Type:</th><td class="field-body">[<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>]</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.PolicyTemplate.type">
<code class="descname">type</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.PolicyTemplate.type" title="Permalink to this definition">¶</a></dt>
<dd><p>The required name of the policy type the policy definition is based upon.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.TopologyTemplate">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">TopologyTemplate</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.TopologyTemplate" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>This section defines the topology template of a cloud application. The main ingredients of the
topology template are node templates representing components of the application and relationship
templates representing links between the components. These elements are defined in the nested
<code class="docutils literal"><span class="pre">node_templates</span></code> section and the nested relationship_templates sections, respectively.
Furthermore, a topology template allows for defining input parameters, output parameters as well
as grouping of node templates.</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#DEFN_ENTITY_TOPOLOGY_TEMPLATE">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.TopologyTemplate.description">
<code class="descname">description</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.TopologyTemplate.description" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional description for the Topology Template.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Description" title="aria_extension_tosca.simple_v1_0.Description"><code class="xref py py-class docutils literal"><span class="pre">Description</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.TopologyTemplate.groups">
<code class="descname">groups</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.TopologyTemplate.groups" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of Group definitions whose members are node templates defined within this
same Topology Template.</p>
<p><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.GroupTemplate" title="aria_extension_tosca.simple_v1_0.GroupTemplate"><code class="xref py py-class docutils literal"><span class="pre">GroupTemplate</span></code></a></p>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.TopologyTemplate.inputs">
<code class="descname">inputs</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.TopologyTemplate.inputs" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of input parameters (i.e., as parameter definitions) for the Topology
Template.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.ParameterDefinition" title="aria_extension_tosca.simple_v1_0.ParameterDefinition"><code class="xref py py-class docutils literal"><span class="pre">ParameterDefinition</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.TopologyTemplate.node_templates">
<code class="descname">node_templates</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.TopologyTemplate.node_templates" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of node template definitions for the Topology Template.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.NodeTemplate" title="aria_extension_tosca.simple_v1_0.NodeTemplate"><code class="xref py py-class docutils literal"><span class="pre">NodeTemplate</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.TopologyTemplate.outputs">
<code class="descname">outputs</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.TopologyTemplate.outputs" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of output parameters (i.e., as parameter definitions) for the Topology
Template.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.ParameterDefinition" title="aria_extension_tosca.simple_v1_0.ParameterDefinition"><code class="xref py py-class docutils literal"><span class="pre">ParameterDefinition</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.TopologyTemplate.policies">
<code class="descname">policies</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.TopologyTemplate.policies" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of Policy definitions for the Topology Template.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.PolicyTemplate" title="aria_extension_tosca.simple_v1_0.PolicyTemplate"><code class="xref py py-class docutils literal"><span class="pre">PolicyTemplate</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.TopologyTemplate.relationship_templates">
<code class="descname">relationship_templates</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.TopologyTemplate.relationship_templates" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of relationship templates for the Topology Template.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.RelationshipTemplate" title="aria_extension_tosca.simple_v1_0.RelationshipTemplate"><code class="xref py py-class docutils literal"><span class="pre">RelationshipTemplate</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.TopologyTemplate.substitution_mappings">
<code class="descname">substitution_mappings</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.TopologyTemplate.substitution_mappings" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional declaration that exports the topology template as an implementation of a Node
type.</p>
<p>This also includes the mappings between the external Node Types named capabilities and
requirements to existing implementations of those capabilities and requirements on Node
templates declared within the topology template.</p>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.ServiceTemplate">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">ServiceTemplate</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ServiceTemplate" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>Servicate template.</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#DEFN_ELEMENT_SERVICE_TEMPLATE">TOSCA Simple Profile v1.0 cos01 specification</a>.</p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ServiceTemplate.artifact_types">
<code class="descname">artifact_types</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ServiceTemplate.artifact_types" title="Permalink to this definition">¶</a></dt>
<dd><p>This section contains an optional list of artifact type definitions for use in the service
template.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.ArtifactType" title="aria_extension_tosca.simple_v1_0.ArtifactType"><code class="xref py py-class docutils literal"><span class="pre">ArtifactType</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ServiceTemplate.capability_types">
<code class="descname">capability_types</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ServiceTemplate.capability_types" title="Permalink to this definition">¶</a></dt>
<dd><p>This section contains an optional list of capability type definitions for use in the service
template.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.CapabilityType" title="aria_extension_tosca.simple_v1_0.CapabilityType"><code class="xref py py-class docutils literal"><span class="pre">CapabilityType</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ServiceTemplate.data_types">
<code class="descname">data_types</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ServiceTemplate.data_types" title="Permalink to this definition">¶</a></dt>
<dd><p>Declares a list of optional TOSCA Data Type definitions.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.DataType" title="aria_extension_tosca.simple_v1_0.DataType"><code class="xref py py-class docutils literal"><span class="pre">DataType</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ServiceTemplate.description">
<code class="descname">description</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ServiceTemplate.description" title="Permalink to this definition">¶</a></dt>
<dd><p>Declares a description for this Service Template and its contents.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Description" title="aria_extension_tosca.simple_v1_0.Description"><code class="xref py py-class docutils literal"><span class="pre">Description</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ServiceTemplate.dsl_definitions">
<code class="descname">dsl_definitions</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ServiceTemplate.dsl_definitions" title="Permalink to this definition">¶</a></dt>
<dd><p>Declares optional DSL-specific definitions and conventions. For example, in YAML, this
allows defining reusable YAML macros (i.e., YAML alias anchors) for use throughout the TOSCA
Service Template.</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#_Toc397688790">TOSCA Simple Profile v1.0 cos01 specification</a></p>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ServiceTemplate.group_types">
<code class="descname">group_types</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ServiceTemplate.group_types" title="Permalink to this definition">¶</a></dt>
<dd><p>This section contains a list of group type definitions for use in the service template.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.GroupType" title="aria_extension_tosca.simple_v1_0.GroupType"><code class="xref py py-class docutils literal"><span class="pre">GroupType</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ServiceTemplate.imports">
<code class="descname">imports</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ServiceTemplate.imports" title="Permalink to this definition">¶</a></dt>
<dd><p>Declares import statements external TOSCA Definitions documents. For example, these may be
file location or URIs relative to the service template file within the same TOSCA CSAR file.</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">Type:</th><td class="field-body">list of <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Import" title="aria_extension_tosca.simple_v1_0.Import"><code class="xref py py-class docutils literal"><span class="pre">Import</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ServiceTemplate.interface_types">
<code class="descname">interface_types</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ServiceTemplate.interface_types" title="Permalink to this definition">¶</a></dt>
<dd><p>This section contains an optional list of interface type definitions for use in the service
template.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.InterfaceType" title="aria_extension_tosca.simple_v1_0.InterfaceType"><code class="xref py py-class docutils literal"><span class="pre">InterfaceType</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ServiceTemplate.metadata">
<code class="descname">metadata</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ServiceTemplate.metadata" title="Permalink to this definition">¶</a></dt>
<dd><p>Defines a section used to declare additional metadata information. Domain-specific TOSCA
profile specifications may define keynames that are required for their implementations.</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#_Toc379455048">TOSCA Simple Profile v1.0 cos01 specification</a></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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.MetaData" title="aria_extension_tosca.simple_v1_0.MetaData"><code class="xref py py-class docutils literal"><span class="pre">MetaData</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ServiceTemplate.node_types">
<code class="descname">node_types</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ServiceTemplate.node_types" title="Permalink to this definition">¶</a></dt>
<dd><p>This section contains a set of node type definitions for use in the service template.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.NodeType" title="aria_extension_tosca.simple_v1_0.NodeType"><code class="xref py py-class docutils literal"><span class="pre">NodeType</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ServiceTemplate.policy_types">
<code class="descname">policy_types</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ServiceTemplate.policy_types" title="Permalink to this definition">¶</a></dt>
<dd><p>This section contains a list of policy type definitions for use in the service template.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.PolicyType" title="aria_extension_tosca.simple_v1_0.PolicyType"><code class="xref py py-class docutils literal"><span class="pre">PolicyType</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ServiceTemplate.relationship_types">
<code class="descname">relationship_types</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ServiceTemplate.relationship_types" title="Permalink to this definition">¶</a></dt>
<dd><p>This section contains a set of relationship type definitions for use in the service
template.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.RelationshipType" title="aria_extension_tosca.simple_v1_0.RelationshipType"><code class="xref py py-class docutils literal"><span class="pre">RelationshipType</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ServiceTemplate.repositories">
<code class="descname">repositories</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ServiceTemplate.repositories" title="Permalink to this definition">¶</a></dt>
<dd><p>Declares the list of external repositories which contain artifacts that are referenced in
the service template along with their addresses and necessary credential information used to
connect to them in order to retrieve the artifacts.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Repository" title="aria_extension_tosca.simple_v1_0.Repository"><code class="xref py py-class docutils literal"><span class="pre">Repository</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ServiceTemplate.topology_template">
<code class="descname">topology_template</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ServiceTemplate.topology_template" title="Permalink to this definition">¶</a></dt>
<dd><p>Defines the topology template of an application or service, consisting of node templates
that represent the application’s or service’s components, as well as relationship templates
representing relations between the components.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.TopologyTemplate" title="aria_extension_tosca.simple_v1_0.TopologyTemplate"><code class="xref py py-class docutils literal"><span class="pre">TopologyTemplate</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ServiceTemplate.tosca_definitions_version">
<code class="descname">tosca_definitions_version</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ServiceTemplate.tosca_definitions_version" title="Permalink to this definition">¶</a></dt>
<dd><p>Defines the version of the TOSCA Simple Profile specification the template (grammar)
complies with.</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#_Toc379455047">TOSCA Simple Profile v1.0 cos01 specification</a></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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.ArtifactType">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">ArtifactType</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ArtifactType" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>An Artifact Type is a reusable entity that defines the type of one or more files that are used
to define implementation or deployment artifacts that are referenced by nodes or relationships
on their operations.</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#DEFN_ENTITY_ARTIFACT_TYPE">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ArtifactType.derived_from">
<code class="descname">derived_from</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ArtifactType.derived_from" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional parent Artifact Type name the Artifact Type derives from.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ArtifactType.description">
<code class="descname">description</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ArtifactType.description" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional description for the Artifact Type.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Description" title="aria_extension_tosca.simple_v1_0.Description"><code class="xref py py-class docutils literal"><span class="pre">Description</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ArtifactType.file_ext">
<code class="descname">file_ext</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ArtifactType.file_ext" title="Permalink to this definition">¶</a></dt>
<dd><p>The required file extension property for the Artifact Type.</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">Type:</th><td class="field-body">[<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>]</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ArtifactType.mime_type">
<code class="descname">mime_type</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ArtifactType.mime_type" title="Permalink to this definition">¶</a></dt>
<dd><p>The required mime type property for the Artifact Type.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ArtifactType.properties">
<code class="descname">properties</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ArtifactType.properties" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of property definitions for the Artifact Type.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.PropertyDefinition" title="aria_extension_tosca.simple_v1_0.PropertyDefinition"><code class="xref py py-class docutils literal"><span class="pre">PropertyDefinition</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ArtifactType.version">
<code class="descname">version</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ArtifactType.version" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional version for the Artifact Type definition.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Version" title="aria_extension_tosca.simple_v1_0.Version"><code class="xref py py-class docutils literal"><span class="pre">Version</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.DataType">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">DataType</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.DataType" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>A Data Type definition defines the schema for new named datatypes in TOSCA.</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#DEFN_ENTITY_DATA_TYPE">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.DataType.constraints">
<code class="descname">constraints</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.DataType.constraints" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional list of sequenced constraint clauses for the Data Type.</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">Type:</th><td class="field-body">list of (str, <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.ConstraintClause" title="aria_extension_tosca.simple_v1_0.ConstraintClause"><code class="xref py py-class docutils literal"><span class="pre">ConstraintClause</span></code></a>)</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.DataType.derived_from">
<code class="descname">derived_from</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.DataType.derived_from" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional key used when a datatype is derived from an existing TOSCA Data Type.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.DataType.description">
<code class="descname">description</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.DataType.description" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional description for the Data Type.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Description" title="aria_extension_tosca.simple_v1_0.Description"><code class="xref py py-class docutils literal"><span class="pre">Description</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.DataType.properties">
<code class="descname">properties</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.DataType.properties" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional list property definitions that comprise the schema for a complex Data Type in
TOSCA.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.PropertyDefinition" title="aria_extension_tosca.simple_v1_0.PropertyDefinition"><code class="xref py py-class docutils literal"><span class="pre">PropertyDefinition</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.DataType.version">
<code class="descname">version</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.DataType.version" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional version for the Data Type definition.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Version" title="aria_extension_tosca.simple_v1_0.Version"><code class="xref py py-class docutils literal"><span class="pre">Version</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.CapabilityType">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">CapabilityType</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.CapabilityType" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>A Capability Type is a reusable entity that describes a kind of capability that a Node Type can
declare to expose. Requirements (implicit or explicit) that are declared as part of one node can
be matched to (i.e., fulfilled by) the Capabilities declared by another node.</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#DEFN_ENTITY_CAPABILITY_TYPE">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.CapabilityType.attributes">
<code class="descname">attributes</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.CapabilityType.attributes" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of attribute definitions for the Capability Type.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.AttributeDefinition" title="aria_extension_tosca.simple_v1_0.AttributeDefinition"><code class="xref py py-class docutils literal"><span class="pre">AttributeDefinition</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.CapabilityType.derived_from">
<code class="descname">derived_from</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.CapabilityType.derived_from" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional parent capability type name this new Capability Type derives from.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.CapabilityType.description">
<code class="descname">description</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.CapabilityType.description" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional description for the Capability Type.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Description" title="aria_extension_tosca.simple_v1_0.Description"><code class="xref py py-class docutils literal"><span class="pre">Description</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.CapabilityType.properties">
<code class="descname">properties</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.CapabilityType.properties" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of property definitions for the Capability Type.</p>
<p>ARIA NOTE: The spec says ‘list’, but the examples are all of dicts.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.PropertyDefinition" title="aria_extension_tosca.simple_v1_0.PropertyDefinition"><code class="xref py py-class docutils literal"><span class="pre">PropertyDefinition</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.CapabilityType.valid_source_types">
<code class="descname">valid_source_types</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.CapabilityType.valid_source_types" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of one or more valid names of Node Types that are supported as valid
sources of any relationship established to the declared Capability Type.</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">Type:</th><td class="field-body">[<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>]</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.CapabilityType.version">
<code class="descname">version</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.CapabilityType.version" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional version for the Capability Type definition.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Version" title="aria_extension_tosca.simple_v1_0.Version"><code class="xref py py-class docutils literal"><span class="pre">Version</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.InterfaceType">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">InterfaceType</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.InterfaceType" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>An Interface Type is a reusable entity that describes a set of operations that can be used to
interact with or manage a node or relationship in a TOSCA topology.</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#DEFN_ENTITY_INTERFACE_TYPE">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.InterfaceType.derived_from">
<code class="descname">derived_from</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.InterfaceType.derived_from" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional parent Interface Type name this new Interface Type derives from.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.InterfaceType.description">
<code class="descname">description</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.InterfaceType.description" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional description for the Interface Type.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Description" title="aria_extension_tosca.simple_v1_0.Description"><code class="xref py py-class docutils literal"><span class="pre">Description</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.InterfaceType.inputs">
<code class="descname">inputs</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.InterfaceType.inputs" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional list of input parameter definitions.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.PropertyDefinition" title="aria_extension_tosca.simple_v1_0.PropertyDefinition"><code class="xref py py-class docutils literal"><span class="pre">PropertyDefinition</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.InterfaceType.operations">
<code class="descname">operations</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.InterfaceType.operations" title="Permalink to this definition">¶</a></dt>
<dd><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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.OperationDefinition" title="aria_extension_tosca.simple_v1_0.OperationDefinition"><code class="xref py py-class docutils literal"><span class="pre">OperationDefinition</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.InterfaceType.version">
<code class="descname">version</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.InterfaceType.version" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional version for the Interface Type definition.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Version" title="aria_extension_tosca.simple_v1_0.Version"><code class="xref py py-class docutils literal"><span class="pre">Version</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.RelationshipType">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">RelationshipType</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RelationshipType" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>A Relationship Type is a reusable entity that defines the type of one or more relationships
between Node Types or Node Templates.</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#DEFN_ENTITY_RELATIONSHIP_TYPE">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.RelationshipType.attributes">
<code class="descname">attributes</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RelationshipType.attributes" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of attribute definitions for the Relationship Type.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.AttributeDefinition" title="aria_extension_tosca.simple_v1_0.AttributeDefinition"><code class="xref py py-class docutils literal"><span class="pre">AttributeDefinition</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.RelationshipType.derived_from">
<code class="descname">derived_from</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RelationshipType.derived_from" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional parent Relationship Type name the Relationship Type derives from.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.RelationshipType.description">
<code class="descname">description</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RelationshipType.description" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional description for the Relationship Type.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Description" title="aria_extension_tosca.simple_v1_0.Description"><code class="xref py py-class docutils literal"><span class="pre">Description</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.RelationshipType.interfaces">
<code class="descname">interfaces</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RelationshipType.interfaces" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of interface definitions interfaces supported by the Relationship Type.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.InterfaceDefinition" title="aria_extension_tosca.simple_v1_0.InterfaceDefinition"><code class="xref py py-class docutils literal"><span class="pre">InterfaceDefinition</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.RelationshipType.properties">
<code class="descname">properties</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RelationshipType.properties" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of property definitions for the Relationship Type.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.PropertyDefinition" title="aria_extension_tosca.simple_v1_0.PropertyDefinition"><code class="xref py py-class docutils literal"><span class="pre">PropertyDefinition</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.RelationshipType.valid_target_types">
<code class="descname">valid_target_types</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RelationshipType.valid_target_types" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of one or more names of Capability Types that are valid targets for this
relationship.</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">Type:</th><td class="field-body">[<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>]</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.RelationshipType.version">
<code class="descname">version</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.RelationshipType.version" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional version for the Relationship Type definition.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Version" title="aria_extension_tosca.simple_v1_0.Version"><code class="xref py py-class docutils literal"><span class="pre">Version</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.NodeType">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">NodeType</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.NodeType" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>A Node Type is a reusable entity that defines the type of one or more Node Templates. As such, a
Node Type defines the structure of observable properties via a Properties Definition, the
Requirements and Capabilities of the node as well as its supported interfaces.</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#DEFN_ENTITY_NODE_TYPE">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.NodeType.artifacts">
<code class="descname">artifacts</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.NodeType.artifacts" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of named artifact definitions for the Node Type.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.ArtifactAssignment" title="aria_extension_tosca.simple_v1_0.ArtifactAssignment"><code class="xref py py-class docutils literal"><span class="pre">ArtifactAssignment</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.NodeType.attributes">
<code class="descname">attributes</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.NodeType.attributes" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of attribute definitions for the Node Type.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.AttributeDefinition" title="aria_extension_tosca.simple_v1_0.AttributeDefinition"><code class="xref py py-class docutils literal"><span class="pre">AttributeDefinition</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.NodeType.capabilities">
<code class="descname">capabilities</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.NodeType.capabilities" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of capability definitions for the Node Type.</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">Type:</th><td class="field-body">list of <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.CapabilityDefinition" title="aria_extension_tosca.simple_v1_0.CapabilityDefinition"><code class="xref py py-class docutils literal"><span class="pre">CapabilityDefinition</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.NodeType.derived_from">
<code class="descname">derived_from</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.NodeType.derived_from" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional parent Node Type name this new Node Type derives from.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.NodeType.description">
<code class="descname">description</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.NodeType.description" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional description for the Node Type.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Description" title="aria_extension_tosca.simple_v1_0.Description"><code class="xref py py-class docutils literal"><span class="pre">Description</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.NodeType.interfaces">
<code class="descname">interfaces</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.NodeType.interfaces" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of interface definitions supported by the Node Type.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.InterfaceDefinition" title="aria_extension_tosca.simple_v1_0.InterfaceDefinition"><code class="xref py py-class docutils literal"><span class="pre">InterfaceDefinition</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.NodeType.properties">
<code class="descname">properties</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.NodeType.properties" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of property definitions for the Node Type.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.PropertyDefinition" title="aria_extension_tosca.simple_v1_0.PropertyDefinition"><code class="xref py py-class docutils literal"><span class="pre">PropertyDefinition</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.NodeType.requirements">
<code class="descname">requirements</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.NodeType.requirements" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional sequenced list of requirement definitions for the Node Type.</p>
<p>ARIA NOTE: The spec seems wrong to make this a sequenced list. It seems that when you have
more than one requirement of the same name, behavior is undefined. The idea is to use the
“occurrences” field if you need to limit the number of requirement assignments.</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">Type:</th><td class="field-body">list of (str, <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.RequirementDefinition" title="aria_extension_tosca.simple_v1_0.RequirementDefinition"><code class="xref py py-class docutils literal"><span class="pre">RequirementDefinition</span></code></a>)</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.NodeType.version">
<code class="descname">version</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.NodeType.version" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional version for the Node Type definition.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Version" title="aria_extension_tosca.simple_v1_0.Version"><code class="xref py py-class docutils literal"><span class="pre">Version</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.GroupType">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">GroupType</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.GroupType" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>A Group Type defines logical grouping types for nodes, typically for different management
purposes. Groups can effectively be viewed as logical nodes that are not part of the physical
deployment topology of an application, yet can have capabilities and the ability to attach
policies and interfaces that can be applied (depending on the group type) to its member nodes.</p>
<p>Conceptually, group definitions allow the creation of logical “membership” relationships to
nodes in a service template that are not a part of the application’s explicit requirement
dependencies in the topology template (i.e. those required to actually get the application
deployed and running). Instead, such logical membership allows for the introduction of things
such as group management and uniform application of policies (i.e., requirements that are also
not bound to the application itself) to the group’s members.</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#DEFN_ENTITY_GROUP_TYPE">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.GroupType.derived_from">
<code class="descname">derived_from</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.GroupType.derived_from" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional parent Group Type name the Group Type derives from.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.GroupType.description">
<code class="descname">description</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.GroupType.description" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional description for the Group Type.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Description" title="aria_extension_tosca.simple_v1_0.Description"><code class="xref py py-class docutils literal"><span class="pre">Description</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.GroupType.interfaces">
<code class="descname">interfaces</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.GroupType.interfaces" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of interface definitions supported by the Group Type.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.InterfaceDefinition" title="aria_extension_tosca.simple_v1_0.InterfaceDefinition"><code class="xref py py-class docutils literal"><span class="pre">InterfaceDefinition</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.GroupType.members">
<code class="descname">members</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.GroupType.members" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of one or more names of Node Types that are valid (allowed) as members of
the Group Type.</p>
<p>Note: This can be viewed by TOSCA Orchestrators as an implied relationship from the listed
members nodes to the group, but one that does not have operational lifecycle considerations.
For example, if we were to name this as an explicit Relationship Type we might call this
“MemberOf” (group).</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">Type:</th><td class="field-body">[<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>]</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.GroupType.properties">
<code class="descname">properties</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.GroupType.properties" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of property definitions for the Group Type.</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">Type:</th><td class="field-body">{<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>: <a class="reference internal" href="#aria_extension_tosca.simple_v1_0.PropertyDefinition" title="aria_extension_tosca.simple_v1_0.PropertyDefinition"><code class="xref py py-class docutils literal"><span class="pre">PropertyDefinition</span></code></a>}</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.GroupType.version">
<code class="descname">version</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.GroupType.version" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional version for the Group Type definition.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Version" title="aria_extension_tosca.simple_v1_0.Version"><code class="xref py py-class docutils literal"><span class="pre">Version</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.PolicyType">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">PolicyType</code><span class="sig-paren">(</span><em>name=None</em>, <em>raw=None</em>, <em>container=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.PolicyType" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria_extension_tosca.simple_v1_0.presentation.html#aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation" title="aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation"><code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.presentation.extensible.ExtensiblePresentation</span></code></a></p>
<p>A Policy Type defines a type of requirement that affects or governs an application or service’s
topology at some stage of its lifecycle, but is not explicitly part of the topology itself
(i.e., it does not prevent the application or service from being deployed or run if it did not
exist).</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#DEFN_ENTITY_POLICY_TYPE">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.PolicyType.derived_from">
<code class="descname">derived_from</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.PolicyType.derived_from" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional parent Policy Type name the Policy Type derives from.</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">Type:</th><td class="field-body"><a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.PolicyType.description">
<code class="descname">description</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.PolicyType.description" title="Permalink to this definition">¶</a></dt>
<dd><p>The optional description for the Policy Type.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Description" title="aria_extension_tosca.simple_v1_0.Description"><code class="xref py py-class docutils literal"><span class="pre">Description</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.PolicyType.properties">
<code class="descname">properties</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.PolicyType.properties" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of property definitions for the Policy Type.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.PropertyDefinition" title="aria_extension_tosca.simple_v1_0.PropertyDefinition"><code class="xref py py-class docutils literal"><span class="pre">PropertyDefinition</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.PolicyType.targets">
<code class="descname">targets</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.PolicyType.targets" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional list of valid Node Types or Group Types the Policy Type can be applied to.</p>
<p>Note: This can be viewed by TOSCA Orchestrators as an implied relationship to the target
nodes, but one that does not have operational lifecycle considerations. For example, if we
were to name this as an explicit Relationship Type we might call this “AppliesTo” (node or
group).</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">Type:</th><td class="field-body">[<a class="reference external" href="https://docs.python.org/2.7/library/functions.html#basestring" title="(in Python v2.7)"><code class="xref py py-obj docutils literal"><span class="pre">basestring</span></code></a>]</td>
</tr>
</tbody>
</table>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.PolicyType.version">
<code class="descname">version</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.PolicyType.version" title="Permalink to this definition">¶</a></dt>
<dd><p>An optional version for the Policy Type definition.</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">Type:</th><td class="field-body"><a class="reference internal" href="#aria_extension_tosca.simple_v1_0.Version" title="aria_extension_tosca.simple_v1_0.Version"><code class="xref py py-class docutils literal"><span class="pre">Version</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.Timestamp">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">Timestamp</code><span class="sig-paren">(</span><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.Timestamp" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference external" href="https://docs.python.org/2.7/library/functions.html#object" title="(in Python v2.7)"><code class="xref py py-class docutils literal"><span class="pre">object</span></code></a></p>
<p>TOSCA timestamps follow the YAML specification, which in turn is a variant of ISO8601.</p>
<p>Long forms and short forms (without time of day and assuming UTC timezone) are supported for
parsing. The canonical form (for rendering) matches the long form at the UTC timezone.</p>
<p>See the <a class="reference external" href="http://yaml.org/type/timestamp.html">Timestamp Language-Independent Type for YAML Version 1.1 (Working Draft 2005-01-18)</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.Timestamp.CANONICAL">
<code class="descname">CANONICAL</code><em class="property"> = '%Y-%m-%dT%H:%M:%S'</em><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.Timestamp.CANONICAL" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.Timestamp.REGULAR_LONG">
<code class="descname">REGULAR_LONG</code><em class="property"> = '^(?P&lt;year&gt;[0-9][0-9][0-9][0-9])-(?P&lt;month&gt;[0-9][0-9]?)-(?P&lt;day&gt;[0-9][0-9]?)([Tt]|[ \\t]+)(?P&lt;hour&gt;[0-9][0-9]?):(?P&lt;minute&gt;[0-9][0-9]):(?P&lt;second&gt;[0-9][0-9])(?P&lt;fraction&gt;\\.[0-9]*)?(([ \\t]*)Z|(?P&lt;tzhour&gt;[-+][0-9][0-9])?(:(?P&lt;tzminute&gt;[0-9][0-9])?)?)?$'</em><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.Timestamp.REGULAR_LONG" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.Timestamp.REGULAR_SHORT">
<code class="descname">REGULAR_SHORT</code><em class="property"> = '^(?P&lt;year&gt;[0-9][0-9][0-9][0-9])-(?P&lt;month&gt;[0-9][0-9])-(?P&lt;day&gt;[0-9][0-9])$'</em><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.Timestamp.REGULAR_SHORT" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

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

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.Timestamp.as_raw">
<code class="descname">as_raw</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.Timestamp.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.Version">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">Version</code><span class="sig-paren">(</span><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.Version" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference external" href="https://docs.python.org/2.7/library/functions.html#object" title="(in Python v2.7)"><code class="xref py py-class docutils literal"><span class="pre">object</span></code></a></p>
<p>TOSCA supports the concept of “reuse” of type definitions, as well as template definitions which
could be version and change over time. It is important to provide a reliable, normative means to
represent a version string which enables the comparison and management of types and templates
over time. Therefore, the TOSCA TC intends to provide a normative version type (string) for this
purpose in future Working Drafts of this specification.</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#TYPE_TOSCA_VERSION">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.Version.REGULAR">
<code class="descname">REGULAR</code><em class="property"> = '^(?P&lt;major&gt;\\d+)\\.(?P&lt;minor&gt;\\d+)(\\.(?P&lt;fix&gt;\\d+)((\\.(?P&lt;qualifier&gt;\\d+))(\\-(?P&lt;build&gt;\\d+))?)?)?$'</em><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.Version.REGULAR" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

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

<dl class="staticmethod">
<dt id="aria_extension_tosca.simple_v1_0.Version.key">
<em class="property">static </em><code class="descname">key</code><span class="sig-paren">(</span><em>version</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.Version.key" title="Permalink to this definition">¶</a></dt>
<dd><p>Key method for fast sorting.</p>
</dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.Range">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">Range</code><span class="sig-paren">(</span><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.Range" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference external" href="https://docs.python.org/2.7/library/functions.html#object" title="(in Python v2.7)"><code class="xref py py-class docutils literal"><span class="pre">object</span></code></a></p>
<p>The range type can be used to define numeric ranges with a lower and upper boundary. For
example, this allows for specifying a range of ports to be opened in a firewall.</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#TYPE_TOSCA_RANGE">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.Range.as_raw">
<code class="descname">as_raw</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.Range.as_raw" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

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

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.List">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">List</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.List" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">list</span></code></p>
<p>The list type allows for specifying multiple values for a parameter of property. For example, if
an application allows for being configured to listen on multiple ports, a list of ports could be
configured using the list data type.</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#TYPE_TOSCA_LIST">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="method">
<dt id="aria_extension_tosca.simple_v1_0.List.as_raw">
<code class="descname">as_raw</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.List.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.Map">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">Map</code><span class="sig-paren">(</span><em>items=None</em><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.Map" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <a class="reference internal" href="aria.utils.html#aria.utils.collections.StrictDict" title="aria.utils.collections.StrictDict"><code class="xref py py-class docutils literal"><span class="pre">aria.utils.collections.StrictDict</span></code></a></p>
<p>The map type allows for specifying multiple values for a parameter of property as a map. In
contrast to the list type, where each entry can only be addressed by its index in the list,
entries in a map are named elements that can be addressed by their keys.</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#TYPE_TOSCA_MAP">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="method">
<dt id="aria_extension_tosca.simple_v1_0.Map.as_raw">
<code class="descname">as_raw</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.Map.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.ScalarSize">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">ScalarSize</code><span class="sig-paren">(</span><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.ScalarSize" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.data_types.Scalar</span></code></p>
<p>Integer scalar for counting bytes.</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#TYPE_TOSCA_SCALAR_UNIT_SIZE">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ScalarSize.REGULAR">
<code class="descname">REGULAR</code><em class="property"> = '^(?P&lt;scalar&gt;[0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?)\\s*(?P&lt;unit&gt;B|kB|KiB|MB|MiB|GB|GiB|TB|TiB)$'</em><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ScalarSize.REGULAR" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ScalarSize.TYPE">
<code class="descname">TYPE</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ScalarSize.TYPE" title="Permalink to this definition">¶</a></dt>
<dd><p>alias of <a class="reference external" href="https://docs.python.org/2.7/library/functions.html#int" title="(in Python v2.7)"><code class="xref py py-class docutils literal"><span class="pre">int</span></code></a></p>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ScalarSize.UNIT">
<code class="descname">UNIT</code><em class="property"> = 'bytes'</em><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ScalarSize.UNIT" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ScalarSize.UNITS">
<code class="descname">UNITS</code><em class="property"> = {'kB': 1000, 'B': 1, 'GB': 1000000000, 'MB': 1000000, 'KiB': 1024, 'MiB': 1048576, 'TB': 1000000000000, 'TiB': 1099511627776, 'GiB': 1073741824}</em><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ScalarSize.UNITS" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.ScalarTime">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">ScalarTime</code><span class="sig-paren">(</span><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.ScalarTime" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.data_types.Scalar</span></code></p>
<p>Floating point scalar for counting seconds.</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#TYPE_TOSCA_SCALAR_UNIT_TIME">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ScalarTime.REGULAR">
<code class="descname">REGULAR</code><em class="property"> = '^(?P&lt;scalar&gt;[0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?)\\s*(?P&lt;unit&gt;ns|us|ms|s|m|h|d)$'</em><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ScalarTime.REGULAR" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ScalarTime.TYPE">
<code class="descname">TYPE</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ScalarTime.TYPE" title="Permalink to this definition">¶</a></dt>
<dd><p>alias of <a class="reference external" href="https://docs.python.org/2.7/library/functions.html#float" title="(in Python v2.7)"><code class="xref py py-class docutils literal"><span class="pre">float</span></code></a></p>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ScalarTime.UNIT">
<code class="descname">UNIT</code><em class="property"> = 'seconds'</em><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ScalarTime.UNIT" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ScalarTime.UNITS">
<code class="descname">UNITS</code><em class="property"> = {'d': 86400.0, 'h': 3600.0, 'm': 60.0, 'us': 1e-06, 's': 1.0, 'ms': 0.001, 'ns': 1e-09}</em><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ScalarTime.UNITS" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</dd></dl>

<dl class="class">
<dt id="aria_extension_tosca.simple_v1_0.ScalarFrequency">
<em class="property">class </em><code class="descclassname">aria_extension_tosca.simple_v1_0.</code><code class="descname">ScalarFrequency</code><span class="sig-paren">(</span><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.ScalarFrequency" title="Permalink to this definition">¶</a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal"><span class="pre">aria_extension_tosca.simple_v1_0.data_types.Scalar</span></code></p>
<p>Floating point scalar for counting cycles per second (Hz).</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#TYPE_TOSCA_SCALAR_UNIT_FREQUENCY">TOSCA Simple Profile v1.0 cos01 specification</a></p>
<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ScalarFrequency.REGULAR">
<code class="descname">REGULAR</code><em class="property"> = '^(?P&lt;scalar&gt;[0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?)\\s*(?P&lt;unit&gt;Hz|kHz|MHz|GHz)$'</em><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ScalarFrequency.REGULAR" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ScalarFrequency.TYPE">
<code class="descname">TYPE</code><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ScalarFrequency.TYPE" title="Permalink to this definition">¶</a></dt>
<dd><p>alias of <a class="reference external" href="https://docs.python.org/2.7/library/functions.html#float" title="(in Python v2.7)"><code class="xref py py-class docutils literal"><span class="pre">float</span></code></a></p>
</dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ScalarFrequency.UNIT">
<code class="descname">UNIT</code><em class="property"> = 'Hz'</em><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ScalarFrequency.UNIT" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="attribute">
<dt id="aria_extension_tosca.simple_v1_0.ScalarFrequency.UNITS">
<code class="descname">UNITS</code><em class="property"> = {'Hz': 1.0, 'kHz': 1000.0, 'MHz': 1000000.0, 'GHz': 1000000000.0}</em><a class="headerlink" href="#aria_extension_tosca.simple_v1_0.ScalarFrequency.UNITS" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

</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.modeling.html" class="btn btn-neutral float-right" title="aria_extension_tosca.simple_v1_0.modeling" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right"></span></a>
      
      
        <a href="aria.utils.html" class="btn btn-neutral" title="aria.utils" 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>