# Path: localized_fields/fields/float_field.py
# class LocalizedFloatField(LocalizedField):
#     """Stores float as a localized value."""
# 
#     attr_class = LocalizedFloatValue
# 
#     @classmethod
#     def from_db_value(cls, value, *_) -> Optional[LocalizedFloatValue]:
#         db_value = super().from_db_value(value)
#         if db_value is None:
#             return db_value
# 
#         # if we were used in an expression somehow then it might be
#         # that we're returning an individual value or an array, so
#         # we should not convert that into an :see:LocalizedFloatValue
#         if not isinstance(db_value, LocalizedValue):
#             return db_value
# 
#         return cls._convert_localized_value(db_value)
# 
#     def to_python(
#         self, value: Union[Dict[str, int], int, None]
#     ) -> LocalizedFloatValue:
#         """Converts the value from a database value into a Python value."""
# 
#         db_value = super().to_python(value)
#         return self._convert_localized_value(db_value)
# 
#     def get_prep_value(self, value: LocalizedFloatValue) -> dict:
#         """Gets the value in a format to store into the database."""
# 
#         # apply default values
#         default_values = LocalizedFloatValue(self.default)
#         if isinstance(value, LocalizedFloatValue):
#             for lang_code, _ in settings.LANGUAGES:
#                 local_value = value.get(lang_code)
#                 if local_value is None:
#                     value.set(lang_code, default_values.get(lang_code, None))
# 
#         prepped_value = super().get_prep_value(value)
#         if prepped_value is None:
#             return None
# 
#         # make sure all values are proper floats
#         for lang_code, _ in settings.LANGUAGES:
#             local_value = prepped_value[lang_code]
#             try:
#                 if local_value is not None:
#                     float(local_value)
#             except (TypeError, ValueError):
#                 raise IntegrityError(
#                     'non-float value in column "%s.%s" violates '
#                     "float constraint" % (self.name, lang_code)
#                 )
# 
#             # convert to a string before saving because the underlying
#             # type is hstore, which only accept strings
#             prepped_value[lang_code] = (
#                 str(local_value) if local_value is not None else None
#             )
# 
#         return prepped_value
# 
#     def formfield(self, **kwargs):
#         """Gets the form field associated with this field."""
#         defaults = {"form_class": LocalizedIntegerFieldForm}
# 
#         defaults.update(kwargs)
#         return super().formfield(**defaults)
# 
#     @staticmethod
#     def _convert_localized_value(value: LocalizedValue) -> LocalizedFloatValue:
#         """Converts from :see:LocalizedValue to :see:LocalizedFloatValue."""
# 
#         float_values = {}
#         for lang_code, _ in settings.LANGUAGES:
#             local_value = value.get(lang_code, None)
#             if local_value is None or local_value.strip() == "":
#                 local_value = None
# 
#             try:
#                 float_values[lang_code] = float(local_value)
#             except (ValueError, TypeError):
#                 float_values[lang_code] = None
# 
#         return LocalizedFloatValue(float_values)
# 
# Path: tests/fake_model.py
# def get_fake_model(fields=None, model_base=LocalizedModel, meta_options={}):
#     """Creates a fake model to use during unit tests."""
# 
#     model = define_fake_model(fields, model_base, meta_options)
# 
#     class TestProject:
#         def clone(self, *_args, **_kwargs):
#             return self
# 
#         @property
#         def apps(self):
#             return self
# 
#     class TestMigration(migrations.Migration):
#         operations = [HStoreExtension()]
# 
#     with connection.schema_editor() as schema_editor:
#         migration_executor = MigrationExecutor(schema_editor.connection)
#         migration_executor.apply_migration(
#             TestProject(), TestMigration("eh", "postgres_extra")
#         )
# 
#         schema_editor.create_model(model)
# 
#     return model


from django.conf import settings
from django.db import connection
from django.db.utils import IntegrityError
from django.test import TestCase
from django.utils import translation
from localized_fields.fields import LocalizedFloatField
from .fake_model import get_fake_model
    def test_translate_primary_fallback(self):
        """Tests whether casting the value to an float results in the value
        begin returned in the active language and falls back to the primary
        language if there is no value in that language."""

        obj = self.TestModel()
        obj.score.set(settings.LANGUAGE_CODE, 25.0)

        secondary_language = settings.LANGUAGES[-1][0]
        assert obj.score.get(secondary_language) is None

        with translation.override(secondary_language):
            assert obj.score.translate() == 25.0
            assert float(obj.score) == 25.0

    def test_get_default_value(self):
        """Tests whether getting the value in a specific language properly
        returns the specified default in case it is not available."""

        obj = self.TestModel()
        obj.score.set(settings.LANGUAGE_CODE, 25.0)

        secondary_language = settings.LANGUAGES[-1][0]
        assert obj.score.get(secondary_language) is None
        assert obj.score.get(secondary_language, 1337.0) == 1337.0

    def test_completely_optional(self):
        """Tests whether having all languages optional works properly."""

        model = get_fake_model(

# Path: localized_fields/fields/float_field.py
# class LocalizedFloatField(LocalizedField):
#     """Stores float as a localized value."""
# 
#     attr_class = LocalizedFloatValue
# 
#     @classmethod
#     def from_db_value(cls, value, *_) -> Optional[LocalizedFloatValue]:
#         db_value = super().from_db_value(value)
#         if db_value is None:
#             return db_value
# 
#         # if we were used in an expression somehow then it might be
#         # that we're returning an individual value or an array, so
#         # we should not convert that into an :see:LocalizedFloatValue
#         if not isinstance(db_value, LocalizedValue):
#             return db_value
# 
#         return cls._convert_localized_value(db_value)
# 
#     def to_python(
#         self, value: Union[Dict[str, int], int, None]
#     ) -> LocalizedFloatValue:
#         """Converts the value from a database value into a Python value."""
# 
#         db_value = super().to_python(value)
#         return self._convert_localized_value(db_value)
# 
#     def get_prep_value(self, value: LocalizedFloatValue) -> dict:
#         """Gets the value in a format to store into the database."""
# 
#         # apply default values
#         default_values = LocalizedFloatValue(self.default)
#         if isinstance(value, LocalizedFloatValue):
#             for lang_code, _ in settings.LANGUAGES:
#                 local_value = value.get(lang_code)
#                 if local_value is None:
#                     value.set(lang_code, default_values.get(lang_code, None))
# 
#         prepped_value = super().get_prep_value(value)
#         if prepped_value is None:
#             return None
# 
#         # make sure all values are proper floats
#         for lang_code, _ in settings.LANGUAGES:
#             local_value = prepped_value[lang_code]
#             try:
#                 if local_value is not None:
#                     float(local_value)
#             except (TypeError, ValueError):
#                 raise IntegrityError(
#                     'non-float value in column "%s.%s" violates '
#                     "float constraint" % (self.name, lang_code)
#                 )
# 
#             # convert to a string before saving because the underlying
#             # type is hstore, which only accept strings
#             prepped_value[lang_code] = (
#                 str(local_value) if local_value is not None else None
#             )
# 
#         return prepped_value
# 
#     def formfield(self, **kwargs):
#         """Gets the form field associated with this field."""
#         defaults = {"form_class": LocalizedIntegerFieldForm}
# 
#         defaults.update(kwargs)
#         return super().formfield(**defaults)
# 
#     @staticmethod
#     def _convert_localized_value(value: LocalizedValue) -> LocalizedFloatValue:
#         """Converts from :see:LocalizedValue to :see:LocalizedFloatValue."""
# 
#         float_values = {}
#         for lang_code, _ in settings.LANGUAGES:
#             local_value = value.get(lang_code, None)
#             if local_value is None or local_value.strip() == "":
#                 local_value = None
# 
#             try:
#                 float_values[lang_code] = float(local_value)
#             except (ValueError, TypeError):
#                 float_values[lang_code] = None
# 
#         return LocalizedFloatValue(float_values)
# 
# Path: tests/fake_model.py
# def get_fake_model(fields=None, model_base=LocalizedModel, meta_options={}):
#     """Creates a fake model to use during unit tests."""
# 
#     model = define_fake_model(fields, model_base, meta_options)
# 
#     class TestProject:
#         def clone(self, *_args, **_kwargs):
#             return self
# 
#         @property
#         def apps(self):
#             return self
# 
#     class TestMigration(migrations.Migration):
#         operations = [HStoreExtension()]
# 
#     with connection.schema_editor() as schema_editor:
#         migration_executor = MigrationExecutor(schema_editor.connection)
#         migration_executor.apply_migration(
#             TestProject(), TestMigration("eh", "postgres_extra")
#         )
# 
#         schema_editor.create_model(model)
# 
#     return model


# Path: tests/test_float_field.py
from django.conf import settings
from django.db import connection
from django.db.utils import IntegrityError
from django.test import TestCase
from django.utils import translation
from localized_fields.fields import LocalizedFloatField
from .fake_model import get_fake_model

    def test_translate_primary_fallback(self):
        """Tests whether casting the value to an float results in the value
        begin returned in the active language and falls back to the primary
        language if there is no value in that language."""

        obj = self.TestModel()
        obj.score.set(settings.LANGUAGE_CODE, 25.0)

        secondary_language = settings.LANGUAGES[-1][0]
        assert obj.score.get(secondary_language) is None

        with translation.override(secondary_language):
            assert obj.score.translate() == 25.0
            assert float(obj.score) == 25.0

    def test_get_default_value(self):
        """Tests whether getting the value in a specific language properly
        returns the specified default in case it is not available."""

        obj = self.TestModel()
        obj.score.set(settings.LANGUAGE_CODE, 25.0)

        secondary_language = settings.LANGUAGES[-1][0]
        assert obj.score.get(secondary_language) is None
        assert obj.score.get(secondary_language, 1337.0) == 1337.0

    def test_completely_optional(self):
        """Tests whether having all languages optional works properly."""

        model = get_fake_model(

            {"score": LocalizedFloatField(null=True, required=[], blank=True)}