From 833feeb9a06c00fb5afb1f80d6880799a5ec451f Mon Sep 17 00:00:00 2001 From: Adam Holmberg Date: Mon, 20 Apr 2015 15:31:48 -0500 Subject: [PATCH] Deprecate cqlengine.Float(double_precision=True) Overload deprecated in favor of distinct Float, Double types PYTHON-246 --- cassandra/cqlengine/columns.py | 38 ++++++++++----- docs/api/cassandra/cqlengine/columns.rst | 2 + .../cqlengine/columns/test_value_io.py | 47 +++++++++++++++---- .../integration/cqlengine/model/test_udts.py | 4 +- 4 files changed, 69 insertions(+), 22 deletions(-) diff --git a/cassandra/cqlengine/columns.py b/cassandra/cqlengine/columns.py index ec6a468f..ae177795 100644 --- a/cassandra/cqlengine/columns.py +++ b/cassandra/cqlengine/columns.py @@ -591,18 +591,9 @@ class Boolean(Column): return self.validate(value) -class Float(Column): - """ - Stores a floating point value - """ - db_type = 'double' - - def __init__(self, double_precision=True, **kwargs): - self.db_type = 'double' if double_precision else 'float' - super(Float, self).__init__(**kwargs) - +class BaseFloat(Column): def validate(self, value): - value = super(Float, self).validate(value) + value = super(BaseFloat, self).validate(value) if value is None: return try: @@ -617,6 +608,31 @@ class Float(Column): return self.validate(value) +class Float(BaseFloat): + """ + Stores a single-precision floating-point value + """ + db_type = 'float' + + def __init__(self, double_precision=None, **kwargs): + if double_precision is None or bool(double_precision): + msg = "Float(double_precision=True) is deprecated. Use Double() type instead." + double_precision = True + warnings.warn(msg, DeprecationWarning) + log.warning(msg) + + self.db_type = 'double' if double_precision else 'float' + + super(Float, self).__init__(**kwargs) + + +class Double(BaseFloat): + """ + Stores a double-precision floating-point value + """ + db_type = 'double' + + class Decimal(Column): """ Stores a variable precision decimal value diff --git a/docs/api/cassandra/cqlengine/columns.rst b/docs/api/cassandra/cqlengine/columns.rst index 425e01e0..a214d2cd 100644 --- a/docs/api/cassandra/cqlengine/columns.rst +++ b/docs/api/cassandra/cqlengine/columns.rst @@ -58,6 +58,8 @@ Columns of all types are initialized by passing :class:`.Column` attributes to t .. autoclass:: Decimal(**kwargs) +.. autoclass:: Double + .. autoclass:: Float .. autoclass:: Integer(**kwargs) diff --git a/tests/integration/cqlengine/columns/test_value_io.py b/tests/integration/cqlengine/columns/test_value_io.py index 2ebfa89b..04be247a 100644 --- a/tests/integration/cqlengine/columns/test_value_io.py +++ b/tests/integration/cqlengine/columns/test_value_io.py @@ -50,8 +50,9 @@ class BaseColumnIOTest(BaseCassEngTestCase): def setUpClass(cls): super(BaseColumnIOTest, cls).setUpClass() - #if the test column hasn't been defined, bail out - if not cls.column: return + # if the test column hasn't been defined, bail out + if not cls.column: + return # create a table with the given column class IOTestModel(Model): @@ -62,7 +63,7 @@ class BaseColumnIOTest(BaseCassEngTestCase): cls._generated_model = IOTestModel sync_table(cls._generated_model) - #tupleify the tested values + # tupleify the tested values if not isinstance(cls.pkey_val, tuple): cls.pkey_val = cls.pkey_val, if not isinstance(cls.data_val, tuple): @@ -71,7 +72,8 @@ class BaseColumnIOTest(BaseCassEngTestCase): @classmethod def tearDownClass(cls): super(BaseColumnIOTest, cls).tearDownClass() - if not cls.column: return + if not cls.column: + return drop_table(cls._generated_model) def comparator_converter(self, val): @@ -80,31 +82,35 @@ class BaseColumnIOTest(BaseCassEngTestCase): def test_column_io(self): """ Tests the given models class creates and retrieves values as expected """ - if not self.column: return + if not self.column: + return for pkey, data in zip(self.pkey_val, self.data_val): - #create + # create m1 = self._generated_model.create(pkey=pkey, data=data) - #get + # get m2 = self._generated_model.get(pkey=pkey) assert m1.pkey == m2.pkey == self.comparator_converter(pkey), self.column assert m1.data == m2.data == self.comparator_converter(data), self.column - #delete + # delete self._generated_model.filter(pkey=pkey).delete() + class TestBlobIO(BaseColumnIOTest): column = columns.Blob pkey_val = six.b('blake'), uuid4().bytes data_val = six.b('eggleston'), uuid4().bytes + class TestBlobIO2(BaseColumnIOTest): column = columns.Blob pkey_val = bytearray(six.b('blake')), uuid4().bytes data_val = bytearray(six.b('eggleston')), uuid4().bytes + class TestTextIO(BaseColumnIOTest): column = columns.Text @@ -118,18 +124,21 @@ class TestNonBinaryTextIO(BaseColumnIOTest): pkey_val = 'bacon' data_val = '0xmonkey' + class TestInteger(BaseColumnIOTest): column = columns.Integer pkey_val = 5 data_val = 6 + class TestBigInt(BaseColumnIOTest): column = columns.BigInt pkey_val = 6 data_val = pow(2, 63) - 1 + class TestDateTime(BaseColumnIOTest): column = columns.DateTime @@ -138,6 +147,7 @@ class TestDateTime(BaseColumnIOTest): pkey_val = now data_val = now + timedelta(days=1) + class TestDate(BaseColumnIOTest): column = columns.Date @@ -146,6 +156,7 @@ class TestDate(BaseColumnIOTest): pkey_val = now data_val = now + timedelta(days=1) + class TestUUID(BaseColumnIOTest): column = columns.UUID @@ -156,6 +167,7 @@ class TestUUID(BaseColumnIOTest): def comparator_converter(self, val): return val if isinstance(val, UUID) else UUID(val) + class TestTimeUUID(BaseColumnIOTest): column = columns.TimeUUID @@ -166,13 +178,29 @@ class TestTimeUUID(BaseColumnIOTest): def comparator_converter(self, val): return val if isinstance(val, UUID) else UUID(val) + +# until Floats are implicitly single: +class FloatSingle(columns.Float): + def __init__(self, **kwargs): + super(FloatSingle, self).__init__(double_precision=False, **kwargs) + + class TestFloatIO(BaseColumnIOTest): - column = columns.Float + column = FloatSingle + + pkey_val = 4.75 + data_val = -1.5 + + +class TestDoubleIO(BaseColumnIOTest): + + column = columns.Double pkey_val = 3.14 data_val = -1982.11 + class TestDecimalIO(BaseColumnIOTest): column = columns.Decimal @@ -183,6 +211,7 @@ class TestDecimalIO(BaseColumnIOTest): def comparator_converter(self, val): return Decimal(val) + class TestQuoter(unittest.TestCase): def test_equals(self): diff --git a/tests/integration/cqlengine/model/test_udts.py b/tests/integration/cqlengine/model/test_udts.py index ab9386b8..89a55d17 100644 --- a/tests/integration/cqlengine/model/test_udts.py +++ b/tests/integration/cqlengine/model/test_udts.py @@ -196,7 +196,7 @@ class UserDefinedTypeTests(BaseCassEngTestCase): e = columns.Date() f = columns.DateTime() g = columns.Decimal() - h = columns.Float() + h = columns.Float(double_precision=False) i = columns.Inet() j = columns.Integer() k = columns.Text() @@ -227,7 +227,7 @@ class UserDefinedTypeTests(BaseCassEngTestCase): e = columns.Date() f = columns.DateTime() g = columns.Decimal() - h = columns.Float(double_precision=True) + h = columns.Double() i = columns.Inet() j = columns.Integer() k = columns.Text()