django-pint 1.0.1__py3-none-any.whl

django_pint/__init__.py

@@ -0,0 +1,14 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    # Change here if project is renamed and does not equal the package name
+    dist_name = "django-pint"
+    __version__ = version(dist_name)
+except PackageNotFoundError:  # pragma: no cover
+    __version__ = "unknown"
+finally:
+    del version, PackageNotFoundError
+
+from quantityfield import fields, helper, settings, units, widgets
+
+__all__ = ["fields", "helper", "settings", "units", "widgets"]

django_pint-1.0.1.dist-info/METADATA

@@ -0,0 +1,211 @@
+Metadata-Version: 2.4
+Name: django-pint
+Version: 1.0.1
+Summary: Quantity Field for Django using pint library for automated unit conversions
+Author: Ben Harling
+Author-email: Carli* Freudenberg <kound@posteo.de>
+Maintainer-email: Carli* Freudenberg <kound@posteo.de>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/CarliJoy/django-pint/
+Project-URL: Documentation, https://django-pint.readthedocs.io/en/latest/
+Project-URL: Source Code, https://github.com/CarliJoy/django-pint/
+Project-URL: Bug Tracker, https://github.com/CarliJoy/django-pint/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: Django>=4.2
+Requires-Dist: pint>=0.16
+Dynamic: license-file
+
+
+[![Build Status](https://api.travis-ci.com/CarliJoy/django-pint.svg?branch=master)](https://travis-ci.com/github/CarliJoy/django-pint)
+[![codecov](https://codecov.io/gh/CarliJoy/django-pint/branch/master/graph/badge.svg?token=I3M4CLILXE)](https://codecov.io/gh/CarliJoy/django-pint)
+[![PyPI Downloads](https://img.shields.io/pypi/dm/django-pint.svg?maxAge=2592000?style=plastic)](https://pypistats.org/packages/django-pint)
+[![Python Versions](https://img.shields.io/pypi/pyversions/django-pint.svg)](https://pypi.org/project/django-pint/)
+[![PyPI Version](https://img.shields.io/pypi/v/django-pint.svg?maxAge=2592000?style=plastic)](https://pypi.org/project/django-pint/)
+[![Project Status](https://img.shields.io/pypi/status/django-pint.svg)](https://pypi.org/project/SyncGitlab2MSProject/)
+[![Wheel Build](https://img.shields.io/pypi/wheel/django-pint.svg)](https://pypi.org/project/django-pint/)
+[![Code Style Black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
+[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/CarliJoy/django-pint/main.svg)](https://results.pre-commit.ci/latest/github/CarliJoy/django-pint/main)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Documentation Status](https://readthedocs.org/projects/django-pint/badge/?version=latest)](https://django-pint.readthedocs.io/en/latest/?badge=latest)
+
+# Django Quantity Field
+
+
+A Small django field extension allowing you to store quantities in certain units and perform conversions easily. Uses [pint](https://github.com/hgrecco/pint) behind the scenes. Also contains a form field class and form widget that allows a user to choose alternative units to input data. The cleaned_data will output the value in the base_units defined for the field, eg: you specify you want to store a value in grams but will allow users to input either grams or ounces.
+
+
+## Help wanted
+I am currently not working with Django anymore. Therefore the Maintenance of this project is not a priority for me anymore.
+If there is anybody that could imagine helping out maintaining the project, send me a mail.
+
+## Compatibility
+
+
+Requires django >= 5.2, and python 3.10/3.11/3.12/3.13/3.14
+
+Tested with the following combinations:
+* Django 5.2 (Python 3.10, 3.11, 3.12, 3.13, 3.14)
+* Django 6.0 (Python 3.12, 3.13, 3.14)
+
+## Installation
+
+
+    pip install django-pint
+
+
+## Simple Example
+
+Best way to illustrate is with an example
+
+    # app/models.py
+
+    from django.db import models
+    from quantityfield.fields import QuantityField
+
+    class HayBale(models.Model):
+	    weight = QuantityField('tonne')
+
+Quantities are stored as float (Django FloatField) and retrieved like any other field
+
+    >> bale = HayBale.objects.create(weight=1.2)
+    >> bale = HayBale.objects.first()
+	>> bale.weight
+	<Quantity(1.2, 'tonne')>
+	>> bale.weight.magnitude
+	1.2
+	>> bale.weight.units
+	'tonne'
+	>> bale.weight.to('kilogram')
+	<Quantity(1200, 'kilogram')>
+	>> bale.weight.to('pound')
+	<Quantity(2645.55, 'pound')>
+
+If your base unit is atomic (i.e. can be represented by an integer), you may also use `IntegerQuantityField` and `BigIntegerQuantityField`.
+
+If you prefer exact units you can use the `DecimalQuantityField`
+
+You can also pass Quantity objects to be stored in models. These are automatically converted to the units defined for the field
+( but can be converted to something else when retrieved of course ).
+
+    >> from quantityfield.units import ureg
+    >> Quantity = ureg.Quantity
+    >> pounds = Quantity(500 * ureg.pound)
+    >> bale = HayBale.objects.create(weight=pounds)
+    >> bale.weight
+    <Quantity(0.226796, 'tonne')>
+
+Use the inbuilt form field and widget to allow input of quantity values in different units
+
+    from quantityfield.fields import QuantityFormField
+
+    class HayBaleForm(forms.Form):
+        weight = QuantityFormField(base_units='gram', unit_choices=['gram', 'ounce', 'milligram'])
+
+The form will render a float input and a select widget to choose the units.
+Whenever cleaned_data is presented from the above form the weight field value will be a
+Quantity with the units set to grams (values are converted from the units input by the user).
+You also can add the `unit_choices` directly to the `ModelField`. It will be propagated
+correctly.
+
+For comparative lookups, query values will be coerced into the correct units when comparing values,
+this means that comparing 1 ounce to 1 tonne should yield the correct results.
+
+    less_than_a_tonne = HayBale.objects.filter(weight__lt=Quantity(2000 * ureg.pound))
+
+You can also use a custom Pint unit registry in your project `settings.py`
+
+    # project/settings.py
+
+    from pint import UnitRegistry
+
+    # django-pint will set the DJANGO_PINT_UNIT_REGISTER automatically
+    # as application_registry
+    DJANGO_PINT_UNIT_REGISTER = UnitRegistry('your_units.txt')
+    DJANGO_PINT_UNIT_REGISTER.define('beer_bootle_weight = 0.8 * kg = beer')
+
+    # app/models.py
+
+    class HayBale(models.Model):
+        # now you can use your custom units in your models
+        custom_unit = QuantityField('beer')
+
+Note: As the [documentation from pint](https://pint.readthedocs.io/en/latest/tutorial.html#using-pint-in-your-projects)
+states quite clearly: For each project there should be only one unit registry.
+Please note that if you change the unit registry for an already created project with
+data in a database, you could invalidate your data! So be sure you know what you are
+doing!
+Still only adding units should be okay.
+
+## Development
+
+### Preparation
+
+You need to install all Python Version that django-pint is compatible with.
+In a *nix environment you best could use [pyenv](https://github.com/pyenv/pyenv) to do so.
+
+Furthermore, you need to install [tox](https://tox.wiki/en/latest/) and [pre-commit](https://pre-commit.com/) to lint and test.
+
+You also need docker as our tests require a postgres database to run.
+We don't use SQL lite as some bugs only occurred using a proper database.
+
+I recommend using [pipx](https://pypa.github.io/pipx/) to install them.
+
+1. Install `pipx` (see pipx documentation), i.e. with `python3 -m pip install --user pipx && python3 -m pipx ensurepath`
+2. Install `pre-commit` running `pipx install pre-commit`
+3. Install `tox`  running `pipx install tox`
+4. Install the `tox-docker` plugin `pipx inject tox tox-docker`
+5. Fork `django-pint` and clone your fork (see [Tutorial](https://docs.github.com/get-started/quickstart/contributing-to-projects))
+6. Change into the repo `cd django-pint`
+7. Activate `pre-commit` for the repo running `pre-commit install`
+8. Check that all linter run fine with the cloned version by running `pre-commit run --all-files`
+9. Check that all tests succeed by running `tox`
+
+**Congratulation** you successfully cloned and tested the upstream version of `django-pint`.
+
+Now you can work on your feature branch and test your changes using `tox`.
+Your code will be automatically linted and formatted by `pre-commit` if you commit your changes.
+If it fails, simply add all changes and try again.
+If this doesn't help look at the output of your `git commit` command.
+
+Once you are done, [create a pull request](https://docs.github.com/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request-from-a-fork).
+
+### Local development environment with Docker
+
+To run a local development environment with Docker you need to run the following steps:
+This is helpful if you have troubles installing `postgresql` or `psycopg2-binary`.
+
+1. `git clone` your fork
+2. run `cp .env.example .env`
+3. edit `.env` file and change it with your credentials ( the postgres host should match the service name in docker-file so you can use "postgres" )
+4. run `cp tests/local.py.docker-example tests/local.py`
+5. run `docker-compose up` in the root folder, this should build and start 2 containers, one for postgres and the other one python dependencies. Note you have to be in the [docker](https://stackoverflow.com/a/47078951/3813064) group for this to work.
+6. open a new terminal and run `docker-compose exec app bash`, this should open a ssh console in the docker container
+7. you can run `pytest` inside the container to see the result of the tests.
+
+### Updating the package
+[Python](https://endoflife.date/python) and [Django](https://endoflife.date/django) major versions have defined EOL.
+To reduce the maintenance burden and encourage users to use version still receiving security updates any `django-pint` update should match all and only these version of Python and Django that are supported.
+Updating these dependencies have to be done in multiple places:
+ - `README.md`: Describing it to end users
+ - `tox.ini`: For local testing
+ - `pyproject.toml`: For usage with pip and displaying it in PyPi
+ - `.github/workflows/test.yaml`: For the CI/CD Definition

django_pint-1.0.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+django_pint/__init__.py,sha256=rLa3Ej2DQbqPaygJUf258b7Cy5juDxvOwS8DHHwjaN8,466
+django_pint-1.0.1.dist-info/licenses/LICENSE.txt,sha256=HMDhAOPCnlDTTF0u6fEEJz9rGCUQiS3lluNuFFvojAs,1154
+quantityfield/__init__.py,sha256=W-x-EjdsFKJr29897UUG1XEBwS-91YxxgZCM8pbAc50,334
+quantityfield/fields.py,sha256=62iV2Av_cpZLqSCXlSyp4RcGeRQSbOzlV0cZ_f4GlgE,15373
+quantityfield/helper.py,sha256=6_7b8T-NKhSeoQQLyehl1NypS85UU8pGCxqUxLiM_wM,756
+quantityfield/settings.py,sha256=XNbZdlOO_tfI1TtxR3Gc0JZSGMPGKVLn5Qob0utLzrQ,349
+quantityfield/units.py,sha256=lIme1byRyf1lm2wfmlxLpq6Akq5pyQq3qBp4d7OfU2c,146
+quantityfield/widgets.py,sha256=tNlszZEJ1Nq-gs9Fb4idp-SBZnW2uM6uobcfqCcK6uM,1180
+django_pint-1.0.1.dist-info/METADATA,sha256=y2ktAr7w2FEqB7ec9t234gjuy9LVKCZDNbz2jjDTA_U,10576
+django_pint-1.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+django_pint-1.0.1.dist-info/top_level.txt,sha256=oBxrgF8d06MHSvF2UQgGOvE4tOQfgG0n_eYvDPi8Jl4,26
+django_pint-1.0.1.dist-info/RECORD,,

django_pint-1.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

django_pint-1.0.1.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,23 @@
+The MIT License (MIT)
+
+Copyright (C) 2020-2022 django-pint authors (see AUTHORS file)
+
+Copyright (c) 2020-2022 Carli* Freudenberg
+
+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.

django_pint-1.0.1.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+django_pint
+quantityfield

quantityfield/__init__.py

@@ -0,0 +1,10 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    # Change here if project is renamed and does not equal the package name
+    dist_name = "django-pint"
+    __version__ = version(dist_name)
+except PackageNotFoundError:  # pragma: no cover
+    __version__ = "unknown"
+finally:
+    del version, PackageNotFoundError

quantityfield/fields.py

@@ -0,0 +1,434 @@
+import datetime
+import typing
+import warnings
+from collections.abc import Callable, Sequence
+from decimal import Decimal
+from typing import Any, Union, cast
+
+from django import forms
+from django.contrib.admin.options import FORMFIELD_FOR_DBFIELD_DEFAULTS
+from django.core.exceptions import ValidationError
+from django.db import models
+from django.utils import formats
+from django.utils.translation import gettext_lazy as _
+
+from pint import Quantity
+
+from .helper import check_matching_unit_dimension
+from .units import ureg
+from .widgets import QuantityWidget
+
+DJANGO_JSON_SERIALIZABLE_BASE = Union[  # noqa: UP007
+    None, bool, str, int, float, complex, datetime.datetime
+]
+DJANGO_JSON_SERIALIZABLE = Union[  # noqa: UP007
+    Sequence[DJANGO_JSON_SERIALIZABLE_BASE], dict[str, DJANGO_JSON_SERIALIZABLE_BASE]
+]
+NUMBER_TYPE = Union[int, float, Decimal]  # noqa: UP007
+
+
+class QuantityFieldMixin:
+    to_number_type: Callable[[Any], NUMBER_TYPE]
+
+    # TODO: Move these stuff into an Protocol or anything
+    #       better defining a Mixin
+    value_from_object: Callable[[Any], Any]
+    name: str
+    validate: Callable
+    run_validators: Callable
+
+    """A Django Model Field that resolves to a pint Quantity object"""
+
+    def __init__(
+        self,
+        base_units: str,
+        *args,
+        unit_choices: typing.Iterable[str] | None = None,
+        **kwargs,
+    ):
+        """
+        Create a Quantity field
+        :param base_units: Unit description of base unit
+        :param unit_choices: If given the possible unit choices with the same
+                             dimension like the base_unit
+        """
+        if not isinstance(base_units, str):
+            raise ValueError(
+                'QuantityField must be defined with base units, eg: "gram"'
+            )
+
+        self.ureg = ureg
+
+        # we do this as a way of raising an exception if some crazy unit was supplied.
+        unit = getattr(self.ureg, base_units)  # noqa: F841
+
+        # if we've not hit an exception here, we should be all good
+        self.base_units = base_units
+
+        if unit_choices is None:
+            self.unit_choices: list[str] = [self.base_units]
+        else:
+            self.unit_choices = list(unit_choices)
+            # The multi widget expects that the base unit is always present as unit
+            # choice.
+            # Otherwise we would need to handle special cases for no good reason.
+            if self.base_units in self.unit_choices:
+                self.unit_choices.remove(self.base_units)
+            # Base unit has to be the first choice, always as all values are saved as
+            # base unit within the database and this would be the first unit shown
+            # in the widget
+            self.unit_choices = [self.base_units, *self.unit_choices]
+
+        # Check if all unit_choices are valid
+        check_matching_unit_dimension(self.ureg, self.base_units, self.unit_choices)
+
+        super().__init__(*args, **kwargs)
+
+    @property
+    def units(self) -> str:
+        return self.base_units
+
+    def deconstruct(
+        self,
+    ) -> tuple[
+        str,
+        str,
+        Sequence[DJANGO_JSON_SERIALIZABLE],
+        dict[str, DJANGO_JSON_SERIALIZABLE],
+    ]:
+        """
+        Return enough information to recreate the field as a 4-tuple:
+
+         * The name of the field on the model, if contribute_to_class() has
+           been run.
+         * The import path of the field, including the class:e.g.
+           django.db.models.IntegerField This should be the most portable
+           version, so less specific may be better.
+         * A list of positional arguments.
+         * A dict of keyword arguments.
+
+        """
+        super_deconstruct = getattr(super(), "deconstruct", None)
+        if not callable(super_deconstruct):
+            raise NotImplementedError(
+                "Tried to use Mixin on a class that has no deconstruct function. "
+            )
+        name, path, args, kwargs = super_deconstruct()
+        kwargs["base_units"] = self.base_units
+        kwargs["unit_choices"] = self.unit_choices
+        return name, path, args, kwargs
+
+    def fix_unit_registry(self, value: Quantity) -> Quantity:
+        """
+        Check if the UnitRegistry from settings is used.
+        If not try to fix it but give a warning.
+        """
+        if isinstance(value, Quantity):
+            if not isinstance(value, self.ureg.Quantity):
+                # Could be fatal if different unit registers are used but we assume
+                # the same is used within one project
+                # As we warn for this behaviour, we assume that the programmer
+                # will fix it and do not include more checks!
+                warnings.warn(
+                    "Trying to set value from a different unit register for "
+                    "quantityfield. "
+                    "We assume the naming is equal but best use the same register as"
+                    " for creating the quantityfield.",
+                    RuntimeWarning,
+                    stacklevel=2,
+                )
+                return value.magnitude * self.ureg(str(value.units))
+            else:
+                return value
+        else:
+            raise ValueError(f"Value '{value}' ({type(value)} is not a quantity.")
+
+    def get_prep_value(self, value: Any) -> NUMBER_TYPE | None:
+        """
+        Perform preliminary non-db specific value checks and conversions.
+
+        Make sure that we compare/use only values without a unit
+        """
+        # we store the value in the base units defined for this field
+        if value is None:
+            return None
+
+        if isinstance(value, Quantity):
+            quantity = self.fix_unit_registry(value)
+            magnitude = quantity.to(self.base_units).magnitude
+        else:
+            magnitude = value
+
+        try:
+            return self.to_number_type(magnitude)
+        except (TypeError, ValueError) as e:
+            raise e.__class__(
+                f"Field '{self.name}' expected a number but got {value!r}.",
+            ) from e
+
+    def get_db_prep_value(self, value, connection, prepared=False):
+        """
+        Convert value to database-compatible format.
+        This is called for both save() operations and filter lookups.
+        """
+        if prepared:
+            return value
+
+        # Use get_prep_value to convert Quantity to magnitude
+        return self.get_prep_value(value)
+
+    def value_to_string(self, obj) -> str:
+        value = self.value_from_object(obj)
+        return str(self.get_prep_value(value))
+
+    def from_db_value(self, value: Any, *args, **kwargs) -> Quantity | None:
+        if value is None:
+            return None
+        return self.ureg.Quantity(value, getattr(self.ureg, self.base_units))
+
+    def to_python(self, value) -> Quantity | None:
+        if isinstance(value, Quantity):
+            return self.fix_unit_registry(value)
+
+        if value is None:
+            return None
+
+        to_number = super().to_python
+        if not callable(to_number):
+            raise NotImplementedError(
+                "Mixin not used with a class that has to_python function"
+            )
+
+        value = cast(NUMBER_TYPE, to_number(value))
+
+        return self.ureg.Quantity(value, getattr(self.ureg, self.base_units))
+
+    def clean(self, value, model_instance) -> Quantity:
+        """
+        Convert the value's type and run validation. Validation errors
+        from to_python() and validate() are propagated. Return the correct
+        value if no error is raised.
+
+        This is a copy from djangos implementation but modified so that validators
+        are only checked against the magnitude as otherwise the default database
+        validators will not fail because of comparison errors
+        """
+        value = self.to_python(value)
+        check_value = self.get_prep_value(value)
+        self.validate(check_value, model_instance)
+        self.run_validators(check_value)
+        return value
+
+    def formfield(self, **kwargs):
+        defaults = {
+            "form_class": self.form_field_class,
+            "base_units": self.base_units,
+            "unit_choices": self.unit_choices,
+        }
+        defaults.update(kwargs)
+        return super().formfield(**defaults)
+
+
+class QuantityFormFieldMixin:
+    """This formfield allows a user to choose which units they
+    wish to use to enter a value, but the value is yielded in
+    the base_units
+    """
+
+    to_number_type: Callable[[Any], NUMBER_TYPE]
+
+    # TODO: Move these stuff into an Protocol or anything
+    #       better defining a Mixin
+    validate: Callable
+    run_validators: Callable
+    error_messages: dict[str, str]
+    empty_values: Sequence[Any]
+    localize: bool
+
+    def __init__(self, *args, **kwargs):
+        self.ureg = ureg
+        self.base_units = kwargs.pop("base_units", None)
+        if self.base_units is None:
+            raise ValueError(
+                "QuantityFormField requires a base_units kwarg of a "
+                "single unit type (eg: grams)"
+            )
+        self.units = kwargs.pop("unit_choices", [self.base_units])
+        if self.base_units not in self.units:
+            self.units.append(self.base_units)
+
+        check_matching_unit_dimension(self.ureg, self.base_units, self.units)
+
+        def is_special_admin_widget(widget) -> bool:
+            """
+            There are some special django admin widgets, defined
+            in django/contrib/admin/options.py in the variable
+            FORMFIELD_FOR_DBFIELD_DEFAULTS
+            The intention for Integer and BigIntegerField is only to
+            define the width.
+
+            They are set through a complicated process of the
+            modelform_factory setting formfield_callback to
+            ModelForm.formfield_to_dbfield
+
+            As they will overwrite our Widget we check for them and
+            will ignore them, if they are set as attribute.
+
+            We still will allow subclasses, so the end user has still
+            the possibility to use this widget.
+            """
+            WIDGETS_TO_IGNORE = [
+                FORMFIELD_FOR_DBFIELD_DEFAULTS[models.IntegerField],
+                FORMFIELD_FOR_DBFIELD_DEFAULTS[models.BigIntegerField],
+            ]
+            classes_to_ignore = [
+                ignored_widget["widget"].__name__
+                for ignored_widget in WIDGETS_TO_IGNORE
+            ]
+            return widget.__name__ in classes_to_ignore
+
+        widget = kwargs.get("widget")
+        if widget is None or is_special_admin_widget(widget):
+            widget = QuantityWidget(
+                base_units=self.base_units, allowed_types=self.units
+            )
+        kwargs["widget"] = widget
+        super().__init__(*args, **kwargs)
+
+    def prepare_value(self, value):
+        if isinstance(value, Quantity):
+            return value.to(self.base_units)
+        else:
+            return value
+
+    def clean(self, value):
+        """
+        General idea, first try to extract the correct number like done in the other
+        classes and then follow the same procedure as in the django default field
+        """
+        if isinstance(value, list) or isinstance(value, tuple):
+            val = value[0]
+            units = value[1]
+        else:
+            # If no multi widget is used
+            val = value
+            units = self.base_units
+
+        if val in self.empty_values:
+            # Make sure the correct functions are called also in case of empty values
+            self.validate(None)
+            self.run_validators(None)
+            return None
+
+        if units not in self.units:
+            raise ValidationError(_("%(units)s is not a valid choice") % locals())
+
+        if self.localize:
+            val = formats.sanitize_separators(value)
+
+        try:
+            val = self.to_number_type(val)
+        except (ValueError, TypeError):
+            raise ValidationError(
+                self.error_messages["invalid"], code="invalid"
+            ) from None
+
+        val = self.ureg.Quantity(val, getattr(self.ureg, units)).to(self.base_units)
+        self.validate(val.magnitude)
+        self.run_validators(val.magnitude)
+        return val
+
+
+class QuantityFormField(QuantityFormFieldMixin, forms.FloatField):
+    to_number_type = float
+
+
+class QuantityField(QuantityFieldMixin, models.FloatField):
+    form_field_class = QuantityFormField
+    to_number_type = float
+
+
+class IntegerQuantityFormField(QuantityFormFieldMixin, forms.IntegerField):
+    to_number_type = int
+
+
+class IntegerQuantityField(QuantityFieldMixin, models.IntegerField):
+    form_field_class = IntegerQuantityFormField
+    to_number_type = int
+
+
+class BigIntegerQuantityField(QuantityFieldMixin, models.BigIntegerField):
+    form_field_class = IntegerQuantityFormField
+    to_number_type = int
+
+
+class PositiveIntegerQuantityField(QuantityFieldMixin, models.PositiveIntegerField):
+    form_field_class = IntegerQuantityFormField
+    to_number_type = int
+
+
+class DecimalQuantityFormField(QuantityFormFieldMixin, forms.DecimalField):
+    def to_number_type(self, x: object) -> Decimal:
+        return Decimal(str(x))
+
+
+class DecimalQuantityField(QuantityFieldMixin, models.DecimalField):
+    form_field_class = DecimalQuantityFormField
+
+    def __init__(
+        self,
+        base_units: str,
+        *args,
+        unit_choices: list[str] | None = None,
+        verbose_name: str = None,
+        name: str = None,
+        max_digits: int = None,
+        decimal_places: int = None,
+        **kwargs,
+    ):
+        # We try to be friendly as default django, if there are missing argument
+        # we throw an error early
+        if not isinstance(max_digits, int) or not isinstance(decimal_places, int):
+            raise ValueError(
+                _(
+                    "Invalid initialization for DecimalQuantityField! "
+                    "We expect max_digits and decimal_places to be set as integers."
+                )
+            )
+        # and we also check the values to be sane
+        if decimal_places < 0 or max_digits < 1 or decimal_places > max_digits:
+            raise ValueError(
+                _(
+                    "Invalid initialization for DecimalQuantityField! "
+                    "max_digits and decimal_places need to positive and max_digits"
+                    "needs to be larger than decimal_places and at least 1. "
+                    "So max_digits=%(max_digits)s and "
+                    "decimal_plactes=%(decimal_places)s "
+                    "are not valid parameters."
+                )
+                % locals()
+            )
+
+        super().__init__(
+            base_units,
+            *args,
+            unit_choices=unit_choices,
+            verbose_name=verbose_name,
+            name=name,
+            max_digits=max_digits,
+            decimal_places=decimal_places,
+            **kwargs,
+        )
+
+    def to_number_type(self, x: object) -> Decimal:
+        return Decimal(str(x))
+
+    def get_db_prep_save(self, value, connection) -> Decimal:
+        """
+        Get Value that shall be saved to database, make sure it is transformed
+        """
+        converted = self.to_python(value)
+        magnitude = self.get_prep_value(converted)
+        return connection.ops.adapt_decimalfield_value(
+            magnitude, self.max_digits, self.decimal_places
+        )

quantityfield/helper.py

@@ -0,0 +1,22 @@
+from pint import DimensionalityError, UnitRegistry
+
+
+def check_matching_unit_dimension(
+    ureg: UnitRegistry, base_units: str, units_to_check: list[str]
+) -> None:
+    """
+    Check if all units_to_check have the same Dimension like the base_units
+    If not
+    :raise DimensionalityError
+    """
+    base_unit = getattr(ureg, base_units)
+    # create a pint quantity by multiplying unit with magnitude of 1
+    base_quant = 1 * base_unit
+
+    for unit_string in units_to_check:
+        unit = getattr(ureg, unit_string)
+        # try to convert base qunatity to new unit, this also work for ureg.context
+        try:
+            base_quant.to(unit)
+        except DimensionalityError as e:
+            raise DimensionalityError(base_unit, unit) from e

quantityfield/settings.py

@@ -0,0 +1,11 @@
+__version__ = "0.4"
+from django.conf import settings
+
+from pint import UnitRegistry, set_application_registry
+
+# Define default unit register
+DJANGO_PINT_UNIT_REGISTER = getattr(
+    settings, "DJANGO_PINT_UNIT_REGISTER", UnitRegistry()
+)
+# Set as default application registry for i.e. for pickle
+set_application_registry(DJANGO_PINT_UNIT_REGISTER)

quantityfield/units.py

@@ -0,0 +1,4 @@
+from .settings import DJANGO_PINT_UNIT_REGISTER
+
+# The unit register that was defined in the settings (shortcut)
+ureg = DJANGO_PINT_UNIT_REGISTER

quantityfield/widgets.py

@@ -0,0 +1,36 @@
+from numbers import Number
+
+from django.forms.widgets import MultiWidget, NumberInput, Select
+
+import pint
+
+from .units import ureg
+
+
+class QuantityWidget(MultiWidget):
+    def __init__(self, *, attrs=None, base_units=None, allowed_types=None):
+        self.ureg = ureg
+        choices = self.get_choices(allowed_types)
+        self.base_units = base_units
+        attrs = attrs or {}
+        attrs.setdefault("step", "any")
+        widgets = (NumberInput(attrs=attrs), Select(attrs=attrs, choices=choices))
+        super().__init__(widgets, attrs)
+
+    def get_choices(self, allowed_types=None):
+        allowed_types = allowed_types or dir(self.ureg)
+        return [(x, x) for x in allowed_types]
+
+    def decompress(self, value):
+        """This function is called during rendering
+
+        It is responsible to split values for the two widgets
+        """
+        if isinstance(value, Number):
+            # We assume that the given value is a proper number,
+            # ready to be rendered
+            return [value, self.base_units]
+        elif isinstance(value, pint.Quantity):
+            return [value.magnitude, value.units]
+
+        return [None, self.base_units]