<!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="Content-Type" content="text/html; charset=utf-8" />
<title>tables.misc.enum — PyTables 3.0.0 documentation</title>
<link rel="stylesheet" href="../../../_static/cloud.css" type="text/css" />
<link rel="stylesheet" href="../../../_static/pygments.css" type="text/css" />
<link rel="stylesheet" href="../../../" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '../../../',
VERSION: '3.0.0',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</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/jquery.cookie.js"></script>
<script type="text/javascript" src="../../../_static/toggle_sections.js"></script>
<script type="text/javascript" src="../../../_static/toggle_sidebar.js"></script>
<link rel="shortcut icon" href="../../../_static/favicon.ico"/>
<link rel="top" title="PyTables 3.0.0 documentation" href="../../../index.html" />
<link rel="up" title="tables" href="../../tables.html" />
</head>
<body>
<div class="relbar-top">
<div class="related">
<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="../../../np-modindex.html" title="Python Module Index"
>modules</a> </li>
<li><a href="../../../index.html">PyTables 3.0.0 documentation</a> »</li>
<li><a href="../../index.html" >Module code</a> »</li>
<li><a href="../../tables.html" accesskey="U">tables</a> »</li>
</ul>
</div>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<h1>Source code for tables.misc.enum</h1><div class="highlight"><pre>
<span class="c"># -*- coding: utf-8 -*-</span>
<span class="c">########################################################################</span>
<span class="c">#</span>
<span class="c"># License: BSD</span>
<span class="c"># Created: May 4, 2005</span>
<span class="c"># Author: Ivan Vilata i Balaguer - reverse:net.selidor@ivan</span>
<span class="c">#</span>
<span class="c"># $Id$</span>
<span class="c">#</span>
<span class="c">########################################################################</span>
<span class="sd">"""Implementation of enumerated types.</span>
<span class="sd">This module provides the `Enum` class, which can be used to construct</span>
<span class="sd">enumerated types. Those types are defined by providing an *exhaustive</span>
<span class="sd">set or list* of possible, named values for a variable of that type.</span>
<span class="sd">Enumerated variables of the same type are usually compared between them</span>
<span class="sd">for equality and sometimes for order, but are not usually operated upon.</span>
<span class="sd">Enumerated values have an associated *name* and *concrete value*. Every</span>
<span class="sd">name is unique and so are concrete values. An enumerated variable</span>
<span class="sd">always takes the concrete value, not its name. Usually, the concrete</span>
<span class="sd">value is not used directly, and frequently it is entirely irrelevant.</span>
<span class="sd">For the same reason, an enumerated variable is not usually compared with</span>
<span class="sd">concrete values out of its enumerated type. For that kind of use,</span>
<span class="sd">standard variables and constants are more adequate.</span>
<span class="sd">"""</span>
<span class="kn">from</span> <span class="nn">tables._past</span> <span class="kn">import</span> <span class="n">previous_api</span>
<span class="n">__docformat__</span> <span class="o">=</span> <span class="s">'reStructuredText'</span>
<span class="sd">"""The format of documentation strings in this module."""</span>
<div class="viewcode-block" id="Enum"><a class="viewcode-back" href="../../../usersguide/libref/helper_classes.html#tables.misc.enum.Enum">[docs]</a><span class="k">class</span> <span class="nc">Enum</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
<span class="sd">"""Enumerated type.</span>
<span class="sd"> Each instance of this class represents an enumerated type. The</span>
<span class="sd"> values of the type must be declared</span>
<span class="sd"> *exhaustively* and named with</span>
<span class="sd"> *strings*, and they might be given explicit</span>
<span class="sd"> concrete values, though this is not compulsory. Once the type is</span>
<span class="sd"> defined, it can not be modified.</span>
<span class="sd"> There are three ways of defining an enumerated type. Each one</span>
<span class="sd"> of them corresponds to the type of the only argument in the</span>
<span class="sd"> constructor of Enum:</span>
<span class="sd"> - *Sequence of names*: each enumerated</span>
<span class="sd"> value is named using a string, and its order is determined by</span>
<span class="sd"> its position in the sequence; the concrete value is assigned</span>
<span class="sd"> automatically::</span>
<span class="sd"> >>> boolEnum = Enum(['True', 'False'])</span>
<span class="sd"> - *Mapping of names*: each enumerated</span>
<span class="sd"> value is named by a string and given an explicit concrete value.</span>
<span class="sd"> All of the concrete values must be different, or a</span>
<span class="sd"> ValueError will be raised::</span>
<span class="sd"> >>> priority = Enum({'red': 20, 'orange': 10, 'green': 0})</span>
<span class="sd"> >>> colors = Enum({'red': 1, 'blue': 1})</span>
<span class="sd"> Traceback (most recent call last):</span>
<span class="sd"> ...</span>
<span class="sd"> ValueError: enumerated values contain duplicate concrete values: 1</span>
<span class="sd"> - *Enumerated type*: in that case, a copy</span>
<span class="sd"> of the original enumerated type is created. Both enumerated</span>
<span class="sd"> types are considered equal::</span>
<span class="sd"> >>> prio2 = Enum(priority)</span>
<span class="sd"> >>> priority == prio2</span>
<span class="sd"> True</span>
<span class="sd"> Please note that names starting with _ are</span>
<span class="sd"> not allowed, since they are reserved for internal usage::</span>
<span class="sd"> >>> prio2 = Enum(['_xx'])</span>
<span class="sd"> Traceback (most recent call last):</span>
<span class="sd"> ...</span>
<span class="sd"> ValueError: name of enumerated value can not start with ``_``: '_xx'</span>
<span class="sd"> The concrete value of an enumerated value is obtained by</span>
<span class="sd"> getting its name as an attribute of the Enum</span>
<span class="sd"> instance (see __getattr__()) or as an item (see</span>
<span class="sd"> __getitem__()). This allows comparisons between</span>
<span class="sd"> enumerated values and assigning them to ordinary Python</span>
<span class="sd"> variables::</span>
<span class="sd"> >>> redv = priority.red</span>
<span class="sd"> >>> redv == priority['red']</span>
<span class="sd"> True</span>
<span class="sd"> >>> redv > priority.green</span>
<span class="sd"> True</span>
<span class="sd"> >>> priority.red == priority.orange</span>
<span class="sd"> False</span>
<span class="sd"> The name of the enumerated value corresponding to a concrete</span>
<span class="sd"> value can also be obtained by using the</span>
<span class="sd"> __call__() method of the enumerated type. In this</span>
<span class="sd"> way you get the symbolic name to use it later with</span>
<span class="sd"> __getitem__()::</span>
<span class="sd"> >>> priority(redv)</span>
<span class="sd"> 'red'</span>
<span class="sd"> >>> priority.red == priority[priority(priority.red)]</span>
<span class="sd"> True</span>
<span class="sd"> (If you ask, the __getitem__() method is</span>
<span class="sd"> not used for this purpose to avoid ambiguity in the case of using</span>
<span class="sd"> strings as concrete values.)</span>
<span class="sd"> """</span>
<span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">enum</span><span class="p">):</span>
<span class="n">mydict</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">__dict__</span>
<span class="n">mydict</span><span class="p">[</span><span class="s">'_names'</span><span class="p">]</span> <span class="o">=</span> <span class="p">{}</span>
<span class="n">mydict</span><span class="p">[</span><span class="s">'_values'</span><span class="p">]</span> <span class="o">=</span> <span class="p">{}</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">enum</span><span class="p">,</span> <span class="nb">list</span><span class="p">)</span> <span class="ow">or</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">enum</span><span class="p">,</span> <span class="nb">tuple</span><span class="p">):</span>
<span class="k">for</span> <span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="n">name</span><span class="p">)</span> <span class="ow">in</span> <span class="nb">enumerate</span><span class="p">(</span><span class="n">enum</span><span class="p">):</span> <span class="c"># values become 0, 1, 2...</span>
<span class="bp">self</span><span class="o">.</span><span class="n">_check_and_set_pair</span><span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span>
<span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">enum</span><span class="p">,</span> <span class="nb">dict</span><span class="p">):</span>
<span class="k">for</span> <span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span> <span class="ow">in</span> <span class="n">enum</span><span class="o">.</span><span class="n">iteritems</span><span class="p">():</span>
<span class="bp">self</span><span class="o">.</span><span class="n">_check_and_set_pair</span><span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span>
<span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">enum</span><span class="p">,</span> <span class="n">Enum</span><span class="p">):</span>
<span class="k">for</span> <span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span> <span class="ow">in</span> <span class="n">enum</span><span class="o">.</span><span class="n">_names</span><span class="o">.</span><span class="n">iteritems</span><span class="p">():</span>
<span class="bp">self</span><span class="o">.</span><span class="n">_check_and_set_pair</span><span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s">"""</span><span class="se">\</span>
<span class="s">enumerations can only be created from </span><span class="se">\</span>
<span class="s">sequences, mappings and other enumerations"""</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">_check_and_set_pair</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
<span class="sd">"""Check validity of enumerated value and insert it into type."""</span>
<span class="n">names</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_names</span>
<span class="n">values</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_values</span>
<span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="nb">basestring</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span>
<span class="s">"name of enumerated value is not a string: </span><span class="si">%r</span><span class="s">"</span> <span class="o">%</span> <span class="p">(</span><span class="n">name</span><span class="p">,))</span>
<span class="k">if</span> <span class="n">name</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s">'_'</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span>
<span class="s">"name of enumerated value can not start with ``_``: </span><span class="si">%r</span><span class="s">"</span>
<span class="o">%</span> <span class="n">name</span><span class="p">)</span>
<span class="c"># This check is only necessary with a sequence base object.</span>
<span class="k">if</span> <span class="n">name</span> <span class="ow">in</span> <span class="n">names</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span>
<span class="s">"enumerated values contain duplicate names: </span><span class="si">%r</span><span class="s">"</span> <span class="o">%</span> <span class="n">name</span><span class="p">)</span>
<span class="c"># This check is only necessary with a mapping base object.</span>
<span class="k">if</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">values</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span>
<span class="s">"enumerated values contain duplicate concrete values: </span><span class="si">%r</span><span class="s">"</span>
<span class="o">%</span> <span class="n">value</span><span class="p">)</span>
<span class="n">names</span><span class="p">[</span><span class="n">name</span><span class="p">]</span> <span class="o">=</span> <span class="n">value</span>
<span class="n">values</span><span class="p">[</span><span class="n">value</span><span class="p">]</span> <span class="o">=</span> <span class="n">name</span>
<span class="bp">self</span><span class="o">.</span><span class="n">__dict__</span><span class="p">[</span><span class="n">name</span><span class="p">]</span> <span class="o">=</span> <span class="n">value</span>
<span class="n">_checkAndSetPair</span> <span class="o">=</span> <span class="n">previous_api</span><span class="p">(</span><span class="n">_check_and_set_pair</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">__getitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Get the concrete value of the enumerated value with that name.</span>
<span class="sd"> The name of the enumerated value must be a string. If there is no value</span>
<span class="sd"> with that name in the enumeration, a KeyError is raised.</span>
<span class="sd"> Examples</span>
<span class="sd"> --------</span>
<span class="sd"> Let ``enum`` be an enumerated type defined as:</span>
<span class="sd"> >>> enum = Enum({'T0': 0, 'T1': 2, 'T2': 5})</span>
<span class="sd"> then:</span>
<span class="sd"> >>> enum['T1']</span>
<span class="sd"> 2</span>
<span class="sd"> >>> enum['foo']</span>
<span class="sd"> Traceback (most recent call last):</span>
<span class="sd"> ...</span>
<span class="sd"> KeyError: "no enumerated value with that name: 'foo'"</span>
<span class="sd"> """</span>
<span class="k">try</span><span class="p">:</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_names</span><span class="p">[</span><span class="n">name</span><span class="p">]</span>
<span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">KeyError</span><span class="p">(</span><span class="s">"no enumerated value with that name: </span><span class="si">%r</span><span class="s">"</span> <span class="o">%</span> <span class="p">(</span><span class="n">name</span><span class="p">,))</span>
<span class="k">def</span> <span class="nf">__setitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
<span class="sd">"""This operation is forbidden."""</span>
<span class="k">raise</span> <span class="ne">IndexError</span><span class="p">(</span><span class="s">"operation not allowed"</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">__delitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">):</span>
<span class="sd">"""This operation is forbidden."""</span>
<span class="k">raise</span> <span class="ne">IndexError</span><span class="p">(</span><span class="s">"operation not allowed"</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">__getattr__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Get the concrete value of the enumerated value with that name.</span>
<span class="sd"> The name of the enumerated value must be a string. If there is no value</span>
<span class="sd"> with that name in the enumeration, an AttributeError is raised.</span>
<span class="sd"> Examples</span>
<span class="sd"> --------</span>
<span class="sd"> Let ``enum`` be an enumerated type defined as:</span>
<span class="sd"> >>> enum = Enum({'T0': 0, 'T1': 2, 'T2': 5})</span>
<span class="sd"> then:</span>
<span class="sd"> >>> enum.T1</span>
<span class="sd"> 2</span>
<span class="sd"> >>> enum.foo</span>
<span class="sd"> Traceback (most recent call last):</span>
<span class="sd"> ...</span>
<span class="sd"> AttributeError: no enumerated value with that name: 'foo'</span>
<span class="sd"> """</span>
<span class="k">try</span><span class="p">:</span>
<span class="k">return</span> <span class="bp">self</span><span class="p">[</span><span class="n">name</span><span class="p">]</span>
<span class="k">except</span> <span class="ne">KeyError</span><span class="p">,</span> <span class="n">ke</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">AttributeError</span><span class="p">(</span><span class="o">*</span><span class="n">ke</span><span class="o">.</span><span class="n">args</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">__setattr__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
<span class="sd">"""This operation is forbidden."""</span>
<span class="k">raise</span> <span class="ne">AttributeError</span><span class="p">(</span><span class="s">"operation not allowed"</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">__delattr__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">):</span>
<span class="sd">"""This operation is forbidden."""</span>
<span class="k">raise</span> <span class="ne">AttributeError</span><span class="p">(</span><span class="s">"operation not allowed"</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">__contains__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Is there an enumerated value with that name in the type?</span>
<span class="sd"> If the enumerated type has an enumerated value with that name, True is</span>
<span class="sd"> returned. Otherwise, False is returned. The name must be a string.</span>
<span class="sd"> This method does *not* check for concrete values matching a value in an</span>
<span class="sd"> enumerated type. For that, please use the :meth:`Enum.__call__` method.</span>
<span class="sd"> Examples</span>
<span class="sd"> --------</span>
<span class="sd"> Let ``enum`` be an enumerated type defined as:</span>
<span class="sd"> >>> enum = Enum({'T0': 0, 'T1': 2, 'T2': 5})</span>
<span class="sd"> then:</span>
<span class="sd"> >>> 'T1' in enum</span>
<span class="sd"> True</span>
<span class="sd"> >>> 'foo' in enum</span>
<span class="sd"> False</span>
<span class="sd"> >>> 0 in enum</span>
<span class="sd"> Traceback (most recent call last):</span>
<span class="sd"> ...</span>
<span class="sd"> TypeError: name of enumerated value is not a string: 0</span>
<span class="sd"> >>> enum.T1 in enum # Be careful with this!</span>
<span class="sd"> Traceback (most recent call last):</span>
<span class="sd"> ...</span>
<span class="sd"> TypeError: name of enumerated value is not a string: 2</span>
<span class="sd"> """</span>
<span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="nb">basestring</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span>
<span class="s">"name of enumerated value is not a string: </span><span class="si">%r</span><span class="s">"</span> <span class="o">%</span> <span class="p">(</span><span class="n">name</span><span class="p">,))</span>
<span class="k">return</span> <span class="n">name</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">_names</span>
<span class="k">def</span> <span class="nf">__call__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">value</span><span class="p">,</span> <span class="o">*</span><span class="n">default</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Get the name of the enumerated value with that concrete value.</span>
<span class="sd"> If there is no value with that concrete value in the enumeration and a</span>
<span class="sd"> second argument is given as a default, this is returned. Else, a</span>
<span class="sd"> ValueError is raised.</span>
<span class="sd"> This method can be used for checking that a concrete value belongs to</span>
<span class="sd"> the set of concrete values in an enumerated type.</span>
<span class="sd"> Examples</span>
<span class="sd"> --------</span>
<span class="sd"> Let ``enum`` be an enumerated type defined as:</span>
<span class="sd"> >>> enum = Enum({'T0': 0, 'T1': 2, 'T2': 5})</span>
<span class="sd"> then:</span>
<span class="sd"> >>> enum(5)</span>
<span class="sd"> 'T2'</span>
<span class="sd"> >>> enum(42, None) is None</span>
<span class="sd"> True</span>
<span class="sd"> >>> enum(42)</span>
<span class="sd"> Traceback (most recent call last):</span>
<span class="sd"> ...</span>
<span class="sd"> ValueError: no enumerated value with that concrete value: 42</span>
<span class="sd"> """</span>
<span class="k">try</span><span class="p">:</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_values</span><span class="p">[</span><span class="n">value</span><span class="p">]</span>
<span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
<span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">default</span><span class="p">)</span> <span class="o">></span> <span class="mi">0</span><span class="p">:</span>
<span class="k">return</span> <span class="n">default</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span>
<span class="s">"no enumerated value with that concrete value: </span><span class="si">%r</span><span class="s">"</span> <span class="o">%</span> <span class="p">(</span><span class="n">value</span><span class="p">,))</span>
<span class="k">def</span> <span class="nf">__len__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Return the number of enumerated values in the enumerated type.</span>
<span class="sd"> Examples</span>
<span class="sd"> --------</span>
<span class="sd"> >>> len(Enum(['e%d' % i for i in range(10)]))</span>
<span class="sd"> 10</span>
<span class="sd"> """</span>
<span class="k">return</span> <span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_names</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">__iter__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Iterate over the enumerated values.</span>
<span class="sd"> Enumerated values are returned as (name, value) pairs *in no particular</span>
<span class="sd"> order*.</span>
<span class="sd"> Examples</span>
<span class="sd"> --------</span>
<span class="sd"> >>> enumvals = {'red': 4, 'green': 2, 'blue': 1}</span>
<span class="sd"> >>> enum = Enum(enumvals)</span>
<span class="sd"> >>> enumdict = dict([(name, value) for (name, value) in enum])</span>
<span class="sd"> >>> enumvals == enumdict</span>
<span class="sd"> True</span>
<span class="sd"> """</span>
<span class="k">for</span> <span class="n">name_value</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">_names</span><span class="o">.</span><span class="n">iteritems</span><span class="p">():</span>
<span class="k">yield</span> <span class="n">name_value</span>
<span class="k">def</span> <span class="nf">__eq__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Is the other enumerated type equivalent to this one?</span>
<span class="sd"> Two enumerated types are equivalent if they have exactly the same</span>
<span class="sd"> enumerated values (i.e. with the same names and concrete values).</span>
<span class="sd"> Examples</span>
<span class="sd"> --------</span>
<span class="sd"> Let ``enum*`` be enumerated types defined as:</span>
<span class="sd"> >>> enum1 = Enum({'T0': 0, 'T1': 2})</span>
<span class="sd"> >>> enum2 = Enum(enum1)</span>
<span class="sd"> >>> enum3 = Enum({'T1': 2, 'T0': 0})</span>
<span class="sd"> >>> enum4 = Enum({'T0': 0, 'T1': 2, 'T2': 5})</span>
<span class="sd"> >>> enum5 = Enum({'T0': 0})</span>
<span class="sd"> >>> enum6 = Enum({'T0': 10, 'T1': 20})</span>
<span class="sd"> then:</span>
<span class="sd"> >>> enum1 == enum1</span>
<span class="sd"> True</span>
<span class="sd"> >>> enum1 == enum2 == enum3</span>
<span class="sd"> True</span>
<span class="sd"> >>> enum1 == enum4</span>
<span class="sd"> False</span>
<span class="sd"> >>> enum5 == enum1</span>
<span class="sd"> False</span>
<span class="sd"> >>> enum1 == enum6</span>
<span class="sd"> False</span>
<span class="sd"> Comparing enumerated types with other kinds of objects produces</span>
<span class="sd"> a false result:</span>
<span class="sd"> >>> enum1 == {'T0': 0, 'T1': 2}</span>
<span class="sd"> False</span>
<span class="sd"> >>> enum1 == ['T0', 'T1']</span>
<span class="sd"> False</span>
<span class="sd"> >>> enum1 == 2</span>
<span class="sd"> False</span>
<span class="sd"> """</span>
<span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="n">Enum</span><span class="p">):</span>
<span class="k">return</span> <span class="bp">False</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_names</span> <span class="o">==</span> <span class="n">other</span><span class="o">.</span><span class="n">_names</span>
<span class="k">def</span> <span class="nf">__ne__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Is the `other` enumerated type different from this one?</span>
<span class="sd"> Two enumerated types are different if they don't have exactly</span>
<span class="sd"> the same enumerated values (i.e. with the same names and</span>
<span class="sd"> concrete values).</span>
<span class="sd"> Examples</span>
<span class="sd"> --------</span>
<span class="sd"> Let ``enum*`` be enumerated types defined as:</span>
<span class="sd"> >>> enum1 = Enum({'T0': 0, 'T1': 2})</span>
<span class="sd"> >>> enum2 = Enum(enum1)</span>
<span class="sd"> >>> enum3 = Enum({'T1': 2, 'T0': 0})</span>
<span class="sd"> >>> enum4 = Enum({'T0': 0, 'T1': 2, 'T2': 5})</span>
<span class="sd"> >>> enum5 = Enum({'T0': 0})</span>
<span class="sd"> >>> enum6 = Enum({'T0': 10, 'T1': 20})</span>
<span class="sd"> then:</span>
<span class="sd"> >>> enum1 != enum1</span>
<span class="sd"> False</span>
<span class="sd"> >>> enum1 != enum2 != enum3</span>
<span class="sd"> False</span>
<span class="sd"> >>> enum1 != enum4</span>
<span class="sd"> True</span>
<span class="sd"> >>> enum5 != enum1</span>
<span class="sd"> True</span>
<span class="sd"> >>> enum1 != enum6</span>
<span class="sd"> True</span>
<span class="sd"> """</span>
<span class="k">return</span> <span class="ow">not</span> <span class="bp">self</span><span class="o">.</span><span class="n">__eq__</span><span class="p">(</span><span class="n">other</span><span class="p">)</span>
<span class="c"># XXX: API incompatible change for PyTables 3 line</span>
<span class="c"># Overriding __eq__ blocks inheritance of __hash__ in 3.x</span>
<span class="c"># def __hash__(self):</span>
<span class="c"># return hash((self.__class__, tuple(self._names.items())))</span>
<span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">"""</span>
<span class="sd"> Return the canonical string representation of the enumeration. The</span>
<span class="sd"> output of this method can be evaluated to give a new enumeration object</span>
<span class="sd"> that will compare equal to this one.</span>
<span class="sd"> Examples</span>
<span class="sd"> --------</span>
<span class="sd"> >>> repr(Enum({'name': 10}))</span>
<span class="sd"> "Enum({'name': 10})"</span>
<span class="sd"> """</span>
<span class="k">return</span> <span class="s">'Enum(</span><span class="si">%s</span><span class="s">)'</span> <span class="o">%</span> <span class="bp">self</span><span class="o">.</span><span class="n">_names</span>
</div>
<span class="k">def</span> <span class="nf">_test</span><span class="p">():</span>
<span class="kn">import</span> <span class="nn">doctest</span>
<span class="k">return</span> <span class="n">doctest</span><span class="o">.</span><span class="n">testmod</span><span class="p">()</span>
<span class="k">if</span> <span class="n">__name__</span> <span class="o">==</span> <span class="s">'__main__'</span><span class="p">:</span>
<span class="n">_test</span><span class="p">()</span>
<span class="c">## Local Variables:</span>
<span class="c">## mode: python</span>
<span class="c">## py-indent-offset: 4</span>
<span class="c">## tab-width: 4</span>
<span class="c">## fill-column: 72</span>
<span class="c">## End:</span>
</pre></div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<p class="logo"><a href="../../../index.html">
<img class="logo" src="../../../_static/logo-pytables-small.png" alt="Logo"/>
</a></p>
<div id="searchbox" style="display: none">
<h3>Quick search</h3>
<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>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="relbar-bottom">
<div class="related">
<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="../../../np-modindex.html" title="Python Module Index"
>modules</a> </li>
<li><a href="../../../index.html">PyTables 3.0.0 documentation</a> »</li>
<li><a href="../../index.html" >Module code</a> »</li>
<li><a href="../../tables.html" >tables</a> »</li>
</ul>
</div>
</div>
<div class="footer">
© Copyright 2011-2013, PyTables maintainers.
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
</div>
<!-- cloud_sptheme 1.3 -->
</body>
</html>
