<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="X-UA-Compatible" content="IE=Edge" />
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Reference — python-semanticversion 2.6.0 documentation</title>
<link rel="stylesheet" href="_static/classic.css" type="text/css" />
<link rel="stylesheet" href="_static/pygments.css" type="text/css" />
<script type="text/javascript" id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></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/language_data.js"></script>
<link rel="index" title="Index" href="genindex.html" />
<link rel="search" title="Search" href="search.html" />
<link rel="next" title="Interaction with Django" href="django.html" />
<link rel="prev" title="python-semanticversion" href="index.html" />
</head><body>
<div class="related" role="navigation" aria-label="related navigation">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="py-modindex.html" title="Python Module Index"
>modules</a> |</li>
<li class="right" >
<a href="django.html" title="Interaction with Django"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="index.html" title="python-semanticversion"
accesskey="P">previous</a> |</li>
<li class="nav-item nav-item-0"><a href="index.html">python-semanticversion 2.6.0 documentation</a> »</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body" role="main">
<div class="section" id="module-semantic_version">
<span id="reference"></span><h1>Reference<a class="headerlink" href="#module-semantic_version" title="Permalink to this headline">¶</a></h1>
<div class="section" id="module-level-functions">
<h2>Module-level functions<a class="headerlink" href="#module-level-functions" title="Permalink to this headline">¶</a></h2>
<dl class="function">
<dt id="semantic_version.compare">
<code class="descclassname">semantic_version.</code><code class="descname">compare</code><span class="sig-paren">(</span><em>v1</em>, <em>v2</em><span class="sig-paren">)</span><a class="headerlink" href="#semantic_version.compare" title="Permalink to this definition">¶</a></dt>
<dd><p>Compare two version strings, and return a result similar to that of <code class="xref py py-func docutils literal notranslate"><span class="pre">cmp()</span></code>:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">compare</span><span class="p">(</span><span class="s1">'0.1.1'</span><span class="p">,</span> <span class="s1">'0.1.2'</span><span class="p">)</span>
<span class="go">-1</span>
<span class="gp">>>> </span><span class="n">compare</span><span class="p">(</span><span class="s1">'0.1.1'</span><span class="p">,</span> <span class="s1">'0.1.1'</span><span class="p">)</span>
<span class="go">0</span>
<span class="gp">>>> </span><span class="n">compare</span><span class="p">(</span><span class="s1">'0.1.1'</span><span class="p">,</span> <span class="s1">'0.1.1-alpha'</span><span class="p">)</span>
<span class="go">1</span>
</pre></div>
</div>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>v1</strong> (<em>str</em>) – The first version to compare</li>
<li><strong>v2</strong> (<em>str</em>) – The second version to compare</li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Raises:</th><td class="field-body"><p class="first"><code class="xref py py-exc docutils literal notranslate"><span class="pre">ValueError</span></code>, if any version string is invalid</p>
</td>
</tr>
<tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><code class="docutils literal notranslate"><span class="pre">int</span></code>, -1 / 0 / 1 as for a <code class="xref py py-func docutils literal notranslate"><span class="pre">cmp()</span></code> comparison;
<code class="docutils literal notranslate"><span class="pre">NotImplemented</span></code> if versions only differ by build metadata</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<div class="admonition warning">
<p class="first admonition-title">Warning</p>
<p class="last">Since build metadata has no ordering,
<code class="docutils literal notranslate"><span class="pre">compare(Version('0.1.1'),</span> <span class="pre">Version('0.1.1+3'))</span></code> returns <code class="docutils literal notranslate"><span class="pre">NotImplemented</span></code></p>
</div>
<dl class="function">
<dt id="semantic_version.match">
<code class="descclassname">semantic_version.</code><code class="descname">match</code><span class="sig-paren">(</span><em>spec</em>, <em>version</em><span class="sig-paren">)</span><a class="headerlink" href="#semantic_version.match" title="Permalink to this definition">¶</a></dt>
<dd><p>Check whether a version string matches a specification string:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">match</span><span class="p">(</span><span class="s1">'>=0.1.1'</span><span class="p">,</span> <span class="s1">'0.1.2'</span><span class="p">)</span>
<span class="go">True</span>
<span class="gp">>>> </span><span class="n">match</span><span class="p">(</span><span class="s1">'>=0.1.1'</span><span class="p">,</span> <span class="s1">'0.1.1-alpha'</span><span class="p">)</span>
<span class="go">False</span>
<span class="gp">>>> </span><span class="n">match</span><span class="p">(</span><span class="s1">'~0.1.1'</span><span class="p">,</span> <span class="s1">'0.1.1-alpha'</span><span class="p">)</span>
<span class="go">True</span>
</pre></div>
</div>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>spec</strong> (<em>str</em>) – The specification to use, as a string</li>
<li><strong>version</strong> (<em>str</em>) – The version string to test against the spec</li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Raises:</th><td class="field-body"><p class="first"><code class="xref py py-exc docutils literal notranslate"><span class="pre">ValueError</span></code>, if the <code class="docutils literal notranslate"><span class="pre">spec</span></code> or the <code class="docutils literal notranslate"><span class="pre">version</span></code> is invalid</p>
</td>
</tr>
<tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><code class="docutils literal notranslate"><span class="pre">bool</span></code></p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="function">
<dt id="semantic_version.validate">
<code class="descclassname">semantic_version.</code><code class="descname">validate</code><span class="sig-paren">(</span><em>version</em><span class="sig-paren">)</span><a class="headerlink" href="#semantic_version.validate" title="Permalink to this definition">¶</a></dt>
<dd><p>Check whether a version string complies with the <a class="reference external" href="http://semver.org/">SemVer</a> rules.</p>
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">semantic_version</span><span class="o">.</span><span class="n">validate</span><span class="p">(</span><span class="s1">'1.1.1'</span><span class="p">)</span>
<span class="go">True</span>
<span class="gp">>>> </span><span class="n">semantic_version</span><span class="o">.</span><span class="n">validate</span><span class="p">(</span><span class="s1">'1.2.3a4'</span><span class="p">)</span>
<span class="go">False</span>
</pre></div>
</div>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>version</strong> (<em>str</em>) – The version string to validate</td>
</tr>
<tr class="field-even field"><th class="field-name">Return type:</th><td class="field-body"><code class="docutils literal notranslate"><span class="pre">bool</span></code></td>
</tr>
</tbody>
</table>
</dd></dl>
</div>
<div class="section" id="representing-a-version-the-version-class">
<h2>Representing a version (the Version class)<a class="headerlink" href="#representing-a-version-the-version-class" title="Permalink to this headline">¶</a></h2>
<dl class="class">
<dt id="semantic_version.Version">
<em class="property">class </em><code class="descclassname">semantic_version.</code><code class="descname">Version</code><span class="sig-paren">(</span><em>version_string</em><span class="optional">[</span>, <em>partial=False</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#semantic_version.Version" title="Permalink to this definition">¶</a></dt>
<dd><p>Object representation of a <a class="reference external" href="http://semver.org/">SemVer</a>-compliant version.</p>
<p>Constructed from a textual version string:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">Version</span><span class="p">(</span><span class="s1">'1.1.1'</span><span class="p">)</span>
<span class="go">Version('1.1.1')</span>
<span class="gp">>>> </span><span class="nb">str</span><span class="p">(</span><span class="n">Version</span><span class="p">(</span><span class="s1">'1.1.1'</span><span class="p">))</span>
<span class="go">'1.1.1'</span>
</pre></div>
</div>
<p class="rubric">Attributes</p>
<dl class="attribute">
<dt id="semantic_version.Version.partial">
<code class="descname">partial</code><a class="headerlink" href="#semantic_version.Version.partial" title="Permalink to this definition">¶</a></dt>
<dd><p><code class="docutils literal notranslate"><span class="pre">bool</span></code>, whether this is a ‘partial’ or a complete version number.
Partial version number may lack <a class="reference internal" href="#semantic_version.Version.minor" title="semantic_version.Version.minor"><code class="xref py py-attr docutils literal notranslate"><span class="pre">minor</span></code></a> or <a class="reference internal" href="#semantic_version.Version.patch" title="semantic_version.Version.patch"><code class="xref py py-attr docutils literal notranslate"><span class="pre">patch</span></code></a> version numbers.</p>
</dd></dl>
<dl class="attribute">
<dt id="semantic_version.Version.major">
<code class="descname">major</code><a class="headerlink" href="#semantic_version.Version.major" title="Permalink to this definition">¶</a></dt>
<dd><p><code class="docutils literal notranslate"><span class="pre">int</span></code>, the major version number</p>
</dd></dl>
<dl class="attribute">
<dt id="semantic_version.Version.minor">
<code class="descname">minor</code><a class="headerlink" href="#semantic_version.Version.minor" title="Permalink to this definition">¶</a></dt>
<dd><p><code class="docutils literal notranslate"><span class="pre">int</span></code>, the minor version number.</p>
<p>May be <code class="docutils literal notranslate"><span class="pre">None</span></code> for a <a class="reference internal" href="#semantic_version.Version.partial" title="semantic_version.Version.partial"><code class="xref py py-attr docutils literal notranslate"><span class="pre">partial</span></code></a> version number in a <code class="docutils literal notranslate"><span class="pre"><major></span></code> format.</p>
</dd></dl>
<dl class="attribute">
<dt id="semantic_version.Version.patch">
<code class="descname">patch</code><a class="headerlink" href="#semantic_version.Version.patch" title="Permalink to this definition">¶</a></dt>
<dd><p><code class="docutils literal notranslate"><span class="pre">int</span></code>, the patch version number.</p>
<p>May be <code class="docutils literal notranslate"><span class="pre">None</span></code> for a <a class="reference internal" href="#semantic_version.Version.partial" title="semantic_version.Version.partial"><code class="xref py py-attr docutils literal notranslate"><span class="pre">partial</span></code></a> version number in a <code class="docutils literal notranslate"><span class="pre"><major></span></code> or <code class="docutils literal notranslate"><span class="pre"><major>.<minor></span></code> format.</p>
</dd></dl>
<dl class="attribute">
<dt id="semantic_version.Version.prerelease">
<code class="descname">prerelease</code><a class="headerlink" href="#semantic_version.Version.prerelease" title="Permalink to this definition">¶</a></dt>
<dd><p><code class="docutils literal notranslate"><span class="pre">tuple</span></code> of <code class="docutils literal notranslate"><span class="pre">strings</span></code>, the prerelease component.</p>
<p>It contains the various dot-separated identifiers in the prerelease component.</p>
<p>May be <code class="docutils literal notranslate"><span class="pre">None</span></code> for a <a class="reference internal" href="#semantic_version.Version.partial" title="semantic_version.Version.partial"><code class="xref py py-attr docutils literal notranslate"><span class="pre">partial</span></code></a> version number in a <code class="docutils literal notranslate"><span class="pre"><major></span></code>, <code class="docutils literal notranslate"><span class="pre"><major>.<minor></span></code> or <code class="docutils literal notranslate"><span class="pre"><major>.<minor>.<patch></span></code> format.</p>
</dd></dl>
<dl class="attribute">
<dt id="semantic_version.Version.build">
<code class="descname">build</code><a class="headerlink" href="#semantic_version.Version.build" title="Permalink to this definition">¶</a></dt>
<dd><p><code class="docutils literal notranslate"><span class="pre">tuple</span></code> of <code class="docutils literal notranslate"><span class="pre">strings</span></code>, the build metadata.</p>
<p>It contains the various dot-separated identifiers in the build metadata.</p>
<p>May be <code class="docutils literal notranslate"><span class="pre">None</span></code> for a <a class="reference internal" href="#semantic_version.Version.partial" title="semantic_version.Version.partial"><code class="xref py py-attr docutils literal notranslate"><span class="pre">partial</span></code></a> version number in a <code class="docutils literal notranslate"><span class="pre"><major></span></code>, <code class="docutils literal notranslate"><span class="pre"><major>.<minor></span></code>,
<code class="docutils literal notranslate"><span class="pre"><major>.<minor>.<patch></span></code> or <code class="docutils literal notranslate"><span class="pre"><major>.<minor>.<patch>-<prerelease></span></code> format.</p>
</dd></dl>
<p class="rubric">Methods</p>
<dl class="method">
<dt id="semantic_version.Version.__iter__">
<code class="descname">__iter__</code><span class="sig-paren">(</span><em>self</em><span class="sig-paren">)</span><a class="headerlink" href="#semantic_version.Version.__iter__" title="Permalink to this definition">¶</a></dt>
<dd><p>Iterates over the version components (<a class="reference internal" href="#semantic_version.Version.major" title="semantic_version.Version.major"><code class="xref py py-attr docutils literal notranslate"><span class="pre">major</span></code></a>, <a class="reference internal" href="#semantic_version.Version.minor" title="semantic_version.Version.minor"><code class="xref py py-attr docutils literal notranslate"><span class="pre">minor</span></code></a>,
<a class="reference internal" href="#semantic_version.Version.patch" title="semantic_version.Version.patch"><code class="xref py py-attr docutils literal notranslate"><span class="pre">patch</span></code></a>, <a class="reference internal" href="#semantic_version.Version.prerelease" title="semantic_version.Version.prerelease"><code class="xref py py-attr docutils literal notranslate"><span class="pre">prerelease</span></code></a>, <a class="reference internal" href="#semantic_version.Version.build" title="semantic_version.Version.build"><code class="xref py py-attr docutils literal notranslate"><span class="pre">build</span></code></a>):</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">list</span><span class="p">(</span><span class="n">Version</span><span class="p">(</span><span class="s1">'0.1.1'</span><span class="p">))</span>
<span class="go">[0, 1, 1, [], []]</span>
</pre></div>
</div>
<div class="admonition note">
<p class="first admonition-title">Note</p>
<p>This may pose some subtle bugs when iterating over a single version
while expecting an iterable of versions – similar to:</p>
<div class="last highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">list</span><span class="p">(</span><span class="s1">'abc'</span><span class="p">)</span>
<span class="go">['a', 'b', 'c']</span>
<span class="gp">>>> </span><span class="nb">list</span><span class="p">((</span><span class="s1">'abc'</span><span class="p">,))</span>
<span class="go">['abc']</span>
</pre></div>
</div>
</div>
</dd></dl>
<dl class="method">
<dt id="semantic_version.Version.__cmp__">
<code class="descname">__cmp__</code><span class="sig-paren">(</span><em>self</em>, <em>other</em><span class="sig-paren">)</span><a class="headerlink" href="#semantic_version.Version.__cmp__" title="Permalink to this definition">¶</a></dt>
<dd><p>Provides comparison methods with other <a class="reference internal" href="#semantic_version.Version" title="semantic_version.Version"><code class="xref py py-class docutils literal notranslate"><span class="pre">Version</span></code></a> objects.</p>
<p>The rules are:</p>
<ul>
<li><p class="first">For non-<a class="reference internal" href="#semantic_version.Version.partial" title="semantic_version.Version.partial"><code class="xref py py-attr docutils literal notranslate"><span class="pre">partial</span></code></a> versions, compare using the <a class="reference external" href="http://semver.org/">SemVer</a> scheme</p>
</li>
<li><dl class="first docutils">
<dt>If any compared object is <a class="reference internal" href="#semantic_version.Version.partial" title="semantic_version.Version.partial"><code class="xref py py-attr docutils literal notranslate"><span class="pre">partial</span></code></a>:</dt>
<dd><ul class="first simple">
<li>Begin comparison using the <a class="reference external" href="http://semver.org/">SemVer</a> scheme</li>
<li>If a component (<a class="reference internal" href="#semantic_version.Version.minor" title="semantic_version.Version.minor"><code class="xref py py-attr docutils literal notranslate"><span class="pre">minor</span></code></a>, <a class="reference internal" href="#semantic_version.Version.patch" title="semantic_version.Version.patch"><code class="xref py py-attr docutils literal notranslate"><span class="pre">patch</span></code></a>, <a class="reference internal" href="#semantic_version.Version.prerelease" title="semantic_version.Version.prerelease"><code class="xref py py-attr docutils literal notranslate"><span class="pre">prerelease</span></code></a> or <a class="reference internal" href="#semantic_version.Version.build" title="semantic_version.Version.build"><code class="xref py py-attr docutils literal notranslate"><span class="pre">build</span></code></a>)
was absent from the <a class="reference internal" href="#semantic_version.Version.partial" title="semantic_version.Version.partial"><code class="xref py py-attr docutils literal notranslate"><span class="pre">partial</span></code></a> <a class="reference internal" href="#semantic_version.Version" title="semantic_version.Version"><code class="xref py py-class docutils literal notranslate"><span class="pre">Version</span></code></a> – represented with <code class="xref py py-obj docutils literal notranslate"><span class="pre">None</span></code>
–, consider both versions equal.</li>
</ul>
<p>For instance, <code class="docutils literal notranslate"><span class="pre">Version('1.0',</span> <span class="pre">partial=True)</span></code> means “any version beginning in <code class="docutils literal notranslate"><span class="pre">1.0</span></code>”.</p>
<p class="last"><code class="docutils literal notranslate"><span class="pre">Version('1.0.1-alpha',</span> <span class="pre">partial=True)</span></code> means “The <code class="docutils literal notranslate"><span class="pre">1.0.1-alpha</span></code> version or any
any release differing only in build metadata”: <code class="docutils literal notranslate"><span class="pre">1.0.1-alpha+build3</span></code> matches, <code class="docutils literal notranslate"><span class="pre">1.0.1-alpha.2</span></code> doesn’t.</p>
</dd>
</dl>
</li>
</ul>
<p>Examples:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">Version</span><span class="p">(</span><span class="s1">'1.0'</span><span class="p">,</span> <span class="n">partial</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span> <span class="o">==</span> <span class="n">Version</span><span class="p">(</span><span class="s1">'1.0.1'</span><span class="p">)</span>
<span class="go">True</span>
<span class="gp">>>> </span><span class="n">Version</span><span class="p">(</span><span class="s1">'1.0.1-rc1.1'</span><span class="p">)</span> <span class="o">==</span> <span class="n">Version</span><span class="p">(</span><span class="s1">'1.0.1-rc1'</span><span class="p">,</span> <span class="n">partial</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
<span class="go">False</span>
<span class="gp">>>> </span><span class="n">Version</span><span class="p">(</span><span class="s1">'1.0.1-rc1+build345'</span><span class="p">)</span> <span class="o">==</span> <span class="n">Version</span><span class="p">(</span><span class="s1">'1.0.1-rc1'</span><span class="p">)</span>
<span class="go">False</span>
<span class="gp">>>> </span><span class="n">Version</span><span class="p">(</span><span class="s1">'1.0.1-rc1+build345'</span><span class="p">)</span> <span class="o">==</span> <span class="n">Version</span><span class="p">(</span><span class="s1">'1.0.1-rc1'</span><span class="p">,</span> <span class="n">partial</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
<span class="go">True</span>
</pre></div>
</div>
</dd></dl>
<dl class="method">
<dt id="semantic_version.Version.__str__">
<code class="descname">__str__</code><span class="sig-paren">(</span><em>self</em><span class="sig-paren">)</span><a class="headerlink" href="#semantic_version.Version.__str__" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the standard text representation of the version:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">v</span> <span class="o">=</span> <span class="n">Version</span><span class="p">(</span><span class="s1">'0.1.1-rc2+build4.4'</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">v</span>
<span class="go">Version('0.1.1-rc2+build4.4')</span>
<span class="gp">>>> </span><span class="nb">str</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
<span class="go">'0.1.1-rc2+build4.4'</span>
</pre></div>
</div>
</dd></dl>
<dl class="method">
<dt id="semantic_version.Version.__hash__">
<code class="descname">__hash__</code><span class="sig-paren">(</span><em>self</em><span class="sig-paren">)</span><a class="headerlink" href="#semantic_version.Version.__hash__" title="Permalink to this definition">¶</a></dt>
<dd><p>Provides a hash based solely on the components.</p>
<p>Allows using a <a class="reference internal" href="#semantic_version.Version" title="semantic_version.Version"><code class="xref py py-class docutils literal notranslate"><span class="pre">Version</span></code></a> as a dictionary key.</p>
<div class="admonition note">
<p class="first admonition-title">Note</p>
<p>A fully qualified <a class="reference internal" href="#semantic_version.Version.partial" title="semantic_version.Version.partial"><code class="xref py py-attr docutils literal notranslate"><span class="pre">partial</span></code></a> <a class="reference internal" href="#semantic_version.Version" title="semantic_version.Version"><code class="xref py py-class docutils literal notranslate"><span class="pre">Version</span></code></a></p>
<p>(up to the <a class="reference internal" href="#semantic_version.Version.build" title="semantic_version.Version.build"><code class="xref py py-attr docutils literal notranslate"><span class="pre">build</span></code></a> component) will hash the same as the
equally qualified, non-<a class="reference internal" href="#semantic_version.Version.partial" title="semantic_version.Version.partial"><code class="xref py py-attr docutils literal notranslate"><span class="pre">partial</span></code></a> <a class="reference internal" href="#semantic_version.Version" title="semantic_version.Version"><code class="xref py py-class docutils literal notranslate"><span class="pre">Version</span></code></a>:</p>
<div class="last highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">hash</span><span class="p">(</span><span class="n">Version</span><span class="p">(</span><span class="s1">'1.0.1+build4'</span><span class="p">))</span> <span class="o">==</span> <span class="nb">hash</span><span class="p">(</span><span class="n">Version</span><span class="p">(</span><span class="s1">'1.0.1+build4'</span><span class="p">,</span> <span class="n">partial</span><span class="o">=</span><span class="kc">True</span><span class="p">))</span>
<span class="go">True</span>
</pre></div>
</div>
</div>
</dd></dl>
<p class="rubric">Class methods</p>
<dl class="classmethod">
<dt id="semantic_version.Version.parse">
<em class="property">classmethod </em><code class="descname">parse</code><span class="sig-paren">(</span><em>cls</em>, <em>version_string</em><span class="optional">[</span>, <em>partial=False</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#semantic_version.Version.parse" title="Permalink to this definition">¶</a></dt>
<dd><p>Parse a version string into a <code class="docutils literal notranslate"><span class="pre">(major,</span> <span class="pre">minor,</span> <span class="pre">patch,</span> <span class="pre">prerelease,</span> <span class="pre">build)</span></code> tuple.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>version_string</strong> (<em>str</em>) – The version string to parse</li>
<li><strong>partial</strong> (<em>bool</em>) – Whether this should be considered a <a class="reference internal" href="#semantic_version.Version.partial" title="semantic_version.Version.partial"><code class="xref py py-attr docutils literal notranslate"><span class="pre">partial</span></code></a> version</li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Raises:</th><td class="field-body"><p class="first"><code class="xref py py-exc docutils literal notranslate"><span class="pre">ValueError</span></code>, if the <code class="xref py py-attr docutils literal notranslate"><span class="pre">version_string</span></code> is invalid.</p>
</td>
</tr>
<tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last">(major, minor, patch, prerelease, build)</p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="classmethod">
<dt id="semantic_version.Version.coerce">
<em class="property">classmethod </em><code class="descname">coerce</code><span class="sig-paren">(</span><em>cls</em>, <em>version_string</em><span class="optional">[</span>, <em>partial=False</em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#semantic_version.Version.coerce" title="Permalink to this definition">¶</a></dt>
<dd><p>Try to convert an arbitrary version string into a <a class="reference internal" href="#semantic_version.Version" title="semantic_version.Version"><code class="xref py py-class docutils literal notranslate"><span class="pre">Version</span></code></a> instance.</p>
<p>Rules are:</p>
<ul class="simple">
<li>If no minor or patch component, and <a class="reference internal" href="#semantic_version.Version.partial" title="semantic_version.Version.partial"><code class="xref py py-attr docutils literal notranslate"><span class="pre">partial</span></code></a> is <code class="xref py py-obj docutils literal notranslate"><span class="pre">False</span></code>,
replace them with zeroes</li>
<li>Any character outside of <code class="docutils literal notranslate"><span class="pre">a-zA-Z0-9.+-</span></code> is replaced with a <code class="docutils literal notranslate"><span class="pre">-</span></code></li>
<li>If more than 3 dot-separated numerical components, everything from the
fourth component belongs to the <a class="reference internal" href="#semantic_version.Version.build" title="semantic_version.Version.build"><code class="xref py py-attr docutils literal notranslate"><span class="pre">build</span></code></a> part</li>
<li>Any extra <code class="docutils literal notranslate"><span class="pre">+</span></code> in the <a class="reference internal" href="#semantic_version.Version.build" title="semantic_version.Version.build"><code class="xref py py-attr docutils literal notranslate"><span class="pre">build</span></code></a> part will be replaced with dots</li>
</ul>
<p>Examples:</p>
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">Version</span><span class="o">.</span><span class="n">coerce</span><span class="p">(</span><span class="s1">'02'</span><span class="p">)</span>
<span class="go">Version('2.0.0')</span>
<span class="gp">>>> </span><span class="n">Version</span><span class="o">.</span><span class="n">coerce</span><span class="p">(</span><span class="s1">'1.2.3.4'</span><span class="p">)</span>
<span class="go">Version('1.2.3+4')</span>
<span class="gp">>>> </span><span class="n">Version</span><span class="o">.</span><span class="n">coerce</span><span class="p">(</span><span class="s1">'1.2.3.4beta2'</span><span class="p">)</span>
<span class="go">Version('1.2.3+4beta2')</span>
<span class="gp">>>> </span><span class="n">Version</span><span class="o">.</span><span class="n">coerce</span><span class="p">(</span><span class="s1">'1.2.3.4.5_6/7+8+9+10'</span><span class="p">)</span>
<span class="go">Version('1.2.3+4.5-6-7.8.9.10')</span>
</pre></div>
</div>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
<li><strong>version_string</strong> (<em>str</em>) – The version string to coerce</li>
<li><strong>partial</strong> (<em>bool</em>) – Whether to allow generating a <a class="reference internal" href="#semantic_version.Version.partial" title="semantic_version.Version.partial"><code class="xref py py-attr docutils literal notranslate"><span class="pre">partial</span></code></a> version</li>
</ul>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Raises:</th><td class="field-body"><p class="first"><code class="xref py py-exc docutils literal notranslate"><span class="pre">ValueError</span></code>, if the <code class="xref py py-attr docutils literal notranslate"><span class="pre">version_string</span></code> is invalid.</p>
</td>
</tr>
<tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="#semantic_version.Version" title="semantic_version.Version"><code class="xref py py-class docutils literal notranslate"><span class="pre">Version</span></code></a></p>
</td>
</tr>
</tbody>
</table>
</dd></dl>
</dd></dl>
</div>
<div class="section" id="version-specifications-the-spec-class">
<h2>Version specifications (the Spec class)<a class="headerlink" href="#version-specifications-the-spec-class" title="Permalink to this headline">¶</a></h2>
<p>Version specifications describe a ‘range’ of accepted versions:
older than, equal, similar to, …</p>
<p>The main issue with representing version specifications is that the usual syntax
does not map well onto <a class="reference external" href="http://semver.org/">SemVer</a> precedence rules:</p>
<ul class="simple">
<li>A specification of <code class="docutils literal notranslate"><span class="pre"><1.3.4</span></code> is not expected to allow <code class="docutils literal notranslate"><span class="pre">1.3.4-rc2</span></code>, but strict <a class="reference external" href="http://semver.org/">SemVer</a> comparisons allow it ;
prereleases has the issue of excluding <code class="docutils literal notranslate"><span class="pre">1.3.3+build3</span></code> ;</li>
<li>It may be necessary to exclude either all variations on a patch-level release
(<code class="docutils literal notranslate"><span class="pre">!=1.3.3</span></code>) or specifically one build-level release (<code class="docutils literal notranslate"><span class="pre">1.3.3-build.434</span></code>).</li>
</ul>
<p>In order to have version specification behave naturally, the rules are the following:</p>
<ul class="simple">
<li>If no pre-release number was included in the specification, pre-release numbers
are ignored when deciding whether a version satisfies a specification.</li>
<li>If no build metadata was included in the specification, build metadata is ignored
when deciding whether a version satisfies a specification.</li>
</ul>
<p>This means that:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">Version</span><span class="p">(</span><span class="s1">'1.1.1-rc1'</span><span class="p">)</span> <span class="ow">in</span> <span class="n">Spec</span><span class="p">(</span><span class="s1">'<1.1.1'</span><span class="p">)</span>
<span class="go">False</span>
<span class="gp">>>> </span><span class="n">Version</span><span class="p">(</span><span class="s1">'1.1.1-rc1'</span><span class="p">)</span> <span class="ow">in</span> <span class="n">Spec</span><span class="p">(</span><span class="s1">'<1.1.1-rc4'</span><span class="p">)</span>
<span class="go">True</span>
<span class="gp">>>> </span><span class="n">Version</span><span class="p">(</span><span class="s1">'1.1.1-rc1+build4'</span><span class="p">)</span> <span class="ow">in</span> <span class="n">Spec</span><span class="p">(</span><span class="s1">'<=1.1.1-rc1'</span><span class="p">)</span>
<span class="go">True</span>
<span class="gp">>>> </span><span class="n">Version</span><span class="p">(</span><span class="s1">'1.1.1-rc1+build4'</span><span class="p">)</span> <span class="ow">in</span> <span class="n">Spec</span><span class="p">(</span><span class="s1">'==1.1.1-rc1+build2'</span><span class="p">)</span>
<span class="go">False</span>
</pre></div>
</div>
<div class="admonition note">
<p class="first admonition-title">Note</p>
<p class="last">python-semanticversion also accepts <code class="docutils literal notranslate"><span class="pre">"*"</span></code> as a version spec,
that matches all (valid) version strings.</p>
</div>
<div class="admonition note">
<p class="first admonition-title">Note</p>
<p>python-semanticversion supports PyPI-style <a class="reference external" href="https://www.python.org/dev/peps/pep-0440/#compatible-release">compatible release clauses</a>:</p>
<ul class="last simple">
<li><code class="docutils literal notranslate"><span class="pre">~=2.2</span></code> means “Any release between 2.2.0 and 3.0.0”</li>
<li><code class="docutils literal notranslate"><span class="pre">~=1.4.5</span></code> means “Any release between 1.4.5 and 1.5.0”</li>
</ul>
</div>
<div class="admonition note">
<p class="first admonition-title">Note</p>
<p>python-semanticversion includes support for NPM-style specs:</p>
<ul class="last simple">
<li><code class="docutils literal notranslate"><span class="pre">~1.2.3</span></code> means “Any release between 1.2.3 and 1.3.0”</li>
<li><code class="docutils literal notranslate"><span class="pre">^1.3.4</span></code> means “Any release between 1.3.4 and 2.0.0”</li>
</ul>
</div>
<p>In order to force matches to <em>strictly</em> compare version numbers, these additional
rules apply:</p>
<ul>
<li><p class="first">Setting a pre-release separator without a pre-release identifier (<code class="docutils literal notranslate"><span class="pre"><=1.1.1-</span></code>)
forces match to take into account pre-release version:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">Version</span><span class="p">(</span><span class="s1">'1.1.1-rc1'</span><span class="p">)</span> <span class="ow">in</span> <span class="n">Spec</span><span class="p">(</span><span class="s1">'<1.1.1'</span><span class="p">)</span>
<span class="go">False</span>
<span class="gp">>>> </span><span class="n">Version</span><span class="p">(</span><span class="s1">'1.1.1-rc1'</span><span class="p">)</span> <span class="ow">in</span> <span class="n">Spec</span><span class="p">(</span><span class="s1">'<1.1.1-'</span><span class="p">)</span>
<span class="go">True</span>
</pre></div>
</div>
</li>
<li><p class="first">Setting a build metadata separator without build metadata (<code class="docutils literal notranslate"><span class="pre"><=1.1.1+</span></code>)
forces matches “up to the build metadata”; use this to include/exclude a
release lacking build metadata while excluding/including all other builds
of that release</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">Version</span><span class="p">(</span><span class="s1">'1.1.1'</span><span class="p">)</span> <span class="ow">in</span> <span class="n">Spec</span><span class="p">(</span><span class="s1">'==1.1.1+'</span><span class="p">)</span>
<span class="go">True</span>
<span class="gp">>>> </span><span class="n">Version</span><span class="p">(</span><span class="s1">'1.1.1+2'</span><span class="p">)</span> <span class="ow">in</span> <span class="n">Spec</span><span class="p">(</span><span class="s1">'==1.1.1+'</span><span class="p">)</span>
<span class="go">False</span>
</pre></div>
</div>
</li>
</ul>
<div class="admonition warning">
<p class="first admonition-title">Warning</p>
<p>As stated in the <a class="reference external" href="http://semver.org/">SemVer</a> specification, the ordering of build metadata is <em>undefined</em>.
Thus, a <a class="reference internal" href="#semantic_version.Spec" title="semantic_version.Spec"><code class="xref py py-class docutils literal notranslate"><span class="pre">Spec</span></code></a> string can only mention build metadata to include or exclude a specific version:</p>
<ul class="last simple">
<li><code class="docutils literal notranslate"><span class="pre">==1.1.1+b1234</span></code> includes this specific build</li>
<li><code class="docutils literal notranslate"><span class="pre">!=1.1.1+b1234</span></code> excludes it (but would match <code class="docutils literal notranslate"><span class="pre">1.1.1+b1235</span></code></li>
<li><code class="docutils literal notranslate"><span class="pre"><1.1.1+b1</span></code> is invalid</li>
</ul>
</div>
<dl class="class">
<dt id="semantic_version.Spec">
<em class="property">class </em><code class="descclassname">semantic_version.</code><code class="descname">Spec</code><span class="sig-paren">(</span><em>spec_string</em><span class="optional">[</span>, <em>spec_string</em><span class="optional">[</span>, <em>...</em><span class="optional">]</span><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#semantic_version.Spec" title="Permalink to this definition">¶</a></dt>
<dd><p>Stores a list of <a class="reference internal" href="#semantic_version.SpecItem" title="semantic_version.SpecItem"><code class="xref py py-class docutils literal notranslate"><span class="pre">SpecItem</span></code></a> and matches any <a class="reference internal" href="#semantic_version.Version" title="semantic_version.Version"><code class="xref py py-class docutils literal notranslate"><span class="pre">Version</span></code></a> against all
contained <a class="reference internal" href="#semantic_version.SpecItem" title="semantic_version.SpecItem"><code class="xref py py-class docutils literal notranslate"><span class="pre">specs</span></code></a>.</p>
<p>It is built from a comma-separated list of version specifications:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">Spec</span><span class="p">(</span><span class="s1">'>=1.0.0,<1.2.0,!=1.1.4'</span><span class="p">)</span>
<span class="go"><Spec: (</span>
<span class="go"> <SpecItem: >= Version('1.0.0', partial=True)>,</span>
<span class="go"> <SpecItem: < Version('1.2.0', partial=True)>,</span>
<span class="go"> <SpecItem: != Version('1.1.4', partial=True)></span>
<span class="go">)></span>
</pre></div>
</div>
<p>Version specifications may also be passed in separated arguments:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">Spec</span><span class="p">(</span><span class="s1">'>=1.0.0'</span><span class="p">,</span> <span class="s1">'<1.2.0'</span><span class="p">,</span> <span class="s1">'!=1.1.4,!=1.1.13'</span><span class="p">)</span>
<span class="go"><Spec: (</span>
<span class="go"> <SpecItem: >= Version('1.0.0', partial=True)>,</span>
<span class="go"> <SpecItem: < Version('1.2.0', partial=True)>,</span>
<span class="go"> <SpecItem: != Version('1.1.4', partial=True)>,</span>
<span class="go"> <SpecItem: != Version('1.1.13', partial=True)>,</span>
<span class="go">)></span>
</pre></div>
</div>
<p class="rubric">Attributes</p>
<dl class="attribute">
<dt id="semantic_version.Spec.specs">
<code class="descname">specs</code><a class="headerlink" href="#semantic_version.Spec.specs" title="Permalink to this definition">¶</a></dt>
<dd><p>Tuple of <a class="reference internal" href="#semantic_version.SpecItem" title="semantic_version.SpecItem"><code class="xref py py-class docutils literal notranslate"><span class="pre">SpecItem</span></code></a>, the included specifications.</p>
</dd></dl>
<p class="rubric">Methods</p>
<dl class="method">
<dt id="semantic_version.Spec.match">
<code class="descname">match</code><span class="sig-paren">(</span><em>self</em>, <em>version</em><span class="sig-paren">)</span><a class="headerlink" href="#semantic_version.Spec.match" title="Permalink to this definition">¶</a></dt>
<dd><p>Test whether a given <a class="reference internal" href="#semantic_version.Version" title="semantic_version.Version"><code class="xref py py-class docutils literal notranslate"><span class="pre">Version</span></code></a> matches all included <a class="reference internal" href="#semantic_version.SpecItem" title="semantic_version.SpecItem"><code class="xref py py-class docutils literal notranslate"><span class="pre">SpecItem</span></code></a>:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">Spec</span><span class="p">(</span><span class="s1">'>=1.1.0,<1.1.2'</span><span class="p">)</span><span class="o">.</span><span class="n">match</span><span class="p">(</span><span class="n">Version</span><span class="p">(</span><span class="s1">'1.1.1'</span><span class="p">))</span>
<span class="go">True</span>
</pre></div>
</div>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>version</strong> (<a class="reference internal" href="#semantic_version.Version" title="semantic_version.Version"><code class="xref py py-class docutils literal notranslate"><span class="pre">Version</span></code></a>) – The version to test against the specs</td>
</tr>
<tr class="field-even field"><th class="field-name">Return type:</th><td class="field-body"><code class="docutils literal notranslate"><span class="pre">bool</span></code></td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="semantic_version.Spec.filter">
<code class="descname">filter</code><span class="sig-paren">(</span><em>self</em>, <em>versions</em><span class="sig-paren">)</span><a class="headerlink" href="#semantic_version.Spec.filter" title="Permalink to this definition">¶</a></dt>
<dd><p>Extract all compatible <a class="reference internal" href="#semantic_version.Version" title="semantic_version.Version"><code class="xref py py-class docutils literal notranslate"><span class="pre">versions</span></code></a> from an iterable of
<a class="reference internal" href="#semantic_version.Version" title="semantic_version.Version"><code class="xref py py-class docutils literal notranslate"><span class="pre">Version</span></code></a> objects.</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>versions</strong> (iterable of <a class="reference internal" href="#semantic_version.Version" title="semantic_version.Version"><code class="xref py py-class docutils literal notranslate"><span class="pre">Version</span></code></a>) – The versions to filter</td>
</tr>
<tr class="field-even field"><th class="field-name">Yield:</th><td class="field-body"><a class="reference internal" href="#semantic_version.Version" title="semantic_version.Version"><code class="xref py py-class docutils literal notranslate"><span class="pre">Version</span></code></a></td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="semantic_version.Spec.select">
<code class="descname">select</code><span class="sig-paren">(</span><em>self</em>, <em>versions</em><span class="sig-paren">)</span><a class="headerlink" href="#semantic_version.Spec.select" title="Permalink to this definition">¶</a></dt>
<dd><p>Select the highest compatible version from an iterable of <a class="reference internal" href="#semantic_version.Version" title="semantic_version.Version"><code class="xref py py-class docutils literal notranslate"><span class="pre">Version</span></code></a>
objects.</p>
<div class="highlight-pycon notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">s</span> <span class="o">=</span> <span class="n">Spec</span><span class="p">(</span><span class="s1">'>=0.1.0'</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">s</span><span class="o">.</span><span class="n">select</span><span class="p">([])</span>
<span class="go">None</span>
<span class="gp">>>> </span><span class="n">s</span><span class="o">.</span><span class="n">select</span><span class="p">([</span><span class="n">Version</span><span class="p">(</span><span class="s1">'0.1.0'</span><span class="p">),</span> <span class="n">Version</span><span class="p">(</span><span class="s1">'0.1.3'</span><span class="p">),</span> <span class="n">Version</span><span class="p">(</span><span class="s1">'0.1.1'</span><span class="p">)])</span>
<span class="go">Version('0.1.3')</span>
</pre></div>
</div>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>versions</strong> (iterable of <a class="reference internal" href="#semantic_version.Version" title="semantic_version.Version"><code class="xref py py-class docutils literal notranslate"><span class="pre">Version</span></code></a>) – The versions to filter</td>
</tr>
<tr class="field-even field"><th class="field-name">Return type:</th><td class="field-body">The highest compatible <a class="reference internal" href="#semantic_version.Version" title="semantic_version.Version"><code class="xref py py-class docutils literal notranslate"><span class="pre">Version</span></code></a> if at least one of the
given versions is compatible; <code class="xref py py-class docutils literal notranslate"><span class="pre">None</span></code> otherwise.</td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="semantic_version.Spec.__contains__">
<code class="descname">__contains__</code><span class="sig-paren">(</span><em>self</em>, <em>version</em><span class="sig-paren">)</span><a class="headerlink" href="#semantic_version.Spec.__contains__" title="Permalink to this definition">¶</a></dt>
<dd><p>Alias of the <a class="reference internal" href="#semantic_version.match" title="semantic_version.match"><code class="xref py py-func docutils literal notranslate"><span class="pre">match()</span></code></a> method;
allows the use of the <code class="docutils literal notranslate"><span class="pre">version</span> <span class="pre">in</span> <span class="pre">speclist</span></code> syntax:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">Version</span><span class="p">(</span><span class="s1">'1.1.1-alpha'</span><span class="p">)</span> <span class="ow">in</span> <span class="n">Spec</span><span class="p">(</span><span class="s1">'>=1.1.0,<1.1.1'</span><span class="p">)</span>
<span class="go">True</span>
</pre></div>
</div>
</dd></dl>
<dl class="method">
<dt id="semantic_version.Spec.__str__">
<code class="descname">__str__</code><span class="sig-paren">(</span><em>self</em><span class="sig-paren">)</span><a class="headerlink" href="#semantic_version.Spec.__str__" title="Permalink to this definition">¶</a></dt>
<dd><p>Converting a <a class="reference internal" href="#semantic_version.Spec" title="semantic_version.Spec"><code class="xref py py-class docutils literal notranslate"><span class="pre">Spec</span></code></a> returns the initial description string:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">str</span><span class="p">(</span><span class="n">Spec</span><span class="p">(</span><span class="s1">'>=0.1.1,!=0.1.2'</span><span class="p">))</span>
<span class="go">'>=0.1.1,!=0.1.2'</span>
</pre></div>
</div>
</dd></dl>
<dl class="method">
<dt id="semantic_version.Spec.__iter__">
<code class="descname">__iter__</code><span class="sig-paren">(</span><em>self</em><span class="sig-paren">)</span><a class="headerlink" href="#semantic_version.Spec.__iter__" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns an iterator over the contained specs:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="k">for</span> <span class="n">spec</span> <span class="ow">in</span> <span class="n">Spec</span><span class="p">(</span><span class="s1">'>=0.1.1,!=0.1.2'</span><span class="p">):</span>
<span class="gp">... </span> <span class="nb">print</span> <span class="n">spec</span>
<span class="go">>=0.1.1</span>
<span class="go">!=0.1.2</span>
</pre></div>
</div>
</dd></dl>
<dl class="method">
<dt id="semantic_version.Spec.__hash__">
<code class="descname">__hash__</code><span class="sig-paren">(</span><em>self</em><span class="sig-paren">)</span><a class="headerlink" href="#semantic_version.Spec.__hash__" title="Permalink to this definition">¶</a></dt>
<dd><p>Provides a hash based solely on the hash of contained specs.</p>
<p>Allows using a <a class="reference internal" href="#semantic_version.Spec" title="semantic_version.Spec"><code class="xref py py-class docutils literal notranslate"><span class="pre">Spec</span></code></a> as a dictionary key.</p>
</dd></dl>
<p class="rubric">Class methods</p>
<dl class="classmethod">
<dt id="semantic_version.Spec.parse">
<em class="property">classmethod </em><code class="descname">parse</code><span class="sig-paren">(</span><em>self</em>, <em>specs_string</em><span class="sig-paren">)</span><a class="headerlink" href="#semantic_version.Spec.parse" title="Permalink to this definition">¶</a></dt>
<dd><p>Retrieve a <code class="docutils literal notranslate"><span class="pre">(*specs)</span></code> tuple from 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">Parameters:</th><td class="field-body"><strong>requirement_string</strong> (<em>str</em>) – The textual description of the specifications</td>
</tr>
<tr class="field-even field"><th class="field-name">Raises:</th><td class="field-body"><code class="xref py py-exc docutils literal notranslate"><span class="pre">ValueError</span></code>: if the <code class="docutils literal notranslate"><span class="pre">requirement_string</span></code> is invalid.</td>
</tr>
<tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><code class="docutils literal notranslate"><span class="pre">(*spec)</span></code> tuple</td>
</tr>
</tbody>
</table>
</dd></dl>
</dd></dl>
<dl class="class">
<dt id="semantic_version.SpecItem">
<em class="property">class </em><code class="descclassname">semantic_version.</code><code class="descname">SpecItem</code><span class="sig-paren">(</span><em>spec_string</em><span class="sig-paren">)</span><a class="headerlink" href="#semantic_version.SpecItem" title="Permalink to this definition">¶</a></dt>
<dd><div class="admonition note">
<p class="first admonition-title">Note</p>
<p class="last">This class belong to the private python-semanticversion API.</p>
</div>
<p>Stores a version specification, defined from a string:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">SpecItem</span><span class="p">(</span><span class="s1">'>=0.1.1'</span><span class="p">)</span>
<span class="go"><SpecItem: >= Version('0.1.1', partial=True)></span>
</pre></div>
</div>
<p>This allows to test <a class="reference internal" href="#semantic_version.Version" title="semantic_version.Version"><code class="xref py py-class docutils literal notranslate"><span class="pre">Version</span></code></a> objects against the <a class="reference internal" href="#semantic_version.SpecItem" title="semantic_version.SpecItem"><code class="xref py py-class docutils literal notranslate"><span class="pre">SpecItem</span></code></a>:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">SpecItem</span><span class="p">(</span><span class="s1">'>=0.1.1'</span><span class="p">)</span><span class="o">.</span><span class="n">match</span><span class="p">(</span><span class="n">Version</span><span class="p">(</span><span class="s1">'0.1.1-rc1'</span><span class="p">))</span> <span class="c1"># pre-release satisfy conditions</span>
<span class="go">True</span>
<span class="gp">>>> </span><span class="n">Version</span><span class="p">(</span><span class="s1">'0.1.1+build2'</span><span class="p">)</span> <span class="ow">in</span> <span class="n">SpecItem</span><span class="p">(</span><span class="s1">'>=0.1.1'</span><span class="p">)</span> <span class="c1"># build metadata is ignored when checking for precedence</span>
<span class="go">True</span>
<span class="go">>>></span>
<span class="gp">>>> </span><span class="c1"># Use the '-' marker to include the pre-release component in checks</span>
<span class="gp">>>> </span><span class="n">SpecItem</span><span class="p">(</span><span class="s1">'>=0.1.1-'</span><span class="p">)</span><span class="o">.</span><span class="n">match</span><span class="p">(</span><span class="n">Version</span><span class="p">(</span><span class="s1">'0.1.1-rc1'</span><span class="p">)</span>
<span class="go">False</span>
<span class="gp">>>> </span><span class="c1"># Use the '+' marker to include the build metadata in checks</span>
<span class="gp">>>> </span><span class="n">SpecItem</span><span class="p">(</span><span class="s1">'==0.1.1+'</span><span class="p">)</span><span class="o">.</span><span class="n">match</span><span class="p">(</span><span class="n">Version</span><span class="p">(</span><span class="s1">'0.1.1+b1234'</span><span class="p">)</span>
<span class="go">False</span>
<span class="go">>>></span>
</pre></div>
</div>
<p class="rubric">Attributes</p>
<dl class="attribute">
<dt id="semantic_version.SpecItem.kind">
<code class="descname">kind</code><a class="headerlink" href="#semantic_version.SpecItem.kind" title="Permalink to this definition">¶</a></dt>
<dd><p>One of <a class="reference internal" href="#semantic_version.SpecItem.KIND_LT" title="semantic_version.SpecItem.KIND_LT"><code class="xref py py-data docutils literal notranslate"><span class="pre">KIND_LT</span></code></a>, <a class="reference internal" href="#semantic_version.SpecItem.KIND_LTE" title="semantic_version.SpecItem.KIND_LTE"><code class="xref py py-data docutils literal notranslate"><span class="pre">KIND_LTE</span></code></a>, <a class="reference internal" href="#semantic_version.SpecItem.KIND_EQUAL" title="semantic_version.SpecItem.KIND_EQUAL"><code class="xref py py-data docutils literal notranslate"><span class="pre">KIND_EQUAL</span></code></a>, <a class="reference internal" href="#semantic_version.SpecItem.KIND_GTE" title="semantic_version.SpecItem.KIND_GTE"><code class="xref py py-data docutils literal notranslate"><span class="pre">KIND_GTE</span></code></a>,
<a class="reference internal" href="#semantic_version.SpecItem.KIND_GT" title="semantic_version.SpecItem.KIND_GT"><code class="xref py py-data docutils literal notranslate"><span class="pre">KIND_GT</span></code></a> and <a class="reference internal" href="#semantic_version.SpecItem.KIND_NEQ" title="semantic_version.SpecItem.KIND_NEQ"><code class="xref py py-data docutils literal notranslate"><span class="pre">KIND_NEQ</span></code></a>.</p>
</dd></dl>
<dl class="attribute">
<dt id="semantic_version.SpecItem.spec">
<code class="descname">spec</code><a class="headerlink" href="#semantic_version.SpecItem.spec" title="Permalink to this definition">¶</a></dt>
<dd><p><a class="reference internal" href="#semantic_version.Version" title="semantic_version.Version"><code class="xref py py-class docutils literal notranslate"><span class="pre">Version</span></code></a> in the <a class="reference internal" href="#semantic_version.SpecItem" title="semantic_version.SpecItem"><code class="xref py py-class docutils literal notranslate"><span class="pre">SpecItem</span></code></a> description.</p>
<p>It is alway a <a class="reference internal" href="#semantic_version.Version.partial" title="semantic_version.Version.partial"><code class="xref py py-attr docutils literal notranslate"><span class="pre">partial</span></code></a> <a class="reference internal" href="#semantic_version.Version" title="semantic_version.Version"><code class="xref py py-class docutils literal notranslate"><span class="pre">Version</span></code></a>.</p>
</dd></dl>
<p class="rubric">Class methods</p>
<dl class="classmethod">
<dt id="semantic_version.SpecItem.parse">
<em class="property">classmethod </em><code class="descname">parse</code><span class="sig-paren">(</span><em>cls</em>, <em>requirement_string</em><span class="sig-paren">)</span><a class="headerlink" href="#semantic_version.SpecItem.parse" title="Permalink to this definition">¶</a></dt>
<dd><p>Retrieve a <code class="docutils literal notranslate"><span class="pre">(kind,</span> <span class="pre">version)</span></code> tuple from 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">Parameters:</th><td class="field-body"><strong>requirement_string</strong> (<em>str</em>) – The textual description of the specification</td>
</tr>
<tr class="field-even field"><th class="field-name">Raises:</th><td class="field-body"><code class="xref py py-exc docutils literal notranslate"><span class="pre">ValueError</span></code>: if the <code class="docutils literal notranslate"><span class="pre">requirement_string</span></code> is invalid.</td>
</tr>
<tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body">(<code class="docutils literal notranslate"><span class="pre">kind</span></code>, <code class="docutils literal notranslate"><span class="pre">version</span></code>) tuple</td>
</tr>
</tbody>
</table>
</dd></dl>
<p class="rubric">Methods</p>
<dl class="method">
<dt id="semantic_version.SpecItem.match">
<code class="descname">match</code><span class="sig-paren">(</span><em>self</em>, <em>version</em><span class="sig-paren">)</span><a class="headerlink" href="#semantic_version.SpecItem.match" title="Permalink to this definition">¶</a></dt>
<dd><p>Test whether a given <a class="reference internal" href="#semantic_version.Version" title="semantic_version.Version"><code class="xref py py-class docutils literal notranslate"><span class="pre">Version</span></code></a> matches this <a class="reference internal" href="#semantic_version.SpecItem" title="semantic_version.SpecItem"><code class="xref py py-class docutils literal notranslate"><span class="pre">SpecItem</span></code></a>:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">SpecItem</span><span class="p">(</span><span class="s1">'>=0.1.1'</span><span class="p">)</span><span class="o">.</span><span class="n">match</span><span class="p">(</span><span class="n">Version</span><span class="p">(</span><span class="s1">'0.1.1-alpha'</span><span class="p">))</span>
<span class="go">True</span>
<span class="gp">>>> </span><span class="n">SpecItem</span><span class="p">(</span><span class="s1">'>=0.1.1-'</span><span class="p">)</span><span class="o">.</span><span class="n">match</span><span class="p">(</span><span class="n">Version</span><span class="p">(</span><span class="s1">'0.1.1-alpha'</span><span class="p">))</span>
<span class="go">False</span>
</pre></div>
</div>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><strong>version</strong> (<a class="reference internal" href="#semantic_version.Version" title="semantic_version.Version"><code class="xref py py-class docutils literal notranslate"><span class="pre">Version</span></code></a>) – The version to test against the spec</td>
</tr>
<tr class="field-even field"><th class="field-name">Return type:</th><td class="field-body"><code class="docutils literal notranslate"><span class="pre">bool</span></code></td>
</tr>
</tbody>
</table>
</dd></dl>
<dl class="method">
<dt id="semantic_version.SpecItem.__str__">
<code class="descname">__str__</code><span class="sig-paren">(</span><em>self</em><span class="sig-paren">)</span><a class="headerlink" href="#semantic_version.SpecItem.__str__" title="Permalink to this definition">¶</a></dt>
<dd><p>Converting a <a class="reference internal" href="#semantic_version.SpecItem" title="semantic_version.SpecItem"><code class="xref py py-class docutils literal notranslate"><span class="pre">SpecItem</span></code></a> to a string returns the initial description string:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">str</span><span class="p">(</span><span class="n">SpecItem</span><span class="p">(</span><span class="s1">'>=0.1.1'</span><span class="p">))</span>
<span class="go">'>=0.1.1'</span>
</pre></div>
</div>
</dd></dl>
<dl class="method">
<dt id="semantic_version.SpecItem.__hash__">
<code class="descname">__hash__</code><span class="sig-paren">(</span><em>self</em><span class="sig-paren">)</span><a class="headerlink" href="#semantic_version.SpecItem.__hash__" title="Permalink to this definition">¶</a></dt>
<dd><p>Provides a hash based solely on the current kind and the specified version.</p>
<p>Allows using a <a class="reference internal" href="#semantic_version.SpecItem" title="semantic_version.SpecItem"><code class="xref py py-class docutils literal notranslate"><span class="pre">SpecItem</span></code></a> as a dictionary key.</p>
</dd></dl>
<p class="rubric">Class attributes</p>
<dl class="data">
<dt id="semantic_version.SpecItem.KIND_LT">
<code class="descname">KIND_LT</code><a class="headerlink" href="#semantic_version.SpecItem.KIND_LT" title="Permalink to this definition">¶</a></dt>
<dd><p>The kind of ‘Less than’ specifications:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">Version</span><span class="p">(</span><span class="s1">'1.0.0-alpha'</span><span class="p">)</span> <span class="ow">in</span> <span class="n">Spec</span><span class="p">(</span><span class="s1">'<1.0.0'</span><span class="p">)</span>
<span class="go">False</span>
</pre></div>
</div>
</dd></dl>
<dl class="data">
<dt id="semantic_version.SpecItem.KIND_LTE">
<code class="descname">KIND_LTE</code><a class="headerlink" href="#semantic_version.SpecItem.KIND_LTE" title="Permalink to this definition">¶</a></dt>
<dd><p>The kind of ‘Less or equal to’ specifications:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">Version</span><span class="p">(</span><span class="s1">'1.0.0-alpha1+build999'</span><span class="p">)</span> <span class="ow">in</span> <span class="n">Spec</span><span class="p">(</span><span class="s1">'<=1.0.0-alpha1'</span><span class="p">)</span>
<span class="go">True</span>
</pre></div>
</div>
</dd></dl>
<dl class="data">
<dt id="semantic_version.SpecItem.KIND_EQUAL">
<code class="descname">KIND_EQUAL</code><a class="headerlink" href="#semantic_version.SpecItem.KIND_EQUAL" title="Permalink to this definition">¶</a></dt>
<dd><p>The kind of ‘equal to’ specifications:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">Version</span><span class="p">(</span><span class="s1">'1.0.0+build3.3'</span><span class="p">)</span> <span class="ow">in</span> <span class="n">Spec</span><span class="p">(</span><span class="s1">'==1.0.0'</span><span class="p">)</span>
<span class="go">True</span>
</pre></div>
</div>
</dd></dl>
<dl class="data">
<dt id="semantic_version.SpecItem.KIND_GTE">
<code class="descname">KIND_GTE</code><a class="headerlink" href="#semantic_version.SpecItem.KIND_GTE" title="Permalink to this definition">¶</a></dt>
<dd><p>The kind of ‘Greater or equal to’ specifications:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">Version</span><span class="p">(</span><span class="s1">'1.0.0'</span><span class="p">)</span> <span class="ow">in</span> <span class="n">Spec</span><span class="p">(</span><span class="s1">'>=1.0.0'</span><span class="p">)</span>
<span class="go">True</span>
</pre></div>
</div>
</dd></dl>
<dl class="data">
<dt id="semantic_version.SpecItem.KIND_GT">
<code class="descname">KIND_GT</code><a class="headerlink" href="#semantic_version.SpecItem.KIND_GT" title="Permalink to this definition">¶</a></dt>
<dd><p>The kind of ‘Greater than’ specifications:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">Version</span><span class="p">(</span><span class="s1">'1.0.0+build667'</span><span class="p">)</span> <span class="ow">in</span> <span class="n">Spec</span><span class="p">(</span><span class="s1">'>1.0.1'</span><span class="p">)</span>
<span class="go">False</span>
</pre></div>
</div>
</dd></dl>
<dl class="data">
<dt id="semantic_version.SpecItem.KIND_NEQ">
<code class="descname">KIND_NEQ</code><a class="headerlink" href="#semantic_version.SpecItem.KIND_NEQ" title="Permalink to this definition">¶</a></dt>
<dd><p>The kind of ‘Not equal to’ specifications:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">Version</span><span class="p">(</span><span class="s1">'1.0.1'</span><span class="p">)</span> <span class="ow">in</span> <span class="n">Spec</span><span class="p">(</span><span class="s1">'!=1.0.1'</span><span class="p">)</span>
<span class="go">False</span>
</pre></div>
</div>
<p>The kind of ‘Almost equal to’ specifications</p>
</dd></dl>
</dd></dl>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper">
<h3><a href="index.html">Table of Contents</a></h3>
<ul>
<li><a class="reference internal" href="#">Reference</a><ul>
<li><a class="reference internal" href="#module-level-functions">Module-level functions</a></li>
<li><a class="reference internal" href="#representing-a-version-the-version-class">Representing a version (the Version class)</a></li>
<li><a class="reference internal" href="#version-specifications-the-spec-class">Version specifications (the Spec class)</a></li>
</ul>
</li>
</ul>
<h4>Previous topic</h4>
<p class="topless"><a href="index.html"
title="previous chapter">python-semanticversion</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="django.html"
title="next chapter">Interaction with Django</a></p>
<div role="note" aria-label="source link">
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="_sources/reference.rst.txt"
rel="nofollow">Show Source</a></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3>
<div class="searchformwrapper">
<form class="search" action="search.html" method="get">
<input type="text" name="q" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
</div>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related" role="navigation" aria-label="related navigation">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="py-modindex.html" title="Python Module Index"
>modules</a> |</li>
<li class="right" >
<a href="django.html" title="Interaction with Django"
>next</a> |</li>
<li class="right" >
<a href="index.html" title="python-semanticversion"
>previous</a> |</li>
<li class="nav-item nav-item-0"><a href="index.html">python-semanticversion 2.6.0 documentation</a> »</li>
</ul>
</div>
<div class="footer" role="contentinfo">
© Copyright 2012-2014, The python-semanticversion project.
Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.8.3.
</div>
</body>
</html>
distrib
>
Mageia
>
7
>
i586
>
media
>
core-release
>
by-pkgid
>
be0ec2edf5701fac1f75c3921aad621f
>
files
>
40
