Ticket #2365: DecimalField-FloatField.2.diff

django/oldforms/__init__.py

@@ -745 +745 @@
-            raise validators.CriticalValidationError, gettext("Enter a whole number between 0 and 32,767.")
-
-class FloatField(TextField):
+    def __init__(self, field_name, is_required=False, validator_list=None): 
+        if validator_list is None: validator_list = [] 
+        validator_list = [validators.isValidFloat] + validator_list 
+        TextField.__init__(self, field_name, is_required=is_required, validator_list=validator_list) 
+ 
+    def html2python(data): 
+        if data == '' or data is None: 
+            return None 
+        return float(data) 
+    html2python = staticmethod(html2python) 
+ 
+class DecimalField(TextField): 
-    def __init__(self, field_name, max_digits, decimal_places, is_required=False, validator_list=None):
-        if validator_list is None: validator_list = []
-        self.max_digits, self.decimal_places = max_digits, decimal_places
-
-
+
+
+
-
-Float(self, field_data, all_data):
-Float(self.max_digits, self.decimal_places)
+Decimal(self, field_data, all_data): 
+Decimal(self.max_digits, self.decimal_places) 
-        try:
-            v(field_data, all_data)
-        except validators.ValidationError, e:
@@ -761 +774 @@
-    def html2python(data):
-        if data == '' or data is None:
-            return None
-
+
+
+
+
+
+
+
+
-    html2python = staticmethod(html2python)
-
-####################

django/db/models/fields/__init__.py

@@ -668 +668 @@
-    def get_manipulator_field_objs(self):
-        return [curry(oldforms.FilePathField, path=self.path, match=self.match, recursive=self.recursive)]
-
-Float
+Decimal
-    empty_strings_allowed = False
-    def __init__(self, verbose_name=None, name=None, max_digits=None, decimal_places=None, **kwargs):
-        self.max_digits, self.decimal_places = max_digits, decimal_places
-        Field.__init__(self, verbose_name, name, **kwargs)
-
+    def to_python(self, value):
+        try:
+            import decimal
+        except ImportError:
+            from django.utils import decimal
+        try:
+            return decimal.Decimal(value)
+        except (decimal.InvalidOperation):
+            raise validators.ValidationError, gettext("This value must be a decimal number.")
+
+    def _format(self, value):
+        if isinstance(value, basestring):
+            return value
+        else:
+            return self.format_number(value)
+    
+    def format_number(self, value):
+        """Formats a number into a string with the requisite number of digits and decimal places."""
+        
+        num_chars = self.max_digits
+        # Allow for a decimal point 
+        if self.decimal_places > 0:
+            num_chars += 1
+        # Allow for a minus sign
+        if value < 0:
+            num_chars += 1
+        
+        return "%.*f" % (self.decimal_places, value)
+
+    def get_db_prep_save(self, value):
+        value = value # self._format(value)
+        return super(DecimalField, self).get_db_prep_save(value)
+
+    def get_db_prep_lookup(self, lookup_type, value):
+        if lookup_type == 'range':
+            value = [self._format(v) for v in value]
+        else:
+            value = self._format(value)
+        return super(DecimalField, self).get_db_prep_lookup(lookup_type, value)
+
-    def get_manipulator_field_objs(self):
-Float
+Decimal
-
+    def formfield(self, **kwargs):
+        "Returns a django.newforms.Field instance for this database Field."
+        defaults = {'required': not self.blank, 'label': capfirst(self.verbose_name),
+            'max_digits': self.max_digits, 'decimal_places': self.decimal_places}
+        defaults.update(kwargs)
+        return forms.DecimalField(**defaults)
+
+class FloatField(Field):
+    empty_strings_allowed = False
+    def __init__(self, verbose_name=None, name=None, **kwargs):
+        Field.__init__(self, verbose_name, name, **kwargs)
+
+    def get_manipulator_field_objs(self):
+        return [oldforms.FloatField]
+
+    def formfield(self, **kwargs):
+        "Returns a django.newforms.FloatField instance for this database Field."
+        defaults = {'required': not self.blank, 'label': capfirst(self.verbose_name)}
+        defaults.update(kwargs)
+        return forms.FloatField(**defaults)
+
-class ImageField(FileField):
-    def __init__(self, verbose_name=None, name=None, width_field=None, height_field=None, **kwargs):
-        self.width_field, self.height_field = width_field, height_field

django/db/backends/ado_mssql/creation.py

@@ -5 +5 @@
-    'CommaSeparatedIntegerField': 'varchar(%(maxlength)s)',
-    'DateField':         'smalldatetime',
-    'DateTimeField':     'smalldatetime',
+    'DecimalField':      'numeric(%(max_digits)s, %(decimal_places)s)',
-    'FileField':         'varchar(100)',
-    'FilePathField':     'varchar(100)',
-numeric(%(max_digits)s, %(decimal_places)s)
+double precision
-    'ImageField':        'varchar(100)',
-    'IntegerField':      'int',
-    'IPAddressField':    'char(15)',

django/db/backends/postgresql/introspection.py

@@ -79 +79 @@
-    1114: 'DateTimeField',
-    1184: 'DateTimeField',
-    1266: 'TimeField',
-Float
+Decimal
-}

django/db/backends/postgresql/creation.py

@@ -9 +9 @@
-    'CommaSeparatedIntegerField': 'varchar(%(maxlength)s)',
-    'DateField':         'date',
-    'DateTimeField':     'timestamp with time zone',
+    'DecimalField':      'numeric(%(max_digits)s, %(decimal_places)s)',
-    'FileField':         'varchar(100)',
-    'FilePathField':     'varchar(100)',
-numeric(%(max_digits)s, %(decimal_places)s)
+double precision
-    'ImageField':        'varchar(100)',
-    'IntegerField':      'integer',
-    'IPAddressField':    'inet',

django/db/backends/sqlite3/base.py

@@ -17 +17 @@
-        module = 'sqlite3'
-    raise ImproperlyConfigured, "Error loading %s module: %s" % (module, e)
-
+try:
+    # Only exists in Python 2.4+
+    import decimal
+except ImportError:
+    # Import copy of decimal.py from Python 2.4
+    from django.utils import decimal
+
-DatabaseError = Database.DatabaseError
-
-Database.register_converter("bool", lambda s: str(s) == '1')
@@ -25 +32 @@
-Database.register_converter("datetime", util.typecast_timestamp)
-Database.register_converter("timestamp", util.typecast_timestamp)
-Database.register_converter("TIMESTAMP", util.typecast_timestamp)
+Database.register_converter("decimal", util.typecast_decimal)
+Database.register_adapter(decimal.Decimal, util.rev_typecast_decimal)
-
-def utf8rowFactory(cursor, row):
-    def utf8(s):

django/db/backends/sqlite3/creation.py

@@ -8 +8 @@
-    'CommaSeparatedIntegerField':   'varchar(%(maxlength)s)',
-    'DateField':                    'date',
-    'DateTimeField':                'datetime',
+    'DecimalField':                 'decimal',
-    'FileField':                    'varchar(100)',
-    'FilePathField':                'varchar(100)',
-numeric(%(max_digits)s, %(decimal_places)s)
+real
-    'ImageField':                   'varchar(100)',
-    'IntegerField':                 'integer',
-    'IPAddressField':               'char(15)',

django/db/backends/util.py

@@ -1 +1 @@
-import datetime
-from time import time
-
+try:
+    # Only exists in Python 2.4+
+    import decimal
+except ImportError:
+    # Import copy of decimal.py from Python 2.4
+    from django.utils import decimal
+
-class CursorDebugWrapper(object):
-    def __init__(self, cursor, db):
-        self.cursor = cursor
@@ -85 +92 @@
-    if not s: return False
-    return str(s)[0].lower() == 't'
-
+def typecast_decimal(s):
+    if s is None: return None
+    return decimal.Decimal(s)
+
-###############################################
-# Converters from Python to database (string) #
-###############################################
@@ -92 +103 @@
-def rev_typecast_boolean(obj, d):
-    return obj and '1' or '0'
-
+def rev_typecast_decimal(d):
+    if d is None: return None
+    return str(d)
+
-##################################################################################
-# Helper functions for dictfetch* for databases that don't natively support them #
-##################################################################################

django/db/backends/mysql/base.py

@@ -23 +23 @@
-    FIELD_TYPE.DATETIME: util.typecast_timestamp,
-    FIELD_TYPE.DATE: util.typecast_date,
-    FIELD_TYPE.TIME: util.typecast_time,
+    FIELD_TYPE.DECIMAL: util.typecast_decimal,
-})
-
-# This should match the numerical portion of the version numbers (we can treat

django/db/backends/mysql/introspection.py

@@ -76 +76 @@
-DATA_TYPES_REVERSE = {
-    FIELD_TYPE.BLOB: 'TextField',
-    FIELD_TYPE.CHAR: 'CharField',
-Float
+Decimal
-    FIELD_TYPE.DATE: 'DateField',
-    FIELD_TYPE.DATETIME: 'DateTimeField',
-    FIELD_TYPE.DOUBLE: 'FloatField',

django/db/backends/mysql/creation.py

@@ -9 +9 @@
-    'CommaSeparatedIntegerField': 'varchar(%(maxlength)s)',
-    'DateField':         'date',
-    'DateTimeField':     'datetime',
+    'DecimalField':      'decimal(%(max_digits)s, %(decimal_places)s)',
-    'FileField':         'varchar(100)',
-    'FilePathField':     'varchar(100)',
-numeric(%(max_digits)s, %(decimal_places)s)
+double precision
-    'ImageField':        'varchar(100)',
-    'IntegerField':      'integer',
-    'IPAddressField':    'char(15)',

django/db/backends/oracle/introspection.py

@@ -46 +46 @@
-    1114: 'DateTimeField',
-    1184: 'DateTimeField',
-    1266: 'TimeField',
-Float
+Decimal
-}

django/db/backends/oracle/creation.py

@@ -5 +5 @@
-    'CommaSeparatedIntegerField': 'varchar2(%(maxlength)s)',
-    'DateField':         'date',
-    'DateTimeField':     'date',
+    'DecimalField':      'number(%(max_digits)s, %(decimal_places)s)',
-    'FileField':         'varchar2(100)',
-    'FilePathField':     'varchar2(100)',
-number(%(max_digits)s, %(decimal_places)s)
+double precision
-    'ImageField':        'varchar2(100)',
-    'IntegerField':      'integer',
-    'IPAddressField':    'char(15)',

django/db/backends/postgresql_psycopg2/introspection.py

@@ -79 +79 @@
-    1114: 'DateTimeField',
-    1184: 'DateTimeField',
-    1266: 'TimeField',
-Float
+Decimal
-}

django/core/validators.py

@@ -25 +25 @@
-    r"(^[-!#$%&'*+/=?^_`{}|~0-9A-Z]+(\.[-!#$%&'*+/=?^_`{}|~0-9A-Z]+)*"  # dot-atom
-    r'|^"([\001-\010\013\014\016-\037!#-\[\]-\177]|\\[\001-011\013\014\016-\177])*"' # quoted-string
-    r')@(?:[A-Z0-9-]+\.)+[A-Z]{2,6}$', re.IGNORECASE)  # domain
+decimal_re = re.compile(r'^-?(?P<digits>\d+)(\.(?P<decimals>\d+))?$')
-integer_re = re.compile(r'^-?\d+$')
-ip4_re = re.compile(r'^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$')
-phone_re = re.compile(r'^[A-PR-Y0-9]{3}-[A-PR-Y0-9]{3}-[A-PR-Y0-9]{4}$', re.IGNORECASE)
@@ -403 +404 @@
-        if val != int(val):
-            raise ValidationError, gettext("This value must be a power of %s.") % self.power_of
-
-Float
+Decimal
-    def __init__(self, max_digits, decimal_places):
-        self.max_digits, self.decimal_places = max_digits, decimal_places
-
-    def __call__(self, field_data, all_data):
-
-
-
-
+
+
-            raise ValidationError, gettext("Please enter a valid decimal number.")
-
-
-
+
+
+
+
+
-            raise ValidationError, ngettext("Please enter a valid decimal number with at most %s total digit.",
-                "Please enter a valid decimal number with at most %s total digits.", self.max_digits) % self.max_digits
-(not '.' in data and len(data) > (max_allowed_length - self.decimal_places - 1)) or ('.' in data and len(data) > (max_allowed_length - (self.decimal_places - len(data.split('.')[1])))
+digits > (self.max_digits - self.decimal_places
-            raise ValidationError, ngettext( "Please enter a valid decimal number with a whole part of at most %s digit.",
-                "Please enter a valid decimal number with a whole part of at most %s digits.", str(self.max_digits-self.decimal_places)) % str(self.max_digits-self.decimal_places)
-'.' in data and len(data.split('.')[1])
+decimals
-            raise ValidationError, ngettext("Please enter a valid decimal number with at most %s decimal place.",
-                "Please enter a valid decimal number with at most %s decimal places.", self.decimal_places) % self.decimal_places
-
+def isValidFloat(field_data, all_data):
+    data = str(field_data)
+    try:
+        float(data)
+    except ValueError:
+        raise ValidationError, gettext("Please enter a valid floating point number.")
+
-class HasAllowableSize(object):
-    """
-    Checks that the file-upload field data is a certain size. min_size and

django/core/management.py

@@ -804 +804 @@
-                if field_type == 'CharField' and row[3]:
-                    extra_params['maxlength'] = row[3]
-
-Float
+Decimal
-                    extra_params['max_digits'] = row[4]
-                    extra_params['decimal_places'] = row[5]
-
@@ -879 +879 @@
-                e.add(opts, '"%s": You can\'t use "id" as a field name, because each model automatically gets an "id" field if none of the fields have primary_key=True. You need to either remove/rename your "id" field or add primary_key=True to a field.' % f.name)
-            if isinstance(f, models.CharField) and f.maxlength in (None, 0):
-                e.add(opts, '"%s": CharFields require a "maxlength" attribute.' % f.name)
-Float
+Decimal
-                if f.decimal_places is None:
-Float
+Decimal
-                if f.max_digits is None:
-Float
+Decimal
-            if isinstance(f, models.FileField) and not f.upload_to:
-                e.add(opts, '"%s": FileFields require an "upload_to" attribute.' % f.name)
-            if isinstance(f, models.ImageField):

django/newforms/fields.py

@@ -17 +17 @@
-    'RegexField', 'EmailField', 'URLField', 'BooleanField',
-    'ChoiceField', 'NullBooleanField', 'MultipleChoiceField',
-    'ComboField', 'MultiValueField',
+    'FloatField', 'DecimalField',
-    'SplitDateTimeField',
-)
-
@@ -28 +29 @@
-except NameError:
-    from sets import Set as set # Python 2.3 fallback
-
+try:
+    from decimal import Decimal # Only available in Python 2.4+
+except ImportError:
+    from django.utils.decimal import Decimal # Use bundled version for Python 2.3
+
-class Field(object):
-    widget = TextInput # Default widget to use when rendering this type of Field.
-    hidden_widget = HiddenInput # Default widget to use when rendering this as "hidden".
@@ -128 +134 @@
-            raise ValidationError(gettext(u'Ensure this value is greater than or equal to %s.') % self.min_value)
-        return value
-
+class FloatField(Field):
+    def __init__(self, max_value=None, min_value=None, required=True, widget=None, label=None, initial=None):
+        self.max_value, self.min_value = max_value, min_value
+        Field.__init__(self, required, widget, label, initial)
+        
+    def clean(self, value):
+        """
+        Validates that float() can be called on the input. Returns a float.
+        Returns None for empty values.
+        """
+        super(FloatField, self).clean(value)
+        if not self.required and value in EMPTY_VALUES:
+            return None
+        try:
+            value = float(value)
+        except (ValueError, TypeError):
+            raise ValidationError(gettext(u'Enter a number.'))
+        if self.max_value is not None and value > self.max_value:
+            raise ValidationError(gettext(u'Ensure this value is less than or equal to %s.') % self.max_value)
+        if self.min_value is not None and value < self.min_value:
+            raise ValidationError(gettext(u'Ensure this value is greater than or equal to %s.') % self.min_value)
+        return value
+
+decimal_re = re.compile(r'^-?(?P<digits>\d+)(\.(?P<decimals>\d+))?$')
+
+class DecimalField(Field):
+    def __init__(self, max_value=None, min_value=None, max_digits=None, decimal_places=None, required=True, widget=None, label=None, initial=None):
+        self.max_value, self.min_value = max_value, min_value
+        self.max_digits, self.decimal_places = max_digits, decimal_places
+        Field.__init__(self, required, widget, label, initial)
+        
+    def clean(self, value):
+        """
+        Validates that the input is a decimal number. Returns a decimal.Decimal
+        instance. Returns None for empty values. Ensures that there are no more
+        than max_digits in the number, and no more than decimal_places digits
+        after the decimal point.
+        """
+        super(DecimalField, self).clean(value)
+        if not self.required and value in EMPTY_VALUES:
+            return None
+        value = value.strip()
+        match = decimal_re.search(value)
+        if not match:
+            raise ValidationError(gettext(u'Enter a number.'))
+        else:
+            value = Decimal(value)
+        digits = len(match.group('digits') or '')
+        decimals = len(match.group('decimals') or '')
+        if self.max_value is not None and value > self.max_value:
+            raise ValidationError(gettext(u'Ensure this value is less than or equal to %s.') % self.max_value)
+        if self.min_value is not None and value < self.min_value:
+            raise ValidationError(gettext(u'Ensure this value is greater than or equal to %s.') % self.min_value)
+        if self.max_digits is not None and (digits + decimals) > self.max_digits:
+            raise ValidationError(gettext(u'Ensure that there are no more than %s digits in total.') % self.max_digits)
+        if self.decimal_places is not None and decimals > self.decimal_places:
+            raise ValidationError(gettext(u'Ensure that there are no more than %s decimal places.') % self.decimal_places)
+        if self.max_digits is not None and self.decimal_places is not None and digits > (self.max_digits - self.decimal_places):
+            raise ValidationError(gettext(u'Ensure that there are no more than %s digits before the decimal point.') % (self.max_digits - self.decimal_places))
+        return value
+
-DEFAULT_DATE_INPUT_FORMATS = (
-    '%Y-%m-%d', '%m/%d/%Y', '%m/%d/%y', # '2006-10-25', '10/25/2006', '10/25/06'
-    '%b %d %Y', '%b %d, %Y',            # 'Oct 25 2006', 'Oct 25, 2006'

django/contrib/admin/templatetags/admin_list.py

@@ -157 +157 @@
-            # Booleans are special: We use images.
-            elif isinstance(f, models.BooleanField) or isinstance(f, models.NullBooleanField):
-                result_repr = _boolean_icon(field_val)
-Float
-Float
+Decimal
+Decimal
-                if field_val is not None:
-                    result_repr = ('%%.%sf' % f.decimal_places) % field_val
-                else:

django/contrib/admin/views/doc.py

@@ -294 +294 @@
-    'CommaSeparatedIntegerField': _('Comma-separated integers'),
-    'DateField'                 : _('Date (without time)'),
-    'DateTimeField'             : _('Date (with time)'),
+    'DecimalField'              : _('Decimal number'),
-    'EmailField'                : _('E-mail address'),
-    'FileField'                 : _('File path'),
-    'FilePathField'             : _('File path'),
-Decimal
+Floating point
-    'ForeignKey'                : _('Integer'),
-    'ImageField'                : _('File path'),
-    'IntegerField'              : _('Integer'),

django/utils/decimal.py

@@ +1 @@
+# Copyright (c) 2004 Python Software Foundation.
+# All rights reserved.
+
+# Written by Eric Price <eprice at tjhsst.edu>
+#    and Facundo Batista <facundo at taniquetil.com.ar>
+#    and Raymond Hettinger <python at rcn.com>
+#    and Aahz <aahz at pobox.com>
+#    and Tim Peters
+
+# This module is currently Py2.3 compatible and should be kept that way
+# unless a major compelling advantage arises.  IOW, 2.3 compatibility is
+# strongly preferred, but not guaranteed.
+
+# Also, this module should be kept in sync with the latest updates of
+# the IBM specification as it evolves.  Those updates will be treated
+# as bug fixes (deviation from the spec is a compatibility, usability
+# bug) and will be backported.  At this point the spec is stabilizing
+# and the updates are becoming fewer, smaller, and less significant.
+
+"""
+This is a Py2.3 implementation of decimal floating point arithmetic based on
+the General Decimal Arithmetic Specification:
+
+    www2.hursley.ibm.com/decimal/decarith.html
+
+and IEEE standard 854-1987:
+
+    www.cs.berkeley.edu/~ejr/projects/754/private/drafts/854-1987/dir.html
+
+Decimal floating point has finite precision with arbitrarily large bounds.
+
+The purpose of the module is to support arithmetic using familiar
+"schoolhouse" rules and to avoid the some of tricky representation
+issues associated with binary floating point.  The package is especially
+useful for financial applications or for contexts where users have
+expectations that are at odds with binary floating point (for instance,
+in binary floating point, 1.00 % 0.1 gives 0.09999999999999995 instead
+of the expected Decimal("0.00") returned by decimal floating point).
+
+Here are some examples of using the decimal module:
+
+>>> from decimal import *
+>>> setcontext(ExtendedContext)
+>>> Decimal(0)
+Decimal("0")
+>>> Decimal("1")
+Decimal("1")
+>>> Decimal("-.0123")
+Decimal("-0.0123")
+>>> Decimal(123456)
+Decimal("123456")
+>>> Decimal("123.45e12345678901234567890")
+Decimal("1.2345E+12345678901234567892")
+>>> Decimal("1.33") + Decimal("1.27")
+Decimal("2.60")
+>>> Decimal("12.34") + Decimal("3.87") - Decimal("18.41")
+Decimal("-2.20")
+>>> dig = Decimal(1)
+>>> print dig / Decimal(3)
+0.333333333
+>>> getcontext().prec = 18
+>>> print dig / Decimal(3)
+0.333333333333333333
+>>> print dig.sqrt()
+1
+>>> print Decimal(3).sqrt()
+1.73205080756887729
+>>> print Decimal(3) ** 123
+4.85192780976896427E+58
+>>> inf = Decimal(1) / Decimal(0)
+>>> print inf
+Infinity
+>>> neginf = Decimal(-1) / Decimal(0)
+>>> print neginf
+-Infinity
+>>> print neginf + inf
+NaN
+>>> print neginf * inf
+-Infinity
+>>> print dig / 0
+Infinity
+>>> getcontext().traps[DivisionByZero] = 1
+>>> print dig / 0
+Traceback (most recent call last):
+  ...
+  ...
+  ...
+DivisionByZero: x / 0
+>>> c = Context()
+>>> c.traps[InvalidOperation] = 0
+>>> print c.flags[InvalidOperation]
+0
+>>> c.divide(Decimal(0), Decimal(0))
+Decimal("NaN")
+>>> c.traps[InvalidOperation] = 1
+>>> print c.flags[InvalidOperation]
+1
+>>> c.flags[InvalidOperation] = 0
+>>> print c.flags[InvalidOperation]
+0
+>>> print c.divide(Decimal(0), Decimal(0))
+Traceback (most recent call last):
+  ...
+  ...
+  ...
+InvalidOperation: 0 / 0
+>>> print c.flags[InvalidOperation]
+1
+>>> c.flags[InvalidOperation] = 0
+>>> c.traps[InvalidOperation] = 0
+>>> print c.divide(Decimal(0), Decimal(0))
+NaN
+>>> print c.flags[InvalidOperation]
+1
+>>>
+"""
+
+__all__ = [
+    # Two major classes
+    'Decimal', 'Context',
+
+    # Contexts
+    'DefaultContext', 'BasicContext', 'ExtendedContext',
+
+    # Exceptions
+    'DecimalException', 'Clamped', 'InvalidOperation', 'DivisionByZero',
+    'Inexact', 'Rounded', 'Subnormal', 'Overflow', 'Underflow',
+
+    # Constants for use in setting up contexts
+    'ROUND_DOWN', 'ROUND_HALF_UP', 'ROUND_HALF_EVEN', 'ROUND_CEILING',
+    'ROUND_FLOOR', 'ROUND_UP', 'ROUND_HALF_DOWN',
+
+    # Functions for manipulating contexts
+    'setcontext', 'getcontext'
+]
+
+import copy
+
+#Rounding
+ROUND_DOWN = 'ROUND_DOWN'
+ROUND_HALF_UP = 'ROUND_HALF_UP'
+ROUND_HALF_EVEN = 'ROUND_HALF_EVEN'
+ROUND_CEILING = 'ROUND_CEILING'
+ROUND_FLOOR = 'ROUND_FLOOR'
+ROUND_UP = 'ROUND_UP'
+ROUND_HALF_DOWN = 'ROUND_HALF_DOWN'
+
+#Rounding decision (not part of the public API)
+NEVER_ROUND = 'NEVER_ROUND'    # Round in division (non-divmod), sqrt ONLY
+ALWAYS_ROUND = 'ALWAYS_ROUND'  # Every operation rounds at end.
+
+#Errors
+
+class DecimalException(ArithmeticError):
+    """Base exception class.
+
+    Used exceptions derive from this.
+    If an exception derives from another exception besides this (such as
+    Underflow (Inexact, Rounded, Subnormal) that indicates that it is only
+    called if the others are present.  This isn't actually used for
+    anything, though.
+
+    handle  -- Called when context._raise_error is called and the
+               trap_enabler is set.  First argument is self, second is the
+               context.  More arguments can be given, those being after
+               the explanation in _raise_error (For example,
+               context._raise_error(NewError, '(-x)!', self._sign) would
+               call NewError().handle(context, self._sign).)
+
+    To define a new exception, it should be sufficient to have it derive
+    from DecimalException.
+    """
+    def handle(self, context, *args):
+        pass
+
+
+class Clamped(DecimalException):
+    """Exponent of a 0 changed to fit bounds.
+
+    This occurs and signals clamped if the exponent of a result has been
+    altered in order to fit the constraints of a specific concrete
+    representation. This may occur when the exponent of a zero result would
+    be outside the bounds of a representation, or  when a large normal
+    number would have an encoded exponent that cannot be represented. In
+    this latter case, the exponent is reduced to fit and the corresponding
+    number of zero digits are appended to the coefficient ("fold-down").
+    """
+
+
+class InvalidOperation(DecimalException):
+    """An invalid operation was performed.
+
+    Various bad things cause this:
+
+    Something creates a signaling NaN
+    -INF + INF
+     0 * (+-)INF
+     (+-)INF / (+-)INF
+    x % 0
+    (+-)INF % x
+    x._rescale( non-integer )
+    sqrt(-x) , x > 0
+    0 ** 0
+    x ** (non-integer)
+    x ** (+-)INF
+    An operand is invalid
+    """
+    def handle(self, context, *args):
+        if args:
+            if args[0] == 1: #sNaN, must drop 's' but keep diagnostics
+                return Decimal( (args[1]._sign, args[1]._int, 'n') )
+        return NaN
+
+class ConversionSyntax(InvalidOperation):
+    """Trying to convert badly formed string.
+
+    This occurs and signals invalid-operation if an string is being
+    converted to a number and it does not conform to the numeric string
+    syntax. The result is [0,qNaN].
+    """
+
+    def handle(self, context, *args):
+        return (0, (0,), 'n') #Passed to something which uses a tuple.
+
+class DivisionByZero(DecimalException, ZeroDivisionError):
+    """Division by 0.
+
+    This occurs and signals division-by-zero if division of a finite number
+    by zero was attempted (during a divide-integer or divide operation, or a
+    power operation with negative right-hand operand), and the dividend was
+    not zero.
+
+    The result of the operation is [sign,inf], where sign is the exclusive
+    or of the signs of the operands for divide, or is 1 for an odd power of
+    -0, for power.
+    """
+
+    def handle(self, context, sign, double = None, *args):
+        if double is not None:
+            return (Infsign[sign],)*2
+        return Infsign[sign]
+
+class DivisionImpossible(InvalidOperation):
+    """Cannot perform the division adequately.
+
+    This occurs and signals invalid-operation if the integer result of a
+    divide-integer or remainder operation had too many digits (would be
+    longer than precision). The result is [0,qNaN].
+    """
+
+    def handle(self, context, *args):
+        return (NaN, NaN)
+
+class DivisionUndefined(InvalidOperation, ZeroDivisionError):
+    """Undefined result of division.
+
+    This occurs and signals invalid-operation if division by zero was
+    attempted (during a divide-integer, divide, or remainder operation), and
+    the dividend is also zero. The result is [0,qNaN].
+    """
+
+    def handle(self, context, tup=None, *args):
+        if tup is not None:
+            return (NaN, NaN) #for 0 %0, 0 // 0
+        return NaN
+
+class Inexact(DecimalException):
+    """Had to round, losing information.
+
+    This occurs and signals inexact whenever the result of an operation is
+    not exact (that is, it needed to be rounded and any discarded digits
+    were non-zero), or if an overflow or underflow condition occurs. The
+    result in all cases is unchanged.
+
+    The inexact signal may be tested (or trapped) to determine if a given
+    operation (or sequence of operations) was inexact.
+    """
+    pass
+
+class InvalidContext(InvalidOperation):
+    """Invalid context.  Unknown rounding, for example.
+
+    This occurs and signals invalid-operation if an invalid context was
+    detected during an operation. This can occur if contexts are not checked
+    on creation and either the precision exceeds the capability of the
+    underlying concrete representation or an unknown or unsupported rounding
+    was specified. These aspects of the context need only be checked when
+    the values are required to be used. The result is [0,qNaN].
+    """
+
+    def handle(self, context, *args):
+        return NaN
+
+class Rounded(DecimalException):
+    """Number got rounded (not  necessarily changed during rounding).
+
+    This occurs and signals rounded whenever the result of an operation is
+    rounded (that is, some zero or non-zero digits were discarded from the
+    coefficient), or if an overflow or underflow condition occurs. The
+    result in all cases is unchanged.
+
+    The rounded signal may be tested (or trapped) to determine if a given
+    operation (or sequence of operations) caused a loss of precision.
+    """
+    pass
+
+class Subnormal(DecimalException):
+    """Exponent < Emin before rounding.
+
+    This occurs and signals subnormal whenever the result of a conversion or
+    operation is subnormal (that is, its adjusted exponent is less than
+    Emin, before any rounding). The result in all cases is unchanged.
+
+    The subnormal signal may be tested (or trapped) to determine if a given
+    or operation (or sequence of operations) yielded a subnormal result.
+    """
+    pass
+
+class Overflow(Inexact, Rounded):
+    """Numerical overflow.
+
+    This occurs and signals overflow if the adjusted exponent of a result
+    (from a conversion or from an operation that is not an attempt to divide
+    by zero), after rounding, would be greater than the largest value that
+    can be handled by the implementation (the value Emax).
+
+    The result depends on the rounding mode:
+
+    For round-half-up and round-half-even (and for round-half-down and
+    round-up, if implemented), the result of the operation is [sign,inf],
+    where sign is the sign of the intermediate result. For round-down, the
+    result is the largest finite number that can be represented in the
+    current precision, with the sign of the intermediate result. For
+    round-ceiling, the result is the same as for round-down if the sign of
+    the intermediate result is 1, or is [0,inf] otherwise. For round-floor,
+    the result is the same as for round-down if the sign of the intermediate
+    result is 0, or is [1,inf] otherwise. In all cases, Inexact and Rounded
+    will also be raised.
+   """
+
+    def handle(self, context, sign, *args):
+        if context.rounding in (ROUND_HALF_UP, ROUND_HALF_EVEN,
+                                     ROUND_HALF_DOWN, ROUND_UP):
+            return Infsign[sign]
+        if sign == 0:
+            if context.rounding == ROUND_CEILING:
+                return Infsign[sign]
+            return Decimal((sign, (9,)*context.prec,
+                            context.Emax-context.prec+1))
+        if sign == 1:
+            if context.rounding == ROUND_FLOOR:
+                return Infsign[sign]
+            return Decimal( (sign, (9,)*context.prec,
+                             context.Emax-context.prec+1))
+
+
+class Underflow(Inexact, Rounded, Subnormal):
+    """Numerical underflow with result rounded to 0.
+
+    This occurs and signals underflow if a result is inexact and the
+    adjusted exponent of the result would be smaller (more negative) than
+    the smallest value that can be handled by the implementation (the value
+    Emin). That is, the result is both inexact and subnormal.
+
+    The result after an underflow will be a subnormal number rounded, if
+    necessary, so that its exponent is not less than Etiny. This may result
+    in 0 with the sign of the intermediate result and an exponent of Etiny.
+
+    In all cases, Inexact, Rounded, and Subnormal will also be raised.
+    """
+
+# List of public traps and flags
+_signals = [Clamped, DivisionByZero, Inexact, Overflow, Rounded,
+           Underflow, InvalidOperation, Subnormal]
+
+# Map conditions (per the spec) to signals
+_condition_map = {ConversionSyntax:InvalidOperation,
+                  DivisionImpossible:InvalidOperation,
+                  DivisionUndefined:InvalidOperation,
+                  InvalidContext:InvalidOperation}
+
+##### Context Functions #######################################
+
+# The getcontext() and setcontext() function manage access to a thread-local
+# current context.  Py2.4 offers direct support for thread locals.  If that
+# is not available, use threading.currentThread() which is slower but will
+# work for older Pythons.  If threads are not part of the build, create a
+# mock threading object with threading.local() returning the module namespace.
+
+try:
+    import threading
+except ImportError:
+    # Python was compiled without threads; create a mock object instead
+    import sys
+    class MockThreading:
+        def local(self, sys=sys):
+            return sys.modules[__name__]
+    threading = MockThreading()
+    del sys, MockThreading
+
+try:
+    threading.local
+
+except AttributeError:
+
+    #To fix reloading, force it to create a new context
+    #Old contexts have different exceptions in their dicts, making problems.
+    if hasattr(threading.currentThread(), '__decimal_context__'):
+        del threading.currentThread().__decimal_context__
+
+    def setcontext(context):
+        """Set this thread's context to context."""
+        if context in (DefaultContext, BasicContext, ExtendedContext):
+            context = context.copy()
+            context.clear_flags()
+        threading.currentThread().__decimal_context__ = context
+
+    def getcontext():
+        """Returns this thread's context.
+
+        If this thread does not yet have a context, returns
+        a new context and sets this thread's context.
+        New contexts are copies of DefaultContext.
+        """
+        try:
+            return threading.currentThread().__decimal_context__
+        except AttributeError:
+            context = Context()
+            threading.currentThread().__decimal_context__ = context
+            return context
+
+else:
+
+    local = threading.local()
+    if hasattr(local, '__decimal_context__'):
+        del local.__decimal_context__
+
+    def getcontext(_local=local):
+        """Returns this thread's context.
+
+        If this thread does not yet have a context, returns
+        a new context and sets this thread's context.