u 2.1__tar.gz → 3.1__tar.gz

{u-2.1 → u-3.1}/PKG-INFO

@@ -1,7 +1,8 @@
 Metadata-Version: 2.4
 Name: u
-Version: 2.1
+Version: 3.1
 Summary: Statically typed units
+Keywords: units,dimensions
 Author-email: Aran-Fey <rawing7@gmail.com>
 Requires-Python: >= 3.10
 Description-Content-Type: text/markdown

u-3.1/changelog.md

@@ -0,0 +1,20 @@
+# 3.1
+
+- Add `__hash__` method
+
+# 3.0
+
+- Add support for `decimal.Decimal`. Unlike floats and Decimals, which throw a TypeError when used
+  together, `Quantity`s remain interoperable regardless of whether they were created with a float or
+  a Decimal.
+- `Unit.multiplier` is now a Decimal.
+- Add `systems` parameter and attribute to `Unit`
+
+# 2.1
+
+- `Quantity.to_number` now raises `ValueError` if an incompatible unit is passed
+
+# 2.0
+
+- Removed `.unit` attribute of `Quantity` objects
+- Renamed `ton` to `tonne`

{u-2.1 → u-3.1}/pyproject.toml

@@ -3,10 +3,12 @@ name = "u"
 description = "Statically typed units"
 authors = [{ name = "Aran-Fey", email = "rawing7@gmail.com" }]
 license = "MIT"
+license-files = ["LICENSE.txt"]
 readme = "README.md"
 dynamic = ["version"]
 requires-python = ">= 3.10"
 classifiers = ["Programming Language :: Python :: 3"]
+keywords = ["units", "dimensions"]
 
 dependencies = ["typing-extensions"]
 

{u-2.1 → u-3.1}/tests/static_tests.py

@@ -59,3 +59,13 @@ ZeroOrDuration = ZeroOrQuantity[u.DURATION]
 
 Speed = u.Quantity[u.DIV[Q, u.DURATION]]
 DownloadSpeed = Speed[u.DATA_VOLUME]
+
+
+# Do the type guards work?
+untyped_quantity: u.Quantity = u.Quantity(0)
+
+if u.Distance.typecheck(untyped_quantity):
+    t.assert_type(untyped_quantity, u.Distance)
+
+if u.seconds(3).is_compatible_with(untyped_quantity):
+    t.assert_type(untyped_quantity, u.Duration)

{u-2.1 → u-3.1}/tests/test_conversions.py

@@ -20,6 +20,7 @@ import u
         (u.meters_per_second(30), u.kilometers_per_hour, 108),
         (u.square_meters(1_000_000), u.square_kilometers, 1),
     ],
+    ids=lambda value: value.symbol if isinstance(value, u.Unit) else repr(value),
 )
 def test_to_number(value: u.Quantity, unit: u.Unit, expected_result: float):
     result = value.to_number(unit)
@@ -50,6 +51,8 @@ def test_repr(value: u.Quantity, expected_result: str):
 @pytest.mark.parametrize(
     "value, expected_result",
     [
+        (u.inches(63360), "1 mi"),
+        (u.centimeters(160934.4), "1.6 km"),
         (u.kilometers(0), "0 m"),
         (u.meters(7), "7 m"),
         (u.kilometers(3.5), ["3.5 km", "3500 m"]),

u-3.1/tests/test_decimal.py

@@ -0,0 +1,31 @@
+from decimal import Decimal
+
+import u
+
+
+def test_decimal_quantity():
+    dec = Decimal("10.5")
+    dist = u.meter(dec)
+
+    assert dist.to_decimal(u.meter) == dec
+
+
+def test_decimal_math():
+    q1 = u.meter(Decimal("10.5"))
+    q2 = u.meter(Decimal("5.5"))
+    res = q1 + q2
+    assert res.to_decimal(u.meter) == Decimal("16.0")
+
+
+def test_mixed_math():
+    q1 = u.meter(Decimal("10.5"))
+    q2 = u.meter(5.5)
+    res = q1 + q2
+    assert res.to_decimal(u.meter) == Decimal("16.0")
+
+
+def test_decimal_conversion():
+    q = u.km(Decimal("1"))
+    res = q.to_decimal(u.meter)
+    assert res == Decimal("1000")
+    assert isinstance(res, Decimal)

{u-2.1 → u-3.1}/tests/test_quantities.py

@@ -8,3 +8,8 @@ def test_getitem():
 
 def test_equality():
     assert u.minutes(60) == u.hours(1)
+
+
+def test_hashing():
+    mapping = {u.minutes(60): "foo"}
+    assert mapping[u.hours(1)] == "foo"

{u-2.1 → u-3.1}/tests/test_typing.py

@@ -1,5 +1,6 @@
 import re
 import typing as t
+import typing_extensions as te
 from pathlib import Path
 
 import mypy.api
@@ -34,6 +35,16 @@ def test_typevars_at_runtime():
     DownloadSpeed = Speed[u.DATA_VOLUME]  # type: ignore
 
 
+def test_typecheck():
+    assert u.Distance.typecheck(u.meters(3))
+    assert not u.Distance.typecheck(u.seconds(3))
+
+
+def test_is_compatible_with():
+    assert u.meters(3).is_compatible_with(u.km(3))
+    assert not u.meters(3).is_compatible_with(u.seconds(3))
+
+
 @pytest.mark.parametrize(
     "expr",
     [

{u-2.1 → u-3.1}/u/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2.1"
+__version__ = "3.1"
 
 from .prefixes import *
 from .quantity import *

{u-2.1 → u-3.1}/u/_utils.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import collections.abc
+import decimal
 import functools
 import re
 import sys
@@ -9,6 +10,8 @@ import typing as t
 
 import u
 
+from .maths import FloatOrDecimal
+
 
 C = t.TypeVar("C", bound=t.Callable)
 

u-3.1/u/maths.py

@@ -0,0 +1,56 @@
+"""
+Floats and Decimals refuse to cooperate, so any math involving mixed types will throw an error. This
+module can be used to safely perform math without worrying about the types of the operands.
+"""
+
+import decimal
+import operator
+import typing as t
+
+
+FloatOrDecimal = float | decimal.Decimal
+TypePreference = type[float] | type[decimal.Decimal] | None
+
+
+def add(
+    lhs: FloatOrDecimal, rhs: FloatOrDecimal, type_preference: TypePreference = None
+) -> FloatOrDecimal:
+    return apply_operator(operator.add, lhs, rhs, type_preference)
+
+
+def subtract(
+    lhs: FloatOrDecimal, rhs: FloatOrDecimal, type_preference: TypePreference = None
+) -> FloatOrDecimal:
+    return apply_operator(operator.sub, lhs, rhs, type_preference)
+
+
+def multiply(
+    lhs: FloatOrDecimal, rhs: FloatOrDecimal, type_preference: TypePreference = None
+) -> FloatOrDecimal:
+    return apply_operator(operator.mul, lhs, rhs, type_preference)
+
+
+def divide(
+    lhs: FloatOrDecimal, rhs: FloatOrDecimal, type_preference: TypePreference = None
+) -> FloatOrDecimal:
+    return apply_operator(operator.truediv, lhs, rhs, type_preference)
+
+
+def apply_operator(
+    operator: t.Callable[[float, float], float],
+    lhs: FloatOrDecimal,
+    rhs: FloatOrDecimal,
+    type_preference: TypePreference = None,
+) -> FloatOrDecimal:
+    try:
+        return operator(lhs, rhs)  # type: ignore
+    except TypeError:
+        pass
+
+    if type_preference is None:
+        type_preference = type(lhs)
+
+    lhs = type_preference(lhs)
+    rhs = type_preference(rhs)
+
+    return operator(lhs, rhs)  # type: ignore

{u-2.1 → u-3.1}/u/prefixes.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
+import decimal
 import typing as t
 
 import u
 
+from .maths import multiply
 from ._utils import cached
 
 __all__ = [
@@ -48,9 +50,9 @@ max_prefix_length = 0
 
 
 class Prefix:
-    def __init__(self, symbol: str, multiplier: float):
+    def __init__(self, symbol: str, multiplier: decimal.Decimal | int):
         self.symbol = symbol
-        self.multiplier = multiplier
+        self.multiplier = decimal.Decimal(multiplier)
 
         prefix_by_symbol[symbol] = self
 
@@ -72,7 +74,8 @@ class Prefix:
         return u.unit.lookup_unit(
             unit.quantity,
             self.symbol + unit.symbol,
-            self.multiplier * unit.multiplier,
+            multiply(self.multiplier, unit.multiplier, decimal.Decimal),
+            unit.systems,
         )
 
     def __repr__(self) -> str:
@@ -82,30 +85,30 @@ class Prefix:
 DUMMY_PREFIX = Prefix("", 1)
 
 
-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)
+quecto = Prefix("q", decimal.Decimal("1e-30"))
+ronto = Prefix("r", decimal.Decimal("1e-27"))
+yocto = Prefix("y", decimal.Decimal("1e-24"))
+zepto = Prefix("z", decimal.Decimal("1e-21"))
+atto = Prefix("a", decimal.Decimal("1e-18"))
+femto = Prefix("f", decimal.Decimal("1e-15"))
+pico = Prefix("p", decimal.Decimal("1e-12"))
+nano = Prefix("n", decimal.Decimal("1e-9"))
+micro = Prefix("µ", decimal.Decimal("1e-6"))
+milli = Prefix("m", decimal.Decimal("1e-3"))
+centi = Prefix("c", decimal.Decimal("1e-2"))
+deci = Prefix("d", decimal.Decimal("1e-1"))
+deka = Prefix("da", 10**1)
+hecto = Prefix("h", 10**2)
+kilo = Prefix("k", 10**3)
+mega = Prefix("M", 10**6)
+giga = Prefix("G", 10**9)
+tera = Prefix("T", 10**12)
+peta = Prefix("P", 10**15)
+exa = Prefix("E", 10**18)
+zetta = Prefix("Z", 10**21)
+yotta = Prefix("Y", 10**24)
+ronna = Prefix("R", 10**27)
+quetta = Prefix("Q", 10**30)
 
 
 STANDARD_SI_PREFIXES = (

{u-2.1 → u-3.1}/u/quantities/__init__.py

@@ -8,13 +8,16 @@ from .duration import *
 from .electric_charge import *
 from .electric_current import *
 from .electric_resistance import *
-from .data_volume import *
+from .energy import *
 from .force import *
 from .frequency import *
 from .luminous_intensity import *
 from .mass import *
 from .one import *
 from .pixels import *
+from .power import *
+from .pressure import *
 from .solid_angle import *
 from .speed import *
 from .temperature import *
+from .volume import *

{u-2.1 → u-3.1}/u/quantities/amount_of_substance.py

@@ -19,4 +19,4 @@ class AMOUNT_OF_SUBSTANCE(QUANTITY):
 AmountOfSubstance = Quantity[AMOUNT_OF_SUBSTANCE]
 
 
-moles = mole = mol = Unit(AmountOfSubstance, "mol", 1)
+moles = mole = mol = Unit(AmountOfSubstance, "mol", 1, systems={"metric"})

u-3.1/u/quantities/angle.py

@@ -0,0 +1,38 @@
+import decimal
+
+from ..quantity import Quantity
+from ..capital_quantities import QUANTITY
+from ..unit import Unit
+
+
+# fmt: off
+__all__ = [
+    "ANGLE",
+    "Angle",
+    "radians", "radian", "rad",
+    "degrees", "degree", "deg",
+    "gradians", "gradian", "gons", "gon",
+    "turns", "turn", "tr",
+    "arcminutes", "arcminute", "arcmin",
+    "arcseconds", "arcsecond", "arcsec",
+]
+# fmt: on
+
+
+# Standard PI with high precision for Decimal math
+PI = decimal.Decimal("3.1415926535897932384626433832795028841971")
+
+
+class ANGLE(QUANTITY):
+    pass
+
+
+Angle = Quantity[ANGLE]
+
+
+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)
+arcminutes = arcminute = arcmin = Unit(Angle, "′", PI / 10800)
+arcseconds = arcsecond = arcsec = Unit(Angle, "″", PI / 648000)

u-3.1/u/quantities/area.py

@@ -0,0 +1,29 @@
+import decimal
+
+from .distance import DISTANCE, meter, kilometer
+from ..quantity import Quantity
+from ..capital_quantities import MUL
+from ..unit import Unit
+
+
+# fmt: off
+__all__ = [
+    "AREA",
+    "Area",
+    "square_meters", "square_meter", "m2",
+    "square_kilometers", "square_kilometer", "km2",
+    "hectares", "hectare", "ha",
+    "acres", "acre",
+]
+# fmt: on
+
+
+AREA = MUL[DISTANCE, DISTANCE]
+
+Area = Quantity[AREA]
+
+
+square_meters = square_meter = m2 = Unit(meter**2, "m²", systems={"metric"})
+square_kilometers = square_kilometer = km2 = Unit(kilometer**2, "km²", systems={"metric"})
+hectares = hectare = ha = Unit(Area, "ha", 10_000, systems={"metric"})
+acres = acre = Unit(Area, "acre", decimal.Decimal("4046.8564224"), systems={"imperial"})

u-3.1/u/quantities/distance.py

@@ -0,0 +1,61 @@
+import decimal
+
+from ..prefixes import nano, micro, milli, centi, deci, kilo
+from ..quantity import Quantity
+from ..capital_quantities import QUANTITY
+from ..unit import Unit
+
+
+# fmt: off
+__all__ = [
+    "DISTANCE",
+    "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",
+    "inches", "inch", "in_",
+    "feet", "foot", "ft",
+    "yards", "yard", "yd",
+    "miles", "mile", "mi",
+    "nautical_miles", "nautical_mile", "nmi",
+    "fathoms", "fathom",
+    "mils", "mil",
+]
+# fmt: on
+
+
+class DISTANCE(QUANTITY):
+    pass
+
+
+Distance = Quantity[DISTANCE]
+
+
+meters = meter = m = Unit(Distance, "m", 1, systems={"metric"})
+light_seconds = light_second = ls = Unit(Distance, "ls", 299792458)
+light_years = light_year = ly = Unit(Distance, "ly", 9460730472580800)
+astronomical_units = astronomical_unit = au = Unit(Distance, "au", 149597870700)
+parsecs = parsec = pc = Unit(Distance, "pc", decimal.Decimal("3.0856775814913673e16"))
+
+inches = inch = in_ = Unit(Distance, "in", decimal.Decimal("0.0254"), systems={"imperial"})
+feet = foot = ft = Unit(Distance, "ft", decimal.Decimal("0.3048"), systems={"imperial"})
+yards = yard = yd = Unit(Distance, "yd", decimal.Decimal("0.9144"), systems={"imperial"})
+miles = mile = mi = Unit(Distance, "mi", decimal.Decimal("1609.344"), systems={"imperial"})
+nautical_miles = nautical_mile = nmi = Unit(Distance, "nmi", 1852, systems={"nautical"})
+fathoms = fathom = Unit(Distance, "fathom", decimal.Decimal("1.8288"), systems={"nautical"})
+mils = mil = Unit(Distance, "mil", decimal.Decimal("0.0000254"), systems={"imperial"})
+
+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-2.1 → u-3.1}/u/quantities/duration.py

@@ -28,13 +28,14 @@ class DURATION(QUANTITY):
 Duration = Quantity[DURATION]
 Duration.prefixes = SI_PREFIXES[: SI_PREFIXES.index(milli) + 1]
 
-
-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", 604_800)
-years = year = yr = y = Unit(Duration, "yr", 31_536_000)
-decades = decade = dec = Unit(Duration, "dec", 315_360_000)
-centuries = century = cent = c = Unit(Duration, "cent", 3_153_600_000)
-millenia = millenium = mil = ka = ky = Unit(Duration, "mil", 31_536_000_000)
+SYSTEMS = {"metric", "imperial", "nautical"}
+
+seconds = second = sec = s = Unit(Duration, "s", 1, systems=SYSTEMS)
+minutes = minute = min = Unit(Duration, "min", 60, systems=SYSTEMS)
+hours = hour = h = Unit(Duration, "h", 3_600, systems=SYSTEMS)
+days = day = d = Unit(Duration, "d", 86_400, systems=SYSTEMS)
+weeks = week = wk = w = Unit(Duration, "wk", 604_800, systems=SYSTEMS)
+years = year = yr = y = Unit(Duration, "yr", 31_536_000, systems=SYSTEMS)
+decades = decade = dec = Unit(Duration, "dec", 315_360_000, systems=SYSTEMS)
+centuries = century = cent = c = Unit(Duration, "cent", 3_153_600_000, systems=SYSTEMS)
+millenia = millenium = mil = ka = ky = Unit(Duration, "mil", 31_536_000_000, systems=SYSTEMS)

{u-2.1 → u-3.1}/u/quantities/electric_charge.py

@@ -17,4 +17,5 @@ ELECTRIC_CHARGE = MUL[DURATION, ELECTRIC_CURRENT]
 
 ElectricCharge = Quantity[ELECTRIC_CHARGE]
 
-coulombs = coulomb = C = Unit(seconds * amperes, "C")
+
+coulombs = coulomb = C = Unit(seconds * amperes, "C", systems={"metric"})

{u-2.1 → u-3.1}/u/quantities/electric_current.py

@@ -19,4 +19,4 @@ class ELECTRIC_CURRENT(QUANTITY):
 ElectricCurrent = Quantity[ELECTRIC_CURRENT]
 
 
-amperes = ampere = A = Unit(ElectricCurrent, "A", 1)
+amperes = ampere = A = Unit(ElectricCurrent, "A", 1, systems={"metric"})

{u-2.1 → u-3.1}/u/quantities/electric_resistance.py

@@ -23,4 +23,5 @@ ELECTRIC_RESISTANCE = t.Union[
 
 ElectricResistance = Quantity[ELECTRIC_RESISTANCE]
 
-ohms = ohm = Unit(kg * m**2 / s**3 / A**2, "Ω")
+
+ohms = ohm = Unit(kg * m**2 / s**3 / A**2, "Ω", systems={"metric"})

u-3.1/u/quantities/energy.py

@@ -0,0 +1,40 @@
+import decimal
+
+from .force import FORCE, newtons
+from .distance import DISTANCE, meters
+from ..quantity import Quantity
+from ..capital_quantities import MUL
+from ..unit import Unit
+
+
+# fmt: off
+__all__ = [
+    "ENERGY",
+    "Energy",
+    "joules", "joule", "J",
+    "calories", "calorie", "cal",
+    "kilocalories", "kilocalorie", "kcal",
+    "kilowatt_hours", "kilowatt_hour", "kWh",
+    "electronvolts", "electronvolt", "eV",
+    "ergs", "erg",
+    "btus", "btu", "BTU",
+]
+# fmt: on
+
+
+ENERGY = MUL[FORCE, DISTANCE]
+
+Energy = Quantity[ENERGY]
+
+
+joules = joule = J = Unit(newtons * meters, "J", systems={"metric"})
+calories = calorie = cal = Unit(Energy, "cal", decimal.Decimal("4.184") * joule.multiplier)
+kilocalories = kilocalorie = kcal = Unit(Energy, "kcal", 4184 * joule.multiplier)
+kilowatt_hours = kilowatt_hour = kWh = Unit(Energy, "kWh", 3600000 * joule.multiplier)
+electronvolts = electronvolt = eV = Unit(
+    Energy, "eV", decimal.Decimal("1.602176634e-19") * joule.multiplier, systems={"technical"}
+)
+ergs = erg = Unit(Energy, "erg", decimal.Decimal("1e-7") * joule.multiplier, systems={"metric"})
+btus = btu = BTU = Unit(
+    Energy, "BTU", decimal.Decimal("1055.05585262") * joule.multiplier, systems={"imperial"}
+)

{u-2.1 → u-3.1}/u/quantities/force.py

@@ -30,4 +30,4 @@ FORCE = t.Union[
 Force = Quantity[FORCE]
 
 
-newtons = newton = N = Unit(kg * m / s / s, "N")
+newtons = newton = N = Unit(kg * m / s / s, "N", systems={"metric"})

{u-2.1 → u-3.1}/u/quantities/frequency.py

@@ -24,7 +24,7 @@ FREQUENCY = DIV[ONE, DURATION]
 Frequency = Quantity[FREQUENCY]
 
 
-hertzes = hertz = Hz = Unit(one / seconds, "Hz")
+hertzes = hertz = Hz = Unit(one / seconds, "Hz", systems={"metric"})
 
 kilohertzes = kilohertz = KHz = kilo(hertz)
 megahertzes = megahertz = MHz = mega(hertz)

{u-2.1 → u-3.1}/u/quantities/luminous_intensity.py

@@ -13,4 +13,4 @@ class LUMINOUS_INTENSITY(QUANTITY):
 LuminousIntensity = Quantity[LUMINOUS_INTENSITY]
 
 
-candelas = candela = cd = Unit(LuminousIntensity, "cd", 1)
+candelas = candela = cd = Unit(LuminousIntensity, "cd", 1, systems={"metric"})

{u-2.1 → u-3.1}/u/quantities/mass.py

@@ -1,3 +1,5 @@
+import decimal
+
 from ..prefixes import nano, micro, milli, centi, deci, kilo, mega
 from ..quantity import Quantity
 from ..capital_quantities import QUANTITY
@@ -18,6 +20,11 @@ __all__ = [
     "metric_tons", "metric_ton", "tonnes", "tonne", "t",
     "kilotonnes", "kilotonne", "kt",
     "megatonnes", "megatonne", "Mt",
+    "pounds", "pound", "lb",
+    "ounces", "ounce", "oz",
+    "stones", "stone", "st",
+    "slugs", "slug",
+    "daltons", "dalton", "Da",
 ]
 # fmt: on
 
@@ -29,10 +36,16 @@ class MASS(QUANTITY):
 Mass = Quantity[MASS]
 
 
-grams = gram = g = Unit(Mass, "g", 1)
+grams = gram = g = Unit(Mass, "g", 1, systems={"metric"})
 
 # Careful: "ton" is not the same thing as "tonne".
-metric_tons = metric_ton = tonnes = tonne = t = Unit(Mass, "t", 1_000_000)
+metric_tons = metric_ton = tonnes = tonne = t = Unit(Mass, "t", 1000000, systems={"metric"})
+
+pounds = pound = lb = Unit(Mass, "lb", decimal.Decimal("453.59237"), systems={"imperial"})
+ounces = ounce = oz = Unit(Mass, "oz", decimal.Decimal("28.349523125"), systems={"imperial"})
+stones = stone = st = Unit(Mass, "st", decimal.Decimal("6350.29318"), systems={"imperial"})
+slugs = slug = Unit(Mass, "slug", decimal.Decimal("14593.9029"), systems={"imperial"})
+daltons = dalton = Da = Unit(Mass, "Da", decimal.Decimal("1.66053906660e-24"))
 
 nanograms = nanogram = ng = nano(grams)
 micrograms = microgram = μg = micro(grams)

u-3.1/u/quantities/power.py

@@ -0,0 +1,32 @@
+import decimal
+
+from .energy import ENERGY, joules
+from .duration import DURATION, seconds
+from ..quantity import Quantity
+from ..capital_quantities import DIV
+from ..unit import Unit
+
+
+# fmt: off
+__all__ = [
+    "POWER",
+    "Power",
+    "watts", "watt", "W",
+    "kilowatts", "kilowatt", "kW",
+    "megawatts", "megawatt", "MW",
+    "horsepower", "hp",
+]
+# fmt: on
+
+
+POWER = DIV[ENERGY, DURATION]
+
+Power = Quantity[POWER]
+
+
+watts = watt = W = Unit(joules / seconds, "W", systems={"metric"})
+kilowatts = kilowatt = kW = Unit(Power, "kW", 1000 * watt.multiplier, systems={"metric"})
+megawatts = megawatt = MW = Unit(Power, "MW", 1000000 * watt.multiplier, systems={"metric"})
+horsepower = hp = Unit(
+    Power, "hp", decimal.Decimal("745.69987158227") * watt.multiplier, systems={"imperial"}
+)