enhlib 0.0.1__tar.gz

enhlib-0.0.1/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.1
+Name: enhlib
+Version: 0.0.1
+Summary: Advanced Enumerations (compatible with Python's stdlib Enum), NamedTuples, and NamedConstants
+Home-page: https://github.com/ethanfurman/enhlib
+Author: Ethan Furman
+Author-email: ethan@stoneleaf.us
+License: BSD License
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3.3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Provides: enhlib
+
+Enhanced Library -- extras beyond Python's stdlib
+
+
+

enhlib-0.0.1/enhlib/__init__.py

@@ -0,0 +1 @@
+version = 0, 0, 1

enhlib-0.0.1/enhlib/collections.py

@@ -0,0 +1,448 @@
+from __future__ import division, print_function
+
+from collections import OrderedDict
+from .types import MISSING
+
+
+class AttrDict(object):
+    """
+    allows dictionary lookup using . notation
+    allows a default similar to defaultdict
+    iterations always ordered by key
+    """
+    _internal = ['_illegal', '_keys', '_values', '_default', '_ordered']
+    _default = None
+    _ordered = True
+    _illegal = ()
+    _values = {}
+    _keys = []
+
+    def __init__(self, *args, **kwds):
+        "kwds is evaluated last"
+        if 'default' in kwds:
+            self._default = kwds.pop('default')
+        self._ordered = True
+        self._keys = []
+        self._values = _values = {}
+        self._illegal = _illegal = tuple([attr for attr in dir(_values) if attr[0] != '_'])
+        if self._default is None:
+            default_factory = lambda : False
+        else:
+            default_factory = self._default
+        for arg in args:
+            # first, see if it's a lone string
+            if isinstance(arg, basestring):
+                arg = [(arg, default_factory())]
+            elif isinstance(arg, tuple):
+                # had better be (name, value)
+                arg = [arg, ]
+            # next, see if it's a mapping
+            elif hasattr(arg, 'items'):
+                new_arg = arg.items()
+                if isinstance(arg, OrderedDict):
+                    pass
+                elif isinstance(arg, AttrDict) and arg._ordered:
+                    pass
+                else:
+                    self._ordered = False
+                arg = new_arg
+            # now iterate over it
+            for item in arg:
+                if isinstance(item, basestring):
+                    key, value = item, default_factory()
+                else:
+                    key, value = item
+                if not isinstance(key, basestring):
+                    raise ValueError('keys must be strings, but %r is %r' % (key, type(key)))
+                if key in _illegal:
+                    raise ValueError('%r is a reserved word' % key)
+                _values[key] = value
+                if key not in self._keys:
+                    self._keys.append(key)
+        if kwds:
+            self._ordered = False
+            _values.update(kwds)
+            self._keys = list(set(self._keys + list(kwds.keys())))
+        assert set(self._keys) == set(self._values.keys()), "%r is not equal to %r" % (self._keys, self._values.keys())
+
+    def __contains__(self, key):
+        return key in self._values
+
+    def __delitem__(self, name):
+        if name[0] == '_':
+            raise KeyError("illegal key name: %r" % name)
+        if name not in self._values:
+            raise KeyError("%s: no such key" % name)
+        self._values.pop(name)
+        self._keys.remove(name)
+        assert set(self._keys) == set(self._values.keys())
+
+    def __delattr__(self, name):
+        if name[0] == '_':
+            raise AttributeError("illegal key name: %r" % name)
+        if name not in self._values:
+            raise AttributeError("%s: no such key" % name)
+        self._values.pop(name)
+        self._keys.remove(name)
+        assert set(self._keys) == set(self._values.keys())
+
+    def __hash__(self):
+        return hash(tuple(sorted(self._keys)))
+
+    def __eq__(self, other):
+        try:
+            if isinstance(other, AttrDict):
+                other = other._values
+            elif not isinstance(other, dict):
+                return NotImplemented
+            return other == self._values
+        except UnicodeWarning:
+            return False
+
+    def __ne__(self, other):
+        result = self == other
+        if result is NotImplemented:
+            return result
+        else:
+            return not result
+
+    def __getitem__(self, name):
+        if name in self._values:
+            return self._values[name]
+        elif self._default:
+            result = self._values[name] = self._default()
+            self._keys.append(name)
+            assert set(self._keys) == set(self._values.keys())
+            return result
+        else:
+            raise KeyError(name)
+
+    def __getattr__(self, name):
+        if name in self._values:
+            return self._values[name]
+        attr = getattr(self._values, name, None)
+        if attr is not None:
+            return attr
+        elif self._default:
+            result = self._values[name] = self._default()
+            self._keys.append(name)
+            assert set(self._keys) == set(self._values.keys())
+            return result
+        else:
+            raise AttributeError(name)
+
+    def __iter__(self):
+        if self._ordered:
+            return iter(self._keys)
+        else:
+            return iter(sorted(self._keys))
+
+    def __len__(self):
+        return len(self._values)
+
+    def __setitem__(self, name, value):
+        if name in self._internal:
+            object.__setattr__(self, name, value)
+        elif isinstance(name, basestring) and name[0:1] == name[-1:] == '_' and name not in ('__module__','__doc__'):
+            raise KeyError("illegal attribute name: %r" % name)
+        elif not isinstance(name, basestring):
+            raise ValueError('attribute names must be str, not %r' % type(name))
+        else:
+            if name not in self._keys:
+                self._keys.append(name)
+            self._values[name] = value
+        assert set(self._keys) == set(self._values.keys())
+
+    def __setattr__(self, name, value):
+        if name in self._internal:
+            object.__setattr__(self, name, value)
+        elif name in self._illegal or name[0:1] == name[-1:] == '_' and name not in ('__module__','__doc__'):
+            raise AttributeError("illegal attribute name: %r" % name)
+        elif not isinstance(name, basestring):
+            raise ValueError('attribute names must be str, not %r' % type(name))
+        else:
+            if name not in self._keys:
+                self._keys.append(name)
+            self._values[name] = value
+        assert set(self._keys) == set(self._values.keys()), "%r is not equal to %r" % (self._keys, self._values.keys())
+
+    def __repr__(self):
+        cls_name = self.__class__.__name__
+        if not self:
+            return "%s()" % cls_name
+        return "%s(%s)" % (cls_name, ', '.join(["%s=%r" % (k, self._values[k]) for k in self.keys()]))
+
+    def clear(self):
+        self._values.clear()
+        self._keys[:] = []
+        self._ordered = True
+        assert set(self._keys) == set(self._values.keys())
+
+    def copy(self):
+        result = self.__class__()
+        result._illegal = self._illegal
+        result._default = self._default
+        result._ordered = self._ordered
+        result._values.update(self._values.copy())
+        result._keys = self._keys[:]
+        return result
+
+    @classmethod
+    def fromkeys(cls, keys, value):
+        return cls([(k, value) for k in keys])
+
+    def items(self):
+        return [(k, self._values[k]) for k in self.keys()]
+
+    def keys(self):
+        if self._ordered:
+            return list(self._keys)
+        else:
+            return sorted(self._keys)
+
+    def pop(self, key, default=MISSING):
+        if default is MISSING:
+            value = self._values.pop(key)
+        else:
+            value = self._values.pop(key, default)
+        if key in self._keys:
+            self._keys.remove(key)
+        assert set(self._keys) == set(self._values.keys())
+        return value
+
+    def popitem(self):
+        k, v = self._values.popitem()
+        self._keys.remove(k)
+        assert set(self._keys) == set(self._values.keys())
+        return k, v
+
+    def setdefault(self, key, value=MISSING):
+        if key not in self._values:
+            self._keys.append(key)
+        if value is MISSING:
+            result = self._values.setdefault(key)
+        else:
+            result = self._values.setdefault(key, value)
+        assert set(self._keys) == set(self._values.keys())
+        return result
+
+    def update(self, items=(), **more_items):
+        before = len(self._values)
+        self._values.update(items, **more_items)
+        after = len(self._values)
+        if before != after:
+            self._keys = self._values.keys()
+            self._ordered = False
+        assert set(self._keys) == set(self._values.keys())
+
+    def updated(self, items=(), **more_items):
+        self.update(items, **more_items)
+        return self
+
+    def values(self):
+        return [self._values[k] for k in self.keys()]
+
+
+class BiDict(object):
+    """
+    key <=> value (value must also be hashable)
+    """
+
+    def __init__(self, *args, **kwargs):
+        _dict = self._dict = dict()
+        original_keys = self._primary_keys = list()
+        for k, v in args:
+            if k not in original_keys:
+                original_keys.append(k)
+            _dict[k] = v
+            if v != k and v in _dict:
+                raise ValueError("%s:%s violates one-to-one mapping" % (k, v))
+            _dict[v] = k
+        for key, value in kwargs.items():
+            if key not in original_keys:
+                original_keys.append(key)
+            _dict[key] = value
+            if value != key and value in _dict:
+                raise ValueError("%s:%s violates one-to-one mapping" % (key, value))
+            _dict[value] = key
+
+    def __contains__(self, key):
+        return key in self._dict
+
+    def __delitem__(self, key):
+        _dict = self._dict
+        value = _dict[key]
+        del _dict[value]
+        if key != value:
+            del _dict[key]
+        target = (key, value)[value in self._primary_keys]
+        self._primary_keys.pop(self._primary_keys.index(target))
+
+    def __getitem__(self, key):
+        return self._dict.__getitem__(key)
+
+    def __iter__(self):
+        return iter(self._primary_keys)
+
+    def __len__(self):
+        return len(self._primary_keys)
+
+    def __setitem__(self, key, value):
+        _dict = self._dict
+        original_keys = self._primary_keys
+        if key in _dict:
+            mapping = key, _dict[key]
+        else:
+            mapping = ()
+        if value in _dict and value not in mapping:
+            raise ValueError("%s:%s violates one-to-one mapping" % (key, value))
+        if mapping:
+            k, v = mapping
+            del _dict[k]
+            if k != v:
+                del _dict[v]
+            target = (k, v)[v in original_keys]
+            original_keys.pop(original_keys.index(target))
+        _dict[key] = value
+        _dict[value] = key
+        original_keys.append(key)
+
+    def __repr__(self):
+        result = []
+        for key in self._primary_keys:
+            result.append(repr((key, self._dict[key])))
+        return "BiDict(%s)" % ', '.join(result)
+
+    def keys(self):
+        return self._primary_keys[:]
+
+    def items(self):
+        return [(k, self._dict[k]) for k in self._primary_keys]
+
+    def values(self):
+        return [self._dict[key] for key in self._primary_keys]
+
+
+class TransformDict(dict):
+    '''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=MISSING):
+        '''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 MISSING:
+            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))
+
+

enhlib-0.0.1/enhlib/contextlib.py

@@ -0,0 +1,13 @@
+from __future__ import division, print_function
+
+
+class suppress(object):
+    "suppresses first execption and exits the with block"
+    def __init__(self, *exceptions):
+        self.exceptions = exceptions
+    def __enter__(self):
+        pass
+    def __exit__(self, etype, val, tb):
+        return etype is None or issubclass(etype, self.exceptions)
+
+

enhlib-0.0.1/enhlib/csv.py

@@ -0,0 +1,264 @@
+from __future__ import division, print_function
+
+from .collections import AttrDict
+from .dbf import Date, DateTime, Time
+from datetime import date, datetime, time
+
+import codecs
+
+enums = ()
+try:
+    import aenum as _aenum
+    enums += _aenum.Enum,
+except ImportError:
+    pass
+try:
+    import enum as _enum
+    enums += _enum.Enum,
+except ImportError:
+    pass
+
+dates = date, Date
+times = time, Time
+datetimes = datetime, DateTime
+moments = dates + times + datetimes
+
+class CSV(object):
+    """
+    represents a .csv file
+    """
+
+    def __init__(self, filename, mode='r', header=True, default_type=None, null=None):
+        if mode not in ('r','w'):
+            raise ValueError("mode must be 'r' or 'w', not %r" % (mode, ))
+        self.filename = filename
+        self.mode = mode
+        self.default_type = default_type
+        self.null = null
+        self.use_header = header
+        if mode == 'r':
+            with codecs.open(filename, mode='r', encoding='utf-8') as csv:
+                raw_data = csv.read().split('\n')
+            if header:
+                self.header = raw_data.pop(0).strip().split(',')
+            else:
+                self.header = []
+            self.data = [l.strip() for l in raw_data if l.strip()]
+        else:
+            self.header = []
+            self.data = []
+        if not header:
+            self.header = []
+
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        if args == (None, None, None) and self.mode == 'w':
+            self.save()
+
+    def __getitem__(self, index):
+        if isinstance(index, int):
+            return self.from_csv(self.data[index])
+        # better be a slice
+        lines = []
+        for line in self.data[index]:
+            lines.append(self.from_csv(line))
+        return lines
+
+    def __iter__(self):
+        """
+        returns data rows (not header)
+        """
+        for line in self.data:
+            yield self.from_csv(line)
+
+    def __len__(self):
+        return len(self.data)
+
+    def append(self, *values):
+        if isinstance(values[0], (list, tuple)):
+            values = tuple(values[0])
+        if self.header and len(values) != len(self.header):
+            raise ValueError('%d fields required, %d value(s) given' % (len(self.header), len(values)))
+        line = self.to_csv(*values)
+        new_values = self.from_csv(line)
+        if values != new_values:
+            print(len(values), len(new_values))
+            print(line)
+            print(values)
+            print(new_values)
+            raise ValueError
+        self.data.append(line)
+
+    def from_csv(self, line):
+        """
+        returns a tuple of converted data from `line`
+
+        supported types:
+
+        date        : nnnn-nn-nn
+        datetime    : nnnn-nn-nn nn:nn:nn
+        time        : nn:nn:nn
+        int         : non-quoted number with no fractions
+        float       : non-quoted number with fraction
+        bool        : true, yes, on, t / false, no, off, f
+        unicode     : "anything else"
+        """
+        # break line into fields
+        fields = []
+        word = []
+        encap = False
+        parens = 0
+        skip_next = False
+        keep_next = False
+        for i, ch in enumerate(line):
+            if skip_next:
+                skip_next = False
+                continue
+            elif keep_next:
+                keep_next = False
+                word.append(ch)
+                continue
+            elif encap:
+                if ch == '"' and line[i+1:i+2] == '"':
+                    word.append(ch)
+                    skip_next = True
+                elif ch =='"' and line[i+1:i+2] in ('', ','):
+                    word.append(ch)
+                    encap = False
+                elif ch == '\\':
+                    if line[i+1:i+2] == 'n':
+                        word.append('\n')
+                        skip_next = True
+                    else:
+                        keep_next = True
+                elif ch == '"':
+                    raise ValueError(
+                            'invalid char following ": <%s> (should be comma or double-quote)\n%r\n%s^'
+                            % (ch, line, ' ' * i)
+                            )
+                else:
+                    word.append(ch)
+            elif ch == '(':
+                word.append(ch)
+                parens += 1
+            elif ch == ')':
+                word.append(ch)
+                parens -= 1
+                if parens < 0:
+                    raise ValueError('unbalanced parentheses in:\n%r' % line)
+            else:
+                if ch == ',' and not parens:
+                    fields.append(''.join(word))
+                    word = []
+                elif ch == '"':
+                    if word: # embedded " are not allowed
+                        raise ValueError('embedded quotes not allowed:\n%s\n%s' % (line[:i], line))
+                    encap = True
+                    word.append(ch)
+                else:
+                    word.append(ch)
+        if parens:
+            raise ValueError('unbalanced parentheses in:\n%r' % line)
+        # don't lose last field!
+        fields.append(''.join(word))
+        #
+        # convert fields to their data types
+        final = []
+        for i, field in enumerate(fields):
+            try:
+                if not field:
+                    final.append(self.null)
+                elif field[0] == field[-1] == '"':
+                    # simple string
+                    final.append(field[1:-1])
+                elif field.lower() in ('true','yes','on','t'):
+                    final.append(True)
+                elif field.lower() in ('false','no','off','f'):
+                    final.append(False)
+                elif '-' in field and ':' in field:
+                    final.append(dates.str_to_datetime(field, localtime=False))
+                elif '-' in field:
+                    final.append(Date.strptime(field, '%Y-%m-%d'))
+                elif ':' in field:
+                    final.append(Time.strptime(field, '%H:%M:%S'))
+                elif 'Many2One' in field:
+                    final.append(eval(field))
+                elif 'Phone' in field:
+                    final.append(eval(field))
+                else:
+                    try:
+                        final.append(int(field))
+                    except ValueError:
+                        final.append(float(field))
+            except ValueError:
+                if self.default_type is not None:
+                    final.append(self.default_type(field))
+                else:
+                    ve = ValueError('unable to determine datatype of <%r>' % (field, ))
+                    ve.__cause__ = None
+                    raise ve
+        return tuple(final)
+
+    def iter_map(self, header=None):
+        header = self.header or header
+        if not header:
+            raise ValueError('header needed for iter_map()')
+        for record in self:
+            yield AttrDict(zip(self.header, record))
+
+    def save(self, filename=None):
+        if filename is None:
+            filename = self.filename
+        with codecs.open(filename, mode='w', encoding='utf-8') as csv:
+            if self.header:
+                # write the header
+                csv.write(','.join(self.header) + '\n')
+            # write the data
+            for line in self.data:
+                csv.write(line + '\n')
+
+    def to_csv(self, *data):
+        """
+        convert data to text and add to CSV.data
+
+        supported types:
+
+        unicode       : "str and unicode"
+        date          : nnnn-nn-nn
+        datetime      : nnnn-nn-nn nn:nn:nn
+        time          : nn:nn:nn
+        bool          : true, yes, on, t / false, no, off, f
+        anything else : repr()
+        """
+        line = []
+        for datum in data:
+            if datum is None or datum == '':
+                line.append('')
+            elif isinstance(datum, unicode):
+                datum = datum.replace('"','""').replace('\\','\\\\').replace('\n',r'\n')
+                line.append('"%s"' % datum)
+            elif isinstance(datum, dates.dates):
+                line.append(datum.strftime('%Y-%m-%d'))
+            elif isinstance(datum, dates.datetimes):
+                line.append(dates.datetime_to_str(datum))
+            elif isinstance(datum, dates.times):
+                line.append(datum.strftime('%H:%M:%S'))
+            elif isinstance(datum, bool):
+                line.append('ft'[datum])
+            elif isinstance(datum, SelectionEnum):
+                line.append(repr(datum.db))
+            elif isinstance(datum, enums):
+                line.append(repr(datum.value))
+            else:
+                line.append(repr(datum))
+        return ','.join(line)
+
+    def to_stream(self):
+        utf8 = codecs.getencoder('utf-8')
+        yield utf8(','.join(self.header) + '\n')
+        for line in self.data:
+            yield utf8(line + '\n')
+

enhlib-0.0.1/enhlib/functools.py

@@ -0,0 +1,66 @@
+from __future__ import division, print_function
+
+
+
+def nested_property(func):
+    """
+    make defining properties simpler (from Mike Muller) [fget, fset, fdel]
+
+    @nested_property
+    def value():
+        "doc string here"
+        def fget(self):
+            pass
+        def fset(self, value):
+            pass
+        return locals()
+    """
+    names = dict([(n, f) for n, f in func().items() if n in ('fset', 'fget', 'fdel')])
+    names['doc'] = func.__doc__
+    return property(**names)
+
+
+try:
+    from functools import simplegeneric
+except ImportError:
+
+    def simplegeneric(func):
+        """Make a trivial single-dispatch generic function (from Python3.4 functools)"""
+        registry = {}
+        def wrapper(*args, **kw):
+            ob = args[0]
+            try:
+                cls = ob.__class__
+            except AttributeError:
+                cls = type(ob)
+            try:
+                mro = cls.__mro__
+            except AttributeError:
+                try:
+                    class cls(cls, object):
+                        pass
+                    mro = cls.__mro__[1:]
+                except TypeError:
+                    mro = object,   # must be an ExtensionClass or some such  :(
+            for t in mro:
+                if t in registry:
+                    return registry[t](*args, **kw)
+            else:
+                return func(*args, **kw)
+        try:
+            wrapper.__name__ = func.__name__
+        except (TypeError, AttributeError):
+            pass    # Python 2.3 doesn't allow functions to be renamed
+
+        def register(typ, func=None):
+            if func is None:
+                return lambda f: register(typ, f)
+            registry[typ] = func
+            return func
+
+        wrapper.__dict__ = func.__dict__
+        wrapper.__doc__ = func.__doc__
+        wrapper.register = register
+        return wrapper
+
+

enhlib-0.0.1/enhlib/itertools.py

@@ -0,0 +1,153 @@
+from __future__ import division, print_function
+
+import sys
+sys
+
+def all_equal(iterator, test=None):
+    """
+    If test is None do a straight equality test.
+    """
+    it = iter(iterator)
+    if test is None:
+        try:
+            target = next(it)
+            test = lambda x: x == target
+        except StopIteration:
+            return True
+    return all(test(x) for x in it)
+
+
+class xrange(object):
+    """
+    Accepts arbitrary objects to use to produce sequence iterators.
+    """
+    def __init__(self, start, stop=None, step=None, count=None, epsilon=None):
+        """
+        range(7) -> start=0, stop=7, step=1, count=None
+        range(5, count=3) -> start=0, stop=5, step=1, count=3 (raises)
+        range(start=5, count=3) -> start=5, stop=None, step=1, count=3
+        range(1, 3, step=2) -> start=1, stop=3, step=2, count=None
+        """
+        if stop is None and count is None:
+            # `start` value is actually `stop`
+            start, stop = None, start
+        if count is not None and count < 0:
+            raise ValueError('count must be a non-negative number')
+        # valid combinations:
+        # start  stop  step  count    notes
+        #          x                  start=0, step=1
+        #          x     x            start=0, step=1
+        #   x                         step=1, infinite
+        #   x      x                  step=1
+        #   x            x            infinite
+        #   x                   x     step=1
+        #   x      x     x
+        #   x      x            x     step=1
+        #   x            x      x
+        #   x      x     x      x
+        #   
+        combo = [1 if a is not None else 0 for a in (start, stop, step, count)]
+        if combo not in (
+                [0, 1, 0, 0],
+                [0, 1, 1, 0],
+                [1, 0, 0, 0],
+                [1, 1, 0, 0],
+                [1, 0, 1, 0],
+                [1, 0, 0, 1],
+                [1, 1, 1, 0],
+                [1, 1, 0, 1],
+                [1, 0, 1, 1],
+                [1, 1, 1, 1],
+                ):
+            args = [name for (name, present) in zip(('start','stop','step','count'), combo) if present]
+            raise TypeError('invalid combination of arguments: %s' % ', '.join(args))
+        if start is not None:
+            ref = type(start)
+        else:
+            ref = type(stop)
+            start = ref(0)
+        if step is None:
+            try:
+                step = ref(1)
+                if stop is not None and stop < start:
+                    step = ref(-1)
+            except TypeError:
+                raise ValueError("step must be specified for type %r" % type(stop))
+        try:
+            if callable(step):
+                start + step(start, 1, start)
+            else:
+                start + step
+        except TypeError:
+            raise TypeError('unable to add %r to %r' % (step, start))
+        self.start = start
+        self.stop = stop
+        self.step = step
+        self.count = count
+        self.epsilon = epsilon
+        self.values = None
+
+    def __contains__(self, value):
+        if self.values is None:
+            self.values = list(self)
+        return value in self.values
+
+    def __iter__(self):
+        if self.values is not None:
+            return iter(self.values)
+        else:
+            return self._generate_values()
+
+    def __repr__(self):
+        values = []
+        if self.start:
+            values.append(repr(self.start))
+        if self.stop is not None:
+            values.append(repr(self.stop))
+        values.extend([
+                '%s=%r' % (k,v)
+                for k,v in (
+                    ('step', self.step),
+                    ('count', self.count),
+                    ('epsilon', self.epsilon),
+                    )
+                if v is not None
+                ])
+        return '%s(%s)' % (self.__class__.__name__, ', '.join(values))
+
+    def _generate_values(self):
+        start, stop, step, count, epsilon = self.start, self.stop, self.step, self.count, self.epsilon
+        i = -1
+        target = None
+        if stop is not None and epsilon is not None:
+            target = stop - epsilon, stop + epsilon
+        reverse = None
+        if stop is not None:
+            reverse = stop < start
+        while 'more values to yield':
+            if count is not None:
+                if count < 1:
+                    break
+                count -= 1
+            i += 1
+            if i == 0:
+                value = start
+            else:
+                if callable(step):
+                    value = step(start, i, value)
+                else:
+                    value = start + i * step
+            if stop is not None:
+                if value == stop:
+                    break
+                if reverse:
+                    if value <= stop:
+                        break
+                else:
+                    if value >= stop:
+                        break
+                if target is not None and target[0] <= value <= target[1]:
+                    break
+            yield value
+
+

enhlib-0.0.1/enhlib/random.py

@@ -0,0 +1,52 @@
+# adapted from https://discuss.python.org/t/finding-a-bloc-star-provider/73918/40
+#
+# Very simple 16-bit PRNG, self-contained, and needing nothing fancier
+# than 16x16->32 bit unsigned integer multiplication.
+#
+# We don't want much from this. After construction, 65536 consecutive
+# calls to .get() will deliver each of the 65536 possible results once
+# each, in a randomish order.
+
+BITS = 16
+PERIOD = 1 << BITS
+MASK = PERIOD - 1
+
+class TinyRand(object):
+    def __init__(self, seed=0):
+        self.seed(seed)
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        return self.get()
+    next == __next__
+
+    def seed(self, seed):
+        self.seed = seed & MASK
+
+    def get(self):
+        """Return a random iot in range(2**16).
+
+        The period is 2**16, and each posdible result appears once
+        across the period.
+        """
+
+        # At heart this is the ordinary LCG
+        #    state <- state * 43317 + 1 (modulo 2**16).
+        # It's strengthed a bit by returning the state xor'ed with a
+        # shifted copy of the state, a PCG-like trick that destroys the
+        # extreme regularity of the base LCG's low-order bits.
+        # 43317 came from a table of multipliers with "good" spectral
+        # scores,
+        self.seed = (self.seed * 43317 + 1) & MASK
+        return (self.seed >> 7) ^ self.seed
+
+if __name__ == '__main__':
+    from scription import *
+
+    for i in ViewProgress(range(PERIOD)):
+        t = TinyRand(seed=i)
+        full = {t.get() for i in range(PERIOD)}
+        assert len(full) == PERIOD, "failed with seed %s" % i
+

enhlib-0.0.1/enhlib/text.py

@@ -0,0 +1,42 @@
+from __future__ import division, print_function
+
+from .types import MISSING
+
+def translator(frm=u'', to=u'', delete=u'', keep=u'', strip=MISSING, compress=False):
+    # delete and keep are mutually exclusive
+    if delete and keep:
+        raise ValueError('cannot specify both keep and delete')
+    replacement = replacement_ord = None
+    if len(to) == 1:
+        if frm == u'':
+            replacement = to
+            replacement_ord = ord(to)
+            to = u''
+        else:
+            to = to * len(frm)
+    if len(to) != len(frm):
+        raise ValueError('frm and to should be equal lengths (or to should be a single character)')
+    uni_table = dict(
+            (ord(f), ord(t))
+            for f, t in zip(frm, to)
+            )
+    for ch in delete:
+        uni_table[ord(ch)] = None
+    def translate(s):
+        if isinstance(s, bytes):
+            s = s.decode('latin1')
+        s = s.translate(uni_table)
+        if keep:
+            remove_table = {}
+            for chr in set(s) - set(keep):
+                remove_table[ord(chr)] = replacement_ord
+            s = s.translate(remove_table)
+        if strip is not MISSING:
+            s = s.strip(strip)
+        if replacement and compress:
+            s = replacement.join([p for p in s.split(replacement) if p])
+        return s
+    return translate
+
+
+

enhlib-0.0.1/enhlib/types.py

@@ -0,0 +1,23 @@
+from __future__ import division, print_function
+
+
+class Sentinel(object):
+    """
+    When you have to be absolutely sure your object is unique.
+    """
+    def __init__(self, name, bool=None, doc=''):
+        self.name = name
+        self.__doc__ = doc
+        self.__bool = bool
+
+    def __repr__(self):
+        return "<%r>" % self.name
+
+    def __bool__(self):
+        if self.__bool is None:
+            raise NotImplementedError('Sentinel %r has no boolean value' % self.name)
+        return self.__bool
+    __nonzero__ = __bool__
+
+
+MISSING = Sentinel('MISSING', doc="argument not provided by caller")

enhlib-0.0.1/enhlib.egg-info/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.1
+Name: enhlib
+Version: 0.0.1
+Summary: Advanced Enumerations (compatible with Python's stdlib Enum), NamedTuples, and NamedConstants
+Home-page: https://github.com/ethanfurman/enhlib
+Author: Ethan Furman
+Author-email: ethan@stoneleaf.us
+License: BSD License
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3.3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Provides: enhlib
+
+Enhanced Library -- extras beyond Python's stdlib
+
+
+

enhlib-0.0.1/enhlib.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+setup.py
+enhlib/__init__.py
+enhlib/collections.py
+enhlib/contextlib.py
+enhlib/csv.py
+enhlib/functools.py
+enhlib/itertools.py
+enhlib/random.py
+enhlib/text.py
+enhlib/types.py
+enhlib.egg-info/PKG-INFO
+enhlib.egg-info/SOURCES.txt
+enhlib.egg-info/dependency_links.txt
+enhlib.egg-info/top_level.txt

enhlib-0.0.1/enhlib.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

enhlib-0.0.1/enhlib.egg-info/top_level.txt

@@ -0,0 +1 @@
+enhlib

enhlib-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

enhlib-0.0.1/setup.py

@@ -0,0 +1,72 @@
+try:
+    import setuptools
+except ImportError:
+    pass
+setuptools # keep pyflakes happy
+from distutils.core import setup
+import sys
+
+long_desc = '''\
+Enhanced Library -- extras beyond Python's stdlib
+
+'''
+
+data = dict(
+       name='enhlib',
+       version='0.0.1',
+       url='https://github.com/ethanfurman/enhlib',
+       packages=['enhlib'],
+       package_data={
+           'enhlib' : [
+               'LICENSE',
+               'README.md',
+               ]
+           },
+       include_package_data=True,
+       license='BSD License',
+       description="Advanced Enumerations (compatible with Python's stdlib Enum), NamedTuples, and NamedConstants",
+       long_description=long_desc,
+       provides=['enhlib'],
+       author='Ethan Furman',
+       author_email='ethan@stoneleaf.us',
+       classifiers=[
+            'Development Status :: 5 - Production/Stable',
+            'Intended Audience :: Developers',
+            'License :: OSI Approved :: BSD License',
+            'Programming Language :: Python',
+            'Topic :: Software Development',
+            'Programming Language :: Python :: 2.7',
+            'Programming Language :: Python :: 3.3',
+            'Programming Language :: Python :: 3.4',
+            'Programming Language :: Python :: 3.5',
+            'Programming Language :: Python :: 3.6',
+            'Programming Language :: Python :: 3.7',
+            'Programming Language :: Python :: 3.8',
+            'Programming Language :: Python :: 3.9',
+            'Programming Language :: Python :: 3.10',
+            'Programming Language :: Python :: 3.11',
+            'Programming Language :: Python :: 3.12',
+            'Programming Language :: Python :: 3.13',
+            ],
+    )
+
+py2_only = ()
+py3_only = ()
+make = [ ]
+
+if __name__ == '__main__':
+    if 'install' in sys.argv:
+        import os, sys
+        if sys.version_info[0] != 2:
+            for file in py2_only:
+                try:
+                    os.unlink(file)
+                except OSError:
+                    pass
+        if sys.version_info[0] != 3:
+            for file in py3_only:
+                try:
+                    os.unlink(file)
+                except OSError:
+                    pass
+    setup(**data)