wbcore 2.2.1__py2.py3-none-any.whl

wbcore/contrib/currency/import_export/parsers/fixerio/currency_fx_rates.py

@@ -0,0 +1,34 @@
+import json
+from typing import Any
+
+from wbcore.contrib.io.models import ImportSource
+
+DUPLICATIONS_MAP = {"GBP": {"currency_key": "GBX", "factor": 100}}
+
+
+def parse(import_source: ImportSource) -> dict[str, Any]:
+    content = json.load(import_source.file)
+    data = []
+    for row in content:
+        if row["success"]:
+            val_date = row["date"]
+            for currency_key, value in row["rates"].items():
+                if duplicated_currency_data := DUPLICATIONS_MAP.get(currency_key, None):
+                    data.append(
+                        {
+                            "currency__provider_id": duplicated_currency_data["currency_key"],
+                            "currency__key": duplicated_currency_data["currency_key"],
+                            "value": value * duplicated_currency_data["factor"],
+                            "date": val_date,
+                        }
+                    )
+                data.append(
+                    {
+                        "currency__provider_id": currency_key,
+                        "currency__key": currency_key,
+                        "value": value,
+                        "date": val_date,
+                    }
+                )
+
+    return {"data": data}

wbcore/contrib/currency/migrations/0001_initial.py

@@ -0,0 +1,89 @@
+# Generated by Django 4.1.8 on 2023-04-06 12:07
+
+import django.db.models.deletion
+import wbcore.contrib.currency.import_export.handlers.currency
+import wbcore.contrib.currency.import_export.handlers.currency_fx_rates
+import wbcore.utils.models
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = [
+        ("io", "0001_initial_squashed"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="Currency",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID"),
+                ),
+                ("title", models.CharField(max_length=255)),
+                ("symbol", models.CharField(blank=True, max_length=10, null=True)),
+                ("key", models.CharField(max_length=3, unique=True)),
+                (
+                    "import_source",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.SET_NULL,
+                        to="io.importsource",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "Currency",
+                "verbose_name_plural": "Currencies",
+                "ordering": ("title",),
+            },
+            bases=(
+                wbcore.utils.models.LabelKeyMixin,
+                models.Model,
+            ),
+        ),
+        migrations.CreateModel(
+            name="CurrencyFXRates",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID"),
+                ),
+                ("date", models.DateField()),
+                ("value", models.DecimalField(decimal_places=6, max_digits=20)),
+                (
+                    "currency",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="fx_rates",
+                        to="currency.currency",
+                    ),
+                ),
+                (
+                    "import_source",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.SET_NULL,
+                        to="io.importsource",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "FX Rate",
+                "verbose_name_plural": "FX Rates",
+            },
+            bases=(models.Model,),
+        ),
+        migrations.AddIndex(
+            model_name="currencyfxrates",
+            index=models.Index(fields=["date", "currency"], name="currency_fx_rate_idx"),
+        ),
+        migrations.AlterUniqueTogether(
+            name="currencyfxrates",
+            unique_together={("date", "currency")},
+        ),
+    ]

wbcore/contrib/currency/models.py

@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+from datetime import date as date_lib
+from decimal import Decimal
+
+from django.db import models
+from django.db.models import Expression, ExpressionWrapper, Subquery
+from wbcore.contrib.io.mixins import ImportMixin
+from wbcore.models import WBModel
+from wbcore.utils.models import LabelKeyMixin
+
+from .import_export.handlers import CurrencyFXRatesImportHandler, CurrencyImportHandler
+
+
+class Currency(ImportMixin, LabelKeyMixin, WBModel):
+    import_export_handler_class = CurrencyImportHandler
+
+    class Meta:
+        verbose_name = "Currency"
+        verbose_name_plural = "Currencies"
+        ordering = ("title",)
+
+    def __str__(self):
+        symbol = f"({self.symbol})" if self.symbol else ""
+        return f"{self.key} {symbol}"
+
+    def __repr__(self):
+        return self.key
+
+    title = models.CharField(max_length=255)
+    symbol = models.CharField(max_length=10, blank=True, null=True)
+    key = models.CharField(max_length=3, unique=True)
+
+    objects = models.Manager()
+
+    LABEL_KEY = "{{key}} ({{symbol}})"
+
+    def convert(self, valuation_date: date_lib, other_currency: Currency, exact_lookup: bool = False) -> Decimal:
+        """
+        Change the base currency of one of its related fx rates
+
+        Arguments:
+            valuation_date {datetime.date} -- The convertion date
+            other_currency {Currency} -- The convertion currency
+        Returns:
+            float -- The fx rate value with the new base currency
+        """
+        try:
+            if exact_lookup:
+                base = CurrencyFXRates.objects.get(date=valuation_date, currency=self)
+                other = CurrencyFXRates.objects.get(date=valuation_date, currency=other_currency)
+            else:
+                base = (
+                    CurrencyFXRates.objects.filter(date__lte=valuation_date, currency=self).order_by("-date").first()
+                )
+                other = (
+                    CurrencyFXRates.objects.filter(date__lte=valuation_date, currency=other_currency)
+                    .order_by("-date")
+                    .first()
+                )
+                if not base or not other:
+                    raise CurrencyFXRates.DoesNotExist
+            return (1 / base.value) * other.value
+        except CurrencyFXRates.DoesNotExist:
+            return Decimal(1.0)
+
+    @classmethod
+    def get_endpoint_basename(cls) -> str:
+        return "wbcore:currency:currency"
+
+    @classmethod
+    def get_representation_endpoint(cls) -> str:
+        return "wbcore:currency:currencyrepresentation-list"
+
+    @classmethod
+    def get_representation_value_key(cls) -> str:
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls) -> str:
+        return "{{key}} ({{symbol}})"
+
+
+class CurrencyFXRates(ImportMixin, models.Model):
+    import_export_handler_class = CurrencyFXRatesImportHandler
+
+    date = models.DateField()
+    currency = models.ForeignKey(to="Currency", related_name="fx_rates", on_delete=models.CASCADE)
+    value = models.DecimalField(max_digits=20, decimal_places=6)
+
+    class Meta:
+        verbose_name = "FX Rate"
+        verbose_name_plural = "FX Rates"
+        unique_together = ("date", "currency")
+        indexes = [
+            models.Index(
+                name="currency_fx_rate_idx",
+                fields=["date", "currency"],
+            )
+        ]
+
+    def __str__(self) -> str:
+        return f"{self.date:%d.%m.%Y} {self.currency.key}"
+
+    @classmethod
+    def get_fx_rates_subquery(
+        cls,
+        val_date: date_lib | str,
+        currency: str = "product__currency",
+        lookup_expr: str = "lte",
+    ) -> Expression:
+        """
+        Create a subquery to annotate the rate at a given date based on currency__key
+
+        Arguments:
+            date {datetime.date|str} -- The fx date
+            is_outerref_key {bool} -- Determines the type of date variable, if true is outerref key string
+            currency_key {str} -- The Outerref field for currency__key
+        Returns:
+            Subquery -- Subquery for rates at a certain date
+        """
+        fx_rates = (
+            cls.objects.filter(
+                **{f"date__{lookup_expr}": models.OuterRef(val_date) if isinstance(val_date, str) else val_date},
+                currency=models.OuterRef(currency),
+            )
+            .order_by("-date")
+            .values("value")[:1]
+        )
+
+        return ExpressionWrapper(1 / Subquery(fx_rates), output_field=models.DecimalField())
+
+    @classmethod
+    def get_fx_rates_subquery_for_two_currencies(
+        cls,
+        date_key: str,
+        start_currency: str | Currency,
+        target_currency: str | Currency,
+    ) -> Expression:
+        """
+        Create a subquery to returns the convertion rate from a start to a target currency
+
+        Arguments:
+            date_key {datetime.date} -- The convertion date
+            start_currency {str} -- The Outerref field for start currency
+            target_currency {str} -- The Outerref field for target currency
+        Returns:
+            Subquery -- Subquery for the convertion rate rates at a certain date
+        """
+        fx_rates_start = (
+            CurrencyFXRates.objects.filter(
+                date__lte=models.OuterRef(date_key),
+                currency=models.OuterRef(start_currency) if isinstance(start_currency, str) else start_currency,
+            )
+            .order_by("-date")
+            .values("value")[:1]
+        )
+        fx_rates_target = (
+            CurrencyFXRates.objects.filter(
+                date__lte=models.OuterRef(date_key),
+                currency=models.OuterRef(target_currency) if isinstance(target_currency, str) else target_currency,
+            )
+            .order_by("-date")
+            .values("value")[:1]
+        )
+        return ExpressionWrapper(
+            Subquery(fx_rates_target) / Subquery(fx_rates_start), output_field=models.FloatField()
+        )
+
+    @classmethod
+    def get_representation_value_key(cls) -> str:
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls) -> str:
+        return "{{value}} ({{currency__symbol}})"

wbcore/contrib/currency/release_notes/1_0_0.md

@@ -0,0 +1,13 @@
+Date: 2023-04-26
+Module: Currency
+Summary: Initial Release Note
+Version: 1.0.0
+
+## New Features
+- Bootstrap module versioning
+
+## Enhancements
+./.
+
+## Bugfixes
+./.

wbcore/contrib/currency/serializers.py

@@ -0,0 +1,40 @@
+from rest_framework.reverse import reverse
+from wbcore import serializers as wb_serializers
+
+from .models import Currency, CurrencyFXRates
+
+
+class CurrencyRepresentationSerializer(wb_serializers.RepresentationSerializer):
+    """Representation Serializer for Currencies"""
+
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbcore:currency:currency-detail")
+
+    class Meta:
+        model = Currency
+        fields = ("id", "title", "key", "symbol", "_detail")
+
+
+class CurrencyModelSerializer(wb_serializers.ModelSerializer):
+    """Model Serializer for Currencies"""
+
+    rates_sparkline = wb_serializers.SparklineField(
+        x_data_label="fx_rates_date", y_data_label="fx_rates_value", label="Rates"
+    )
+
+    @wb_serializers.register_resource()
+    def currency_currencyfxrates(self, instance, request, user):
+        return {
+            "currency_currencyfxrates": reverse(
+                "wbcore:currency:currency-currencyfxrates-list", args=[instance.id], request=request
+            )
+        }
+
+    class Meta:
+        model = Currency
+        fields = ("id", "title", "symbol", "key", "rates_sparkline", "_additional_resources")
+
+
+class CurrencyFXRatesModelSerializer(wb_serializers.ModelSerializer):
+    class Meta:
+        model = CurrencyFXRates
+        fields = ("id", "date", "currency", "value")

wbcore/contrib/currency/tests/conftest.py

@@ -0,0 +1,7 @@
+from pytest_factoryboy import register
+from wbcore.tests.conftest import *
+
+from ..factories import CurrencyFactory, CurrencyFXRatesFactory
+
+register(CurrencyFactory)
+register(CurrencyFXRatesFactory)

wbcore/contrib/currency/tests/test_models.py

@@ -0,0 +1,104 @@
+from datetime import timedelta
+from decimal import Decimal
+
+import pytest
+from django.utils import timezone
+from pytest_mock import MockerFixture
+from wbcore.contrib.currency.models import Currency, CurrencyFXRates
+
+
+@pytest.mark.currency_model_tests
+@pytest.mark.with_db
+@pytest.mark.django_db
+class TestSpecificModels:
+    @pytest.fixture
+    def base_currency(self, mocker: MockerFixture):
+        base_currency = Currency()
+        mocker.patch.object(base_currency, "key", "ABC")
+        return base_currency
+
+    @pytest.fixture
+    def other_currency(self, mocker: MockerFixture):
+        base_currency = Currency()
+        mocker.patch.object(base_currency, "key", "XYZ")
+        return base_currency
+
+    @pytest.fixture
+    def base_fx_rate(self, mocker: MockerFixture):
+        base_fx_rate = CurrencyFXRates()
+        mocker.patch.object(base_fx_rate, "value", 0.85)
+        return base_fx_rate
+
+    @pytest.fixture
+    def other_fx_rate(self, mocker: MockerFixture):
+        other_fx_rate = CurrencyFXRates()
+        mocker.patch.object(other_fx_rate, "value", 1.15)
+        return other_fx_rate
+
+    @pytest.mark.parametrize("exact_lookup", [True, False])
+    def test_convert(
+        self, exact_lookup, mocker: MockerFixture, base_currency, other_currency, base_fx_rate, other_fx_rate
+    ):
+        # Arrange
+        today = timezone.now().date()
+        if exact_lookup:
+            mocker.patch(
+                "wbcore.contrib.currency.models.CurrencyFXRates.objects.get", side_effect=[base_fx_rate, other_fx_rate]
+            )
+        else:
+            mock_filter = mocker.patch("wbcore.contrib.currency.models.CurrencyFXRates.objects.filter")
+            mock_filter.return_value.order_by.return_value.first.side_effect = [base_fx_rate, other_fx_rate]
+
+        # Act
+        new_fx_rates = base_currency.convert(today, other_currency, exact_lookup)
+
+        # Assert
+        assert new_fx_rates == (1 / base_fx_rate.value) * other_fx_rate.value
+
+    def test_convert_with_date_today_exists(self, currency_factory, currency_fx_rates_factory):
+        currency = currency_factory(key="EUR")
+        other_currency = currency_factory(key="CHF")
+        today = timezone.now().date()
+        fx_rates = currency_fx_rates_factory(date=today, currency=currency)
+        other_fx_rates = currency_fx_rates_factory(date=today, currency=other_currency)
+        new_fx_rates = currency.convert(fx_rates.date, other_currency)
+        assert new_fx_rates == (1 / fx_rates.value) * other_fx_rates.value
+
+    def test_convert_with_date_lte(self, currency_factory, currency_fx_rates_factory):
+        date_test = timezone.now().date() - timedelta(days=1)
+        currency = currency_factory(key="EUR")
+        other_currency = currency_factory(key="CHF")
+        today = timezone.now().date()
+        fx_rates = currency_fx_rates_factory(date=date_test, currency=currency)
+        other_fx_rates = currency_fx_rates_factory(date=date_test, currency=other_currency)
+        new_fx_rates = currency.convert(today, other_currency)
+        assert new_fx_rates == (1 / fx_rates.value) * other_fx_rates.value
+
+    def test_get_fx_rates_subquery_normal_date(self, currency_fx_rates_factory):
+        today = timezone.now().date()
+        fx_rates = currency_fx_rates_factory(date=today)
+
+        qs = CurrencyFXRates.objects.annotate(fx_rate=fx_rates.get_fx_rates_subquery(today, currency="currency"))
+
+        fx_rate = [fx_r.get("fx_rate") for fx_r in qs.filter(id=fx_rates.id).values("fx_rate")]
+        assert len(fx_rate) == 1
+        assert isinstance(fx_rate[0], Decimal)
+
+    def test_get_fx_rates_subquery_outerref_date(self, currency_fx_rates_factory):
+        today = timezone.now().date()
+        fx_rates = currency_fx_rates_factory(date=today)
+        qs = CurrencyFXRates.objects.annotate(fx_rate=fx_rates.get_fx_rates_subquery("date", currency="currency"))
+        fx_rate = [fx_r.get("fx_rate") for fx_r in qs.filter(id=fx_rates.id).values("fx_rate")]
+        assert len(fx_rate) == 1
+        assert isinstance(fx_rate[0], Decimal)
+
+    def test_get_fx_rates_subquery_for_two_currencies(self, currency_fx_rates_factory):
+        today = timezone.now().date()
+        fx_rates = currency_fx_rates_factory(date=today)
+        qs = CurrencyFXRates.objects.annotate(
+            fx_rate=fx_rates.get_fx_rates_subquery_for_two_currencies("date", "currency", "currency")
+        )
+        fx_rate = [fx_r.get("fx_rate") for fx_r in qs.filter(id=fx_rates.id).values("fx_rate")]
+        assert len(fx_rate) == 1
+        assert isinstance(fx_rate[0], float)
+        assert fx_rate[0] == 1.0

wbcore/contrib/currency/tests/test_serializers.py

@@ -0,0 +1,62 @@
+import pytest
+from django.utils import timezone
+from pytest_mock import MockerFixture
+from wbcore.contrib.currency.models import Currency, CurrencyFXRates
+from wbcore.contrib.currency.serializers import (
+    CurrencyFXRatesModelSerializer,
+    CurrencyModelSerializer,
+    CurrencyRepresentationSerializer,
+)
+
+
+@pytest.mark.serializer_tests
+class TestSerializers:
+    @pytest.fixture
+    def currency(self, mocker: MockerFixture):
+        currency = Currency()
+        mocker.patch.object(currency, "id", 1)
+        mocker.patch.object(currency, "key", "abc")
+        mocker.patch.object(currency, "title", "ABC")
+        mocker.patch.object(currency, "symbol", "$")
+        return currency
+
+    @pytest.fixture
+    def currency_fx_rate(self, mocker: MockerFixture, currency):
+        currency_fx_rate = CurrencyFXRates()
+        mocker.patch.object(currency_fx_rate, "id", 1)
+        mocker.patch.object(currency_fx_rate, "date", timezone.now().date().isoformat())
+        mocker.patch.object(currency_fx_rate, "value", "1.150000")
+        mocker.patch.object(currency_fx_rate, "currency_id", currency.id)
+        return currency_fx_rate
+
+    @pytest.fixture
+    def expected_data(self, currency):
+        return {"id": currency.id, "title": currency.title, "key": currency.key, "symbol": currency.symbol}
+
+    @pytest.fixture
+    def expected_data_fx_rate(self, currency_fx_rate):
+        return {
+            "id": currency_fx_rate.id,
+            "value": currency_fx_rate.value,
+            "date": currency_fx_rate.date,
+            "currency": currency_fx_rate.currency_id,
+        }
+
+    def test_currency_representation_serializer(self, mocker: MockerFixture, currency, expected_data):
+        detail = f"/wbcore/currency/currency/{currency.id}/"
+        mocker.patch("wbcore.serializers.fields.fields.HyperlinkField", return_value=detail)
+        serializer = CurrencyRepresentationSerializer(instance=currency)
+        expected_data["_detail"] = detail
+        assert serializer.data == expected_data
+
+    def test_currency_model_serializer(self, mocker: MockerFixture, currency, expected_data):
+        mocker.patch(
+            "wbcore.serializers.fields.list.SparklineField.to_representation", return_value={"Rates": [1, 2, 3]}
+        )
+        serializer = CurrencyModelSerializer(instance=currency)
+        expected_data.update({"rates_sparkline": {"Rates": [1, 2, 3]}, "_additional_resources": {}})
+        assert serializer.data == expected_data
+
+    def test_currency_fx_rate_model_serializer(self, currency_fx_rate, expected_data_fx_rate):
+        serializer = CurrencyFXRatesModelSerializer(instance=currency_fx_rate)
+        assert serializer.data == expected_data_fx_rate