Use enum.Enum in a couple cases.

QuLogic · QuLogic · commit 36986a975fd7 · 2018-02-16T19:09:46.000-05:00
diff --git a/lib/matplotlib/dviread.py b/lib/matplotlib/dviread.py
@@ -18,15 +18,17 @@
 
 """
 from collections import namedtuple
+import enum
 from functools import lru_cache, partial, wraps
 import logging
-import numpy as np
 import os
 import re
 import struct
 import sys
 import textwrap
 
+import numpy as np
+
 from matplotlib import cbook, rcParams
 from matplotlib.compat import subprocess
 
@@ -48,7 +50,7 @@
 #              just stops reading)
 #   finale:    the finale (unimplemented in our current implementation)
 
-_dvistate = cbook.Bunch(pre=0, outer=1, inpage=2, post_post=3, finale=4)
+_dvistate = enum.Enum('DviState', 'pre outer inpage post_post finale')
 
 # The marks on a page consist of text and boxes. A page also has dimensions.
 Page = namedtuple('Page', 'text boxes height width descent')
@@ -301,7 +303,7 @@ def _read(self):
             self._dtable[byte](self, byte)
             if byte == 140:                         # end of page
                 return True
-            if self.state == _dvistate.post_post:   # end of file
+            if self.state is _dvistate.post_post:   # end of file
                 self.close()
                 return False
 
@@ -622,7 +624,7 @@ def _read(self):
         while True:
             byte = self.file.read(1)[0]
             # If we are in a packet, execute the dvi instructions
-            if self.state == _dvistate.inpage:
+            if self.state is _dvistate.inpage:
                 byte_at = self.file.tell()-1
                 if byte_at == packet_ends:
                     self._finalize_packet(packet_char, packet_width)
@@ -678,7 +680,7 @@ def _finalize_packet(self, packet_char, packet_width):
         self.state = _dvistate.outer
 
     def _pre(self, i, x, cs, ds):
-        if self.state != _dvistate.pre:
+        if self.state is not _dvistate.pre:
             raise ValueError("pre command in middle of vf file")
         if i != 202:
             raise ValueError("Unknown vf format %d" % i)
diff --git a/lib/matplotlib/type1font.py b/lib/matplotlib/type1font.py
@@ -28,6 +28,7 @@
 import six
 
 import binascii
+import enum
 import io
 import itertools
 import re
@@ -40,6 +41,11 @@ def ord(x):
         return x
 
 
+# token types
+_TokenType = enum.Enum('_TokenType',
+                       'whitespace name string delimiter number')
+
+
 class Type1Font(object):
     """
     A class representing a Type-1 font, for use by backends.
@@ -143,25 +149,18 @@ def _split(self, data):
     _comment_re = re.compile(br'%[^\r\n\v]*')
     _instring_re = re.compile(br'[()\\]')
 
-    # token types, compared via object identity (poor man's enum)
-    _whitespace = object()
-    _name = object()
-    _string = object()
-    _delimiter = object()
-    _number = object()
-
     @classmethod
     def _tokens(cls, text):
         """
         A PostScript tokenizer. Yield (token, value) pairs such as
-        (cls._whitespace, '   ') or (cls._name, '/Foobar').
+        (_TokenType.whitespace, '   ') or (_TokenType.name, '/Foobar').
         """
         pos = 0
         while pos < len(text):
             match = (cls._comment_re.match(text[pos:]) or
                      cls._whitespace_re.match(text[pos:]))
             if match:
-                yield (cls._whitespace, match.group())
+                yield (_TokenType.whitespace, match.group())
                 pos += match.end()
             elif text[pos] == b'(':
                 start = pos
@@ -178,25 +177,25 @@ def _tokens(cls, text):
                         depth -= 1
                     else:  # a backslash - skip the next character
                         pos += 1
-                yield (cls._string, text[start:pos])
+                yield (_TokenType.string, text[start:pos])
             elif text[pos:pos + 2] in (b'<<', b'>>'):
-                yield (cls._delimiter, text[pos:pos + 2])
+                yield (_TokenType.delimiter, text[pos:pos + 2])
                 pos += 2
             elif text[pos] == b'<':
                 start = pos
                 pos += text[pos:].index(b'>')
-                yield (cls._string, text[start:pos])
+                yield (_TokenType.string, text[start:pos])
             else:
                 match = cls._token_re.match(text[pos:])
                 if match:
                     try:
                         float(match.group())
-                        yield (cls._number, match.group())
+                        yield (_TokenType.number, match.group())
                     except ValueError:
-                        yield (cls._name, match.group())
+                        yield (_TokenType.name, match.group())
                     pos += match.end()
                 else:
-                    yield (cls._delimiter, text[pos:pos + 1])
+                    yield (_TokenType.delimiter, text[pos:pos + 1])
                     pos += 1
 
     def _parse(self):
@@ -210,23 +209,23 @@ def _parse(self):
                 'UnderlinePosition': -100, 'UnderlineThickness': 50}
         filtered = ((token, value)
                     for token, value in self._tokens(self.parts[0])
-                    if token is not self._whitespace)
+                    if token is not _TokenType.whitespace)
         # The spec calls this an ASCII format; in Python 2.x we could
         # just treat the strings and names as opaque bytes but let's
         # turn them into proper Unicode, and be lenient in case of high bytes.
         convert = lambda x: x.decode('ascii', 'replace')
         for token, value in filtered:
-            if token is self._name and value.startswith(b'/'):
+            if token is _TokenType.name and value.startswith(b'/'):
                 key = convert(value[1:])
                 token, value = next(filtered)
-                if token is self._name:
+                if token is _TokenType.name:
                     if value in (b'true', b'false'):
                         value = value == b'true'
                     else:
                         value = convert(value.lstrip(b'/'))
-                elif token is self._string:
+                elif token is _TokenType.string:
                     value = convert(value.lstrip(b'(').rstrip(b')'))
-                elif token is self._number:
+                elif token is _TokenType.number:
                     if b'.' in value:
                         value = float(value)
                     else:
@@ -284,7 +283,7 @@ def replacer(tokens):
                 token, value = next(tokens)      # name, e.g., /FontMatrix
                 yield bytes(value)
                 token, value = next(tokens)      # possible whitespace
-                while token is cls._whitespace:
+                while token is _TokenType.whitespace:
                     yield bytes(value)
                     token, value = next(tokens)
                 if value != b'[':                # name/number/etc.
@@ -309,7 +308,7 @@ def suppress(tokens):
                  b'/UniqueID': suppress}
 
         for token, value in tokens:
-            if token is cls._name and value in table:
+            if token is _TokenType.name and value in table:
                 for value in table[value](itertools.chain([(token, value)],
                                                           tokens)):
                     yield value
