wbcore 2.2.1__py2.py3-none-any.whl → 2.2.4__py2.py3-none-any.whl

wbcore/contrib/color/enums.py

@@ -0,0 +1,17 @@
+from enum import Enum
+
+
+class WBColor(Enum):
+    GREEN_LIGHT = "rgb(214, 229, 145)"
+    GREEN = "rgb(182, 223, 18)"
+    GREEN_DARK = "rgb(111, 181, 68)"
+    RED_LIGHT = "rgb(244, 132, 116)"
+    RED = "rgb(250, 84, 62)"
+    RED_DARK = "rgb(224, 57, 49)"
+    YELLOW_LIGHT = "rgb(247, 232, 113)"
+    YELLOW = "rgb(247, 207, 77)"
+    YELLOW_DARK = "rgb(247, 190, 47)"
+    GREY = "rgb(133, 144, 162)"
+    BLUE_LIGHT = "rgb(104, 198, 224)"
+    BLUE = "rgb(69, 112, 224)"
+    BLUE_DARK = "rgb(33, 26, 233)"

wbcore/contrib/color/factories.py

@@ -0,0 +1,10 @@
+import factory
+from wbcore.contrib.color.models import ColorGradient
+
+
+class ColorGradientFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = ColorGradient
+
+    title = factory.Sequence(lambda n: f"Color Gradient {n}")
+    colors = factory.List([factory.Faker("color") for _ in range(10)])

wbcore/contrib/color/fields.py

@@ -0,0 +1,29 @@
+import re
+
+from django.core.exceptions import ValidationError
+from django.db.models import CharField
+
+
+def validate_color(color_string):
+    """Hexadecimal validation."""
+    if color_string is None:
+        return color_string
+
+    if not re.search(r"^#(?:[0-9a-fA-F]{3}){1,2}$", color_string):
+        raise ValidationError("Please provide a valid hexadecimal color.")
+
+    return color_string
+
+
+class ColorField(CharField):
+    description = "A field storing a hexadecimal color value"
+    default_validators = [validate_color]
+
+    def __init__(self, *args, **kwargs):
+        kwargs["max_length"] = 7
+        super().__init__(*args, **kwargs)
+
+    def deconstruct(self):
+        name, path, args, kwargs = super().deconstruct()
+        del kwargs["max_length"]
+        return name, path, args, kwargs

wbcore/contrib/color/forms.py

@@ -0,0 +1,13 @@
+from django_better_admin_arrayfield.forms.widgets import DynamicArrayWidget
+
+
+class DynamicArrayColorWidget(DynamicArrayWidget):
+    template_name = "wbcore/dynamic_color_array.html"
+
+    def get_context(self, name, value, attrs):
+        context = super().get_context(name, value, attrs)
+        context["default"] = "#ffffff"
+        return context
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)

wbcore/contrib/color/models.py

@@ -0,0 +1,62 @@
+from typing import Generator
+
+from colorfield.fields import ColorField
+from django.db import models
+from django_better_admin_arrayfield.models.fields import ArrayField
+
+
+class ColorGradient(models.Model):
+    """
+    Utility class for color gradient support in report
+    """
+
+    title = models.CharField(max_length=128, default="")
+    colors = ArrayField(ColorField(default="#FF0000"), default=list)
+
+    def __str__(self) -> str:
+        return self.title
+
+    def get_gradient(self, color: str | None = None, color_size: int = -1) -> Generator:
+        """
+        Return the consecutive colors (gradient) given a color based on the closest distance
+
+        Args:
+            color: a hex color. Optional.
+            color_size: The number of colors the list should return. Optional.
+
+        Returns:
+            A generator of colors bounds in size by the color_size parameters or the gradient defaults color palette size
+        """
+
+        def _hex2rgb(_color):
+            _color = _color.replace("#", "")
+            return tuple(int(_color[i : i + 2], 16) for i in (0, 2, 4))
+
+        if color_size < 0:
+            color_size = len(self.colors)
+
+        index = 0
+        if color:
+            color_rgb = _hex2rgb(color)
+            nearest_color = min(
+                self.colors, key=lambda subject: sum((s - q) ** 2 for s, q in zip(_hex2rgb(subject), color_rgb))
+            )
+
+            index = self.colors.index(nearest_color)
+        for i in range(color_size):
+            yield self.colors[(index + i) % len(self.colors)]
+
+
+class TransparencyMixin:
+    def get_cell_formatting(self, request):
+        return [
+            {
+                "column": None,
+                "conditions": [
+                    {
+                        "condition": None,
+                        "style": {"backgroundColor": f'rgba(255, 255, 255, {getattr(self, "TRANSPARENCY", 0.4)})'},
+                    },
+                ],
+            }
+        ]

wbcore/contrib/color/tests/conftest.py

@@ -0,0 +1,10 @@
+from django.apps import apps
+from django.db.models.signals import pre_migrate
+from pytest_factoryboy import register
+from wbcore.contrib.color.factories import ColorGradientFactory
+from wbcore.contrib.geography.tests.signals import app_pre_migration
+
+register(ColorGradientFactory)
+
+
+pre_migrate.connect(app_pre_migration, sender=apps.get_app_config("geography"))

wbcore/contrib/color/tests/test_color_models.py

@@ -0,0 +1,61 @@
+import pytest
+from wbcore.contrib.color.factories import ColorGradientFactory
+from wbcore.contrib.color.models import ColorGradient
+
+COLORS = ["#FFFFFF", "#000000", "#FF5733", "#3357FF", "#FF33A1", "#800080"]
+
+
+class TestColorGradientModel:
+    @pytest.mark.django_db
+    def integration_test(self, mocker):
+        gradient = ColorGradientFactory()
+        assert ColorGradient.objects.filter(id=gradient.id).exists()
+
+    def test_str_method(self, mocker):
+        gradient = ColorGradient()
+        mocker.patch.object(gradient, "title", "My Gradient")
+        assert str(gradient) == "My Gradient"
+
+    def test_default_colors(self):
+        gradient = ColorGradient()
+        assert gradient.colors == []
+
+    def test_get_gradient(self, mocker):
+        gradient = ColorGradient()
+        assert list(gradient.get_gradient()) == []
+
+    def test_get_gradient_no_color_argument(self, mocker):
+        gradient = ColorGradient()
+        mocker.patch.object(gradient, "colors", COLORS)
+        palette = list(gradient.get_gradient(color=None, color_size=3))
+        assert len(palette) == 3
+
+    def test_get_gradient_with_non_existent_color(self, mocker):
+        gradient = ColorGradient()
+        mocker.patch.object(gradient, "colors", COLORS)
+        non_existent_color = "#123456"
+        palette = list(gradient.get_gradient(color=non_existent_color))
+        assert len(palette) == len(COLORS)
+        assert palette == ["#000000", "#FF5733", "#3357FF", "#FF33A1", "#800080", "#FFFFFF"]
+
+    @pytest.mark.parametrize("color_size", [20, 1, 0, -1])
+    def test_get_gradient_with_different_size(self, color_size, mocker):
+        gradient = ColorGradient()
+        mocker.patch.object(gradient, "colors", COLORS)
+        palette = list(gradient.get_gradient(color_size=color_size))
+        base_colors = gradient.colors
+        assert len(palette) == color_size if color_size > 0 else len(base_colors)
+        for index, color in enumerate(palette):
+            assert color == base_colors[index % len(base_colors)]
+
+    @pytest.mark.parametrize("color", COLORS)
+    def test_get_gradient_with_different_color(self, color, mocker):
+        gradient = ColorGradient()
+        mocker.patch.object(gradient, "colors", COLORS)
+        base_colors = gradient.colors
+
+        color_index = base_colors.index(color)
+        palette = list(gradient.get_gradient(color=color))
+
+        assert len(palette) == len(base_colors)
+        assert palette == base_colors[color_index:] + base_colors[:color_index]

wbcore/contrib/color/tests/test_fields.py

@@ -0,0 +1,25 @@
+import pytest
+from django.core.exceptions import ValidationError
+from wbcore.contrib.color.fields import validate_color
+
+
+class TestColorield:
+    @pytest.mark.parametrize(
+        ("input", "valid"),
+        [
+            ("#1234567", False),
+            ("259868", False),
+            ("#25986", False),
+            ("", False),
+            ("#d225b0", True),
+            ("#4839a3", True),
+            ("#259868", True),
+            (None, True),
+        ],
+    )
+    def test_color_validator(self, input, valid):
+        if valid:
+            assert input == validate_color(input)
+        else:
+            with pytest.raises(ValidationError):
+                validate_color(input)