wbcore 1.59.9__py2.py3-none-any.whl

wbcore/contrib/currency/tests/test_serializers.py

@@ -0,0 +1,67 @@
+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_representation_data(self, currency):
+        return {"id": currency.id, "name_repr": f"{currency.title} ({currency.symbol})", "key": currency.key}
+
+    @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_representation_data):
+        detail = f"/wbcore/currency/currency/{currency.id}/"
+        mocker.patch("wbcore.serializers.fields.fields.HyperlinkField", return_value=detail)
+        serializer = CurrencyRepresentationSerializer(instance=currency)
+        expected_representation_data["_detail"] = detail
+        assert serializer.data == expected_representation_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

wbcore/contrib/currency/tests/test_viewsets.py

@@ -0,0 +1,196 @@
+from datetime import date, timedelta
+from decimal import Decimal
+
+import pytest
+from django.contrib.postgres.aggregates import ArrayAgg
+from django.db.models import Q
+from django.forms.models import model_to_dict
+from rest_framework import status
+from rest_framework.test import APIRequestFactory
+
+from wbcore.contrib.authentication.factories import SuperUserFactory
+from wbcore.contrib.currency.factories import CurrencyFactory, CurrencyFXRatesFactory
+from wbcore.contrib.currency.models import Currency
+from wbcore.contrib.currency.viewsets import (
+    CurrencyModelViewSet,
+    CurrencyRepresentationViewSet,
+)
+
+
+@pytest.mark.viewset_tests
+@pytest.mark.with_db
+@pytest.mark.django_db
+class TestCurrencyRepresentationViewSets:
+    @pytest.fixture()
+    def test_request(self):
+        factory = APIRequestFactory()
+        request = factory.get("")
+        request.user = SuperUserFactory()
+        return request
+
+    def test_currency_list_representation_viewset(self, test_request, currency_factory):
+        # Arrange
+        currency_factory.create_batch(2)
+        vs = CurrencyRepresentationViewSet.as_view({"get": "list"})
+        # Act
+        response = vs(test_request)
+        # Assert
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data
+        assert len(response.data["results"]) == 2
+
+    def test_currency_representation_viewset(self, test_request, currency_factory):
+        # Arrange
+        euro = currency_factory(symbol="€", key="EUR", title="Euro")
+        vs = CurrencyRepresentationViewSet.as_view({"get": "retrieve"})
+        # Act
+        response = vs(test_request, pk=euro.pk)
+        instance = response.data.get("instance")
+        # Assert
+        assert response.status_code == status.HTTP_200_OK
+        assert instance.get("id") == euro.id
+        assert instance.get("key") == euro.key
+        assert instance.get("name_repr") == f"{euro.title} ({euro.symbol})"
+
+
+@pytest.mark.viewset_tests
+@pytest.mark.with_db
+@pytest.mark.django_db
+class TestCurrencyViewSets:
+    @pytest.fixture()
+    def api_rf(self):
+        factory = APIRequestFactory()
+        return factory
+
+    @pytest.fixture()
+    def su(self):
+        super_user = SuperUserFactory()
+        return super_user
+
+    @pytest.fixture()
+    def get_request(self, api_rf, su):
+        request = api_rf.get("")
+        request.user = su
+        return request
+
+    @pytest.fixture()
+    def currency(self):
+        currency = CurrencyFactory()
+        return currency
+
+    @pytest.fixture()
+    def currencies(self):
+        currency_a = CurrencyFactory()
+        currency_b = CurrencyFactory()
+        currency_c = CurrencyFactory()
+        return [currency_a, currency_b, currency_c]
+
+    def test_get_instance_request(self, get_request, currency):
+        # Arrange
+        vs = CurrencyModelViewSet.as_view({"get": "retrieve"})
+        # Act
+        response = vs(get_request, pk=currency.pk)
+        # Assert
+        assert response.status_code == status.HTTP_200_OK
+        assert not response.data.get("results")
+        assert response.data["instance"]["id"] == currency.id
+
+    def test_get_list_request(self, get_request):
+        # Arrange
+        CurrencyFactory.create_batch(3)
+        vs = CurrencyModelViewSet.as_view({"get": "list"})
+        # Act
+        response = vs(get_request)
+        # Assert
+        results = response.data.get("results")
+        assert response.status_code == status.HTTP_200_OK
+        assert not response.data.get("instance")
+        assert len(results) == 3
+
+    def test_delete_instance(self, api_rf, su, currency):
+        # Arrange
+        request = api_rf.delete("")
+        request.user = su
+        view = CurrencyModelViewSet.as_view({"delete": "destroy"})
+        # Act
+        response = view(request, pk=currency.id)
+        # Assert
+        assert response.status_code == status.HTTP_204_NO_CONTENT
+        assert Currency.objects.count() == 0
+
+    def test_update_instance(self, api_rf, su, currency):
+        # Arrange
+        new_currency = model_to_dict(CurrencyFactory.build())
+        # Add missing values to the dict, because we cannot update data with 'None' values
+        new_currency["id"] = currency.id
+        new_currency["import_source"] = ""
+        request = api_rf.put("", data=new_currency)
+        request.user = su
+        view = CurrencyModelViewSet.as_view({"put": "update"})
+        # Act
+        response = view(request, pk=currency.id)
+        instance = response.data.get("instance")
+        # Assert
+        assert response.status_code == status.HTTP_200_OK
+        assert instance["id"] == currency.id
+        assert instance["key"] == new_currency["key"]
+        assert instance["key"] != currency.key
+
+    @pytest.mark.parametrize("title", ["New_title"])
+    def test_patch_instance(self, api_rf, su, currency, title):
+        # Arrange
+        request = api_rf.patch("", data={"title": title})
+        request.user = su
+        # Act
+        view = CurrencyModelViewSet.as_view({"patch": "partial_update"})
+        response = view(request, pk=currency.id)
+        # Assert
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data["instance"]["title"] == title
+        assert currency.title != title
+        currency.refresh_from_db()  # The patch changes are only visible after a refresh
+        assert currency.title == title
+
+    def test_get_queryset_no_fx_rates(self, currencies):
+        viewset = CurrencyModelViewSet()
+        qs = viewset.get_queryset()
+        last_rate_date = date.today() - timedelta(days=30)
+        expected_queryset = Currency.objects.annotate(
+            fx_rates_date=ArrayAgg("fx_rates__date", filter=Q(fx_rates__date__gt=last_rate_date)),
+            fx_rates_value=ArrayAgg("fx_rates__value", filter=Q(fx_rates__date__gt=last_rate_date)),
+        )
+        assert list(qs) == list(expected_queryset)
+        for currency in qs:
+            assert currency.fx_rates_date is None
+            assert currency.fx_rates_value is None
+
+    def test_get_queryset_with_fx_rates(self, currencies):
+        recent_fx_rate_date, mid_fx_rate_date, past_cutoff_fx_rate_date = (
+            date.today() - timedelta(days=5),
+            date.today() - timedelta(days=20),
+            date.today() - timedelta(days=35),
+        )
+        value_a, value_b, value_c = (
+            Decimal("1.10"),
+            Decimal("0.85"),
+            Decimal("1.20"),
+        )
+
+        fx_rate_data = [
+            {"date": recent_fx_rate_date, "value": value_a},
+            {"date": mid_fx_rate_date, "value": value_b},
+            {"date": past_cutoff_fx_rate_date, "value": value_c},
+        ]
+
+        for currency in currencies:
+            for data in fx_rate_data:
+                CurrencyFXRatesFactory(currency=currency, date=data["date"], value=data["value"])
+
+        viewset = CurrencyModelViewSet()
+        qs = viewset.get_queryset()
+        expected_rates = [value_a, value_b]
+        expected_dates = [recent_fx_rate_date, mid_fx_rate_date]
+        assert len(qs) == 3
+        for currency in qs:
+            assert currency.fx_rates_date == expected_dates
+            assert currency.fx_rates_value == expected_rates

wbcore/contrib/currency/urls.py

@@ -0,0 +1,20 @@
+from django.urls import include, path
+
+from wbcore.routers import WBCoreRouter
+
+from .viewsets import (
+    CurrencyFXRatesCurrencyModelViewSet,
+    CurrencyModelViewSet,
+    CurrencyRepresentationViewSet,
+)
+
+router = WBCoreRouter()
+router.register(r"currency", CurrencyModelViewSet, basename="currency")
+router.register(r"currencyrepresentation", CurrencyRepresentationViewSet, basename="currencyrepresentation")
+
+
+currency_router = WBCoreRouter()
+currency_router.register(r"currencyfxrates", CurrencyFXRatesCurrencyModelViewSet, basename="currency-currencyfxrates")
+
+
+urlpatterns = [path("", include(router.urls)), path("currency/<int:currency_id>/", include(currency_router.urls))]

wbcore/contrib/currency/viewsets/__init__.py

@@ -0,0 +1,2 @@
+from .currency import CurrencyModelViewSet, CurrencyRepresentationViewSet
+from .currency_fx_rates import CurrencyFXRatesCurrencyModelViewSet

wbcore/contrib/currency/viewsets/currency.py

@@ -0,0 +1,57 @@
+from datetime import date, timedelta
+
+from django.contrib.postgres.aggregates import ArrayAgg
+from django.db.models import Q
+from rest_framework import filters
+
+from wbcore import viewsets
+from wbcore.filters import DjangoFilterBackend
+
+from ..models import Currency, CurrencyFXRates
+from ..serializers import CurrencyModelSerializer, CurrencyRepresentationSerializer
+from .display import CurrencyDisplayConfig
+from .preview import CurrencyPreviewConfig
+from .titles import CurrencyTitleConfig
+
+
+class CurrencyRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = Currency.objects.all()
+    serializer_class = CurrencyRepresentationSerializer
+    filter_backends = (filters.OrderingFilter, filters.SearchFilter)
+
+    ordering = ["name_repr"]
+    search_fields = ("name_repr", "key")
+
+
+class CurrencyModelViewSet(viewsets.ModelViewSet):
+    display_config_class = CurrencyDisplayConfig
+    title_config_class = CurrencyTitleConfig
+    preview_config_class = CurrencyPreviewConfig
+
+    queryset = Currency.objects.all()
+    serializer_class = CurrencyModelSerializer
+
+    filter_backends = (DjangoFilterBackend, filters.OrderingFilter)
+
+    filterset_fields = {
+        "title": ["exact", "icontains"],
+        "symbol": ["exact", "icontains"],
+        "key": ["exact", "icontains"],
+    }
+    ordering_fields = ("title", "symbol", "key")
+
+    ordering = ["title"]
+
+    def get_queryset(self):
+        last_rate_date = date.today()
+        if CurrencyFXRates.objects.exists():
+            last_rate_date = CurrencyFXRates.objects.latest("date").date
+        last_rate_date -= timedelta(days=30)
+        return (
+            super()
+            .get_queryset()
+            .annotate(
+                fx_rates_date=ArrayAgg("fx_rates__date", filter=Q(fx_rates__date__gt=last_rate_date)),
+                fx_rates_value=ArrayAgg("fx_rates__value", filter=Q(fx_rates__date__gt=last_rate_date)),
+            )
+        )

wbcore/contrib/currency/viewsets/currency_fx_rates.py

@@ -0,0 +1,33 @@
+from rest_framework import filters
+
+from wbcore import viewsets
+from wbcore.filters import DjangoFilterBackend
+
+from ..models import CurrencyFXRates
+from ..serializers import CurrencyFXRatesModelSerializer
+from .display import CurrencyFXRatesCurrencyDisplayConfig
+from .endpoints import CurrencyFXRatesCurrencyEndpointConfig
+from .titles import CurrencyFXRatesCurrencyTitleConfig
+
+
+class CurrencyFXRatesCurrencyModelViewSet(viewsets.ModelViewSet):
+    display_config_class = CurrencyFXRatesCurrencyDisplayConfig
+    endpoint_config_class = CurrencyFXRatesCurrencyEndpointConfig
+    title_config_class = CurrencyFXRatesCurrencyTitleConfig
+
+    serializer_class = CurrencyFXRatesModelSerializer
+    filter_backends = (filters.OrderingFilter, DjangoFilterBackend)
+
+    ordering = ordering_fields = ["-date"]
+
+    filter_backends = (DjangoFilterBackend, filters.OrderingFilter)
+    queryset = CurrencyFXRates.objects.all()
+
+    filterset_fields = {"date": ["gte", "exact", "lte"], "value": ["gte", "exact", "lte"]}
+    ordering_fields = ("date", "value")
+
+    ordering = ["-date"]
+
+    def get_queryset(self):
+        _id = self.kwargs["currency_id"]
+        return CurrencyFXRates.objects.filter(currency__id=_id).all()

wbcore/contrib/currency/viewsets/display/__init__.py

@@ -0,0 +1,2 @@
+from .currency import CurrencyDisplayConfig
+from .currency_fx_rates import CurrencyFXRatesCurrencyDisplayConfig

wbcore/contrib/currency/viewsets/display/currency.py

@@ -0,0 +1,38 @@
+from typing import Optional
+
+from django.utils.translation import gettext_lazy as _
+
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    Display,
+    create_simple_display,
+    create_simple_section,
+)
+from wbcore.metadata.configs.display.instance_display.utils import repeat_field
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+
+
+class CurrencyDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="title", label="Title"),
+                dp.Field(key="symbol", label="Sybmol"),
+                dp.Field(key="key", label="Key"),
+                dp.Field(key="rates_sparkline", label="Rates"),
+            ]
+        )
+
+    def get_instance_display(self) -> Display:
+        return create_simple_display(
+            [["title", "symbol", "key"], [repeat_field(3, "currencyfxrates_section")]],
+            [
+                create_simple_section(
+                    "currencyfxrates_section",
+                    _("Rates"),
+                    [["currency_currencyfxrates"]],
+                    "currency_currencyfxrates",
+                    collapsed=False,
+                )
+            ],
+        )

wbcore/contrib/currency/viewsets/display/currency_fx_rates.py

@@ -0,0 +1,9 @@
+from typing import Optional
+
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+
+
+class CurrencyFXRatesCurrencyDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(fields=[dp.Field(key="date", label="Date"), dp.Field(key="value", label="Value")])

wbcore/contrib/currency/viewsets/endpoints/__init__.py

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

wbcore/contrib/currency/viewsets/endpoints/currency_fx_rates.py

@@ -0,0 +1,6 @@
+from wbcore.metadata.configs.endpoints import EndpointViewConfig
+
+
+class CurrencyFXRatesCurrencyEndpointConfig(EndpointViewConfig):
+    def get_endpoint(self, **kwargs):
+        return None

wbcore/contrib/currency/viewsets/menu/__init__.py

@@ -0,0 +1 @@
+from .currency import CURRENCY_MENUITEM

wbcore/contrib/currency/viewsets/menu/currency.py

@@ -0,0 +1,8 @@
+from wbcore.menus import ItemPermission, MenuItem
+
+CURRENCY_MENUITEM = MenuItem(
+    label="Currency",
+    endpoint="wbcore:currency:currency-list",
+    add=MenuItem(label="New Currency", endpoint="wbcore:currency:currency-list"),
+    permission=ItemPermission(method=lambda request: request.user.is_staff),
+)

wbcore/contrib/currency/viewsets/preview/__init__.py

@@ -0,0 +1 @@
+from .currency import CurrencyPreviewConfig

wbcore/contrib/currency/viewsets/preview/currency.py

@@ -0,0 +1,10 @@
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    Display,
+    create_simple_display,
+)
+from wbcore.metadata.configs.preview import PreviewViewConfig
+
+
+class CurrencyPreviewConfig(PreviewViewConfig):
+    def get_display(self) -> Display:
+        return create_simple_display([["title", "symbol", "key"]])

wbcore/contrib/currency/viewsets/titles/__init__.py

@@ -0,0 +1,2 @@
+from .currency import CurrencyTitleConfig
+from .currency_fx_rates import CurrencyFXRatesCurrencyTitleConfig

wbcore/contrib/currency/viewsets/titles/currency.py

@@ -0,0 +1,6 @@
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+
+class CurrencyTitleConfig(TitleViewConfig):
+    def get_instance_title(self):
+        return "{{key}} ({{symbol}})"

wbcore/contrib/currency/viewsets/titles/currency_fx_rates.py

@@ -0,0 +1,8 @@
+from wbcore.contrib.currency.models import Currency
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+
+class CurrencyFXRatesCurrencyTitleConfig(TitleViewConfig):
+    def get_list_title(self):
+        currency = Currency.objects.get(id=self.view.kwargs["currency_id"])
+        return f"Rates for {currency.key} ({currency.symbol})"

wbcore/contrib/dataloader/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

wbcore/contrib/dataloader/apps.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class WBDataAppConfig(AppConfig):
+    name = "wbcore.contrib.dataloader"

wbcore/contrib/dataloader/dataloaders/__init__.py

@@ -0,0 +1,2 @@
+from .dataloaders import Dataloader
+from .proxies import DataloaderProxy

wbcore/contrib/dataloader/dataloaders/dataloaders.py

@@ -0,0 +1,25 @@
+from typing import TYPE_CHECKING, Generator
+
+if TYPE_CHECKING:
+    from django.db.models import QuerySet
+
+    from wbcore.contrib.dataloader.models.entities import Entity
+
+
+class Dataloader:
+    """Base class for dataloaders, providing a foundational structure for subclasses.
+
+    This class includes an attribute `entities`, which is a Django queryset of Entity objects.
+    It is designed to be subclassed by other classes which will implement specific methods.
+
+    Attributes:
+        entities (QuerySet[Entity]): A Django queryset of Entity objects.
+    """
+
+    def __init__(self, entities: "QuerySet[Entity]"):
+        self.entities = entities
+        super().__init__()
+
+    @property
+    def entity_ids(self) -> Generator[int, None, None]:
+        return self.entities.values_list("id", flat=True)

wbcore/contrib/dataloader/dataloaders/proxies.py

@@ -0,0 +1,82 @@
+from contextlib import suppress
+from typing import TYPE_CHECKING, Generic, Iterator, Type, TypeVar
+
+from django.utils.module_loading import import_string
+
+if TYPE_CHECKING:
+    from django.db.models import QuerySet
+
+    from wbcore.contrib.dataloader.dataloaders import Dataloader
+    from wbcore.contrib.dataloader.models import Entity
+
+
+T = TypeVar("T")
+
+
+class DataloaderProxy(Generic[T]):
+    """Manages and facilitates data loading from remote resources using dataloaders.
+
+    This class serves as a proxy for various dataloader instances. Each dataloader is
+    a subclass of `Dataloader`, designed to fetch data from a remote resource. The
+    `DataloaderProxy` class enables the splicing of a queryset into parts, where each
+    part uses a specific dataloader, thus abstracting the complexity of data fetching
+    from multiple sources.
+
+    The key responsibility of this class includes:
+    - Splicing a queryset into segments, ensuring each segment uses the corresponding dataloader.
+    - Providing an external interface to interact with different dataloaders, which allows
+      for efficient data retrieval and processing.
+
+    To utilize this class, it should be subclassed and associated with a Django model
+    that can be processed by the `Dataloader` subclasses. This setup facilitates the
+    dynamic and efficient retrieval of data, tailored to the specific needs of the application.
+
+    Attributes:
+        queryset (QuerySet[Entity]): A Django queryset that represents a collection of
+            entities to be processed by the dataloaders.
+    """
+
+    def __init__(self, queryset: "QuerySet[Entity]"):
+        self.queryset = queryset
+
+    @staticmethod
+    def load_dataloader(path: str) -> Type["Dataloader"]:
+        """Loads a Dataloader object from a given path.
+
+        This static method imports a Dataloader class from the specified path string.
+
+        Args:
+            path (str): The dot-delimited path to the Dataloader class to be imported.
+                For example, 'module.submodule.ClassName'.
+
+        Returns:
+            Type["Dataloader"]: An instance of the Dataloader class loaded from the given path.
+
+        Raises:
+            ImportError: If the path does not correspond to a valid class.
+        """
+        return import_string(path)
+
+    def iterate_dataloaders(self, dl_name: str) -> Iterator[T]:
+        """Iterates over distinct dataloaders specified by a given name.
+
+        This method retrieves a distinct list of paths associated with the specified
+        dataloader name, then iterates over these paths. For each path, it loads a
+        dataloader instance and filters the queryset based on the path, then yields
+        this dataloader.
+
+        The type `T` represents the specific type of the dataloaders that will be loaded and
+        iterated over.
+
+        Args:
+            dl_name (str): The name of the dataloader to be iterated over. This name
+                is used to construct the path key for querying distinct dataloader paths.
+
+        Returns:
+            Iterator[T]: An iterator of dataloader instances of the generic type `T` corresponding
+            to each distinct path found in the queryset.
+        """
+        dl_path = f"dl_parameters__{dl_name}__path"
+        for path in self.queryset.distinct(dl_path).values_list(dl_path, flat=True):
+            with suppress(AttributeError):
+                yield self.load_dataloader(path)(self.queryset.filter(**{dl_path: path}))

wbcore/contrib/dataloader/models/__init__.py

@@ -0,0 +1 @@
+from .entities import Entity

wbcore/contrib/dataloader/models/entities.py

@@ -0,0 +1,30 @@
+from django.db import models
+
+from wbcore.contrib.dataloader.dataloaders import DataloaderProxy
+from wbcore.contrib.dataloader.models.querysets import EntityQuerySet
+
+
+class Entity(models.Model):
+    """An abstract model representing an entity with associated dataloaders.
+
+    This model serves as a base for entities that store data and have dataloaders
+    attached for data retrieval and processing. It includes specialized fields to
+    facilitate the use of dataloaders:
+
+    Attributes:
+        dl_proxy (DataloaderProxy): A reference to the DataloaderProxy. This should be
+            set when using this model to manage the associated dataloaders.
+        dl_parameters (models.JSONField): A field to store parameters for various
+            dataloaders. It is structured in the format:
+            `{"dataloader_name": {"path": "path.to.dataloader", "parameters": {}}}`.
+        objects (EntityQuerySet): A custom model manager providing an interface to a
+            dataloader proxy. This proxy can be accessed through the 'dl' method on a
+            queryset, e.g., `Entity.objects.all().dl`.
+    """
+
+    dl_proxy: DataloaderProxy
+    dl_parameters = models.JSONField(default=dict, blank=True)
+    objects = EntityQuerySet.as_manager()
+
+    class Meta:
+        abstract = True

wbcore/contrib/dataloader/models/querysets/__init__.py

@@ -0,0 +1 @@
+from .entities import EntityQuerySet