naw 0.0.1__tar.gz

naw-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 INRIA
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

naw-0.0.1/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: naw
+Version: 0.0.1
+Summary: Log and manage metrics for machine learning projects
+Author-email: Mathieu Lacage <mathieu.lacage@inria.fr>
+Maintainer-email: Mathieu Lacage <mathieu.lacage@inria.fr>
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: argcomplete>=3.7.0
+Requires-Dist: pyyaml
+Requires-Dist: tabulate
+Dynamic: license-file
+
+# baw
+
+This library logs time-series metrics to disk in compressed format.
+
+## References
+
+- [Gorilla](https://www.vldb.org/pvldb/vol8/p1816-teller.pdf): A fast, scalable, in-memory time series database
+- [Chimp](https://www.vldb.org/pvldb/vol15/p3058-liakos.pdf): efficient lossless floating point compression for time series databases
+- [Elf](https://www.vldb.org/pvldb/vol16/p1763-li.pdf): Erasing-Based Lossless Floating-Point Compression
+
+## License
+
+MIT — see [LICENSE](https://gitlab.inria.fr/mlacage/baw/-/raw/main/LICENSE?ref_type=heads).

naw-0.0.1/README.md

@@ -0,0 +1,13 @@
+# baw
+
+This library logs time-series metrics to disk in compressed format.
+
+## References
+
+- [Gorilla](https://www.vldb.org/pvldb/vol8/p1816-teller.pdf): A fast, scalable, in-memory time series database
+- [Chimp](https://www.vldb.org/pvldb/vol15/p3058-liakos.pdf): efficient lossless floating point compression for time series databases
+- [Elf](https://www.vldb.org/pvldb/vol16/p1763-li.pdf): Erasing-Based Lossless Floating-Point Compression
+
+## License
+
+MIT — see [LICENSE](https://gitlab.inria.fr/mlacage/baw/-/raw/main/LICENSE?ref_type=heads).

naw-0.0.1/pyproject.toml

@@ -0,0 +1,97 @@
+[project]
+name = "naw"
+description = "Log and manage metrics for machine learning projects"
+version = "0.0.1"
+dependencies = [
+   "argcomplete>=3.7.0",
+   "pyyaml",
+   "tabulate",
+]
+requires-python = ">=3.10"
+authors = [
+  {name = "Mathieu Lacage", email = "mathieu.lacage@inria.fr"}
+]
+maintainers = [
+  {name = "Mathieu Lacage", email = "mathieu.lacage@inria.fr"}
+]
+license = "MIT"
+readme = "README.md"
+
+[project.scripts]
+naw = "naw.cli:main"
+
+[project.optional-dependencies]
+
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[dependency-groups]
+dev = [
+    "cython>=3.0",
+    "licensecheck>=2025.1.0",
+    "matplotlib>=3.10.9",
+    "pre-commit>=3.5.0",
+    "pyright>=1.1.411",
+    "pytest>=8.3.5",
+    "pytest-benchmark>=5.1.0",
+    "ruff>=0.15.21",
+    "setuptools>=82.0.1",
+    "towncrier>=25.8.0",
+    "tox>=4.23.0",
+    "tox-uv>=1.11.0",
+    "uniplot>=0.23.2",
+    "zensical>=0.0.50",
+]
+
+[tool.pyright]
+typeCheckingMode = "strict"
+
+[tool.towncrier]
+package = "naw"
+package_dir = "src"
+directory = "changes"
+filename = "CHANGELOG.md"
+start_string = "<!-- towncrier release notes start -->\n"
+underlines = ["", "", ""]
+title_format = "## [{version}] - {project_date}"
+issue_format = "[#{issue}]"
+
+[[tool.towncrier.type]]
+directory = "highlight"
+name = "Highlights"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "feature"
+name = "Features"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "bugfix"
+name = "Bugfixes"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "doc"
+name = "Improved Documentation"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "removal"
+name = "Deprecations and Removals"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "misc"
+name = "Misc"
+showcontent = false
+
+[tool.tox]
+env_list = ["py310", "py311", "py312", "py313", "py314"]
+requires = ["tox-uv>=1.11"]
+
+[tool.tox.env_run_base]
+package = "editable"
+dependency_groups = ["dev"]
+commands = [["pytest", "{posargs}"]]

naw-0.0.1/setup.cfg

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

naw-0.0.1/setup.py

@@ -0,0 +1,36 @@
+import typing
+
+import setuptools
+import setuptools.extension
+
+ext_modules: list[typing.Any]
+try:
+    import Cython.Build
+
+    ext_modules = typing.cast(
+        "list[typing.Any]",
+        Cython.Build.cythonize(  # type: ignore[reportUnknownMemberType]
+            [
+                setuptools.extension.Extension(
+                    "baw._leb", sources=["src/baw/_leb.pyx"]
+                ),
+                setuptools.extension.Extension(
+                    "baw._bfloat16", sources=["src/baw/_bfloat16.pyx"]
+                ),
+                setuptools.extension.Extension(
+                    "baw._float16", sources=["src/baw/_float16.pyx"]
+                ),
+                setuptools.extension.Extension(
+                    "baw._float32", sources=["src/baw/_float32.pyx"]
+                ),
+                setuptools.extension.Extension(
+                    "baw._float64", sources=["src/baw/_float64.pyx"]
+                ),
+            ],
+            compiler_directives={"language_level": "3"},
+        ),
+    )
+except ImportError:
+    ext_modules = []
+
+setuptools.setup(ext_modules=ext_modules)

naw-0.0.1/src/naw/_bfloat16.pyi

@@ -0,0 +1,13 @@
+import collections.abc
+
+def write_bfloat16_array(data: collections.abc.Iterable[float]) -> list[int]: ...
+def write_bfloat16_xor_array(
+    values: collections.abc.Iterable[float],
+    previous_values: collections.abc.Iterable[float],
+) -> list[int]: ...
+def read_bfloat16_array(data: bytes, n: int) -> tuple[int, list[float]]: ...
+def read_bfloat16_xor_array(
+    data: bytes,
+    n: int,
+    previous_values: collections.abc.Sequence[float],
+) -> tuple[int, list[float]]: ...

naw-0.0.1/src/naw/_float16.pyi

@@ -0,0 +1,11 @@
+import collections.abc
+
+def write_float16_xor_array(
+    values: collections.abc.Iterable[float],
+    previous_values: collections.abc.Iterable[float],
+) -> list[int]: ...
+def read_float16_xor_array(
+    data: bytes,
+    n: int,
+    previous_values: collections.abc.Sequence[float],
+) -> tuple[int, list[float]]: ...

naw-0.0.1/src/naw/_float32.pyi

@@ -0,0 +1,11 @@
+import collections.abc
+
+def write_float32_xor_array(
+    values: collections.abc.Iterable[float],
+    previous_values: collections.abc.Iterable[float],
+) -> list[int]: ...
+def read_float32_xor_array(
+    data: bytes,
+    n: int,
+    previous_values: collections.abc.Sequence[float],
+) -> tuple[int, list[float]]: ...

naw-0.0.1/src/naw/_float64.pyi

@@ -0,0 +1,11 @@
+import collections.abc
+
+def write_float64_xor_array(
+    values: collections.abc.Iterable[float],
+    previous_values: collections.abc.Iterable[float],
+) -> list[int]: ...
+def read_float64_xor_array(
+    data: bytes,
+    n: int,
+    previous_values: collections.abc.Sequence[float],
+) -> tuple[int, list[float]]: ...

naw-0.0.1/src/naw/_leb.pyi

@@ -0,0 +1,6 @@
+import collections.abc
+
+def read_unsigned_array(data: bytes, n: int) -> tuple[int, list[int]]: ...
+def read_signed_array(data: bytes, n: int) -> tuple[int, list[int]]: ...
+def write_unsigned_array(data: collections.abc.Iterable[int]) -> list[int]: ...
+def write_signed_array(data: collections.abc.Iterable[int]) -> list[int]: ...

naw-0.0.1/src/naw/bench_bfloat16.py

@@ -0,0 +1,69 @@
+import pytest
+import pytest_benchmark.fixture
+
+from . import bfloat16
+
+N = 1000
+
+_float_values = [float(i) for i in range(N)]
+_float_prev_values = [float(i) for i in range(-1, N - 1)]
+_bf16_data = bytes(bfloat16.write_bfloat16_array(_float_values))
+_bf16_xor_data = bytes(
+    bfloat16.write_bfloat16_xor_array(_float_values, _float_prev_values)
+)
+
+
+def test_py_write_bfloat16_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    benchmark(lambda: bfloat16.write_bfloat16_array(_float_values))
+
+
+def test_py_read_bfloat16_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    benchmark(lambda: bfloat16.read_bfloat16_array(_bf16_data, N))
+
+
+def test_py_write_bfloat16_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    benchmark(
+        lambda: bfloat16.write_bfloat16_xor_array(_float_values, _float_prev_values)
+    )
+
+
+def test_py_read_bfloat16_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    benchmark(
+        lambda: bfloat16.read_bfloat16_xor_array(_bf16_xor_data, N, _float_prev_values)
+    )
+
+
+def test_cy_write_bfloat16_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    cy = pytest.importorskip("baw._bfloat16")
+    benchmark(lambda: cy.write_bfloat16_array(_float_values))
+
+
+def test_cy_read_bfloat16_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    cy = pytest.importorskip("baw._bfloat16")
+    benchmark(lambda: cy.read_bfloat16_array(_bf16_data, N))
+
+
+def test_cy_write_bfloat16_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    cy = pytest.importorskip("baw._bfloat16")
+    benchmark(lambda: cy.write_bfloat16_xor_array(_float_values, _float_prev_values))
+
+
+def test_cy_read_bfloat16_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    cy = pytest.importorskip("baw._bfloat16")
+    benchmark(lambda: cy.read_bfloat16_xor_array(_bf16_xor_data, N, _float_prev_values))

naw-0.0.1/src/naw/bench_byteio.py

@@ -0,0 +1,241 @@
+import pytest_benchmark.fixture
+
+from . import byteio
+
+N = 1000
+
+_int_values = list(range(N))
+_float_values = [float(i) for i in range(N)]
+_float_prev_values = [float(i) for i in range(-1, N - 1)]
+
+
+def test_write_sleb_array(benchmark: pytest_benchmark.fixture.BenchmarkFixture) -> None:
+    def run() -> None:
+        w = byteio.Writer()
+        w.write_sleb_array(_int_values)
+
+    benchmark(run)
+
+
+def test_read_sleb_array(benchmark: pytest_benchmark.fixture.BenchmarkFixture) -> None:
+    w = byteio.Writer()
+    w.write_sleb_array(_int_values)
+    data = w.bytes
+
+    def run() -> None:
+        r = byteio.Reader(data)
+        r.read_sleb_array(N)
+
+    benchmark(run)
+
+
+def test_write_uleb_array(benchmark: pytest_benchmark.fixture.BenchmarkFixture) -> None:
+    def run() -> None:
+        w = byteio.Writer()
+        w.write_uleb_array(_int_values)
+
+    benchmark(run)
+
+
+def test_read_uleb_array(benchmark: pytest_benchmark.fixture.BenchmarkFixture) -> None:
+    w = byteio.Writer()
+    w.write_uleb_array(_int_values)
+    data = w.bytes
+
+    def run() -> None:
+        r = byteio.Reader(data)
+        r.read_uleb_array(N)
+
+    benchmark(run)
+
+
+def test_write_float16_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    def run() -> None:
+        w = byteio.Writer()
+        w.write_float16_array(_float_values)
+
+    benchmark(run)
+
+
+def test_read_float16_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    w = byteio.Writer()
+    w.write_float16_array(_float_values)
+    data = w.bytes
+
+    def run() -> None:
+        r = byteio.Reader(data)
+        r.read_float16_array(N)
+
+    benchmark(run)
+
+
+def test_write_float16_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    def run() -> None:
+        w = byteio.Writer()
+        w.write_float16_xor_array(_float_values, _float_prev_values)
+
+    benchmark(run)
+
+
+def test_read_float16_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    w = byteio.Writer()
+    w.write_float16_xor_array(_float_values, _float_prev_values)
+    data = w.bytes
+
+    def run() -> None:
+        r = byteio.Reader(data)
+        r.read_float16_xor_array(N, _float_prev_values)
+
+    benchmark(run)
+
+
+def test_write_bfloat16_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    def run() -> None:
+        w = byteio.Writer()
+        w.write_bfloat16_array(_float_values)
+
+    benchmark(run)
+
+
+def test_read_bfloat16_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    w = byteio.Writer()
+    w.write_bfloat16_array(_float_values)
+    data = w.bytes
+
+    def run() -> None:
+        r = byteio.Reader(data)
+        r.read_bfloat16_array(N)
+
+    benchmark(run)
+
+
+def test_write_bfloat16_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    def run() -> None:
+        w = byteio.Writer()
+        w.write_bfloat16_xor_array(_float_values, _float_prev_values)
+
+    benchmark(run)
+
+
+def test_read_bfloat16_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    w = byteio.Writer()
+    w.write_bfloat16_xor_array(_float_values, _float_prev_values)
+    data = w.bytes
+
+    def run() -> None:
+        r = byteio.Reader(data)
+        r.read_bfloat16_xor_array(N, _float_prev_values)
+
+    benchmark(run)
+
+
+def test_write_float32_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    def run() -> None:
+        w = byteio.Writer()
+        w.write_float32_array(_float_values)
+
+    benchmark(run)
+
+
+def test_read_float32_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    w = byteio.Writer()
+    w.write_float32_array(_float_values)
+    data = w.bytes
+
+    def run() -> None:
+        r = byteio.Reader(data)
+        r.read_float32_array(N)
+
+    benchmark(run)
+
+
+def test_write_float32_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    def run() -> None:
+        w = byteio.Writer()
+        w.write_float32_xor_array(_float_values, _float_prev_values)
+
+    benchmark(run)
+
+
+def test_read_float32_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    w = byteio.Writer()
+    w.write_float32_xor_array(_float_values, _float_prev_values)
+    data = w.bytes
+
+    def run() -> None:
+        r = byteio.Reader(data)
+        r.read_float32_xor_array(N, _float_prev_values)
+
+    benchmark(run)
+
+
+def test_write_float64_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    def run() -> None:
+        w = byteio.Writer()
+        w.write_float64_array(_float_values)
+
+    benchmark(run)
+
+
+def test_read_float64_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    w = byteio.Writer()
+    w.write_float64_array(_float_values)
+    data = w.bytes
+
+    def run() -> None:
+        r = byteio.Reader(data)
+        r.read_float64_array(N)
+
+    benchmark(run)
+
+
+def test_write_float64_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    def run() -> None:
+        w = byteio.Writer()
+        w.write_float64_xor_array(_float_values, _float_prev_values)
+
+    benchmark(run)
+
+
+def test_read_float64_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    w = byteio.Writer()
+    w.write_float64_xor_array(_float_values, _float_prev_values)
+    data = w.bytes
+
+    def run() -> None:
+        r = byteio.Reader(data)
+        r.read_float64_xor_array(N, _float_prev_values)
+
+    benchmark(run)

naw-0.0.1/src/naw/bench_float16.py

@@ -0,0 +1,38 @@
+import pytest
+import pytest_benchmark.fixture
+
+from . import float16
+
+N = 1000
+
+_float_values = [float(i) for i in range(N)]
+_float_prev_values = [float(i) for i in range(-1, N - 1)]
+_xor_data = bytes(float16.write_float16_xor_array(_float_values, _float_prev_values))
+
+
+def test_py_write_float16_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    benchmark(
+        lambda: float16.write_float16_xor_array(_float_values, _float_prev_values)
+    )
+
+
+def test_py_read_float16_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    benchmark(lambda: float16.read_float16_xor_array(_xor_data, N, _float_prev_values))
+
+
+def test_cy_write_float16_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    cy = pytest.importorskip("baw._float16")
+    benchmark(lambda: cy.write_float16_xor_array(_float_values, _float_prev_values))
+
+
+def test_cy_read_float16_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    cy = pytest.importorskip("baw._float16")
+    benchmark(lambda: cy.read_float16_xor_array(_xor_data, N, _float_prev_values))

naw-0.0.1/src/naw/bench_float32.py

@@ -0,0 +1,38 @@
+import pytest
+import pytest_benchmark.fixture
+
+from . import float32
+
+N = 1000
+
+_float_values = [float(i) for i in range(N)]
+_float_prev_values = [float(i) for i in range(-1, N - 1)]
+_xor_data = bytes(float32.write_float32_xor_array(_float_values, _float_prev_values))
+
+
+def test_py_write_float32_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    benchmark(
+        lambda: float32.write_float32_xor_array(_float_values, _float_prev_values)
+    )
+
+
+def test_py_read_float32_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    benchmark(lambda: float32.read_float32_xor_array(_xor_data, N, _float_prev_values))
+
+
+def test_cy_write_float32_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    cy = pytest.importorskip("baw._float32")
+    benchmark(lambda: cy.write_float32_xor_array(_float_values, _float_prev_values))
+
+
+def test_cy_read_float32_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    cy = pytest.importorskip("baw._float32")
+    benchmark(lambda: cy.read_float32_xor_array(_xor_data, N, _float_prev_values))

naw-0.0.1/src/naw/bench_float64.py

@@ -0,0 +1,38 @@
+import pytest
+import pytest_benchmark.fixture
+
+from . import float64
+
+N = 1000
+
+_float_values = [float(i) for i in range(N)]
+_float_prev_values = [float(i) for i in range(-1, N - 1)]
+_xor_data = bytes(float64.write_float64_xor_array(_float_values, _float_prev_values))
+
+
+def test_py_write_float64_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    benchmark(
+        lambda: float64.write_float64_xor_array(_float_values, _float_prev_values)
+    )
+
+
+def test_py_read_float64_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    benchmark(lambda: float64.read_float64_xor_array(_xor_data, N, _float_prev_values))
+
+
+def test_cy_write_float64_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    cy = pytest.importorskip("baw._float64")
+    benchmark(lambda: cy.write_float64_xor_array(_float_values, _float_prev_values))
+
+
+def test_cy_read_float64_xor_array(
+    benchmark: pytest_benchmark.fixture.BenchmarkFixture,
+) -> None:
+    cy = pytest.importorskip("baw._float64")
+    benchmark(lambda: cy.read_float64_xor_array(_xor_data, N, _float_prev_values))