bytesz 0.2.0__tar.gz

bytesz-0.2.0/.gitattributes

@@ -0,0 +1 @@
+* text=auto eol=lf

bytesz-0.2.0/.gitignore

@@ -0,0 +1,12 @@
+__pycache__/
+*.py[cod]
+.venv/
+venv/
+build/
+dist/
+*.egg-info/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/

bytesz-0.2.0/CHANGELOG.md

@@ -0,0 +1,57 @@
+# Changelog
+
+All notable changes to this project are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project uses
+[Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.2.0]
+
+### Added
+
+- The 2022 SI prefixes ronna and quetta (`RB`, `QB`) and the IEC 80000-13:2025
+  prefixes robi and quebi (`RiB`, `QiB`).
+- `format` options (also on `format_bits`): `system` may be omitted and then follows
+  `unit` (default IEC); `rounding` (`half-up`, `half-even`, `half-down`, `up`, `down`,
+  `ceiling`, `floor`), `unit` to force one unit, `signed`, `trailing_zeros`,
+  `decimal_point` and `separator`.
+- `parse` options: `rounding` for values that are not whole bytes, `signed`,
+  `decimal_point`, and an opt-in `legacy` mode that reads `KB`, `MB`, `GB` (and bare
+  `K`, `M`, `G`) as powers of 1024. Bare IEC prefixes (`1.5Mi`) are accepted, and bare
+  SI prefixes (`1.5M`) when `system="si"` is pinned, matching `numfmt` output.
+- `parse_bits` and `format_bits` for bit counts with the `bit` symbol.
+- `convert(count, unit)` for the exact `Decimal` value in one unit.
+- Typed errors `UnknownUnitError`, `SystemMismatchError` and `FractionalBytesError`,
+  all subclasses of `InvalidSizeError`; every error carries `.text` and `.unit`.
+- `System` and `Rounding` type aliases, `IEC_SUFFIXES` and `SI_SUFFIXES`.
+- A `bytesz` command with `format` and `parse` subcommands, stdin input and a
+  numfmt style `--field` option. Also runnable as `python -m bytesz`.
+- GUIDE.md.
+
+### Changed
+
+- Rounding now carries into the next unit: `format(1048575)` is `"1 MiB"` instead of
+  `"1024 KiB"`.
+- Counts of 1024**9 bytes and above now use `RiB` and `QiB` (and `RB`, `QB` for SI)
+  instead of large numbers of `YiB`.
+- A lower case `b` in `parse` now explains that it means bits, and a bit unit such
+  as `Kibit` raises `UnknownUnitError` pointing at `parse_bits`.
+
+### Fixed
+
+- Parsing stays exact for long inputs and the largest units; the default decimal
+  context used to round products above 28 digits.
+- Arithmetic runs in a private decimal context, so a caller's global settings
+  (traps, precision, exponent limits) no longer change or break the results.
+
+## [0.1.0]
+
+- `parse` turns a human size into an exact integer number of bytes, choosing the
+  system from the unit: IEC suffixes (KiB, MiB) use 1024 and SI suffixes (kB, MB)
+  use 1000.
+- `format` turns a byte count into a human size for either system with a chosen
+  precision.
+- Strict by design: ambiguous spellings such as `KB` raise `AmbiguousUnitError`,
+  and inputs that do not land on a whole byte raise `InvalidSizeError`.
+- `system` can pin `parse` to one system so the other is rejected.

bytesz-0.2.0/CONTRIBUTING.md

@@ -0,0 +1,22 @@
+# Contributing
+
+Thanks for taking the time. This project keeps a small, predictable shape.
+
+## Setup
+
+```
+pip install -r requirements-dev.txt
+```
+
+## Before you open a pull request
+
+- Keep public API in `src/bytesz/__init__.py`; internals live in `_`-prefixed modules.
+- Add a test for the behaviour you change. Tests inject time, disk and network; they
+  never touch the real thing.
+- Run `scripts/check.ps1` (format, lint, types, tests, and an end to end run of the
+  built wheel through `scripts/e2e_wheel.py`) and make sure it passes. The GNU
+  `numfmt` cross-check runs when WSL with GNU coreutils is available and is skipped
+  otherwise.
+- One logical change per commit, imperative subject line.
+
+Open an issue first if the change is large or shifts the public API.

bytesz-0.2.0/GUIDE.md

@@ -0,0 +1,141 @@
+# bytesz guide
+
+This guide explains the rules `bytesz` follows and why. The short version: the unit
+alone decides the meaning, arithmetic is exact, and nothing ambiguous is guessed.
+
+## Two systems
+
+| Factor | IEC symbol | IEC name | SI symbol | SI name | SI factor |
+| ------ | ---------- | -------- | --------- | ------- | --------- |
+| 1024^1 | KiB | kibibyte | kB | kilobyte | 1000^1 |
+| 1024^2 | MiB | mebibyte | MB | megabyte | 1000^2 |
+| 1024^3 | GiB | gibibyte | GB | gigabyte | 1000^3 |
+| 1024^4 | TiB | tebibyte | TB | terabyte | 1000^4 |
+| 1024^5 | PiB | pebibyte | PB | petabyte | 1000^5 |
+| 1024^6 | EiB | exbibyte | EB | exabyte | 1000^6 |
+| 1024^7 | ZiB | zebibyte | ZB | zettabyte | 1000^7 |
+| 1024^8 | YiB | yobibyte | YB | yottabyte | 1000^8 |
+| 1024^9 | RiB | robibyte | RB | ronnabyte | 1000^9 |
+| 1024^10 | QiB | quebibyte | QB | quettabyte | 1000^10 |
+
+- The IEC binary prefixes were approved in December 1998 and published as an
+  amendment to IEC 60027-2; NIST documents them at
+  https://physics.nist.gov/cuu/Units/binary.html. NIST notes that they are not part
+  of the SI and that the symbol is `Ki`, not `ki`.
+- Zebi and yobi were added in 2005. Ronna and quetta joined the SI in 2022
+  (https://www.bipm.org/en/measurement-units/si-prefixes), and their binary partners
+  robi and quebi were adopted in IEC 80000-13:2025.
+- The SI kilo is a lower case `k`. `bytesz` writes `kB` and refuses `KB` by default.
+
+## Case rules
+
+Units are case sensitive because case carries meaning: `B` is a byte, `b` is a bit,
+`k` is kilo, `Ki` is kibi. `parse` accepts exactly the symbols above plus `B`, the
+bare IEC prefixes (`1.5Mi`, as `numfmt --to=iec-i` writes them), and a bare number.
+Anything that only matches when case is ignored (`KB`, `kib`, `Mb`, `GIB`) raises
+`AmbiguousUnitError`; anything else raises `UnknownUnitError`. Whitespace between the
+number and the unit is optional (`1.5GB` and `512 MiB` both work).
+
+## The legacy "KB = 1024" usage
+
+Before 1999, and still today in places, `KB`, `MB` and `GB` meant powers of 1024.
+JEDEC keeps those definitions for semiconductor memory, saying they are "included
+only to reflect common usage", and several operating systems label sizes that way.
+NIST also recalls the "1.44 MB" diskette, which holds 1 474 560 bytes: 1440 times
+1024, a third meaning of megabyte. So `KB` really is ambiguous, and `bytesz` will not
+pick a side for you. If your input comes from such a source, say so:
+
+```python
+from bytesz import parse
+
+parse("4 GB", legacy=True)  # 4294967296
+parse("4G", legacy=True)  # 4294967296, bare prefixes as numfmt --from=iec reads them
+parse("4 kB", legacy=True)  # 4000, lower case k is never legacy
+```
+
+`legacy=True` cannot be combined with `system="si"`. Pinning `system="si"` on its
+own makes bare prefixes (`1.5M`, `2K`) mean powers of 1000, as `numfmt --from=si` does.
+
+## Bits
+
+`parse` rejects `Mb` because a bit rate mistaken for a byte size is off by a factor
+of eight. Use `parse_bits` and `format_bits` for bit counts. They write the
+unambiguous `bit` symbol (`kbit`, `Mibit`) and also read the short `b` form (`kb`,
+`Mb`, `Kib`). Upper case `Kb` stays ambiguous there too.
+
+## Rounding and carry
+
+`format` picks the largest unit that keeps the number at one or more, rounds to
+`precision` decimals (default 2) and drops trailing zeros unless
+`trailing_zeros=True`. If rounding pushes the number up to the base, it carries:
+1048575 bytes is `1 MiB`, not `1024 KiB`. Note what that means for IEC: 999.95 KiB
+rounds to `1000 KiB` at one decimal, and that is correct, because 1000 KiB is still
+below 1024 KiB. In SI, 999.95 kB does carry to `1 MB`. GNU `numfmt` behaves the same.
+
+| bytesz rounding | ties | numfmt `--round` |
+| --------------- | ---- | ---------------- |
+| `half-up` (default) | away from zero | `nearest` |
+| `half-even` | to the even digit | none |
+| `half-down` | toward zero | none |
+| `up` | away from zero always | `from-zero` |
+| `down` | toward zero always | `towards-zero` |
+| `ceiling` | toward positive infinity | `up` |
+| `floor` | toward negative infinity | `down` |
+
+Note that `numfmt` defaults to `from-zero` while `bytesz` defaults to `half-up`.
+Pass `unit="MiB"` to force a unit; there is no carry then, and the unit picks the
+system unless you also pass `system` (a unit from the other one raises
+`SystemMismatchError`). `convert(count, unit)`
+gives the exact `Decimal` value with no rounding at all.
+
+## Fractions when parsing
+
+`parse("1.5 B")` raises `FractionalBytesError`: half a byte is a bug in the input.
+Pass a rounding mode when you would rather round: `parse("0.1 KiB",
+rounding="half-up")` is 102.
+
+## Exactness and huge values
+
+All arithmetic is integer or `Decimal` with enough precision for the input, so
+`parse("123456789012345678901234567890 QiB")` is exact and
+`parse(format(n, precision=110)) == n` holds for any `n`. Every power of 1000 or 1024
+divides into a terminating decimal, so `convert` never rounds.
+
+## Signs and separators
+
+Negative values are refused unless `signed=True`, which also allows a leading `+`
+when parsing. `decimal_point=","` reads and writes a comma; it is never inferred
+from the locale. `separator` sets the text between number and unit when formatting.
+
+## Errors
+
+| Error | Raised when | Subclass of |
+| ----- | ----------- | ----------- |
+| `ByteszError` | base class | `ValueError` |
+| `InvalidSizeError` | malformed input, a sign without `signed=True` | `ByteszError` |
+| `AmbiguousUnitError` | `KB`, `Mb`, `kib`, a bare `M` unless `system="si"` or `legacy=True` | `ByteszError` |
+| `UnknownUnitError` | not a size unit, or a bit unit given to `parse` (and the reverse) | `InvalidSizeError` |
+| `SystemMismatchError` | an SI unit with `system="iec"` or the reverse | `InvalidSizeError` |
+| `FractionalBytesError` | not a whole byte and no `rounding` | `InvalidSizeError` |
+
+Each carries `.text` (the input) and `.unit` (the unit involved) when known. Bad
+option values (an unknown `system` or `rounding`) raise a plain `ValueError`, and a
+non-string input to `parse` raises `TypeError`.
+
+## Command line
+
+```
+bytesz format [--system iec|si] [--precision N] [--rounding MODE] [--unit U]
+              [--signed] [--trailing-zeros] [--separator S] [--decimal-point ,]
+              [--bits] [--field N] [VALUES ...]
+bytesz parse  [--system iec|si] [--legacy] [--rounding MODE] [--signed]
+              [--decimal-point ,] [--bits] [--field N] [VALUES ...]
+```
+
+With no values, each line of stdin is one value. `--field N` converts only the Nth
+whitespace separated field and keeps the rest of the line, so a size in that field
+must be written without an inner space (`1.5MiB`). Blank lines pass through and a
+leading byte order mark is ignored. `format` takes plain ASCII integers only. The
+first error stops the run, goes to stderr, and the exit status is 1; usage errors,
+such as a negative `--precision` or an unknown `--unit`, exit with 2. Messages name
+the flags (`--signed`, `--legacy`) rather than the keyword arguments.

bytesz-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Javier Lianes
+
+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.

bytesz-0.2.0/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.5
+Name: bytesz
+Version: 0.2.0
+Summary: Strict two-way conversion between byte counts and human sizes with explicit IEC and SI units
+Project-URL: Homepage, https://lianes8studio.com
+Project-URL: Repository, https://github.com/JaviLianes8/bytesz
+Project-URL: Issues, https://github.com/JaviLianes8/bytesz/issues
+Project-URL: Changelog, https://github.com/JaviLianes8/bytesz/blob/main/CHANGELOG.md
+Project-URL: LinkedIn, https://www.linkedin.com/in/jlianes/
+Project-URL: Funding, https://buymeacoffee.com/jlianesglrs
+Author-email: Javier Lianes <javier@lianes8studio.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: bytes,format,human,iec,kib,mib,numfmt,parse,si,size
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# bytesz
+
+Strict two-way conversion between byte counts and human sizes with explicit IEC and SI units.
+Typed, exact (integer and `Decimal` arithmetic only), zero dependencies, with a small CLI.
+
+## Install
+
+```
+pip install bytesz
+```
+
+## Usage
+
+```python
+from bytesz import format, parse
+
+# Human size to an exact integer number of bytes. The unit picks the system.
+parse("1.5 MiB")  # 1572864     (IEC, 1024 based)
+parse("1.5 MB")  # 1500000     (SI, 1000 based)
+parse("512 B")  # 512
+parse("2048")  # 2048        (a bare number is bytes)
+
+# Bytes back to a human size, for whichever system you ask for.
+format(1572864)  # "1.5 MiB"   (IEC is the default)
+format(1500000, system="si")  # "1.5 MB"
+format(1234567, system="si", precision=2)  # "1.23 MB"
+format(1048575)  # "1 MiB"     (rounding carries into the next unit)
+```
+
+It refuses to guess:
+
+```python
+from bytesz import AmbiguousUnitError, FractionalBytesError, SystemMismatchError, parse
+
+parse("1 KB")  # AmbiguousUnitError: KB could mean kB (1000) or KiB (1024)
+parse("100 Mb")  # AmbiguousUnitError: a lower case b means bits, see parse_bits
+parse("1.5 B")  # FractionalBytesError: not a whole number of bytes
+parse("1 kB", system="iec")  # SystemMismatchError: an SI unit under a pinned IEC system
+```
+
+Every input error is a `ByteszError` (a `ValueError`) carrying `.text` and `.unit`. Bad
+option values raise a plain `ValueError`, and a non-string input to `parse` a `TypeError`.
+
+## Options
+
+```python
+from bytesz import convert, format, format_bits, parse, parse_bits
+
+# Formatting
+format(1250, system="si", precision=1, rounding="half-even")  # "1.2 kB"
+format(1_000_000, unit="MiB")  # "0.95 MiB"
+format(5000, unit="kB")  # "5 kB" (the unit picks the system)
+format(-1536, signed=True)  # "-1.5 KiB"
+format(1536, precision=3, trailing_zeros=True)  # "1.500 KiB"
+format(1536, decimal_point=",", separator="")  # "1,5KiB"
+
+# Parsing
+parse("1.0005 kB", rounding="half-up")  # 1001
+parse("1,5 MiB", decimal_point=",")  # 1572864
+parse("-2 KiB", signed=True)  # -2048
+parse("1.5M", system="si")  # 1500000 (bare prefixes, as numfmt writes them)
+parse("1.5Mi")  # 1572864 (bare IEC prefix)
+parse("4 GB", legacy=True)  # 4294967296 (JEDEC style KB/MB/GB = 1024, opt-in)
+
+# Bits, with the unambiguous "bit" symbol
+parse_bits("100 Mbit")  # 100000000
+format_bits(1_500_000, system="si")  # "1.5 Mbit"
+
+# Exact value in one unit, no rounding at all
+convert(1, "KiB")  # Decimal("0.0009765625")
+```
+
+Rounding modes: `half-up` (default, ties away from zero), `half-even`, `half-down`,
+`up`, `down`, `ceiling`, `floor`. Units reach the 2022 SI prefixes `RB` and `QB` and
+the IEC 80000-13:2025 prefixes `RiB` and `QiB`.
+
+## Command line
+
+```
+bytesz format 1572864                 # 1.5 MiB
+bytesz format --system si 1234567     # 1.23 MB
+bytesz parse "1.5 MiB" 2GB            # 1572864, 2000000000
+bytesz parse --legacy 4KB             # 4096
+du -b * | bytesz format --field 1     # rewrite one column, like numfmt --field
+```
+
+Values come from the arguments or, when there are none, one per line from stdin.
+Errors go to stderr with exit status 1. `bytesz --help` lists every option.
+
+## Why
+
+Human byte sizes are a well known trap: `KB` means 1000 bytes to a disk vendor and
+1024 bytes to an operating system, and most libraries quietly pick one. The popular
+options lean on guessing or only go one way: `humanize` and `hurry.filesize` format
+numbers but do not parse them back, `humanfriendly` parses but treats `KB` and `KiB`
+as the same 1024 based value, and `bitmath` mixes bits and bytes with a broad API.
+
+`bytesz` is deliberately narrow and strict. The unit alone decides the system, both
+directions are exact, and anything ambiguous or fractional is rejected with a clear
+error instead of being rounded, unless you ask for rounding. Reach for it when a
+wrong factor of 1024 would be a real bug, such as quotas, billing, or on-disk
+accounting. With matching `--round` and `--format=%.Nf`, its formatting agrees with
+GNU `numfmt` (checked in the test suite on seeded values), except where `numfmt` itself
+drifts because it divides in floating point.
+
+See [GUIDE.md](GUIDE.md) for the rules in depth.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+## Links
+
+- Website: https://lianes8studio.com
+- GitHub: https://github.com/JaviLianes8
+- LinkedIn: https://www.linkedin.com/in/jlianes/

bytesz-0.2.0/README.md

@@ -0,0 +1,116 @@
+# bytesz
+
+Strict two-way conversion between byte counts and human sizes with explicit IEC and SI units.
+Typed, exact (integer and `Decimal` arithmetic only), zero dependencies, with a small CLI.
+
+## Install
+
+```
+pip install bytesz
+```
+
+## Usage
+
+```python
+from bytesz import format, parse
+
+# Human size to an exact integer number of bytes. The unit picks the system.
+parse("1.5 MiB")  # 1572864     (IEC, 1024 based)
+parse("1.5 MB")  # 1500000     (SI, 1000 based)
+parse("512 B")  # 512
+parse("2048")  # 2048        (a bare number is bytes)
+
+# Bytes back to a human size, for whichever system you ask for.
+format(1572864)  # "1.5 MiB"   (IEC is the default)
+format(1500000, system="si")  # "1.5 MB"
+format(1234567, system="si", precision=2)  # "1.23 MB"
+format(1048575)  # "1 MiB"     (rounding carries into the next unit)
+```
+
+It refuses to guess:
+
+```python
+from bytesz import AmbiguousUnitError, FractionalBytesError, SystemMismatchError, parse
+
+parse("1 KB")  # AmbiguousUnitError: KB could mean kB (1000) or KiB (1024)
+parse("100 Mb")  # AmbiguousUnitError: a lower case b means bits, see parse_bits
+parse("1.5 B")  # FractionalBytesError: not a whole number of bytes
+parse("1 kB", system="iec")  # SystemMismatchError: an SI unit under a pinned IEC system
+```
+
+Every input error is a `ByteszError` (a `ValueError`) carrying `.text` and `.unit`. Bad
+option values raise a plain `ValueError`, and a non-string input to `parse` a `TypeError`.
+
+## Options
+
+```python
+from bytesz import convert, format, format_bits, parse, parse_bits
+
+# Formatting
+format(1250, system="si", precision=1, rounding="half-even")  # "1.2 kB"
+format(1_000_000, unit="MiB")  # "0.95 MiB"
+format(5000, unit="kB")  # "5 kB" (the unit picks the system)
+format(-1536, signed=True)  # "-1.5 KiB"
+format(1536, precision=3, trailing_zeros=True)  # "1.500 KiB"
+format(1536, decimal_point=",", separator="")  # "1,5KiB"
+
+# Parsing
+parse("1.0005 kB", rounding="half-up")  # 1001
+parse("1,5 MiB", decimal_point=",")  # 1572864
+parse("-2 KiB", signed=True)  # -2048
+parse("1.5M", system="si")  # 1500000 (bare prefixes, as numfmt writes them)
+parse("1.5Mi")  # 1572864 (bare IEC prefix)
+parse("4 GB", legacy=True)  # 4294967296 (JEDEC style KB/MB/GB = 1024, opt-in)
+
+# Bits, with the unambiguous "bit" symbol
+parse_bits("100 Mbit")  # 100000000
+format_bits(1_500_000, system="si")  # "1.5 Mbit"
+
+# Exact value in one unit, no rounding at all
+convert(1, "KiB")  # Decimal("0.0009765625")
+```
+
+Rounding modes: `half-up` (default, ties away from zero), `half-even`, `half-down`,
+`up`, `down`, `ceiling`, `floor`. Units reach the 2022 SI prefixes `RB` and `QB` and
+the IEC 80000-13:2025 prefixes `RiB` and `QiB`.
+
+## Command line
+
+```
+bytesz format 1572864                 # 1.5 MiB
+bytesz format --system si 1234567     # 1.23 MB
+bytesz parse "1.5 MiB" 2GB            # 1572864, 2000000000
+bytesz parse --legacy 4KB             # 4096
+du -b * | bytesz format --field 1     # rewrite one column, like numfmt --field
+```
+
+Values come from the arguments or, when there are none, one per line from stdin.
+Errors go to stderr with exit status 1. `bytesz --help` lists every option.
+
+## Why
+
+Human byte sizes are a well known trap: `KB` means 1000 bytes to a disk vendor and
+1024 bytes to an operating system, and most libraries quietly pick one. The popular
+options lean on guessing or only go one way: `humanize` and `hurry.filesize` format
+numbers but do not parse them back, `humanfriendly` parses but treats `KB` and `KiB`
+as the same 1024 based value, and `bitmath` mixes bits and bytes with a broad API.
+
+`bytesz` is deliberately narrow and strict. The unit alone decides the system, both
+directions are exact, and anything ambiguous or fractional is rejected with a clear
+error instead of being rounded, unless you ask for rounding. Reach for it when a
+wrong factor of 1024 would be a real bug, such as quotas, billing, or on-disk
+accounting. With matching `--round` and `--format=%.Nf`, its formatting agrees with
+GNU `numfmt` (checked in the test suite on seeded values), except where `numfmt` itself
+drifts because it divides in floating point.
+
+See [GUIDE.md](GUIDE.md) for the rules in depth.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+## Links
+
+- Website: https://lianes8studio.com
+- GitHub: https://github.com/JaviLianes8
+- LinkedIn: https://www.linkedin.com/in/jlianes/

bytesz-0.2.0/pyproject.toml

@@ -0,0 +1,61 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "bytesz"
+version = "0.2.0"
+description = "Strict two-way conversion between byte counts and human sizes with explicit IEC and SI units"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Javier Lianes", email = "javier@lianes8studio.com" }]
+keywords = ["bytes", "size", "human", "iec", "si", "kib", "mib", "numfmt", "parse", "format"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Environment :: Console",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Utilities",
+    "Typing :: Typed",
+]
+dependencies = []
+
+[project.scripts]
+bytesz = "bytesz._cli:main"
+
+[project.optional-dependencies]
+dev = ["ruff", "mypy", "pytest", "build", "twine"]
+
+[project.urls]
+Homepage = "https://lianes8studio.com"
+Repository = "https://github.com/JaviLianes8/bytesz"
+Issues = "https://github.com/JaviLianes8/bytesz/issues"
+Changelog = "https://github.com/JaviLianes8/bytesz/blob/main/CHANGELOG.md"
+LinkedIn = "https://www.linkedin.com/in/jlianes/"
+Funding = "https://buymeacoffee.com/jlianesglrs"
+
+[tool.hatch.build.targets.sdist]
+exclude = ["IMPROVEMENTS-round*.md", ".github"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/bytesz"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM", "RUF"]
+
+[tool.mypy]
+python_version = "3.10"
+strict = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+addopts = "-q"

bytesz-0.2.0/requirements-dev.txt

@@ -0,0 +1,3 @@
+# Development dependencies: the package in editable mode plus its dev extras
+# (ruff, mypy, pytest, build, twine). Install with:  pip install -r requirements-dev.txt
+-e .[dev]

bytesz-0.2.0/scripts/check.ps1

@@ -0,0 +1,8 @@
+# Local quality gate. Run before every commit. No CI runs in the cloud.
+$ErrorActionPreference = "Stop"
+
+ruff format --check .
+ruff check .
+mypy --strict src tests
+pytest
+python scripts/e2e_wheel.py