frequenz-quantities 1.0.0__tar.gz

frequenz-quantities-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright © 2024 Frequenz Energy-as-a-Service GmbH
+
+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.

frequenz-quantities-1.0.0/MANIFEST.in

@@ -0,0 +1,13 @@
+exclude .cookiecutter-replay.json
+exclude .editorconfig
+exclude .gitignore
+exclude CODEOWNERS
+exclude CONTRIBUTING.md
+exclude mkdocs.yml
+exclude noxfile.py
+exclude src/conftest.py
+recursive-exclude .github *
+recursive-exclude benchmarks *
+recursive-exclude docs *
+recursive-exclude tests *
+recursive-include py *.pyi

frequenz-quantities-1.0.0/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.1
+Name: frequenz-quantities
+Version: 1.0.0
+Summary: Types for holding quantities with units
+Author-email: Frequenz Energy-as-a-Service GmbH <floss@frequenz.com>
+License: MIT
+Project-URL: Documentation, https://frequenz-floss.github.io/frequenz-quantities-python/
+Project-URL: Changelog, https://github.com/frequenz-floss/frequenz-quantities-python/releases
+Project-URL: Issues, https://github.com/frequenz-floss/frequenz-quantities-python/issues
+Project-URL: Repository, https://github.com/frequenz-floss/frequenz-quantities-python
+Project-URL: Support, https://github.com/frequenz-floss/frequenz-quantities-python/discussions/categories/support
+Keywords: frequenz,python,lib,library,quantities,unit,conversion
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: <4,>=3.11
+Description-Content-Type: text/markdown
+Provides-Extra: dev-flake8
+Provides-Extra: dev-formatting
+Provides-Extra: dev-mkdocs
+Provides-Extra: dev-mypy
+Provides-Extra: dev-noxfile
+Provides-Extra: dev-pylint
+Provides-Extra: dev-pytest
+Provides-Extra: marshmallow
+Provides-Extra: dev
+License-File: LICENSE
+
+# Frequenz Quantities Library
+
+[![Build Status](https://github.com/frequenz-floss/frequenz-quantities-python/actions/workflows/ci.yaml/badge.svg)](https://github.com/frequenz-floss/frequenz-quantities-python/actions/workflows/ci.yaml)
+[![PyPI Package](https://img.shields.io/pypi/v/frequenz-quantities)](https://pypi.org/project/frequenz-quantities/)
+[![Docs](https://img.shields.io/badge/docs-latest-informational)](https://frequenz-floss.github.io/frequenz-quantities-python/)
+
+## Introduction
+
+This library provide types for holding quantities with units. The main goal is
+to avoid mistakes while working with different types of quantities, for example
+avoiding adding a length to a time.
+
+It also prevents mistakes when operating between the same quantity but in
+different units, like adding a power in Joules to a power in Watts without
+converting one of them.
+
+Quantities store the value in a base unit, and then provide methods to get that
+quantity as a particular unit.
+
+## Documentation
+
+For more information on how to use this library and examples, please check the
+[Documentation website](https://frequenz-floss.github.io/frequenz-quantities-python/).
+
+## Supported Platforms
+
+The following platforms are officially supported (tested):
+
+- **Python:** 3.11
+- **Operating System:** Ubuntu Linux 20.04
+- **Architectures:** amd64, arm64
+
+## Contributing
+
+If you want to know how to build this project and contribute to it, please
+check out the [Contributing Guide](CONTRIBUTING.md).

frequenz-quantities-1.0.0/README.md

@@ -0,0 +1,36 @@
+# Frequenz Quantities Library
+
+[![Build Status](https://github.com/frequenz-floss/frequenz-quantities-python/actions/workflows/ci.yaml/badge.svg)](https://github.com/frequenz-floss/frequenz-quantities-python/actions/workflows/ci.yaml)
+[![PyPI Package](https://img.shields.io/pypi/v/frequenz-quantities)](https://pypi.org/project/frequenz-quantities/)
+[![Docs](https://img.shields.io/badge/docs-latest-informational)](https://frequenz-floss.github.io/frequenz-quantities-python/)
+
+## Introduction
+
+This library provide types for holding quantities with units. The main goal is
+to avoid mistakes while working with different types of quantities, for example
+avoiding adding a length to a time.
+
+It also prevents mistakes when operating between the same quantity but in
+different units, like adding a power in Joules to a power in Watts without
+converting one of them.
+
+Quantities store the value in a base unit, and then provide methods to get that
+quantity as a particular unit.
+
+## Documentation
+
+For more information on how to use this library and examples, please check the
+[Documentation website](https://frequenz-floss.github.io/frequenz-quantities-python/).
+
+## Supported Platforms
+
+The following platforms are officially supported (tested):
+
+- **Python:** 3.11
+- **Operating System:** Ubuntu Linux 20.04
+- **Architectures:** amd64, arm64
+
+## Contributing
+
+If you want to know how to build this project and contribute to it, please
+check out the [Contributing Guide](CONTRIBUTING.md).

frequenz-quantities-1.0.0/RELEASE_NOTES.md

@@ -0,0 +1,14 @@
+# Frequenz Quantities Library Release Notes
+
+## Summary
+
+This first stable release of `frequenz-quantities`!
+
+The code is based on the quantities code in the [`frequenz-sdk` v1.0.0rc601](https://github.com/frequenz-floss/frequenz-sdk-python/releases/tag/v1.0.0-rc601) but with some new features and improvements.
+
+## New Features
+
+- Added support for `__round__` (`round(quantity)`), `__pos__` (`+quantity`) and `__mod__` (`quantity % quantity`) operators.
+- Add `ReactivePower` quantity.
+- Add `ApparentPower` quantity.
+- Add an **experimental** marshmallow module available when adding `[marshmallow]` to the requirements. This module provides `marshmallow` fields for quantities and a `QuantitySchema` to use as a base schema that supports loading and dumping quantities.

frequenz-quantities-1.0.0/pyproject.toml

@@ -0,0 +1,180 @@
+# License: MIT
+# Copyright © 2024 Frequenz Energy-as-a-Service GmbH
+
+[build-system]
+requires = [
+  "setuptools == 68.1.0",
+  "setuptools_scm[toml] == 7.1.0",
+  "frequenz-repo-config[lib] == 0.10.0",
+]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "frequenz-quantities"
+description = "Types for holding quantities with units"
+readme = "README.md"
+license = { text = "MIT" }
+keywords = [
+  "frequenz",
+  "python",
+  "lib",
+  "library",
+  "quantities",
+  "unit",
+  "conversion",
+]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Topic :: Software Development :: Libraries",
+  "Typing :: Typed",
+]
+requires-python = ">= 3.11, < 4"
+dependencies = ["typing-extensions >= 4.5.0, < 5"]
+dynamic = ["version"]
+
+[[project.authors]]
+name = "Frequenz Energy-as-a-Service GmbH"
+email = "floss@frequenz.com"
+
+[project.optional-dependencies]
+dev-flake8 = [
+  "flake8 == 7.1.1",
+  "flake8-docstrings == 1.7.0",
+  "flake8-pyproject == 1.2.3",  # For reading the flake8 config from pyproject.toml
+  "pydoclint == 0.5.9",
+  "pydocstyle == 6.3.0",
+]
+dev-formatting = ["black == 24.10.0", "isort == 5.13.2"]
+dev-mkdocs = [
+  "Markdown == 3.7",
+  "black == 24.10.0",
+  "mike == 2.1.3",
+  "mkdocs-gen-files == 0.5.0",
+  "mkdocs-literate-nav == 0.6.1",
+  "mkdocs-macros-plugin == 1.3.7",
+  "mkdocs-material == 9.5.43",
+  "mkdocstrings[python] == 0.26.2",
+  "mkdocstrings-python == 1.12.2",
+  "frequenz-repo-config[lib] == 0.10.0",
+]
+dev-mypy = [
+  "mypy == 1.13.0",
+  "types-Markdown == 3.7.0.20240822",
+  # For checking the noxfile, docs/ script, and tests
+  "frequenz-quantities[dev-mkdocs,dev-noxfile,dev-pytest,marshmallow]",
+]
+dev-noxfile = ["nox == 2024.10.9", "frequenz-repo-config[lib] == 0.10.0"]
+dev-pylint = [
+  # dev-pytest already defines a dependency to pylint because of the examples
+  # For checking the noxfile, docs/ script, and tests
+  "frequenz-quantities[dev-mkdocs,dev-noxfile,dev-pytest,marshmallow]",
+]
+dev-pytest = [
+  "pytest == 8.3.3",
+  "pylint == 3.3.1",                                     # We need this to check for the examples
+  "frequenz-repo-config[extra-lint-examples] == 0.10.0",
+  "pytest-mock == 3.14.0",
+  "pytest-asyncio == 0.24.0",
+  "async-solipsism == 0.7",
+  "hypothesis == 6.116.0",
+  "frequenz-quantities[marshmallow]",
+]
+
+marshmallow = [
+  "marshmallow >= 3.0.0, < 4",
+  "marshmallow-dataclass >= 8.0.0, < 9",
+]
+
+dev = [
+  "frequenz-quantities[dev-mkdocs,dev-flake8,dev-formatting,dev-mkdocs,dev-mypy,dev-noxfile,dev-pylint,dev-pytest,marshmallow]",
+]
+
+[project.urls]
+Documentation = "https://frequenz-floss.github.io/frequenz-quantities-python/"
+Changelog = "https://github.com/frequenz-floss/frequenz-quantities-python/releases"
+Issues = "https://github.com/frequenz-floss/frequenz-quantities-python/issues"
+Repository = "https://github.com/frequenz-floss/frequenz-quantities-python"
+Support = "https://github.com/frequenz-floss/frequenz-quantities-python/discussions/categories/support"
+
+[tool.black]
+line-length = 88
+target-version = ['py311']
+include = '\.pyi?$'
+
+[tool.isort]
+profile = "black"
+line_length = 88
+src_paths = ["benchmarks", "examples", "src", "tests"]
+
+[tool.flake8]
+# We give some flexibility to go over 88, there are cases like long URLs or
+# code in documenation that have extra indentation. Black will still take care
+# of making everything that can be 88 wide, 88 wide.
+max-line-length = 100
+extend-ignore = [
+  "E203", # Whitespace before ':' (conflicts with black)
+  "W503", # Line break before binary operator (conflicts with black)
+]
+# pydoclint options
+style = "google"
+check-return-types = false
+check-yield-types = false
+arg-type-hints-in-docstring = false
+arg-type-hints-in-signature = true
+allow-init-docstring = true
+
+[tool.pylint.similarities]
+ignore-comments = ['yes']
+ignore-docstrings = ['yes']
+ignore-imports = ['no']
+min-similarity-lines = 40
+
+[tool.pylint.messages_control]
+disable = [
+  "too-few-public-methods",
+  "too-many-return-statements",
+  # disabled because it conflicts with isort
+  "wrong-import-order",
+  "ungrouped-imports",
+  # pylint's unsubscriptable check is buggy and is not needed because
+  # it is a type-check, for which we already have mypy.
+  "unsubscriptable-object",
+  # Checked by mypy
+  "no-member",
+  # Checked by flake8
+  "f-string-without-interpolation",
+  "line-too-long",
+  "missing-function-docstring",
+  "redefined-outer-name",
+  "unnecessary-lambda-assignment",
+  "unused-import",
+  "unused-variable",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests", "src"]
+asyncio_mode = "auto"
+required_plugins = ["pytest-asyncio", "pytest-mock"]
+
+[tool.mypy]
+explicit_package_bases = true
+namespace_packages = true
+# This option disables mypy cache, and it is sometimes useful to enable it if
+# you are getting weird intermittent error, or error in the CI but not locally
+# (or vice versa). In particular errors saying that type: ignore is not
+# used but getting the original ignored error when removing the type: ignore.
+# See for example: https://github.com/python/mypy/issues/2960
+#no_incremental = true
+packages = ["frequenz.quantities"]
+strict = true
+
+[[tool.mypy.overrides]]
+module = ["mkdocs_macros.*", "sybil", "sybil.*"]
+ignore_missing_imports = true
+
+[tool.setuptools_scm]
+version_scheme = "post-release"

frequenz-quantities-1.0.0/setup.cfg

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

frequenz-quantities-1.0.0/src/frequenz/quantities/__init__.py

@@ -0,0 +1,112 @@
+# License: MIT
+# Copyright © 2024 Frequenz Energy-as-a-Service GmbH
+
+"""Types for holding quantities with units.
+
+This library provide types for holding quantities with units. The main goal is to avoid
+mistakes while working with different types of quantities, for example avoiding adding
+a length to a time.
+
+It also prevents mistakes when operating between the same quantity but in different
+units, like adding a power in Joules to a power in Watts without converting one of them.
+
+Quantities store the value in a base unit, and then provide methods to get that quantity
+as a particular unit. They can only be constructed using special constructors with the
+form `Quantity.from_<unit>`, for example
+[`Power.from_watts(10.0)`][frequenz.quantities.Power.from_watts].
+
+Internally quantities store values as `float`s, so regular [float issues and limitations
+apply](https://docs.python.org/3/tutorial/floatingpoint.html), although some of them are
+tried to be mitigated.
+
+Quantities are also immutable, so operations between quantities return a new instance of
+the quantity.
+
+This library provides the following types:
+
+- [ApparentPower][frequenz.quantities.ApparentPower]: A quantity representing apparent
+  power.
+- [Current][frequenz.quantities.Current]: A quantity representing an electric current.
+- [Energy][frequenz.quantities.Energy]: A quantity representing energy.
+- [Frequency][frequenz.quantities.Frequency]: A quantity representing frequency.
+- [Percentage][frequenz.quantities.Percentage]: A quantity representing a percentage.
+- [Power][frequenz.quantities.Power]: A quantity representing power.
+- [ReactivePower][frequenz.quantities.ReactivePower]: A quantity representing reactive
+  power.
+- [Temperature][frequenz.quantities.Temperature]: A quantity representing temperature.
+- [Voltage][frequenz.quantities.Voltage]: A quantity representing electric voltage.
+
+There is also the unitless [Quantity][frequenz.quantities.Quantity] class. All
+quantities are subclasses of this class and it can be used as a base to create new
+quantities. Using the `Quantity` class directly is discouraged, as it doesn't provide
+any unit conversion methods.
+
+Example:
+    ```python
+    from datetime import timedelta
+    from frequenz.quantities import Power, Voltage, Current, Energy
+
+    # Create a power quantity
+    power = Power.from_watts(230.0)
+
+    # Printing uses a unit to make the string as short as possible
+    print(f"Power: {power}")  # Power: 230.0 W
+    # The precision can be changed
+    print(f"Power: {power:0.3}")  # Power: 230.000 W
+    # The conversion methods can be used to get the value in a particular unit
+    print(f"Power in MW: {power.as_megawatt()}")  # Power in MW: 0.00023 MW
+
+    # Create a voltage quantity
+    voltage = Voltage.from_volts(230.0)
+
+    # Calculate the current
+    current = power / voltage
+    assert isinstance(current, Current)
+    print(f"Current: {current}")  # Current: 1.0 A
+    assert current.isclose(Current.from_amperes(1.0))
+
+    # Calculate the energy
+    energy = power * timedelta(hours=1)
+    assert isinstance(energy, Energy)
+    print(f"Energy: {energy}")  # Energy: 230.0 Wh
+    print(f"Energy in kWh: {energy.as_kilowatt_hours()}") # Energy in kWh: 0.23
+
+    # Invalid operations are not permitted
+    # (when using a type hinting linter like mypy, this will be caught at linting time)
+    try:
+        power + voltage
+    except TypeError as e:
+        print(f"Error: {e}")  # Error: unsupported operand type(s) for +: 'Power' and 'Voltage'
+    ```
+
+This library also provides an [**experimental** module with marshmallow fields and
+a base schema][frequenz.quantities.experimental.marshmallow] to serialize and
+deserialize quantities using the marshmallow library. To use it, you need to make sure
+to install this package with the `marshmallow` optional dependencies (e.g.
+`pip install frequenz-quantities[marshmallow]`).
+"""
+
+
+from ._apparent_power import ApparentPower
+from ._current import Current
+from ._energy import Energy
+from ._frequency import Frequency
+from ._percentage import Percentage
+from ._power import Power
+from ._quantity import Quantity
+from ._reactive_power import ReactivePower
+from ._temperature import Temperature
+from ._voltage import Voltage
+
+__all__ = [
+    "ApparentPower",
+    "Current",
+    "Energy",
+    "Frequency",
+    "Percentage",
+    "Power",
+    "Quantity",
+    "ReactivePower",
+    "Temperature",
+    "Voltage",
+]

frequenz-quantities-1.0.0/src/frequenz/quantities/_apparent_power.py

@@ -0,0 +1,234 @@
+# License: MIT
+# Copyright © 2024 Frequenz Energy-as-a-Service GmbH
+
+"""Types for holding apparent power quantities with units."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Self, overload
+
+from ._quantity import NoDefaultConstructible, Quantity
+
+if TYPE_CHECKING:
+    from ._current import Current
+    from ._percentage import Percentage
+    from ._voltage import Voltage
+
+
+class ApparentPower(
+    Quantity,
+    metaclass=NoDefaultConstructible,
+    exponent_unit_map={
+        -3: "mVA",
+        0: "VA",
+        3: "kVA",
+        6: "MVA",
+    },
+):
+    """A apparent power quantity.
+
+    Objects of this type are wrappers around `float` values and are immutable.
+
+    The constructors accept a single `float` value, the `as_*()` methods return a
+    `float` value, and each of the arithmetic operators supported by this type are
+    actually implemented using floating-point arithmetic.
+
+    So all considerations about floating-point arithmetic apply to this type as well.
+    """
+
+    @classmethod
+    def from_volt_amperes(cls, value: float) -> Self:
+        """Initialize a new apparent power quantity.
+
+        Args:
+            value: The apparent power in volt-amperes (VA).
+
+        Returns:
+            A new apparent power quantity.
+        """
+        return cls._new(value)
+
+    @classmethod
+    def from_milli_volt_amperes(cls, mva: float) -> Self:
+        """Initialize a new apparent power quantity.
+
+        Args:
+            mva: The apparent power in millivolt-amperes (mVA).
+
+        Returns:
+            A new apparent power quantity.
+        """
+        return cls._new(mva, exponent=-3)
+
+    @classmethod
+    def from_kilo_volt_amperes(cls, kva: float) -> Self:
+        """Initialize a new apparent power quantity.
+
+        Args:
+            kva: The apparent power in kilovolt-amperes (kVA).
+
+        Returns:
+            A new apparent power quantity.
+        """
+        return cls._new(kva, exponent=3)
+
+    @classmethod
+    def from_mega_volt_amperes(cls, mva: float) -> Self:
+        """Initialize a new apparent power quantity.
+
+        Args:
+            mva: The apparent power in megavolt-amperes (MVA).
+
+        Returns:
+            A new apparent power quantity.
+        """
+        return cls._new(mva, exponent=6)
+
+    def as_volt_amperes(self) -> float:
+        """Return the apparent power in volt-amperes (VA).
+
+        Returns:
+            The apparent power in volt-amperes (VA).
+        """
+        return self._base_value
+
+    def as_milli_volt_amperes(self) -> float:
+        """Return the apparent power in millivolt-amperes (mVA).
+
+        Returns:
+            The apparent power in millivolt-amperes (mVA).
+        """
+        return self._base_value * 1e3
+
+    def as_kilo_volt_amperes(self) -> float:
+        """Return the apparent power in kilovolt-amperes (kVA).
+
+        Returns:
+            The apparent power in kilovolt-amperes (kVA).
+        """
+        return self._base_value / 1e3
+
+    def as_mega_volt_amperes(self) -> float:
+        """Return the apparent power in megavolt-amperes (MVA).
+
+        Returns:
+            The apparent power in megavolt-amperes (MVA).
+        """
+        return self._base_value / 1e6
+
+    @overload
+    def __mul__(self, scalar: float, /) -> Self:
+        """Scale this power by a scalar.
+
+        Args:
+            scalar: The scalar by which to scale this power.
+
+        Returns:
+            The scaled power.
+        """
+
+    @overload
+    def __mul__(self, percent: Percentage, /) -> Self:
+        """Scale this power by a percentage.
+
+        Args:
+            percent: The percentage by which to scale this power.
+
+        Returns:
+            The scaled power.
+        """
+
+    def __mul__(self, other: float | Percentage, /) -> Self:
+        """Return a power or energy from multiplying this power by the given value.
+
+        Args:
+            other: The scalar, percentage or duration to multiply by.
+
+        Returns:
+            A power or energy.
+        """
+        from ._percentage import Percentage  # pylint: disable=import-outside-toplevel
+
+        match other:
+            case float() | Percentage():
+                return super().__mul__(other)
+            case _:
+                return NotImplemented
+
+    # We need the ignore here because otherwise mypy will give this error:
+    # > Overloaded operator methods can't have wider argument types in overrides
+    # The problem seems to be when the other type implements an **incompatible**
+    # __rmul__ method, which is not the case here, so we should be safe.
+    # Please see this example:
+    # https://github.com/python/mypy/blob/c26f1297d4f19d2d1124a30efc97caebb8c28616/test-data/unit/check-overloading.test#L4738C1-L4769C55
+    # And a discussion in a mypy issue here:
+    # https://github.com/python/mypy/issues/4985#issuecomment-389692396
+    @overload  # type: ignore[override]
+    def __truediv__(self, other: float, /) -> Self:
+        """Divide this power by a scalar.
+
+        Args:
+            other: The scalar to divide this power by.
+
+        Returns:
+            The divided power.
+        """
+
+    @overload
+    def __truediv__(self, other: Self, /) -> float:
+        """Return the ratio of this power to another.
+
+        Args:
+            other: The other power.
+
+        Returns:
+            The ratio of this power to another.
+        """
+
+    @overload
+    def __truediv__(self, current: Current, /) -> Voltage:
+        """Return a voltage from dividing this power by the given current.
+
+        Args:
+            current: The current to divide by.
+
+        Returns:
+            A voltage from dividing this power by the a current.
+        """
+
+    @overload
+    def __truediv__(self, voltage: Voltage, /) -> Current:
+        """Return a current from dividing this power by the given voltage.
+
+        Args:
+            voltage: The voltage to divide by.
+
+        Returns:
+            A current from dividing this power by a voltage.
+        """
+
+    def __truediv__(
+        self, other: float | Self | Current | Voltage, /
+    ) -> Self | float | Voltage | Current:
+        """Return a current or voltage from dividing this power by the given value.
+
+        Args:
+            other: The scalar, power, current or voltage to divide by.
+
+        Returns:
+            A current or voltage from dividing this power by the given value.
+        """
+        from ._current import Current  # pylint: disable=import-outside-toplevel
+        from ._voltage import Voltage  # pylint: disable=import-outside-toplevel
+
+        match other:
+            case float():
+                return super().__truediv__(other)
+            case ApparentPower():
+                return self._base_value / other._base_value
+            case Current():
+                return Voltage._new(self._base_value / other._base_value)
+            case Voltage():
+                return Current._new(self._base_value / other._base_value)
+            case _:
+                return NotImplemented