wbcore 1.59.9__py2.py3-none-any.whl

wbcore/contrib/currency/import_export/backends/__init__.py

@@ -0,0 +1 @@
+from .fixerio import *

wbcore/contrib/currency/import_export/backends/fixerio/__init__.py

@@ -0,0 +1 @@
+from .currency_fx_rates import DataBackend

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

@@ -0,0 +1,69 @@
+import json
+from datetime import datetime
+from io import BytesIO
+from typing import Generator, Optional
+
+import pandas as pd
+import requests
+from django.db.models import QuerySet
+from dynamic_preferences.registries import global_preferences_registry
+from pandas.tseries.offsets import BDay
+
+from wbcore.contrib.currency.models import Currency
+from wbcore.contrib.io.backends import AbstractDataBackend, register
+from wbcore.contrib.io.models import ImportCredential
+
+from ..utils import get_timedelta_import_currency_fx_rates
+
+
+@register("Currency FX Rates", provider_key="fixerio", save_data_in_import_source=False, passive_only=False)
+class DataBackend(AbstractDataBackend):
+    ENDPOINT = "https://data.fixer.io/api/"
+    HEADERS = {"user-agent": "stainly", "Content-Type": "application/json", "Accept": "application/json"}
+
+    def get_provider_id(self, obj: Currency) -> str:
+        return obj.key
+
+    def get_default_queryset(self) -> QuerySet[Currency]:
+        return Currency.objects.all()
+
+    def __init__(
+        self,
+        import_credential: Optional[ImportCredential] = None,
+        base_currency: Optional[str] = None,
+        **kwargs,
+    ):
+        if not import_credential or not import_credential.authentication_token:
+            raise ValueError("Fixer IO backend needs a valid import credential object")
+        if not base_currency:
+            base_currency = global_preferences_registry.manager()["currency__default_currency"]
+        self.authentication_token = import_credential.authentication_token
+        self.base_currency = base_currency
+
+    def get_files(
+        self,
+        execution_time: datetime,
+        obj_external_ids: Optional[list[str]] = None,
+        **kwargs,
+    ) -> Generator[tuple[str, BytesIO], None, None]:
+        execution_date = execution_time.date()
+        start = kwargs.get("start", execution_date - BDay(get_timedelta_import_currency_fx_rates() + 1))
+        params = {"access_key": self.authentication_token, "base": self.base_currency}
+        if (
+            obj_external_ids and len(obj_external_ids) < Currency.objects.count()
+        ):  # We add symbols only if the requests objects count is lower than the maximum expected currency
+            params["symbols"] = ",".join(obj_external_ids)
+        res = []
+        for _date in pd.date_range(start, execution_date, freq="B"):
+            r = requests.get(
+                f'{self.ENDPOINT}/{_date.strftime("%Y-%m-%d")}?', params=params, headers=self.HEADERS, timeout=10
+            )
+            if r.status_code == requests.codes.ok:
+                res_json = r.json()
+                if res_json and res_json["success"]:
+                    res.append(res_json)
+        if res:
+            content_file = BytesIO()
+            content_file.write(json.dumps(res).encode())
+            file_name = f"fixerio_currency_fx_rates_{start:%Y-%m-%d}_{execution_date:%Y-%m-%d}_{datetime.timestamp(execution_time)}.json"
+            yield file_name, content_file

wbcore/contrib/currency/import_export/backends/utils.py

@@ -0,0 +1,5 @@
+from dynamic_preferences.registries import global_preferences_registry
+
+
+def get_timedelta_import_currency_fx_rates():
+    return global_preferences_registry.manager()["currency__timedelta_import_currency_fx_rates"]

wbcore/contrib/currency/import_export/handlers/__init__.py

@@ -0,0 +1,2 @@
+from .currency import CurrencyImportHandler
+from .currency_fx_rates import CurrencyFXRatesImportHandler

wbcore/contrib/currency/import_export/handlers/currency.py

@@ -0,0 +1,25 @@
+from typing import Any, Dict
+
+from django.db import models
+
+from wbcore.contrib.io.imports import ImportExportHandler
+
+
+class CurrencyImportHandler(ImportExportHandler):
+    MODEL_APP_LABEL: str = "currency.Currency"
+
+    def _deserialize(self, data: Dict[str, Any]):
+        if key := data.get("key"):
+            if key == "CNH":  # We switch CNH to CNY because we don't support it
+                data["key"] = "CNY"
+            if key == "GBp":
+                data["key"] = "GBX"
+
+    def _get_instance(self, data: Dict[str, Any], **kwargs) -> models.Model | None:
+        try:
+            if key := data.get("key", None):
+                return self.model.objects.get(key=key)
+            if _id := data.get("id", None):
+                return self.model.objects.get(id=_id)
+        except self.model.DoesNotExist:
+            pass

wbcore/contrib/currency/import_export/handlers/currency_fx_rates.py

@@ -0,0 +1,29 @@
+from datetime import datetime
+from decimal import Decimal
+from typing import Any, Dict, Optional
+
+from django.db import models
+
+from wbcore.contrib.io.imports import ImportExportHandler
+
+from .currency import CurrencyImportHandler
+
+
+class CurrencyFXRatesImportHandler(ImportExportHandler):
+    MODEL_APP_LABEL: str = "currency.CurrencyFXRates"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.currency_handler = CurrencyImportHandler(self.import_source)
+
+    def _deserialize(self, data: Dict[str, Any]):
+        data["date"] = datetime.strptime(data["date"], "%Y-%m-%d").date()
+        data["currency"] = self.currency_handler.process_object(data["currency"])[0]
+        data["value"] = round(Decimal(data["value"]), 6)
+
+    def _get_instance(self, data: Dict[str, Any], history: Optional[models.QuerySet] = None, **kwargs) -> models.Model:
+        return self.model.objects.filter(currency=data["currency"], date=data["date"]).first()
+
+    def _create_instance(self, data: Dict[str, Any], **kwargs) -> models.Model:
+        self.import_source.log += "\nCreate Fx Rate."
+        return self.model.objects.create(**data, import_source=self.import_source)

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,199 @@
+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 Case, CharField, Expression, ExpressionWrapper, F, Q, Subquery, Value, When
+from django.db.models.functions import Concat
+from persisting_theory import QuerySet
+
+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 CurrencyDefaultManager(models.Manager):
+    def get_queryset(self) -> QuerySet:
+        return (
+            super()
+            .get_queryset()
+            .annotate(
+                name_repr=Case(
+                    When(Q(symbol="") | Q(symbol__isnull=True), then=F("title")),
+                    default=Concat(F("title"), Value(" ("), F("symbol"), Value(")")),
+                    output_field=CharField(),
+                )
+            )
+        )
+
+
+class Currency(ImportMixin, LabelKeyMixin, WBModel):
+    import_export_handler_class = CurrencyImportHandler
+
+    class Meta:
+        verbose_name = "Currency"
+        verbose_name_plural = "Currencies"
+        ordering = ("title",)
+
+    def __str__(self) -> str:
+        if self.symbol:
+            return f"{self.title} ({self.symbol})"
+        return self.title
+
+    def __repr__(self) -> str:
+        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 = CurrencyDefaultManager()
+
+    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
+        """
+        if self == other_currency:
+            return Decimal(1.0)
+        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:
+            if exact_lookup:
+                return self.convert(valuation_date, other_currency, exact_lookup=False)
+            raise CurrencyFXRates.DoesNotExist from None
+
+    @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 "{{name_repr}}"
+
+
+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=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=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.DecimalField()
+        )
+
+    @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,45 @@
+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"""
+
+    name_repr = wb_serializers.SerializerMethodField(read_only=True)
+    _detail = wb_serializers.HyperlinkField(reverse_name="wbcore:currency:currency-detail")
+
+    def get_name_repr(self, obj):
+        return str(obj)
+
+    class Meta:
+        model = Currency
+        fields = ("id", "name_repr", "key", "_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,115 @@
+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.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], Decimal)
+        assert fx_rate[0] == Decimal("1.0")