Normalize internal representation to uniform floating-point

Finishes the Python 2 to 3 cleanup of the numeric internals.

- Remove dead Py2-era float() casts from division expressions, where
  Python 3 true division already yields a float
- Force float on the three constructor paths (bytes=, bits=, and the
  Bit value constructor) that previously leaked int, so .bytes and
  .bits return float regardless of how an instance was built
- Add regression tests pinning the float invariant
- Document the uniform float behavior in the Rules for Math appendix
- Add the bitmath-2.1.0 NEWS section and bump VERSION to 2.1.0

Author: timlnx

NEWS.rst

@@ -5,6 +5,80 @@ NEWS
    :depth: 1
    :local:
 
+.. _bitmath-2.1.0:
+
+bitmath-2.1.0
+*************
+
+*Unreleased*
+
+bitmath 2.1.0 is a focused follow-up to the 2.0.0 modernization. It
+finishes the last of the Python 2 cleanup, tightens the project's
+quality tooling, and retires one piece of legacy API surface.
+
+
+Breaking Changes
+================
+
+**Internal representation is uniformly floating-point**
+   Every bitmath instance now stores its size as a 64-bit float, no
+   matter which constructor created it. Previously the ``bytes=`` and
+   ``bits=`` keyword constructors, along with the bit-family value
+   constructors such as ``Kib(N)``, leaked Python ``int`` values
+   through the ``.bytes`` and ``.bits`` properties. Those properties
+   now always return ``float``, matching the long-documented
+   floating-point measurement design described in the :ref:`Rules for
+   Math <appendix_math>` appendix. Equality, ordering, ``repr()``, and
+   arithmetic results are unchanged; only code that inspected
+   ``type(instance.bytes)`` or ``type(instance.bits)`` directly will
+   observe the difference.
+
+**listdir() is deprecated**
+   :func:`bitmath.listdir` now emits a :exc:`DeprecationWarning` on
+   every call and will be removed in a future release. Iterate with
+   :py:func:`os.walk` and call :func:`bitmath.getsize` directly
+   instead. Closes `issue #27
+   <https://github.com/timlnx/bitmath/issues/27>`_.
+
+
+Library Improvements
+====================
+
+**pathlib support**
+   :func:`bitmath.getsize` and :func:`bitmath.listdir` now accept
+   :class:`pathlib.Path` objects, not just strings, for their path
+   and ``search_base`` arguments.
+
+
+Project Infrastructure
+======================
+
+**Linting moved to pylint**
+   pylint replaces flake8/pyflakes across the CI workflow and the
+   local toolchain, and the library is held at a 10.00/10 score.
+   pycodestyle is retained for the PEP 8 whitespace checks pylint
+   does not cover.
+
+**Security scanning with bandit**
+   bandit runs as part of ``make ci`` and as a dedicated GitHub
+   Actions workflow that fires on every push, every pull request, and
+   on a weekly schedule, scanning both ``bitmath/`` and ``tests/``.
+
+**100% test coverage**
+   The remaining coverage gaps were closed, including the
+   platform-specific :func:`bitmath.query_device_capacity` branches,
+   bringing the suite to 100% measured coverage on every supported
+   platform.
+
+**SPDX license headers**
+   Every source and test file now carries ``SPDX-License-Identifier``
+   and ``SPDX-FileCopyrightText`` headers.
+
+**Single-sourced version**
+   The package version is read dynamically from the ``VERSION`` file
+   by hatchling, so bumping that one file propagates everywhere.
+
+
 .. _bitmath-2.0.0:
 
 bitmath-2.0.0

VERSION

@@ -1 +1 @@
-2.0.2
+2.1.0

bitmath.1

@@ -2,12 +2,12 @@
 .\"     Title: bitmath
 .\"    Author: [see the "AUTHOR" section]
 .\" Generator: DocBook XSL Stylesheets vsnapshot <http://docbook.sf.net/>
-.\"      Date: 05/05/2026
+.\"      Date: 05/15/2026
 .\"    Manual: python-bitmath
-.\"    Source: bitmath 2.0.2
+.\"    Source: bitmath 2.1.0
 .\"  Language: English
 .\"
-.TH "BITMATH" "1" "05/05/2026" "bitmath 2\&.0\&.2" "python\-bitmath"
+.TH "BITMATH" "1" "05/15/2026" "bitmath 2\&.1\&.0" "python\-bitmath"
 .\" -----------------------------------------------------------------
 .\" * Define some portability stuff
 .\" -----------------------------------------------------------------

bitmath/__init__.py

@@ -220,14 +220,14 @@ def __init__(self, value=0, bytes=None, bits=None):  # pylint: disable=redefined
         if bytes:
             # We were provided with the fundamental base unit, no need
             # to normalize
-            self._byte_value = bytes
+            self._byte_value = float(bytes)
             self._bit_value = bytes * 8.0
         elif bits:
             # We were *ALMOST* given the fundamental base
             # unit. Translate it into the fundamental unit then
             # normalize.
-            self._byte_value = bits / 8.0
-            self._bit_value = bits
+            self._byte_value = bits / 8
+            self._bit_value = float(bits)
         else:
             # We were given a value representative of this *prefix
             # unit*. We need to normalize it into the number of bytes
@@ -243,7 +243,7 @@ def _set_prefix_value(self) -> None:
     def _to_prefix_value(self, value: float) -> float:
         """Return the number of bits/bytes as they would look like if we
 converted *to* this unit"""
-        return value / float(self._unit_value)
+        return value / self._unit_value
 
     def _setup(self) -> tuple:
         raise NotImplementedError("The base 'bitmath.Bitmath' class can not be used directly")
@@ -845,7 +845,7 @@ def __truediv__(self, other):
             result = self._byte_value / other
             return (type(self))(bytes=result)
         # bm1 / bm2
-        return self._byte_value / float(other.bytes)
+        return self._byte_value / other.bytes
 
     def __floordiv__(self, other):
         """Floor division: Supported operations with result types:
@@ -899,7 +899,7 @@ def __rmul__(self, other):
 
     def __rtruediv__(self, other):
         # num / bm = num
-        return other / float(self.value)
+        return other / self.value
 
     # Called to implement the built-in functions complex(), int(), and
     # float(). These return the int/float equivalent of the prefix value:
@@ -1196,8 +1196,8 @@ def _setup(self):
     def _norm(self, value):
         """Normalize the input value into the fundamental unit for this prefix
 type"""
-        self._bit_value = value * self._unit_value
-        self._byte_value = self._bit_value / 8.0
+        self._bit_value = float(value) * self._unit_value
+        self._byte_value = self._bit_value / 8
 
 
 ######################################################################

docsite/source/appendices/mixed_math.rst

@@ -298,6 +298,9 @@ Design Philosophy: Floating-Point Measurements
 
 bitmath represents sizes as **floating-point measurements**, not as
 discrete counts of hardware bits. This is an intentional design choice.
+Every constructor (by unit value, by ``bytes=``, or by ``bits=``)
+normalizes its input to a float, so the ``bytes`` and ``bits``
+properties always return floating-point values.
 
 A file reported as ``1.7 GiB`` is a *measurement* — the same way
 ``2.3 miles`` or ``1.7 liters`` are measurements. Physical storage is

docsite/source/appendices/on_units.rst

@@ -21,23 +21,23 @@ a percent one "unit" of SI is to one "unit" of NIST.
 
    In [16]: one_kibi = 1 * 2**10
 
-   In [17]: round(one_kilo / float(one_kibi), 2)
+   In [17]: round(one_kilo / one_kibi, 2)
 
    Out[17]: 0.98
 
    In [18]: one_tera = 1 * 10**12
 
    In [19]: one_tebi = 1 * 2**40
 
-   In [20]: round(one_tera / float(one_tebi), 2)
+   In [20]: round(one_tera / one_tebi, 2)
 
    Out[20]: 0.91
 
    In [21]: one_exa = 1 * 10**18
 
    In [22]: one_exbi = 1 * 2**60
 
-   In [23]: round(one_exa / float(one_exbi), 2)
+   In [23]: round(one_exa / one_exbi, 2)
 
    Out[23]: 0.87
 

tests/test_properties.py

@@ -82,3 +82,25 @@ def test_system_property_invalid_base_raises(self):
         obj._base = 7
         with self.assertRaises(ValueError):
             _ = obj.system
+
+
+class TestPropertyTypesAlwaysFloat(TestCase):
+    """The .bytes and .bits properties are float for every construction
+    path. The internal representation is uniformly floating-point (see
+    the 'Floating-Point Measurements' design philosophy appendix)."""
+
+    def test_bytes_property_float_from_value_constructor(self):
+        """.bytes is float when built via the unit-value constructor"""
+        self.assertIs(type(bitmath.KiB(1).bytes), float)
+
+    def test_bytes_property_float_from_bytes_kwarg(self):
+        """.bytes is float when built via the bytes= keyword"""
+        self.assertIs(type(bitmath.Byte(bytes=1).bytes), float)
+
+    def test_bits_property_float_from_bits_kwarg(self):
+        """.bits is float when built via the bits= keyword"""
+        self.assertIs(type(bitmath.Byte(bits=1).bits), float)
+
+    def test_bits_property_float_from_bit_value_constructor(self):
+        """.bits is float when a Bit-family unit is built by value"""
+        self.assertIs(type(bitmath.Kib(1).bits), float)