| Andrew Cooke | Contents | Latest | RSS | Twitter | Previous | Next


Welcome to my blog, which was once a mailing list of the same name and is still generated by mail. Please reply via the "comment" links.

Always interested in offers/projects/new ideas. Eclectic experience in fields like: numerical computing; Python web; Java enterprise; functional languages; GPGPU; SQL databases; etc. Based in Santiago, Chile; telecommute worldwide. CV; email.

Personal Projects

Lepl parser for Python.

Colorless Green.

Photography around Santiago.

SVG experiment.

Professional Portfolio

Calibration of seismometers.

Data access via web services.

Cache rewrite.

Extending OpenSSH.

C-ORM: docs, API.

Last 100 entries

Sending Email On Time; Maybe run a command; Sterile Neutrinos; Strawberry and Banana Jam; The Best Of All Possible Worlds; Kenzaburo Oe: The Changeling; Peach Jam; Taste Test; Strawberry and Raspberry Jam; flac to mp3 on OpenSuse 42.1; Also, Sebald; Kenzaburo Oe Interview; Otake (Kitani Minoru) move Black 121; Is free speech in British universities under threat?; I am actually good at computers; Was This Mansplaining?; WebFaction / LetsEncrypt / General Disappointment; Sensible Philosophy of Science; George Ellis; Misplaced Intuition and Online Communities; More Reading About Japan; Visibilty / Public Comments / Domestic Violence; Ferias de Santiago; More (Clearly Deliberate); Deleted Obit Post; And then a 50 yo male posts this...; We Have Both Kinds Of Contributors; Free Springer Books; Books on Religion; Books on Linguistics; Palestinan Electronica; Books In Anthropology; Taylor Expansions of Spacetime; Info on Juniper; Efficient Stream Processing; The Moral Character of Crypto; Hearing Aid Info; Small Success With Go!; Re: Quick message - This link is broken; Adding Reverb To The Echo Chamber; Sox Audio Tools; Would This Have Been OK?; Honesty only important economically before institutions develop; Stegangraphy via PS4; OpenCL Mess; More Book Recommendations; Good Explanation of Difference Between Majority + Minority; Musical Chairs - Who's The Privileged White Guy; I can see straight men watching this conversation and laffing; Meta Thread Defending POC Causes POC To Close Account; Indigenous People Of Chile; Curry Recipe; Interesting Link On Marginality; A Nuclear Launch Ordered, 1962; More Book Recs (Better Person); It's Nuanced, And I Tried, So Back Off; Marx; The Negative Of Positive; Jenny Holzer Rocks; Huge Article on Cultural Evolution and More; "Ignoring language theory"; Negative Finger Counting; Week 12; Communication Via Telecomm Bids; Finding Suspects Via Relatives' DNA From Non-Crime Databases; Statistics and Information Theory; Ice OK in USA; On The Other Hand; (Current Understanding Of) Chilean Taxes / Contributions; M John Harrison; Playing Games on a Cloud GPU; China Gamifies Real Life; Can't Help Thinking It's Thoughtcrime; Mefi Quotes; Spray Painting Bike Frame; Weeks 10 + 11; Change: No Longer Possible To Merge Metadata; Books on Old Age; Health Tree Maps; MRA - Men's Rights Activists; Writing Good C++14; Risk Assessment - Fukushima; The Future of Advertising and Surveillance; Travelling With Betaferon; I think I know what I dislike so much about Metafilter; Weeks 8 + 9; More; Pastamore - Bad Italian in Vitacura; History Books; Iraq + The (UK) Governing Elite; Answering Some Hard Questions; Pinochet: The Dictator's Shadow; An Outsider's Guide To Julia Packages; Nobody gives a shit; Lepton Decay Irregularity; An Easier Way; Julia's BinDeps (aka How To Install Cairo); Good Example Of Good Police Work (And Anonymity Being Hard); Best Santiago Burgers; Also; Michael Emmerich (Vibrator Translator) Interview (Japanese Books)

© 2006-2015 Andrew Cooke (site) / post authors (content).

Python Enums on Crack, Part II

From: andrew cooke <andrew@...>

Date: Tue, 4 Jun 2013 08:50:28 -0400

Just under a month ago I wrote a disappointed rant[1] about the new Enum for
Python 3.

Since then I spent time extending the existing code[2] (to produce bnum[3]),
before changing direction and writing my own, alternative Enum from
scratch[4].  I've also swapped a few emails with various kind people.

While all that doesn't make me an expert, I do now have a better understanding
of the design and some of the choices it embodies.  So I thought I'd revisit
the points I made earlier and try explain why things work that way, where I
can, and what space for change still remains.

Implicit Values

In the original article I said that my first example -

  class Colour(Enum):

- was illegal syntax.  I was wrong.

When Python parses the class definition it looks for values in the dict of the
class that it is building.  Python 3's metaclass protocol allows us to provide
that dict, so we can use a subclass that assigns default values to unknown
names (and provide values from 'red' and 'green' instead of triggering an

I use this trick in simple-enum[4], and the above is a valid declaration when
using that package.  But it's not a risk-free solution: there's the
possibility of very confusing errors / bugs.

The problem is that elsewhere in the code we may refer to a name in the global
scope.  The class dict will, incorrectly, provide a default value for that
name too.  And while you can reduce the effect[5], I am not (yet) convinced
that you can remove the risk entirely.

Implicit Values 2 (Strange Syntaxes)

But all is not lost.  The PEP 0435 test code includes support for:

  class Colour(Enum):
      red = ...
      green = ...

which, although uglier, avoids the issues with "magic values".  This is not in
the default implementation, but it can be added by providing an alternate

Duplicate Values

Python 3's metaclass support includes keyword arguments.  Here's an example
from simple-enum:

  class WithAliases(Enum, implicit=False, allow_aliases=True):
      one = 1
      another_one = 1

Please ignore the 'implicit=False' (it does what you'd expect; it's needed
because of the shadowing issue I discussed earlier) - I am showing this
example because the 'allow_aliases' flag seems like a good solution to whether
or not duplicate values should be flagged: duplicates are errors by default,
but can be enabled if required.

Unfortunately I don't see anything likle this in the PEP 0345 code.  There's
no such flag (no metaclass keyword args are used at all) and no related tests.
But it is fairly easy to add - I included it in bnum[3].


The PEP Enum code is complicated by the need to support inheritance -
something that is used mainly (in the tests) to allow Enums to "be" integers.

In case the above is not clear, this is valid with PEP 0435:

  # PEP 0435
  class Number(int, Enum):
      one = 1
      two = 2

  > Number.one + Number.two
  > isinstance(Number.one, Number)
  > isinstance(Number.one, int)

In contrast, the simple-enum implementation is, well, simpler, treating all
enumerations as named tuples (with name and value components), so equivalent
code would read:

  # simple-enum
  > Number.one.value + Number.two.value

Now, after that long introduction, the question is: why does PEP 0435 have
this emphasis?  I chose the simple (but more verbose) solution because it
seemed easier to understand, simplified the implementation, and allowed me to
present enumerations in terms of both dicts and tuples (something I haven't
explained here, since I'm focussing on PEP 0435, but see [4] if you're

Nick Coghlan explained this to me, and it shone a completely new light on the
design: the PEP is designed to be backwards compatible with existing Python
library code.

For example, the socket module is full of constants like TIPC_ADDR_NAME and
AF_BLUETOOTH.  Existing code *expects* them to evaluate to whatever their
current value is.  Changing all that existing code to TIPC_ADDR_NAME.value is
impossible.  So the PEP Enum *must* "be" an int (or a str, or whatever the
original design chose) if these constants are going to be replaced by Enums.

Hence the inheritance.

Alternate Implcit Values

I mentioned this in my rant, and support it in simple-enum with metaclass
keyword arguments (eg. 'values=from_zero'), but implicit values currently play
a very small part in the PEP 0435 Enum (they are available only through the
"functional API").

Language Changes

While the "names in a class" syntax is possible, it's something of a hack (see
above).  Since support for such a syntax might also help named tuples it's
interesting to ask whether the language could be extended in some way to
support this.  I don't have a concrete suggestion, but it seems like an
interesting avenue to explore.

A simpler change, which I stumbled across while considering alternatives, is
to extend matching to infinite sequences.  This would allow a syntax like:

  class SequenceBased(Enum):
      one, two, three, ... = count()


Much of the design of the PEP 0435 Enum is driven by the requirement that it
be applied retroactively to existing classes (without changing existing code).
Honestly, to me, that seems a bit "too clever", but I understand the

The "clean" syntax (names in a class) is possible in Python, but concerns
about opaque errors / bugs from name shadowing have excluded it from the PEP.
Alternative syntaxes (like 'name = ...') exist in the tests, but are not
enabled by default.

Duplicate values could be enabled by a named argument to the metaclass.  I
don't understand why this issue is missing from the code (even in the tests,
which otherwise do a good job of exploring alternative ideas).

[1] rant - http://www.acooke.org/cute/Pythonssad0.html
[2] PEP 0435 code - https://bitbucket.org/stoneleaf/ref435
[3] mod of [2] - https://github.com/andrewcooke/bnum
[4] new start - https://github.com/andrewcooke/simple-enum
[5] magic values - https://github.com/andrewcooke/simple-enum#the-danger-of-magic

The back-wards compatibility fallacy

From: Poul-Henning Kamp <phk@...>

Date: Tue, 04 Jun 2013 14:56:22 +0000

"Much of the design of the PEP 0435 Enum is driven by the
	requirement that it be applied retroactively to existing
	classes (without changing existing code).  Honestly, to me,
	that seems a bit "too clever", but I understand the

There is a finite amount of existing python code, it may be a lot of
python code, but it is a finite amount.

There is a unbounded amount of python code yet to be written and
in all likelyhood, much more python code will be written in the
future, than has been written in the past.

It is therefore a very short-sighted tradeoff and a grave mistake
to handicap such an important language tool as enums, just to cater
to the smaller of these two codebases.

If in doubt about this arguments validity, recall how
backwards-compat-at-all-cost-standardization has totally stopped
the evolution of the C language.

Poul-Henning Kamp       | UNIX since Zilog Zeus 3.20
phk@...         | TCP/IP since RFC 956
FreeBSD committer       | BSD since 4.3-tahoe
Never attribute to malice what can adequately be explained by incompetence.

Comment on this post