From ec58b26d64683fffbe29c06e3a0fe456132605e3 Mon Sep 17 00:00:00 2001 From: Hernan Grecco Date: Fri, 6 Feb 2015 17:13:06 -0300 Subject: [PATCH] Removed code that is not needed any more Close #219 Close #218 --- pint/compat/__init__.py | 5 -- pint/compat/transformdict.py | 136 -------------------------------- pint/context.py | 10 --- pint/testsuite/test_contexts.py | 13 +-- 4 files changed, 1 insertion(+), 163 deletions(-) delete mode 100644 pint/compat/transformdict.py diff --git a/pint/compat/__init__.py b/pint/compat/__init__.py index 7c4e7de..043f1bf 100644 --- a/pint/compat/__init__.py +++ b/pint/compat/__init__.py @@ -65,11 +65,6 @@ try: except ImportError: from .chainmap import ChainMap -try: - from collections import TransformDict -except ImportError: - from .transformdict import TransformDict - try: from functools import lru_cache except ImportError: diff --git a/pint/compat/transformdict.py b/pint/compat/transformdict.py deleted file mode 100644 index c01ea30..0000000 --- a/pint/compat/transformdict.py +++ /dev/null @@ -1,136 +0,0 @@ -# -*- coding: utf-8 -*- -""" - pint.compat.transformdict - ~~~~~~~~~~~~~~~~~~~~~~~~~ - - Taken from the Python 3.4 source code. - - :copyright: 2013, PSF - :license: PSF License -""" - -from collections import MutableMapping - -_sentinel = object() - -class TransformDict(MutableMapping): - '''Dictionary that calls a transformation function when looking - up keys, but preserves the original keys. - - >>> d = TransformDict(str.lower) - >>> d['Foo'] = 5 - >>> d['foo'] == d['FOO'] == d['Foo'] == 5 - True - >>> set(d.keys()) - {'Foo'} - ''' - - __slots__ = ('_transform', '_original', '_data') - - def __init__(self, transform, init_dict=None, **kwargs): - '''Create a new TransformDict with the given *transform* function. - *init_dict* and *kwargs* are optional initializers, as in the - dict constructor. - ''' - if not callable(transform): - raise TypeError("expected a callable, got %r" % transform.__class__) - self._transform = transform - # transformed => original - self._original = {} - self._data = {} - if init_dict: - self.update(init_dict) - if kwargs: - self.update(kwargs) - - def getitem(self, key): - 'D.getitem(key) -> (stored key, value)' - transformed = self._transform(key) - original = self._original[transformed] - value = self._data[transformed] - return original, value - - @property - def transform_func(self): - "This TransformDict's transformation function" - return self._transform - - # Minimum set of methods required for MutableMapping - - def __len__(self): - return len(self._data) - - def __iter__(self): - return iter(self._original.values()) - - def __getitem__(self, key): - return self._data[self._transform(key)] - - def __setitem__(self, key, value): - transformed = self._transform(key) - self._data[transformed] = value - self._original.setdefault(transformed, key) - - def __delitem__(self, key): - transformed = self._transform(key) - del self._data[transformed] - del self._original[transformed] - - # Methods overriden to mitigate the performance overhead. - - def clear(self): - 'D.clear() -> None. Remove all items from D.' - self._data.clear() - self._original.clear() - - def __contains__(self, key): - return self._transform(key) in self._data - - def get(self, key, default=None): - 'D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.' - return self._data.get(self._transform(key), default) - - def pop(self, key, default=_sentinel): - '''D.pop(k[,d]) -> v, remove specified key and return the corresponding value. - If key is not found, d is returned if given, otherwise KeyError is raised. - ''' - transformed = self._transform(key) - if default is _sentinel: - del self._original[transformed] - return self._data.pop(transformed) - else: - self._original.pop(transformed, None) - return self._data.pop(transformed, default) - - def popitem(self): - '''D.popitem() -> (k, v), remove and return some (key, value) pair - as a 2-tuple; but raise KeyError if D is empty. - ''' - transformed, value = self._data.popitem() - return self._original.pop(transformed), value - - # Other methods - - def copy(self): - 'D.copy() -> a shallow copy of D' - other = self.__class__(self._transform) - other._original = self._original.copy() - other._data = self._data.copy() - return other - - __copy__ = copy - - def __getstate__(self): - return (self._transform, self._data, self._original) - - def __setstate__(self, state): - self._transform, self._data, self._original = state - - def __repr__(self): - try: - equiv = dict(self) - except TypeError: - # Some keys are unhashable, fall back on .items() - equiv = list(self.items()) - return '%s(%r, %s)' % (self.__class__.__name__, - self._transform, repr(equiv)) diff --git a/pint/context.py b/pint/context.py index aeb626a..5b9fda8 100644 --- a/pint/context.py +++ b/pint/context.py @@ -27,16 +27,6 @@ _header_re = re.compile('@context\s*(?P\(.*\))?\s+(?P\w+)\s*(=(? _varname_re = re.compile('[A-Za-z_][A-Za-z0-9_]*') -def _freeze(d): - """Return a hashable view of dict. - """ - if isinstance(d, string_types): - d = ParserHelper.from_string(d) - if isinstance(d, frozenset): - return d - return frozenset(d.items()) - - def _expression_to_function(eq): def func(ureg, value, **kwargs): return ureg.parse_expression(eq, value=value, **kwargs) diff --git a/pint/testsuite/test_contexts.py b/pint/testsuite/test_contexts.py index a84b654..cb54d55 100644 --- a/pint/testsuite/test_contexts.py +++ b/pint/testsuite/test_contexts.py @@ -6,7 +6,7 @@ import itertools from collections import defaultdict from pint import UnitRegistry -from pint.context import Context, _freeze +from pint.context import Context from pint.util import UnitsContainer from pint.testsuite import QuantityTestCase @@ -81,17 +81,6 @@ def add_sharedargdef_ctxs(ureg): class TestContexts(QuantityTestCase): - def test_freeze(self): - self.assertEqual(_freeze('meter'), frozenset([('meter', 1)])) - self.assertEqual(_freeze('meter/second'), frozenset((('meter', 1), ('second', -1)))) - x = frozenset((('meter', 1))) - self.assertIs(_freeze(x), x) - self.assertEqual(_freeze({'meter': 1}), - frozenset([('meter', 1)])) - self.assertEqual(_freeze({'meter': -1, 'second': -1}), - frozenset((('meter', -1), ('second', -1)))) - - def test_known_context(self): ureg = UnitRegistry() add_ctxs(ureg)