counted-float 0.8.2__tar.gz → 0.8.4__tar.gz

{counted_float-0.8.2 → counted_float-0.8.4}/PKG-INFO

@@ -1,25 +1,26 @@
 Metadata-Version: 2.4
 Name: counted-float
-Version: 0.8.2
+Version: 0.8.4
 Summary: Count floating-point operations in Python code & benchmark relative flop costs.
 Project-URL: Source, https://github.com/bertpl/counted-float
+Project-URL: ChangeLog, https://github.com/bertpl/counted-float/blob/develop/RELEASE_NOTES.md
 Project-URL: Issues, https://github.com/bertpl/counted-float/issues
 Project-URL: Roadmap, https://github.com/bertpl/counted-float/milestones
 License-File: LICENSE
 Requires-Python: >=3.10
 Requires-Dist: backports-strenum>=1.3.1
+Requires-Dist: numpy>=1.20
+Requires-Dist: psutil>=5.0
 Requires-Dist: pydantic>=2.0.0
-Provides-Extra: benchmarking
-Requires-Dist: numba>=0.50; extra == 'benchmarking'
-Requires-Dist: numpy>=1.20; extra == 'benchmarking'
-Requires-Dist: psutil>=5.0; extra == 'benchmarking'
+Provides-Extra: numba
+Requires-Dist: numba>=0.50; extra == 'numba'
 Description-Content-Type: text/markdown
 
 <!--START_SECTION:images-->
 ![shields.io-python-versions](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-blue)
-![genbadge-test-count](https://bertpl.github.io/counted-float/version_artifacts/v0.8.2/badge-test-count.svg)
-![genbadge-test-coverage](https://bertpl.github.io/counted-float/version_artifacts/v0.8.2/badge-coverage.svg)
-![counted_float logo](https://bertpl.github.io/counted-float/version_artifacts/v0.8.2/splash.webp)
+![genbadge-test-count](https://bertpl.github.io/counted-float/version_artifacts/v0.8.4/badge-test-count.svg)
+![genbadge-test-coverage](https://bertpl.github.io/counted-float/version_artifacts/v0.8.4/badge-coverage.svg)
+![counted_float logo](https://bertpl.github.io/counted-float/version_artifacts/v0.8.4/splash.webp)
 <!--END_SECTION:images-->
 
 # counted-float
@@ -33,8 +34,8 @@ feasible or desirable.
 
 The package contains two components:
  - `counting`: provides a CountedFloat class & flop counting context managers to count flops of code blocks.
- - `benchmarking`: (optional) provides functionality to micro-benchmark floating point operations to get an empirical
-   ballpark estimate of the relative cost of different operations on the target hardware.
+ - `benchmarking`: provides functionality to micro-benchmark floating point operations to get an empirical
+   ballpark estimate of the relative cost of different operations on the target hardware.  Requires 'numba' optional dependency for accurate results.
 
 # 1. Installation
 
@@ -43,11 +44,11 @@ The package contains two components:
 Use you favorite package manager such as `uv` or `pip`:
 
 ```
-pip install counted-float                  # install without benchmarking optional dependencies
-pip install counted-float[benchmarking]    # install with benchmarking optional dependencies
+pip install counted-float           # install without numba optional dependency
+pip install counted-float[numba]    # install with numba optional dependency
 ```
-Benchmarking dependencies are optional due to the large size of the numba (+llvmlite) package, which is used for
-micro-benchmarking, which relies on jit-compiled code to get more accurate estimates with less Python overhead. 
+Numba is optional due to its relatively large size (40-50MB, including llvmlite), but without it, benchmarks will
+not be reliable (but will still run, but not in jit-compiled form).
 
 # 2. Counting Flops
 
@@ -243,7 +244,7 @@ The default weights that are configured in the package are the integer-rounded `
 
 # 3. Benchmarking
 
-If the package is installed with the optional `benchmarking` dependencies, it provides
+If the package is installed with the optional `numba` dependency, it provides
 the ability to micro-benchmark floating point operations as follows:
 
 ```

{counted_float-0.8.2 → counted_float-0.8.4}/README.md

@@ -1,8 +1,8 @@
 <!--START_SECTION:images-->
 ![shields.io-python-versions](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-blue)
-![genbadge-test-count](https://bertpl.github.io/counted-float/version_artifacts/v0.8.2/badge-test-count.svg)
-![genbadge-test-coverage](https://bertpl.github.io/counted-float/version_artifacts/v0.8.2/badge-coverage.svg)
-![counted_float logo](https://bertpl.github.io/counted-float/version_artifacts/v0.8.2/splash.webp)
+![genbadge-test-count](https://bertpl.github.io/counted-float/version_artifacts/v0.8.4/badge-test-count.svg)
+![genbadge-test-coverage](https://bertpl.github.io/counted-float/version_artifacts/v0.8.4/badge-coverage.svg)
+![counted_float logo](https://bertpl.github.io/counted-float/version_artifacts/v0.8.4/splash.webp)
 <!--END_SECTION:images-->
 
 # counted-float
@@ -16,8 +16,8 @@ feasible or desirable.
 
 The package contains two components:
  - `counting`: provides a CountedFloat class & flop counting context managers to count flops of code blocks.
- - `benchmarking`: (optional) provides functionality to micro-benchmark floating point operations to get an empirical
-   ballpark estimate of the relative cost of different operations on the target hardware.
+ - `benchmarking`: provides functionality to micro-benchmark floating point operations to get an empirical
+   ballpark estimate of the relative cost of different operations on the target hardware.  Requires 'numba' optional dependency for accurate results.
 
 # 1. Installation
 
@@ -26,11 +26,11 @@ The package contains two components:
 Use you favorite package manager such as `uv` or `pip`:
 
 ```
-pip install counted-float                  # install without benchmarking optional dependencies
-pip install counted-float[benchmarking]    # install with benchmarking optional dependencies
+pip install counted-float           # install without numba optional dependency
+pip install counted-float[numba]    # install with numba optional dependency
 ```
-Benchmarking dependencies are optional due to the large size of the numba (+llvmlite) package, which is used for
-micro-benchmarking, which relies on jit-compiled code to get more accurate estimates with less Python overhead. 
+Numba is optional due to its relatively large size (40-50MB, including llvmlite), but without it, benchmarks will
+not be reliable (but will still run, but not in jit-compiled form).
 
 # 2. Counting Flops
 
@@ -226,7 +226,7 @@ The default weights that are configured in the package are the integer-rounded `
 
 # 3. Benchmarking
 
-If the package is installed with the optional `benchmarking` dependencies, it provides
+If the package is installed with the optional `numba` dependency, it provides
 the ability to micro-benchmark floating point operations as follows:
 
 ```

{counted_float-0.8.2 → counted_float-0.8.4}/counted_float/__init__.py

@@ -1,3 +1,4 @@
+import counted_float.benchmarking as benchmarking
 import counted_float.config as config
 
 from ._core.counting import BuiltInData, CountedFloat, FlopCountingContext, PauseFlopCounting
@@ -12,6 +13,7 @@ from ._core.counting.models import (
 )
 
 __all__ = [
+    "benchmarking",
     "config",
     "CountedFloat",
     "FlopCountingContext",
@@ -24,16 +26,3 @@ __all__ = [
     "PauseFlopCounting",
     "SystemInfo",
 ]
-
-# -------------------------------------------------------------------------
-#  Optional [benchmarking] dependencies
-# -------------------------------------------------------------------------
-from ._core._optional_deps import FLAG_BENCHMARK_DEPS
-
-if FLAG_BENCHMARK_DEPS:
-    import counted_float.benchmarking as benchmarking
-
-    __all__.append("benchmarking")
-
-# delete variable again, we don't want to expose this
-del FLAG_BENCHMARK_DEPS

{counted_float-0.8.2 → counted_float-0.8.4}/counted_float/_core/benchmarking/__init__.py

@@ -1,10 +1,8 @@
-from counted_float._core._optional_deps import requires_benchmark_deps
 from counted_float._core.counting.models import FlopsBenchmarkResults
 
 from ._flops_benchmark_suite import FlopsBenchmarkSuite
 
 
-@requires_benchmark_deps
 def run_flops_benchmark() -> FlopsBenchmarkResults:
     """Run the flops benchmark suite with default settings returns a FlopsBenchmarkResults object."""
     return FlopsBenchmarkSuite().run()

{counted_float-0.8.2 → counted_float-0.8.4}/counted_float/_core/benchmarking/_flops_benchmark_suite.py

@@ -1,8 +1,9 @@
 import platform
 
+import numpy as np
 import psutil
 
-from counted_float._core._optional_deps import requires_benchmark_deps
+from counted_float._core.compatibility import is_numba_installed, numba
 from counted_float._core.counting.models import (
     BenchmarkSettings,
     FlopsBenchmarkDurations,
@@ -30,6 +31,13 @@ class FlopsBenchmarkSuite:
         Run entire flops benchmarking suite and return the results as a FlopsBenchmarkResults object.
         """
 
+        # warn if needed
+        if not is_numba_installed():
+            print("========= WARNING =========")
+            print("'numba' was not found; results of this benchmark will be wildly inaccurate & unusable.")
+            print("Install this package with the numba optional dependency: 'pip install counted-float[numba]'")
+            print("========= WARNING =========")
+
         # run actual benchmarks
         benchmarks = self.get_flops_benchmarking_suite(size=array_size)
         results_dict: dict[FlopType | None, Quantiles] = {
@@ -70,16 +78,11 @@ class FlopsBenchmarkSuite:
     #  Static methods
     # -------------------------------------------------------------------------
     @staticmethod
-    @requires_benchmark_deps
     def get_flops_benchmarking_suite(size: int) -> dict[FlopType | None, FlopsMicroBenchmark]:
         """
         Returns a benchmark for each FlopType + None (=baseline test), of requested array size.
         """
 
-        # --- late import of optional dependencies --------
-        import numba
-        import numpy as np
-
         # --- define all test functions -------------------
         @numba.njit(parallel=False)
         def baseline(n: int, in_f1: np.ndarray, in_f2: np.ndarray, out_f: np.ndarray, out_i: np.ndarray):

{counted_float-0.8.2 → counted_float-0.8.4}/counted_float/_core/benchmarking/_flops_micro_benchmark.py

@@ -1,6 +1,6 @@
 from typing import Callable
 
-from counted_float._core._optional_deps import requires_benchmark_deps
+import numpy as np
 
 from ._micro_benchmark import MicroBenchmark
 
@@ -32,10 +32,7 @@ class FlopsMicroBenchmark(MicroBenchmark):
     operations, so we can make representative estimates of the number of FLOPS executed by instrumented algorithms.
     """
 
-    @requires_benchmark_deps
     def __init__(self, name: str, f: Callable, size: int):
-        import numpy as np  # late import of optional dependency
-
         super().__init__(name=name)
         self.size = size
         self.f = f
@@ -48,8 +45,6 @@ class FlopsMicroBenchmark(MicroBenchmark):
         self.out_i: np.ndarray = np.zeros(size, dtype=int)
 
     def _prepare_benchmark(self, n_operations: int):
-        import numpy as np  # late import of optional dependency
-
         self.n_operations = n_operations
         # input arrays
         self.in_f1 = 10 * np.random.rand(self.size)

{counted_float-0.8.2 → counted_float-0.8.4}/counted_float/_core/benchmarking/_micro_benchmark.py

@@ -1,7 +1,5 @@
 from abc import ABC, abstractmethod
 
-from counted_float._core._optional_deps import requires_benchmark_deps
-
 from ._models import MicroBenchmarkResult, SingleRunResult
 from ._time_utils import Timer, format_time_durations
 
@@ -25,7 +23,6 @@ class MicroBenchmark(ABC):
 
     MAX_N_OPERATIONS_FACTOR = 10  # never adjust n_operations by more than this factor (up or down)
 
-    @requires_benchmark_deps
     def __init__(self, name: str):
         self.name = name
 

{counted_float-0.8.2 → counted_float-0.8.4}/counted_float/_core/benchmarking/_models.py

@@ -1,3 +1,5 @@
+import numpy as np
+
 from counted_float._core.counting.models import MyBaseModel, Quantiles
 
 
@@ -19,8 +21,6 @@ class MicroBenchmarkResult(MyBaseModel):
 
     def get_nsec_per_op_quantile(self, q: float) -> float:
         """Returns a specific quantile of all results in the 'benchmark_runs' category expressed as nsec/op."""
-        import numpy as np  # late import of optional dependency
-
         return float(np.quantile([el.nsecs_per_op() for el in self.benchmark_runs], q))
 
     def summary_stats(self) -> Quantiles:

counted_float-0.8.4/counted_float/_core/compatibility/__init__.py

@@ -0,0 +1,2 @@
+from ._numba import is_numba_installed, numba
+from ._strenum import StrEnum

counted_float-0.8.4/counted_float/_core/compatibility/_numba.py

@@ -0,0 +1,31 @@
+from collections.abc import Callable
+
+try:
+    import numba
+
+
+except ImportError:
+    # dummy decorator that will replace numba.jit and numba.njit
+    def dummy_decorator(*args, **kwargs):
+        # dummy decorator that does nothing and can be used with or without arguments
+        if len(args) == 1 and isinstance(args[0], Callable):
+            # decorator used without arguments
+            return args[0]
+        else:
+            # decorator used with arguments
+            def decorator(func):
+                return func
+
+            return decorator
+
+    # create a dummy numba object with numba.jit and numba.njit dummy decorators
+    class Numba:
+        __version__ = "0.0.0"
+        jit = dummy_decorator
+        njit = dummy_decorator
+
+    numba = Numba
+
+
+def is_numba_installed() -> bool:
+    return numba.__version__ != "0.0.0"

{counted_float-0.8.2 → counted_float-0.8.4}/counted_float/_core/counting/models/_flop_type.py

@@ -1,4 +1,4 @@
-from counted_float._core._backwards_compat import StrEnum
+from counted_float._core.compatibility import StrEnum
 
 
 class FlopType(StrEnum):

{counted_float-0.8.2 → counted_float-0.8.4}/counted_float/_core/counting/models/_fpu_instruction.py

@@ -1,4 +1,4 @@
-from counted_float._core._backwards_compat import StrEnum
+from counted_float._core.compatibility import StrEnum
 
 
 class FPUInstruction(StrEnum):

counted_float-0.8.4/counted_float/benchmarking/__init__.py

@@ -0,0 +1,6 @@
+from counted_float._core.benchmarking import FlopsBenchmarkResults, run_flops_benchmark
+
+__all__ = [
+    "FlopsBenchmarkResults",
+    "run_flops_benchmark",
+]

{counted_float-0.8.2 → counted_float-0.8.4}/pyproject.toml

@@ -1,24 +1,25 @@
 [project]
 name = "counted-float"
-version = "0.8.2"
+version = "0.8.4"
 description = "Count floating-point operations in Python code & benchmark relative flop costs."
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
     "backports-strenum>=1.3.1",
     "pydantic>=2.0.0",
+    "numpy>=1.20",
+    "psutil>=5.0",
 ]
 
 [project.urls]
 Source = "https://github.com/bertpl/counted-float"
+ChangeLog = "https://github.com/bertpl/counted-float/blob/develop/RELEASE_NOTES.md"
 Issues = "https://github.com/bertpl/counted-float/issues"
 Roadmap = "https://github.com/bertpl/counted-float/milestones"
 
 [project.optional-dependencies]
-benchmarking = [
+numba = [
     "numba>=0.50",
-    "numpy>=1.20",
-    "psutil>=5.0",
 ]
 
 [build-system]
@@ -46,9 +47,3 @@ dev = [
     "pytest>=8.0",
     "pytest-cov>=6.0",
 ]
-
-[tool.pytest.ini_options]
-markers = [
-    "requires_benchmarking_deps: only run this test if benchmark options ARE installed",
-    "requires_no_benchmarking_deps: only run this test if benchmark options ARE NOT installed"
-]

counted_float-0.8.2/counted_float/_core/_optional_deps.py

@@ -1,49 +0,0 @@
-"""
-Module implementing boolean flags indicating whether optional dependencies are available & decorators to
-safeguard execution of functions that require these dependencies.
-"""
-
-import functools
-from typing import Callable
-
-# -------------------------------------------------------------------------
-#  Flags
-# -------------------------------------------------------------------------
-try:
-    import numba
-    import numpy
-    import psutil
-
-    FLAG_BENCHMARK_DEPS = True
-except ImportError:
-    FLAG_BENCHMARK_DEPS = False
-
-
-# -------------------------------------------------------------------------
-#  Decorators
-# -------------------------------------------------------------------------
-def requires_benchmark_deps(fun: Callable) -> Callable:
-    """
-    Decorator to mark a function that requires some deps to be installed.
-
-    USAGE:
-
-        @requires_benchmark_deps
-        def fun_that_needs_numba_or_numpy_or_psutil():
-            pass
-
-    This will ensure that the function - when it is called for the first time - will check if the required
-    dependencies are available.  If not, an ImportError will be raised with an informative message.
-    """
-
-    @functools.wraps(fun)
-    def wrapped_fun(*args, **kwargs):
-        if not FLAG_BENCHMARK_DEPS:
-            raise ImportError(
-                "This function requires counted_float to be installed with benchmark optional dependencies. "
-                + "Please install this package as counted_float[benchmark]."
-            )
-        else:
-            return fun(*args, **kwargs)
-
-    return wrapped_fun

counted_float-0.8.2/counted_float/benchmarking/__init__.py

@@ -1,14 +0,0 @@
-from counted_float._core._optional_deps import FLAG_BENCHMARK_DEPS
-
-__all__ = []
-
-if FLAG_BENCHMARK_DEPS:
-    from counted_float._core.benchmarking import FlopsBenchmarkResults, run_flops_benchmark
-
-    __all__ = [
-        "FlopsBenchmarkResults",
-        "run_flops_benchmark",
-    ]
-
-# delete variable again, we don't want to expose this
-del FLAG_BENCHMARK_DEPS