wbcore 1.59.9__py2.py3-none-any.whl

wbcore/models/base.py

@@ -0,0 +1,184 @@
+from contextlib import suppress
+from typing import Any, List, Optional
+
+from celery import shared_task
+from django.contrib.contenttypes.models import ContentType
+from django.core import checks
+from django.db import models
+from django.db.models.base import ModelBase
+from django.utils.functional import cached_property
+from django_better_admin_arrayfield.models.fields import ArrayField
+from igraph import Graph
+
+from wbcore.signals.models import get_dependant_dynamic_fields_instances
+
+from ..workers import Queue
+from .fields import DynamicDecimalField, DynamicFloatField
+
+
+class DynamicMetaClass(ModelBase):
+    def __new__(cls, name, bases, attrs, **kwargs):
+        new_class = super().__new__(cls, name, bases, attrs, **kwargs)
+        # Construct dependencies graph
+        dynamic_field_names = {
+            field.name: field.dependencies
+            for field in new_class._meta.fields
+            if type(field) in [DynamicFloatField, DynamicDecimalField]
+        }
+        ordered_dependencies_fields = []
+        if dynamic_field_names:
+            g = Graph(len(dynamic_field_names), directed=True)
+            # label vertices
+            g.vs["name"] = list(dynamic_field_names.keys())
+            for field_name, dependencies in dynamic_field_names.items():
+                for dependency in dependencies:
+                    g[dependency, field_name] = 1
+            # Store dynamic field ordered by topological sorting
+            ordered_dependencies_fields = [g.vs[v_id]["name"] for v_id in g.topological_sorting()]
+        new_class.add_to_class("ordered_dependencies_fields", ordered_dependencies_fields)
+        return new_class
+
+
+class DynamicModel(models.Model, metaclass=DynamicMetaClass):
+    DATE_RANGE_UPPER_FIELD_NAME = "date"
+    DATE_RANGE_LOWER_FIELD_NAME = "date"
+
+    lock_all_dynamic_fields = models.BooleanField(
+        default=False, help_text="If True, will not allow dynamic fields to be updated"
+    )
+    locked_dynamic_fields = ArrayField(
+        models.CharField(
+            max_length=128,
+        ),
+        blank=True,
+        default=list,
+    )
+    updated_at = models.DateTimeField(auto_now=True)
+
+    @classmethod
+    def get_static_locked_fields(cls) -> list[str]:
+        """
+        Override if the model needs to define a set of dynamic fields that can only be set when the value is null
+
+        Returns:
+            Return a list of field names
+        """
+        return []
+
+    @cached_property
+    def _locked_fields(self) -> set[str]:
+        return set(self.locked_dynamic_fields + self.get_static_locked_fields())
+
+    def set_dynamic_field(
+        self,
+        update_all_dynamic_fields: bool,
+        update_only_fields: list[str] | None = None,
+        update_exclude_fields: list[str] | None = None,
+    ):
+        if not update_only_fields:
+            update_only_fields = []
+        if not update_exclude_fields:
+            update_exclude_fields = []
+        # Loop over the dynamic field ordered by their place in the dependency graph
+        for dynamic_field_name in self.ordered_dependencies_fields:
+            # Check if field value is not assigned or if we explicitly want to override its value
+            if (
+                not self.lock_all_dynamic_fields
+                and (
+                    getattr(self, dynamic_field_name, None) is None
+                    or (
+                        dynamic_field_name not in self._locked_fields
+                        and (update_all_dynamic_fields or dynamic_field_name in update_only_fields)
+                    )
+                )
+            ) and dynamic_field_name not in update_exclude_fields:
+                # call the appropriate callback and check if this is a function
+                if (
+                    (compute_function := getattr(self, f"_compute_{dynamic_field_name}", None))
+                    and (callable(compute_function))
+                    and (res := compute_function()) is not None
+                ):
+                    setattr(self, dynamic_field_name, res)
+
+    @classmethod
+    def update_dynamic_fields_of_dependant_objects(
+        cls,
+        updated_instance,
+        already_visited_instances: set[Any] | None = None,
+        update_all_dynamic_fields: bool | None = True,
+    ):
+        if not already_visited_instances:
+            already_visited_instances = set()
+        for _, dependant_instance_generator in get_dependant_dynamic_fields_instances.send(
+            sender=updated_instance.__class__, instance=updated_instance
+        ):
+            for dependant_instance in dependant_instance_generator:
+                if dependant_instance not in already_visited_instances:
+                    dependant_instance.set_dynamic_field(update_all_dynamic_fields)
+                    already_visited_instances.add(updated_instance)
+                    DynamicModel.update_dynamic_fields_of_dependant_objects(
+                        dependant_instance, already_visited_instances=already_visited_instances
+                    )
+
+    def save(
+        self,
+        *args,
+        update_all_dynamic_fields: Optional[bool] = False,
+        update_only_fields: Optional[List] = None,
+        update_exclude_fields: Optional[List] = None,
+        set_dynamic_field_on_save: Optional[bool] = True,
+        **kwargs,
+    ):
+        if set_dynamic_field_on_save:
+            self.set_dynamic_field(update_all_dynamic_fields, update_only_fields, update_exclude_fields)
+        return super().save(*args, **kwargs)
+
+    class Meta:
+        abstract = True
+
+
+@shared_task(queue=Queue.DEFAULT.value)
+def set_dynamic_field_as_task(content_type_id, object_id, **kwargs):
+    content_type = ContentType.objects.get(id=content_type_id)
+    instance = content_type.model_class().objects.get(id=object_id)
+    instance.set_dynamic_field(True, **kwargs)
+    instance.save()
+
+
+class WBModel(models.Model):
+    """Implements checks on the model class"""
+
+    id: int
+
+    class Meta:
+        abstract = True
+
+    @classmethod
+    def _check_model_methods(cls) -> list[checks.Error]:
+        methods_to_check = [
+            "get_endpoint_basename",
+            "get_representation_value_key",
+            "get_representation_endpoint",
+            "get_representation_label_key",
+        ]
+        method_errors = []
+        for method in methods_to_check:
+            if not hasattr(cls._meta.model, method):
+                method_errors.append(checks.Error(f"{cls._meta.model.__name__} does not have method {method}"))
+        return method_errors
+
+    @classmethod
+    def check(cls, **kwargs):
+        errors = super().check(**kwargs)
+        errors.extend(cls._check_model_methods())
+        return errors
+
+
+@shared_task(queue=Queue.DEFAULT.value)
+def merge_as_task(content_type_id: int, main_object_id: int, merged_object_id: int):
+    content_type = ContentType.objects.get(id=content_type_id)
+    with suppress(content_type.model_class().DoesNotExist):
+        main_object = content_type.get_object_for_this_type(id=main_object_id)
+        merged_object = content_type.get_object_for_this_type(id=merged_object_id)
+        if hasattr(main_object, "merge") and callable(main_object.merge):
+            main_object.merge(merged_object)

wbcore/models/fields.py

@@ -0,0 +1,29 @@
+from django.core.exceptions import ValidationError
+from django.db.models import DecimalField, Field, FloatField, PositiveIntegerField
+
+
+class AbstractDynamicField(Field):
+    dependencies = []
+
+    def __init__(self, *args, dependencies: list | None = None, **kwargs):
+        blank = kwargs.pop("blank", True)
+        null = kwargs.pop("null", True)
+        self.dependencies = dependencies if dependencies else []
+        super().__init__(*args, blank=blank, null=null, **kwargs)
+
+
+class DynamicDecimalField(DecimalField, AbstractDynamicField):
+    description = "Use a custom callback to compute this field if None"
+
+
+class DynamicFloatField(FloatField, AbstractDynamicField):
+    description = "Use a custom callback to compute this field if None"
+
+
+def validate_year(year: int | None):
+    if year and not len(str(year)) == 4:
+        raise ValidationError("Please provide a valid 4-digit year.")
+
+
+class YearField(PositiveIntegerField):
+    default_validators = [validate_year]

wbcore/models/orderable.py

@@ -0,0 +1,6 @@
+from ordered_model.models import OrderedModel as BaseOrderedModel
+
+
+class OrderableModel(BaseOrderedModel):
+    class Meta(BaseOrderedModel.Meta):
+        abstract = True

wbcore/pagination.py

@@ -0,0 +1,64 @@
+from typing import TYPE_CHECKING, Callable
+
+from rest_framework import pagination
+
+if TYPE_CHECKING:
+    from django.db.models import QuerySet
+    from rest_framework.request import Request
+    from rest_framework.views import View
+
+
+class EndlessPaginationMixin(pagination.BasePagination):
+    """Custom pagination mixin to support disabling pagination through a query parameter."""
+
+    def paginate_queryset(self, queryset: "QuerySet", request: "Request", view: "View | None" = None):
+        """
+        Paginate the queryset if pagination is not explicitly disabled.
+
+        Args:
+            queryset (QuerySet): The queryset to paginate.
+            request (Request): The request object.
+            view (View, optional): The view calling this method.
+
+        Returns:
+            QuerySet: The paginated queryset or None if pagination is disabled.
+        """
+        if request.query_params.get("disable_pagination") == "true":
+            return None
+        return super().paginate_queryset(queryset, request, view)
+
+
+class InitialPaginationMixin:
+    """Mixin to determine whether the current page is the initial page."""
+
+    get_previous_link: Callable[[], str | None]
+
+    def is_initial(self) -> bool:
+        """
+        Determine if the current page is the initial page.
+
+        Returns:
+            bool: True if it's the initial page, False otherwise.
+        """
+        return self.get_previous_link() is None
+
+
+class CursorPagination(EndlessPaginationMixin, InitialPaginationMixin, pagination.CursorPagination):
+    def _get_position_from_instance(self, instance, ordering) -> str:
+        """
+        Returns the super _get_position_from_instance but adjusts the first item of ordering
+        to ensure that no foreignkey is included to not break the frontend.
+
+        Args:
+            instance: The instance to get the position from.
+            ordering (list): The ordering criteria.
+
+        Returns:
+            Any: The position from the instance.
+        """
+        new_ordering = [*ordering]
+        new_ordering[0] = new_ordering[0].split("__")[0]
+        return super()._get_position_from_instance(instance, new_ordering)
+
+
+class LimitOffsetPagination(EndlessPaginationMixin, InitialPaginationMixin, pagination.LimitOffsetPagination): ...

wbcore/pandas/__init__.py

@@ -0,0 +1,53 @@
+import warnings
+
+warnings.warn(
+    "The 'wbcore.pandas' module is deprecated and will be removed in a future version. "
+    "Please use 'wbcore.contrib.pandas' instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+from wbcore.contrib.pandas import fields
+from wbcore.contrib.pandas.fields import (  # noqa
+    PKField,
+    CharField,
+    DateField,
+    DateTimeField,
+    DateRangeField,
+    BooleanField,
+    TextField,
+    EmojiRatingField,
+    FloatField,
+    IntegerField,
+    YearField,
+    ListField,
+    JsonField,
+    SparklineField,
+    PandasFields,
+)
+from wbcore.contrib.pandas.filters import (  # noqa
+    PandasDjangoFilterBackend,
+    PandasSearchFilter,
+    PandasOrderingFilter,
+)
+from wbcore.contrib.pandas.filterset import PandasFilterSetMixin  # noqa
+from wbcore.contrib.pandas.metadata import PandasMetadata  # noqa
+from wbcore.contrib.pandas.utils import (  # noqa
+    rule,
+    overwrite,
+    overwrite_rule,
+    overwrite_row,
+    overwrite_row_df,
+    override_number_to_percent,
+    override_number_with_currency,
+    override_number_to_x,
+    override_number_precision,
+    override_number_to_decimal,
+    override_number_to_integer_without_decorations,
+    pct_change_with_negative_values,
+    get_empty_series,
+    sanitize_field,
+    sanitize_fields,
+)
+from wbcore.contrib.pandas import views
+from wbcore.contrib.pandas.views import PandasMixin, PandasAPIView, PandasAPIViewSet  # noqa

wbcore/pandas/fields.py

@@ -0,0 +1,25 @@
+import warnings
+
+warnings.warn(
+    "The 'wbcore.pandas' module is deprecated and will be removed in a future version. "
+    "Please use 'wbcore.contrib.pandas' instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+from wbcore.contrib.pandas.fields import (  # noqa
+    PKField,
+    CharField,
+    DateField,
+    DateTimeField,
+    DateRangeField,
+    BooleanField,
+    TextField,
+    EmojiRatingField,
+    FloatField,
+    IntegerField,
+    YearField,
+    ListField,
+    JsonField,
+    SparklineField,
+    PandasFields,
+)

wbcore/pandas/filterset.py

@@ -0,0 +1,9 @@
+import warnings
+
+warnings.warn(
+    "The 'wbcore.pandas' module is deprecated and will be removed in a future version. "
+    "Please use 'wbcore.contrib.pandas' instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+from wbcore.contrib.pandas.filterset import PandasFilterSetMixin  # noqa

wbcore/pandas/utils.py

@@ -0,0 +1,25 @@
+import warnings
+
+warnings.warn(
+    "The 'wbcore.pandas' module is deprecated and will be removed in a future version. "
+    "Please use 'wbcore.contrib.pandas' instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+from wbcore.contrib.pandas.utils import (  # noqa
+    rule,
+    overwrite,
+    overwrite_rule,
+    overwrite_row,
+    overwrite_row_df,
+    override_number_to_percent,
+    override_number_with_currency,
+    override_number_to_x,
+    override_number_precision,
+    override_number_to_decimal,
+    override_number_to_integer_without_decorations,
+    pct_change_with_negative_values,
+    get_empty_series,
+    sanitize_field,
+    sanitize_fields,
+)

wbcore/pandas/views.py

@@ -0,0 +1,9 @@
+import warnings
+
+warnings.warn(
+    "The 'wbcore.pandas' module is deprecated and will be removed in a future version. "
+    "Please use 'wbcore.contrib.pandas' instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+from wbcore.contrib.pandas.views import PandasMixin, PandasAPIView, PandasAPIViewSet  # noqa

wbcore/permissions/backend.py

@@ -0,0 +1,36 @@
+from contextlib import suppress
+
+from django.contrib.auth.models import Group, Permission
+from django.db.models import Q, QuerySet
+from django.utils.functional import cached_property
+from guardian.utils import get_anonymous_user
+
+from wbcore.contrib.authentication.models.users import User
+
+
+class UserBackend:
+    """
+    Base UserBackend for basic support (default to all valid user except the anonymous user)
+    """
+
+    @cached_property
+    def internal_user_permission(self) -> Permission | None:
+        try:
+            return Permission.objects.get(content_type__app_label="authentication", codename="is_internal_user")
+        except Permission.DoesNotExist:
+            return None
+
+    def get_internal_groups(self) -> QuerySet[Group]:
+        if self.internal_user_permission:
+            return Group.objects.filter(permissions=self.internal_user_permission)
+        return Group.objects.none()
+
+    def get_internal_users(self) -> QuerySet[User]:
+        if self.internal_user_permission:
+            qs = User.objects.filter(is_active=True).filter(
+                Q(user_permissions=self.internal_user_permission) | Q(groups__in=self.get_internal_groups().all())
+            )
+            with suppress(User.DoesNotExist):
+                qs = qs.exclude(id=get_anonymous_user().id)
+            return qs.distinct()
+        return User.objects.none()

wbcore/permissions/mixins.py

@@ -0,0 +1,72 @@
+from django.db import models
+
+
+class PermissionMixin(models.Model):
+    class Meta:
+        abstract = True
+
+    @classmethod
+    @property
+    def view_perm_str(cls) -> str:
+        """
+        Get the view string permission identifer
+
+        Returns:
+            The view string permission identifier
+        """
+        return f"{cls._meta.app_label}.view_{cls._meta.model_name}"
+
+    @classmethod
+    @property
+    def change_perm_str(cls) -> str:
+        """
+        Get the change string permission identifer
+
+        Returns:
+            The change string permission identifier
+        """
+        return f"{cls._meta.app_label}.change_{cls._meta.model_name}"
+
+    @classmethod
+    @property
+    def delete_perm_str(cls) -> str:
+        """
+        Get the delete string permission identifer
+
+        Returns:
+            The delete string permission identifier
+        """
+        return f"{cls._meta.app_label}.delete_{cls._meta.model_name}"
+
+    @classmethod
+    @property
+    def select_perm_str(cls) -> str:
+        """
+        Get the select string permission identifer
+
+        Returns:
+            The select string permission identifier
+        """
+        return f"{cls._meta.app_label}.select_{cls._meta.model_name}"
+
+    @classmethod
+    @property
+    def admin_perm_str(cls) -> str:
+        """
+        Get the admin string permission identifer
+
+        Returns:
+            The admin string permission identifier
+        """
+        return f"{cls._meta.app_label}.administrate_{cls._meta.model_name}"
+
+    @classmethod
+    @property
+    def add_perm_str(cls) -> str:
+        """
+        Get the add string permission identifer
+
+        Returns:
+            The add string permission identifier
+        """
+        return f"{cls._meta.app_label}.add_{cls._meta.model_name}"

wbcore/permissions/permissions.py

@@ -0,0 +1,51 @@
+from rest_framework import permissions
+from rest_framework.permissions import IsAuthenticated
+
+from wbcore.enums import WidgetType
+
+from .shortcuts import is_internal_user
+
+
+class RestAPIModelPermissions(permissions.DjangoModelPermissions):
+    """
+    Mixin for adding the view permission to the perms_map
+    NOTE: This is only here until Django Rest Framework patches
+    their DjangoModelPermissions to include view permissions
+    """
+
+    perms_map = {
+        "GET": ["%(app_label)s.view_%(model_name)s"],
+        "OPTIONS": ["%(app_label)s.select_%(model_name)s"],
+        "SELECT": ["%(app_label)s.select_%(model_name)s"],
+        "HEAD": ["%(app_label)s.select_%(model_name)s"],
+        "POST": ["%(app_label)s.add_%(model_name)s"],
+        "PUT": ["%(app_label)s.change_%(model_name)s"],
+        "PATCH": ["%(app_label)s.change_%(model_name)s"],
+        "DELETE": ["%(app_label)s.delete_%(model_name)s"],
+    }
+
+    def has_permission(self, request, view):
+        method = request.method
+        if getattr(view, "WIDGET_TYPE", None) == WidgetType.SELECT.value:
+            method = "SELECT"
+        if getattr(view, "_ignore_model_permissions", False):
+            return True
+
+        if not request.user or (not request.user.is_authenticated and self.authenticated_users_only):
+            return False
+
+        queryset = self._queryset(view)
+        perms = self.get_required_permissions(method, queryset.model)
+
+        return request.user.has_perms(perms)
+
+
+class IsInternalUser(IsAuthenticated):
+    def has_permission(self, request, view) -> bool:
+        return is_internal_user(request.user, True)
+
+
+class InternalUserPermissionMixin:
+    def get_permissions(self):
+        permissions = super().get_permissions()  # type: ignore
+        return [*permissions, IsInternalUser()]

wbcore/permissions/registry.py

@@ -0,0 +1,33 @@
+from contextlib import suppress
+
+from django.conf import settings
+from django.contrib.auth.models import Group
+from django.db.models import QuerySet
+from django.utils.functional import cached_property
+
+from wbcore.contrib.authentication.models import User
+from wbcore.utils.importlib import import_from_dotted_path
+
+
+class UserBackendRegistry:
+    def __init__(self):
+        internal_users_backend_path = getattr(settings, "USER_BACKEND", "wbcore.permissions.backend.UserBackend")
+        internal_users_backend_class = import_from_dotted_path(internal_users_backend_path)
+        self.backend = internal_users_backend_class()
+
+    @cached_property
+    def internal_groups(self) -> QuerySet[Group]:
+        return self.backend.get_internal_groups().all()
+
+    @cached_property
+    def internal_users(self) -> QuerySet[User]:
+        return self.backend.get_internal_users().all()
+
+    def reset_cache(self):
+        with suppress(AttributeError):
+            del self.internal_users
+        with suppress(AttributeError):
+            del self.internal_groups
+
+
+user_registry = UserBackendRegistry()

wbcore/permissions/shortcuts.py

@@ -0,0 +1,38 @@
+from django.contrib.auth.models import Group
+from django.db.models.query import QuerySet
+
+from wbcore.contrib.authentication.models.users import User
+
+
+def get_internal_groups() -> QuerySet[Group]:
+    from wbcore.permissions.registry import user_registry
+
+    """
+    Return the cached groups of internals users
+
+    Returns:
+        A queryset of group corresponding to the internal notion defined by the set UserBackend
+
+    Raises:
+        ValueError: If user backend path does not correspond to a valid module
+    """
+    return user_registry.internal_groups
+
+
+def get_internal_users() -> QuerySet[User]:
+    from wbcore.permissions.registry import user_registry
+
+    """
+    Return the cached queryset of internals users
+
+    Returns:
+        A queryset of user corresponding to the internal notion defined by the set UserBackend
+
+    Raises:
+        ValueError: If user backend path does not correspond to a valid module
+    """
+    return user_registry.internal_users
+
+
+def is_internal_user(user: User, include_superuser: bool = False) -> bool:
+    return user and (user.is_internal or (include_superuser and user.is_superuser))

wbcore/permissions/utils.py

@@ -0,0 +1,26 @@
+from django.contrib.auth.models import Permission
+
+
+def perm_to_permission(perm: str) -> Permission:
+    """
+    Convert a identifier string permission format in 'app_label.codename'
+    (teremd as *perm*) to a django permission instance.
+
+    Args:
+        perm: The string permission identifier in the form 'app_label.codename'
+
+    Returns:
+        The Permission object corresponding to the given string identifier
+
+    Raises:
+        AttributeError: When the given string identifier does not match the expected format 'app_label.codename'
+    """
+    try:
+        app_label, codename = perm.split(".", 1)
+    except IndexError as e:
+        raise AttributeError(
+            "The format of identifier string permission (perm) is wrong. " "It should be in 'app_label.codename'."
+        ) from e
+    else:
+        permission = Permission.objects.get(content_type__app_label=app_label, codename=codename)
+        return permission