wbcore 2.2.1__py2.py3-none-any.whl

wbcore/shares/sites.py

@@ -0,0 +1,28 @@
+from dataclasses import dataclass, field
+
+from django.utils.functional import cached_property
+from django.utils.translation import gettext as _
+from wbcore.metadata.configs.display.instance_display import Section
+from wbcore.serializers import Serializer
+from wbcore.serializers.fields import CharField
+
+
+@dataclass
+class ShareSite:
+    serializers: list[Serializer] = field(default_factory=list)
+    sections: list[Section] = field(default_factory=list)
+
+    @cached_property
+    def serializer_class(self) -> Serializer:
+        return type(
+            "ShareSerializer",
+            tuple(self.serializers),
+            dict(widget_endpoint=CharField(label=_("Widget URL"), read_only=True)),
+        )
+
+    @cached_property
+    def sorted_sections(self) -> list[Section]:
+        return list(map(lambda x: x["section"], sorted(self.sections, key=lambda x: x["weight"])))
+
+
+share_site = ShareSite()

wbcore/shares/views.py

@@ -0,0 +1,24 @@
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.request import Request
+from rest_framework.response import Response
+from rest_framework.views import APIView
+from wbcore.shares.signals import handle_widget_sharing
+from wbcore.utils.urls import clean_shareable_url
+
+from .sites import share_site
+
+
+class ShareAPIView(APIView):
+    permission_classes = [IsAuthenticated]
+
+    def post(self, request: Request) -> Response:
+        if widget_endpoint := request.POST.get("widget_endpoint"):
+            serializer = share_site.serializer_class(data=request.data)
+            serializer.is_valid(raise_exception=True)
+            handle_widget_sharing.send(
+                sender=self.__class__,
+                request=request,
+                widget_relative_endpoint=clean_shareable_url(widget_endpoint),
+                **serializer.validated_data.copy(),
+            )
+        return Response({})

wbcore/signals/__init__.py

@@ -0,0 +1,6 @@
+from .filters import add_filters
+from .instance_buttons import add_button, add_instance_button
+from .models import get_dependant_dynamic_fields_instances, pre_collection
+from .permissions import load_permission_objects
+from .serializers import add_additional_resource, add_instance_additional_resource, add_dynamic_button
+from .merge import pre_merge

wbcore/signals/filters.py

@@ -0,0 +1,3 @@
+from django.dispatch import Signal
+
+add_filters = Signal()

wbcore/signals/instance_buttons.py

@@ -0,0 +1,5 @@
+from django.dispatch import Signal
+
+add_instance_button = Signal()  # many
+add_extra_button = Signal()  # many
+add_button = Signal()  # many

wbcore/signals/merge.py

@@ -0,0 +1,4 @@
+from django.db.models.signals import ModelSignal
+
+# Signal fired before merged/obsolete object are deleted during a merge phase
+pre_merge = ModelSignal(use_caching=False)

wbcore/signals/models.py

@@ -0,0 +1,8 @@
+from django.db.models.signals import ModelSignal
+
+get_dependant_dynamic_fields_instances = (
+    ModelSignal()
+)  # Signal use to gather the dependant fields to be computed before the sender (use for the dynamic field framework). Experimental state
+pre_collection = (
+    ModelSignal()
+)  # pre_delete signal is sent after collection. Therefore, protect field will trigger an IntergrityError. This signal can be used to circuvent that.

wbcore/signals/permissions.py

@@ -0,0 +1,3 @@
+from django.dispatch import Signal
+
+load_permission_objects = Signal()

wbcore/signals/serializers.py

@@ -0,0 +1,5 @@
+from django.dispatch import Signal
+
+add_additional_resource = Signal()  # "serializer", "instance", "request", "user"
+add_instance_additional_resource = Signal()  # "serializer", "instance", "request", "user"
+add_dynamic_button = Signal()  # "serializer", "instance", "request", "user"

wbcore/tasks.py

@@ -0,0 +1,83 @@
+from contextlib import suppress
+from datetime import timedelta
+
+from celery import shared_task
+from django.db.models import ProtectedError
+from django.utils import timezone
+from dynamic_preferences.registries import global_preferences_registry
+from tqdm import tqdm
+from wbcore.cache.registry import periodic_cache_registry
+from wbcore.models import DynamicModel
+from wbcore.utils.itertools import get_inheriting_subclasses
+from wbcore.utils.models import ComplexToStringMixin, DeleteToDisableMixin
+
+
+@shared_task
+def recompute_latest_modified_dynamic_fields(from_datetime=None, to_datetime=None, timedelta_days=1):
+    """
+    Daily (expected frequency) recompute of all dynamic model objects that falls within the specified time frame (default to the last 24h).
+    For each recently modified object, a subroutine sends a signal to get the dependant object to be recomputed
+    Args:
+        from_datetime: A datetime, default to today - 24h
+        to_datetime: A Datetime, default to today
+        timedelta_days: time range, default to 24h
+    """
+    if not to_datetime:
+        to_datetime = timezone.now()
+    if not from_datetime:
+        from_datetime = timezone.now() - timedelta(days=timedelta_days)
+
+    if from_datetime >= to_datetime:
+        raise ValueError("From date needs to be strictly lower than To date")
+
+    # already_updated_objects = set() # We don't pass the list anymore because of in memory issue. For instrument price, we extend 10GB. We migh want to implement a non deterministric approach with Bloom filter for instance
+
+    for subclass in get_inheriting_subclasses(DynamicModel):
+        qs = subclass.objects.filter(updated_at__gte=from_datetime, updated_at__lte=to_datetime)
+        for already_updated_object in tqdm(qs.distinct().iterator(), total=qs.count()):
+            DynamicModel.update_dynamic_fields_of_dependant_objects(already_updated_object)
+
+
+@shared_task
+def recompute_computed_str(debug: bool = False):
+    """
+    When this task is executed, it will loop over all objects that inherit from ComplexToStringMixin and compare their current computed_str value with the expected one.
+    If different, the expected one is saved in place.
+    """
+    BULK_SIZE = 1000
+    for subclass in get_inheriting_subclasses(ComplexToStringMixin):
+        if getattr(subclass, "COMPUTED_STR_RECOMPUTE_PERIODICALLY", True):
+            objs = []
+            if debug:
+                qs = tqdm(subclass.objects.iterator(), total=subclass.objects.count())
+            else:
+                qs = subclass.objects.iterator()
+            for instance in qs:
+                with suppress(Exception):  # we don't want this task to fail because of
+                    new_computed_str = instance.compute_str()
+                    if new_computed_str != instance.computed_str:
+                        instance.computed_str = new_computed_str
+                        objs.append(instance)
+                    if len(objs) % BULK_SIZE == 0:
+                        subclass.objects.bulk_update(objs, ["computed_str"])
+                        objs = []
+
+
+@shared_task
+def clean_deleted_objects():
+    """
+    Periodically arise deleted objects that have passed the retention period from the database.
+    """
+    retention_period = global_preferences_registry.manager()["wbcore__retention_period"]
+    for subclass in get_inheriting_subclasses(DeleteToDisableMixin):
+        if subclass.AUTOMATICALLY_CLEAN_SOFT_DELETED_OBJECTS:
+            with suppress(ProtectedError):
+                subclass.all_objects.filter(
+                    is_active=False, deletion_datetime__lte=timezone.now() - timedelta(days=retention_period)
+                ).delete()
+
+
+@shared_task
+def refetch_pandas_api_view():
+    for cache_api_view in periodic_cache_registry.classes:
+        cache_api_view.fetch_cache()

wbcore/templates/reversion/compare_detail.html

@@ -0,0 +1,19 @@
+<style type="text/css">
+    /* minimal style for the diffs */
+    pre.highlight {
+        max-width: 900px;
+        white-space: pre-line;
+    }
+    del, ins {
+        color: #000;
+        text-decoration: none;
+    }
+    del { background-color: #ffe6e6; }
+    ins { background-color: #e6ffe6; }
+    sup.follow { color: #5555ff; }
+</style>
+
+
+{% include "reversion-compare/action_list_partial.html"  %}
+{% include "reversion-compare/compare_partial.html"  %}
+{% include "reversion-compare/compare_links_partial.html"  %}

wbcore/test/__init__.py

@@ -0,0 +1,30 @@
+from .e2e_helpers_methods.e2e_helper_methods import (
+    click_button_by_label,
+    click_close_all_widgets,
+    click_element_by_path,
+    click_new_button,
+    delete_list_entry,
+    edit_list_instance,
+    fill_out_form_fields,
+    find_element,
+    find_element_by_text,
+    login,
+    navigate_to_filter,
+    open_create_instance,
+    open_menu_item,
+    select_async_filter,
+    select_column_filter,
+    select_filter,
+    set_up,
+)
+from .e2e_helpers_methods.e2e_checks import (
+    does_background_color_match,
+    is_counter_as_expected,
+    is_error_visible,
+    is_string_not_visible,
+    is_tag_not_visible,
+    is_tag_visible,
+    is_text_visible,
+)
+
+from .tests import GenerateTest, default_config