u 0.1__tar.gz

u-0.1/.gitignore

@@ -0,0 +1,10 @@
+# python generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# venv
+.venv

u-0.1/.python-version

@@ -0,0 +1 @@
+3.12.2

u-0.1/.vscode/settings.json

@@ -0,0 +1,7 @@
+{
+    "python.testing.pytestArgs": [
+        "tests"
+    ],
+    "python.testing.unittestEnabled": false,
+    "python.testing.pytestEnabled": true
+}

u-0.1/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.3
+Name: u
+Version: 0.1
+Summary: Statically typed units
+Author-email: Aran-Fey <rawing7@gmail.com>
+Requires-Python: >=3.8
+Requires-Dist: typing-extensions
+Description-Content-Type: text/markdown
+
+# u
+
+Statically typed units.
+
+## Quickstart
+
+```python
+# Type safe assignments
+duration: u.Duration = u.seconds(5)  # Ok
+distance: u.Distance = u.amperes(5)  # Type checking error
+
+# Type safe math
+print(u.seconds(120) + u.minutes(3))  # Ok
+print(u.seconds(120) + u.amperes(3))  # Type checking error
+
+# Type safe compound units (with some caveats)
+speed: u.Div[u.Distance, u.Duration] = u.km(5) / u.hours(1)  # Ok
+
+# Reusable prefixes
+print(u.bytes(1000) == u.mega(u.bytes)(1))
+
+# Define your own Quantities and Units
+class Tastiness(u.Quantity):
+    pass
+
+mmm = u.Unit[Tastiness](symbol='mmm', multiplier=1)
+yum = u.Unit[Tastiness]('yum', 10)
+```

u-0.1/README.md

@@ -0,0 +1,28 @@
+# u
+
+Statically typed units.
+
+## Quickstart
+
+```python
+# Type safe assignments
+duration: u.Duration = u.seconds(5)  # Ok
+distance: u.Distance = u.amperes(5)  # Type checking error
+
+# Type safe math
+print(u.seconds(120) + u.minutes(3))  # Ok
+print(u.seconds(120) + u.amperes(3))  # Type checking error
+
+# Type safe compound units (with some caveats)
+speed: u.Div[u.Distance, u.Duration] = u.km(5) / u.hours(1)  # Ok
+
+# Reusable prefixes
+print(u.bytes(1000) == u.mega(u.bytes)(1))
+
+# Define your own Quantities and Units
+class Tastiness(u.Quantity):
+    pass
+
+mmm = u.Unit[Tastiness](symbol='mmm', multiplier=1)
+yum = u.Unit[Tastiness]('yum', 10)
+```

u-0.1/__init__.py

@@ -0,0 +1,18 @@
+
+# fake module that resides in my lib folder and
+# imports the actual implementation
+
+from pathlib import Path
+
+here = Path(__file__).absolute().parent
+name = here.stem
+
+
+import sys
+sys.path.insert(0, str(here))
+del sys.modules[name]
+module = __import__(name)
+del sys.path[0]
+
+del Path, here, name, sys
+globals().update(module.__dict__)

u-0.1/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "u"
+description = "Statically typed units"
+authors = [{ name = "Aran-Fey", email = "rawing7@gmail.com" }]
+dependencies = ["typing-extensions"]
+readme = "README.md"
+requires-python = ">= 3.8"
+dynamic = ["version"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+path = "u/__init__.py"
+
+[tool.rye]
+managed = true
+dev-dependencies = ["pytest"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["u"]

u-0.1/requirements-dev.lock

@@ -0,0 +1,19 @@
+# generated by rye
+# use `rye lock` or `rye sync` to update this lockfile
+#
+# last locked with the following flags:
+#   pre: false
+#   features: []
+#   all-features: false
+#   with-sources: false
+
+-e file:.
+iniconfig==2.0.0
+    # via pytest
+packaging==24.0
+    # via pytest
+pluggy==1.5.0
+    # via pytest
+pytest==8.1.1
+typing-extensions==4.11.0
+    # via u

u-0.1/requirements.lock

@@ -0,0 +1,12 @@
+# generated by rye
+# use `rye lock` or `rye sync` to update this lockfile
+#
+# last locked with the following flags:
+#   pre: false
+#   features: []
+#   all-features: false
+#   with-sources: false
+
+-e file:.
+typing-extensions==4.11.0
+    # via u

u-0.1/tests/test_conversions.py

@@ -0,0 +1,38 @@
+import pytest
+
+import u
+from u import Quantity, Unit
+
+
+@pytest.mark.parametrize(
+    "value, unit, expected_result",
+    [
+        (u.meters(7_000), u.kilometers, 7),
+        (u.kilometers(3.5), u.meters, 3_500),
+        # (u.celsius(10), u.kelvin, 283.15),
+        # (u.kelvin(100), u.celsius, -173.15),
+        # (u.kelvin(0), u.fahrenheit, -459.67),
+        # (u.fahrenheit(50), u.kelvin, 283.15),
+        (u.meters_per_second(1234), u.kilometers / u.seconds, 1.234),
+        (u.meters_per_second(1), u.meters / u.minutes, 60),
+        (u.kilometers_per_hour(90), u.meters_per_second, 25),
+        (u.meters_per_second(30), u.kilometers_per_hour, 108),
+        (u.square_meters(1_000_000), u.square_kilometers, 1),
+    ],
+)
+def test_to_number(value: Quantity, unit: Unit, expected_result: float):
+    result = value.to_number(unit)
+    assert result == pytest.approx(expected_result)
+
+
+@pytest.mark.parametrize(
+    "value, expected_result",
+    [
+        (u.meters(7), "7m"),
+        (u.kilometers(3.5), "3.5km"),
+        (u.meters_per_second(5), "5m/s"),
+        (u.square_meters(3), "3m²"),
+    ],
+)
+def test_to_string(value: Quantity, expected_result: str):
+    assert str(value) == expected_result

u-0.1/tests/test_math.py

@@ -0,0 +1,48 @@
+import pytest
+
+import u
+
+
+@pytest.mark.parametrize(
+    "result, expected_result",
+    [
+        (u.seconds(10) + u.seconds(5), u.seconds(15)),
+        (u.seconds(10) + u.seconds(50), u.minutes(1)),
+        (u.hours(0.25) + u.hours(0.5), u.minutes(45)),
+    ],
+)
+def test_addition(result: u.Quantity, expected_result: u.Quantity):
+    assert result == expected_result
+
+
+@pytest.mark.parametrize(
+    "result, expected_result",
+    [
+        (u.seconds(10) - u.seconds(3), u.seconds(7)),
+        (u.seconds(70) - u.seconds(10), u.minutes(1)),
+        (u.hours(0.75) - u.hours(0.5), u.minutes(15)),
+    ],
+)
+def test_subtraction(result: u.Quantity, expected_result: u.Quantity):
+    assert result == expected_result
+
+
+@pytest.mark.parametrize(
+    "result, expected_result",
+    [
+        (u.meters(10) * u.meters(5), u.square_meters(50)),
+        (u.meters(10) * u.meters(5), u.square_meters(50)),
+    ],
+)
+def test_multiplication(result: u.Quantity, expected_result: u.Quantity):
+    assert result == expected_result
+
+
+@pytest.mark.parametrize(
+    "result, expected_result",
+    [
+        (u.meters(10) / u.seconds(5), u.meters_per_second(2)),
+    ],
+)
+def test_division(result: u.Quantity, expected_result: u.Quantity):
+    assert result == expected_result

u-0.1/u/__init__.py

@@ -0,0 +1,5 @@
+__version__ = "0.1"
+
+from .prefixes import *
+from .quantity_and_unit import *
+from .quantities import *

u-0.1/u/_utils.py

@@ -0,0 +1,21 @@
+import functools
+from typing import Callable, TypeVar
+
+
+C = TypeVar("C", bound=Callable)
+
+
+def cached(func: C) -> C:
+    cache = {}
+
+    @functools.wraps(func)
+    def wrapper(*args):
+        try:
+            return cache[args]
+        except KeyError:
+            pass
+
+        result = cache[args] = func(*args)
+        return result
+
+    return wrapper  # type: ignore

u-0.1/u/prefixes.py

@@ -0,0 +1,83 @@
+from ._utils import cached
+from .quantity_and_unit import Unit, Q
+
+__all__ = [
+    "Prefix",
+    "atto",
+    "femto",
+    "pico",
+    "nano",
+    "micro",
+    "milli",
+    "centi",
+    "deci",
+    "deka",
+    "hecto",
+    "kilo",
+    "mega",
+    "giga",
+    "tera",
+    "peta",
+    "exa",
+    "zetta",
+    "yotta",
+    "kibi",
+    "mebi",
+    "gibi",
+    "tebi",
+    "pebi",
+    "exbi",
+    "zebi",
+    "yobi",
+]
+
+
+class Prefix:
+    def __init__(self, symbol: str, multiplier: float):
+        self.symbol = symbol
+        self.multiplier = multiplier
+
+    @cached
+    def __call__(self, unit: Unit[Q]) -> Unit[Q]:
+        return Unit(
+            self.symbol + unit.symbol,
+            self.multiplier * unit.multiplier,
+        )
+
+    def __repr__(self) -> str:
+        return f"<Prefix {self.symbol}>"
+
+
+quecto = Prefix("q", 1e-30)
+ronto = Prefix("r", 1e-27)
+yocto = Prefix("y", 1e-24)
+zepto = Prefix("z", 1e-21)
+atto = Prefix("a", 1e-18)
+femto = Prefix("f", 1e-15)
+pico = Prefix("p", 1e-12)
+nano = Prefix("n", 1e-9)
+micro = Prefix("µ", 1e-6)
+milli = Prefix("m", 1e-3)
+centi = Prefix("c", 1e-2)
+deci = Prefix("d", 1e-1)
+deka = Prefix("da", 1e1)
+hecto = Prefix("h", 1e2)
+kilo = Prefix("k", 1e3)
+mega = Prefix("M", 1e6)
+giga = Prefix("G", 1e9)
+tera = Prefix("T", 1e12)
+peta = Prefix("P", 1e15)
+exa = Prefix("E", 1e18)
+zetta = Prefix("Z", 1e21)
+yotta = Prefix("Y", 1e24)
+ronna = Prefix("R", 1e27)
+quetta = Prefix("Q", 1e30)
+
+kibi = Prefix("ki", 2**10)
+mebi = Prefix("Mi", 2**20)
+gibi = Prefix("Gi", 2**30)
+tebi = Prefix("Ti", 2**40)
+pebi = Prefix("Pi", 2**50)
+exbi = Prefix("Ei", 2**60)
+zebi = Prefix("Zi", 2**70)
+yobi = Prefix("Yi", 2**80)

u-0.1/u/quantities/__init__.py

@@ -0,0 +1,14 @@
+from .acceleration import *
+from .amount_of_substance import *
+from .area import *
+from .data_volume import *
+from .distance import *
+from .duration import *
+from .electric_current import *
+from .data_volume import *
+from .frequency import *
+from .luminous_intensity import *
+from .mass import *
+from .one import *
+from .speed import *
+from .temperature import *

u-0.1/u/quantities/acceleration.py

@@ -0,0 +1,18 @@
+from ..quantity_and_unit import Div
+from .duration import Duration, second, hour
+from .speed import Speed, meters_per_second, kilometers_per_hour
+
+
+# fmt: off
+__all__ = [
+    "Acceleration",
+    "meters_per_second_squared", "mps2",
+    "kilometers_per_hour_squared", "kph2",
+]
+# fmt: on
+
+
+Acceleration = Div[Speed, Duration]
+
+meters_per_second_squared = mps2 = meters_per_second / second
+kilometers_per_hour_squared = kph2 = kilometers_per_hour / hour

u-0.1/u/quantities/amount_of_substance.py

@@ -0,0 +1,16 @@
+from ..quantity_and_unit import Quantity, Unit
+
+
+# fmt: off
+__all__ = [
+    "AmountOfSubstance",
+    "moles", "mole", "mol",
+]
+# fmt: on
+
+
+class AmountOfSubstance(Quantity):
+    pass
+
+
+moles = mole = mol = Unit[AmountOfSubstance]("mol", 1)

u-0.1/u/quantities/angle.py

@@ -0,0 +1,24 @@
+from math import pi
+
+from ..quantity_and_unit import Quantity, Unit
+
+
+# fmt: off
+__all__ = [
+    "Angle",
+    "radians", "radian", "rad",
+    "degrees", "degree", "deg",
+    "gradians", "gradian", "gons", "gon",
+    "turns", "turn", "tr",
+]
+# fmt: on
+
+
+class Angle(Quantity):
+    pass
+
+
+radians = radian = rad = Unit[Angle]("rad", 1)
+degrees = degree = deg = Unit[Angle]("°", 2 * pi / 360)
+gradians = gradian = gons = gon = Unit[Angle]("ᵍ", 2 * pi / 400)
+turns = turn = tr = Unit[Angle]("tr", 2 * pi)

u-0.1/u/quantities/area.py

@@ -0,0 +1,17 @@
+from ..quantity_and_unit import Mul
+from .distance import Distance, meter, kilometer
+
+
+# fmt: off
+__all__ = [
+    "Area",
+    "square_meters", "square_meter", "m2",
+    "square_kilometers", "square_kilometer", "km2",
+]
+# fmt: on
+
+
+Area = Mul[Distance, Distance]
+
+square_meters = square_meter = m2 = meter * meter
+square_kilometers = square_kilometer = km2 = kilometer * kilometer

u-0.1/u/quantities/data_transfer_speed.py

@@ -0,0 +1,24 @@
+from ..quantity_and_unit import Div
+from .data_volume import DataVolume, bytes, kilobytes, megabytes, gigabytes, terabytes
+from .duration import Duration, second
+
+
+# fmt: off
+__all__ = [
+    "DataTransferSpeed",
+    "bytes_per_second", "Bps",
+    "kilobytes_per_second", "Bps",
+    "megabytes_per_second", "MBps",
+    "gigabytes_per_second", "GBps",
+    "terabytes_per_second", "TBps",
+]
+# fmt: on
+
+
+DataTransferSpeed = Div[DataVolume, Duration]
+
+bytes_per_second = Bps = bytes / second
+kilobytes_per_second = KBps = kilobytes / second
+megabytes_per_second = MBps = megabytes / second
+gigabytes_per_second = GBps = gigabytes / second
+terabytes_per_second = TBps = terabytes / second

u-0.1/u/quantities/data_volume.py

@@ -0,0 +1,44 @@
+# fmt: off
+from ..prefixes import (
+    kilo, mega, giga, tera, peta, exa, zetta, yotta,
+    kibi, mebi, gibi, tebi, pebi, exbi, zebi, yobi,
+)
+# fmt: on
+from ..quantity_and_unit import Quantity, Unit
+
+
+# fmt: off
+__all__ = [
+    "DataVolume",
+    "bytes", "byte", "B",
+]
+# fmt: on
+
+
+class DataVolume(Quantity):
+    pass
+
+
+# TODO: Bits don't really fit in here. I initially wanted to define a byte as 8 bits, but that's not
+# true - 8 bits is an octet. Bytes don't have a fixed amount of bits.
+# bits = bit = b = Unit[FileSize]('b', 1)
+
+bytes = byte = B = Unit[DataVolume]("B", 1)
+
+kilobytes = kilobyte = kB = kilo(bytes)
+megabytes = megabyte = MB = mega(bytes)
+gigabytes = gigabyte = GB = giga(bytes)
+terabytes = terabyte = TB = tera(bytes)
+petabytes = petabyte = PB = peta(bytes)
+exabytes = exabyte = EB = exa(bytes)
+zettabytes = zettabyte = ZB = zetta(bytes)
+yottabytes = yottabyte = YB = yotta(bytes)
+
+kibibytes = kibibyte = kiB = kibi(bytes)
+mebibytes = mebibyte = MiB = mebi(bytes)
+gibibytes = gibibyte = GiB = gibi(bytes)
+tebibytes = tebibyte = TiB = tebi(bytes)
+pebibytes = pebibyte = PiB = pebi(bytes)
+exbibytes = exbibyte = EiB = exbi(bytes)
+zebibytes = zebibyte = ZiB = zebi(bytes)
+yobibytes = yobibyte = YiB = yobi(bytes)

u-0.1/u/quantities/distance.py

@@ -0,0 +1,38 @@
+from ..prefixes import nano, micro, milli, centi, deci, kilo
+from ..quantity_and_unit import Quantity, Unit
+
+
+# fmt: off
+__all__ = [
+    "Distance",
+    "nanometers", "nanometer", "nm",
+    "micrometers", "micrometer", "μm",
+    "millimeters", "millimeter", "mm",
+    "centimeters", "centimeter", "cm",
+    "decimeters", "decimeter", "dm",
+    "meters", "meter", "m",
+    "kilometers", "kilometer", "km",
+    "light_seconds", "light_second", "ls",
+    "light_years", "light_year", "ly",
+    "astronomical_units", "astronomical_unit", "au",
+    "parsecs", "parsec", "pc",
+]
+# fmt: on
+
+
+class Distance(Quantity):
+    pass
+
+
+meters = meter = m = Unit[Distance]("m", 1)
+light_seconds = light_second = ls = Unit[Distance]("ls", 299_792_458)
+light_years = light_year = ly = Unit[Distance]("ly", 9_460_730_472_580_800)
+astronomical_units = astronomical_unit = au = Unit[Distance]("au", 149_597_870_700)
+parsecs = parsec = pc = Unit[Distance]("pc", 3.085_677_581_491_367_3e16)
+
+nanometers = nanometer = nm = nano(meter)
+micrometers = micrometer = μm = micro(meter)
+millimeters = millimeter = mm = milli(meter)
+centimeters = centimeter = cm = centi(meter)
+decimeters = decimeter = dm = deci(meter)
+kilometers = kilometer = km = kilo(meter)

u-0.1/u/quantities/duration.py

@@ -0,0 +1,32 @@
+from ..quantity_and_unit import Quantity, Unit
+
+
+# fmt: off
+__all__ = [
+    "Duration",
+    "seconds", "second", "sec", "s",
+    "minutes", "minute", "min",
+    "hours", "hour", "h",
+    "days", "day", "d",
+    "weeks", "week", "wk", "w",
+    "years", "year", "yr", "y",
+    "decades", "decade", "dec",
+    "centuries", "century", "cent", "c",
+    "millenia", "millenium", "mil", "ka", "ky",
+]
+# fmt: on
+
+
+class Duration(Quantity):
+    pass
+
+
+seconds = second = sec = s = Unit[Duration]("s", 1)
+minutes = minute = min = Unit[Duration]("min", 60)
+hours = hour = h = Unit[Duration]("h", 3_600)
+days = day = d = Unit[Duration]("d", 86_400)
+weeks = week = wk = w = Unit[Duration]("wk", 86_400)
+years = year = yr = y = Unit[Duration]("yr", 31_557_600)
+decades = decade = dec = Unit[Duration]("dec", 315_576_000)
+centuries = century = cent = c = Unit[Duration]("cent", 3_155_760_000)
+millenia = millenium = mil = ka = ky = Unit[Duration]("mil", 31_557_600_000)

u-0.1/u/quantities/electric_charge.py

@@ -0,0 +1,17 @@
+from ..quantity_and_unit import Mul
+from .duration import Duration, seconds
+from .electric_current import ElectricCurrent, amperes
+
+
+# fmt: off
+__all__ = [
+    "ElectricCharge",
+    "coulombs", "coulomb", "C",
+]
+# fmt: on
+
+
+ElectricCharge = Mul[Duration, ElectricCurrent]
+
+coulombs = coulomb = C = seconds * amperes
+coulombs.symbol = "C"

u-0.1/u/quantities/electric_current.py

@@ -0,0 +1,16 @@
+from ..quantity_and_unit import Quantity, Unit
+
+
+# fmt: off
+__all__ = [
+    "ElectricCurrent",
+    "amperes", "ampere", "A",
+]
+# fmt: on
+
+
+class ElectricCurrent(Quantity):
+    pass
+
+
+amperes = ampere = A = Unit[ElectricCurrent]("A", 1)

u-0.1/u/quantities/frequency.py

@@ -0,0 +1,12 @@
+from ..quantity_and_unit import Div
+from .duration import Duration, seconds
+from .one import One, one
+
+
+__all__ = ["Frequency", "hertz", "hertzes", "Hz"]
+
+
+Frequency = Div[One, Duration]
+
+hertz = hertzes = Hz = one / seconds
+hertz.symbol = "Hz"

u-0.1/u/quantities/luminous_intensity.py

@@ -0,0 +1,11 @@
+from ..quantity_and_unit import Quantity, Unit
+
+
+__all__ = ["LuminousIntensity", "candelas", "candela", "cd"]
+
+
+class LuminousIntensity(Quantity):
+    pass
+
+
+candelas = candela = cd = Unit[LuminousIntensity]("cd", 1)

u-0.1/u/quantities/mass.py

@@ -0,0 +1,37 @@
+from ..prefixes import nano, micro, milli, centi, deci, kilo, mega
+from ..quantity_and_unit import Quantity, Unit
+
+
+# fmt: off
+__all__ = [
+    "Mass",
+    "nanograms", "nanogram", "ng",
+    "micrograms", "microgram", "μg",
+    "milligrams", "milligram", "mg",
+    "centigrams", "centigram", "cg",
+    "decigrams", "decigram", "dg",
+    "grams", "gram", "g",
+    "kilograms", "kilogram", "kg",
+    "tons", "ton", "t",
+    "kilotons", "kiloton", "kt",
+    "megatons", "megaton", "Mt",
+]
+# fmt: on
+
+
+class Mass(Quantity):
+    pass
+
+
+grams = gram = g = Unit[Mass]("g", 1)
+tons = ton = t = Unit[Mass]("t", 1_000_000)
+
+nanograms = nanogram = ng = nano(grams)
+micrograms = microgram = μg = micro(grams)
+milligrams = milligram = mg = milli(grams)
+centigrams = centigram = cg = centi(grams)
+decigrams = decigram = dg = deci(grams)
+kilograms = kilogram = kg = kilo(grams)
+
+kilotons = kiloton = kt = kilo(tons)
+megatons = megaton = Mt = mega(tons)

u-0.1/u/quantities/one.py

@@ -0,0 +1,14 @@
+from ..quantity_and_unit import Quantity, Unit
+
+
+__all__ = ["One", "ones", "one"]
+
+
+class One(Quantity):
+    """
+    Represents the absence of a quantity. Used to create "inverted" quantities like `Frequency =
+    Div[One, Duration]`.
+    """
+
+
+ones = one = Unit[One]("1", 1)

u-0.1/u/quantities/pixels.py

@@ -0,0 +1,11 @@
+from ..quantity_and_unit import Quantity, Unit
+
+
+__all__ = ["Pixels", "pixels", "pixel", "px"]
+
+
+class Pixels(Quantity):
+    pass
+
+
+pixels = pixel = px = Unit[Pixels]("px", 1)

u-0.1/u/quantities/speed.py

@@ -0,0 +1,12 @@
+from ..quantity_and_unit import Div
+from .duration import Duration, seconds, hours
+from .distance import Distance, meters, kilometers
+
+
+__all__ = ["Speed", "meters_per_second", "mps", "kilometers_per_hour", "kph"]
+
+
+Speed = Div[Distance, Duration]
+
+meters_per_second = mps = meters / seconds
+kilometers_per_hour = kph = kilometers / hours

u-0.1/u/quantities/temperature.py

@@ -0,0 +1,13 @@
+from ..quantity_and_unit import Quantity, Unit
+
+__all__ = ["Temperature", "kelvins", "kelvin", "K"]
+
+
+class Temperature(Quantity):
+    pass
+
+
+# FIXME: What happens if you add two temperatures?
+kelvins = kelvin = K = Unit[Temperature]("K", 1)
+# celsius = C = Unit[Temperature]("°C", offset=273.15)
+# fahrenheit = F = Unit[Temperature]("°F", formula=((BASE_UNIT - 273.15) * 1.8) + 32)

u-0.1/u/quantity_and_unit.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+import math
+from typing import Generic, TypeVar, Union
+from typing_extensions import Self
+
+from ._utils import cached
+
+
+__all__ = ["Quantity", "Mul", "Div", "Unit"]
+
+
+class Quantity:
+    """
+    Represents a measurable quantity, like mass or acceleration.
+
+    FIXME: Correct docstring
+
+    In order to be able to represent compound quantities (like speed, which is distance divided by
+    time), this is a generic class that accepts an arbitrary number of type arguments. Each type
+    argument represents either a multiplication or, through the use of `Inv`, a division.
+
+    Examples:
+
+    ```
+    Distance = Quantity[DISTANCE]  # just distance
+    Area = Quantity[DISTANCE, DISTANCE]  # distance squared
+    Speed = Quantity[DISTANCE, Inv[DURATION]]  # distance divided by time
+    ```
+
+    Unfortunately this isn't ideal: Because type checkers care about the order of the arguments,
+    they treat `Quantity[A, B]` as different from `Quantity[B, A]`.
+    """
+
+    def __init__(self, value: float, unit: Unit[Self]):
+        self._value = value
+        self.unit = unit
+
+    def to(self, unit: Unit[Self]) -> Self:
+        return Quantity(self.to_number(unit), unit)  # type: ignore
+
+    def to_number(self, unit: Unit[Self]) -> float:
+        return self._value * (self.unit.multiplier / unit.multiplier)
+
+    def __eq__(self, quantity: object, /) -> bool:
+        if not isinstance(quantity, __class__):
+            return NotImplemented
+
+        num = self.to_number(quantity.unit)  # type: ignore
+        return math.isclose(num, quantity._value)
+
+    def __lt__(self, quantity: object, /) -> bool:
+        if not isinstance(quantity, __class__):
+            return NotImplemented
+
+        num = self.to_number(quantity.unit)  # type: ignore
+        return num < quantity._value and not math.isclose(num, quantity._value)
+
+    def __le__(self, quantity: object, /) -> bool:
+        if not isinstance(quantity, __class__):
+            return NotImplemented
+
+        num = self.to_number(quantity.unit)  # type: ignore
+        return num < quantity._value or math.isclose(num, quantity._value)
+
+    def __gt__(self, quantity: object, /) -> bool:
+        if not isinstance(quantity, __class__):
+            return NotImplemented
+
+        num = self.to_number(quantity.unit)  # type: ignore
+        return num > quantity._value and not math.isclose(num, quantity._value)
+
+    def __ge__(self, quantity: object, /) -> bool:
+        if not isinstance(quantity, __class__):
+            return NotImplemented
+
+        num = self.to_number(quantity.unit)  # type: ignore
+        return num > quantity._value or math.isclose(num, quantity._value)
+
+    def __add__(self, quantity: Self) -> Self:
+        return Quantity(
+            self._value + quantity.to_number(self.unit),
+            self.unit,  # type: ignore
+        )  # type: ignore
+
+    def __sub__(self, quantity: Self) -> Self:
+        return Quantity(
+            self._value - quantity.to_number(self.unit),
+            self.unit,  # type: ignore
+        )  # type: ignore
+
+    def __mul__(self, quantity: Quantity) -> Self:
+        return Quantity(
+            self._value * quantity._value,
+            self.unit * quantity.unit,  # type: ignore
+        )  # type: ignore
+
+    def __truediv__(self, quantity: Quantity) -> Self:
+        return Quantity(
+            self._value / quantity._value,
+            self.unit / quantity.unit,  # type: ignore
+        )  # type: ignore
+
+    def __repr__(self) -> str:
+        return f"{self._value}{self.unit.symbol}"
+
+
+Q = TypeVar("Q", bound=Quantity)
+Q2 = TypeVar("Q2", bound=Quantity)
+
+
+class _Mul(Generic[Q, Q2], Quantity): ...
+
+
+# Make multiplication commutative, otherwise type checkers would complain every time you do a
+# multiplication in the "wrong" order. For example:
+#
+# electric_charge: Mul[Duration, ElectricCurrent] = ampere(1) * second(1)
+Mul = Union[_Mul[Q, Q2], _Mul[Q2, Q]]
+
+
+class Div(Generic[Q, Q2], Quantity): ...
+
+
+class Unit(Generic[Q]):
+    """
+    Represents a unit of measurement for a certain `Quantity`.
+
+    To create your own unit, simply create an instance of this class. Make sure to pass the
+    corresponding `Quantity` as a type argument as seen here:
+
+    ```
+    seconds = Unit[Duration]("s", 1)
+    minutes = Unit[Duration]("min", 60)
+    ```
+    """
+
+    def __init__(self, symbol: str, multiplier: float):
+        self.symbol = symbol
+        self.multiplier = multiplier
+
+    @cached
+    def __mul__(self, other: Unit[Q2]) -> Unit[Mul[Q, Q2]]:
+        return Unit(
+            f"{self.symbol}*{other.symbol}",
+            self.multiplier * other.multiplier,
+        )
+
+    @cached
+    def __truediv__(self, other: Unit[Q2]) -> Unit[Div[Q, Q2]]:
+        return Unit(f"{self.symbol}/{other.symbol}", self.multiplier / other.multiplier)
+
+    def __call__(self, value: float) -> Q:
+        return Quantity(value, self)  # type: ignore
+
+    def __rmul__(self, value: float) -> Q:
+        return Quantity(value, self)  # type: ignore