wbcore 2.2.1__py2.py3-none-any.whl

wbcore/__init__.py

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

wbcore/admin.py

@@ -0,0 +1,197 @@
+import csv
+from functools import partial
+from io import StringIO
+
+import pandas as pd
+from django import forms
+from django.contrib import admin
+from django.contrib.admin.checks import InlineModelAdminChecks
+from django.contrib.admin.options import flatten_fieldsets
+from django.forms import ALL_FIELDS
+from django.forms.models import modelform_defines_fields
+from django.http import HttpResponse
+from django.shortcuts import redirect, render
+from django.urls import path
+from django.utils.translation import gettext_lazy as _
+
+from .content_type.admin import ContentTypeModelAdmin  # noqa: F401
+from .forms import NonrelatedInlineFormSet, nonrelated_inlineformset_factory
+from .markdown.admin import AssetModelAdmin  # noqa: F401
+from .models import AppliedPreset, FrontendUserConfiguration, Preset
+from .release_notes.admin import ReleaseNoteModelAdmin  # noqa: F401
+
+admin.site.register(AppliedPreset)
+admin.site.register(Preset)
+
+
+class FrontendUserConfigurationInline(admin.TabularInline):
+    model = FrontendUserConfiguration
+    extra = 0
+    fields = ["id", "user", "config"]
+    readonly_fields = ["id", "user", "config"]
+
+
+@admin.register(FrontendUserConfiguration)
+class FrontendUserConfigurationModelAdmin(admin.ModelAdmin):
+    list_display = ["id", "user"]
+    search_fields = ["user__email", "user__username", "id"]
+    fieldsets = ((_("Main Information"), {"fields": ("user", "parent_configuration", "config")}),)
+    inlines = [FrontendUserConfigurationInline]
+    list_filter = ["user"]
+
+
+class CsvImportForm(forms.Form):
+    csv_file = forms.FileField()
+
+
+class ExportCsvMixin:
+    def export_as_csv(self, admin, request, queryset, *args, **kwargs):
+        meta = queryset.model._meta
+        field_names = [field.name for field in meta.fields]
+
+        response = HttpResponse(content_type="text/csv")
+        response["Content-Disposition"] = "attachment; filename={}.csv".format(meta)
+        writer = csv.writer(response)
+
+        writer.writerow(field_names)
+        for obj in queryset:
+            writer.writerow([getattr(obj, field) for field in field_names])
+
+        return response
+
+    def get_actions(self, request):
+        actions = super().get_actions(request)
+        actions["export_as_csv"] = (self.export_as_csv, "export_as_csv", "Export Selected")
+        return actions
+
+
+class ImportCsvMixin:
+    change_list_template = "wbcore/admin/change_list.html"
+
+    def get_urls(self):
+        urls = super().get_urls()
+        my_urls = [path("import-csv/", self._import_csv)]
+        return my_urls + urls
+
+    def manipulate_df(self, df):
+        return df
+
+    def process_model(self, model):
+        self.model.create(**model)
+
+    def get_import_fields(self):
+        return [f.name for f in self.model._meta.get_fields()]
+
+    def _import_csv(self, request):
+        if request.method == "POST":
+            csv_file = request.FILES["csv_file"]
+
+            str_text = ""
+            for line in csv_file:
+                str_text = str_text + line.decode()
+            # Import csv as df
+            df = pd.read_csv(StringIO(str_text))
+            # Sanitize dataframe
+            df = df.where(pd.notnull(df), None)
+            df = df.drop(df.columns.difference(self.get_import_fields()), axis=1)
+
+            # Overide this function if there is foreign key ids in the dataframe
+            df = self.manipulate_df(df)
+            errors = 0
+            for model in df.to_dict("records"):
+                # by default, process the modela as a create request. Can be override to change the behavior
+                try:
+                    self.process_model(model)
+                except Exception:
+                    errors += 1
+            self.message_user(
+                request,
+                _("Your CSV file has been imported ( {imports}  imported, {errors} errors)").format(
+                    imports=df.shape[0] - errors, errors=errors
+                ),
+            )
+            return redirect("..")
+        form = CsvImportForm()
+        payload = {"form": form}
+        return render(request, "wbcore/admin/csv_form.html", payload)
+
+
+class NonrelatedInlineModelAdminChecks(InlineModelAdminChecks):
+    """
+    Check used by the admin system to determine whether or not an inline model
+    has a relationship to the parent object.
+    In this case we always want this check to pass.
+    """
+
+    def _check_exclude_of_parent_model(self, obj, parent_model):
+        return []
+
+    def _check_relation(self, obj, parent_model):
+        return []
+
+
+class NonrelatedInlineMixin:
+    """
+    Mixin for models not explicitly related to the inline model.
+    """
+
+    checks_class = NonrelatedInlineModelAdminChecks
+    formset = NonrelatedInlineFormSet
+
+    def get_form_queryset(self, obj):
+        raise NotImplementedError()
+
+    def save_new_instance(self, parent, instance):
+        raise NotImplementedError()
+
+    def save_formset(self, request, form, formset, change):
+        instances = formset.save(commit=False)
+        for instance in instances:
+            self.update_instance(formset.instance, instance)
+            instance.save()
+        formset.save_m2m()
+
+    def get_formset(self, request, obj=None, **kwargs):
+        if "fields" in kwargs:
+            fields = kwargs.pop("fields")
+        else:
+            fields = flatten_fieldsets(self.get_fieldsets(request, obj))
+
+        exclude = [*(self.exclude or []), *self.get_readonly_fields(request, obj)]
+        if self.exclude is None and hasattr(self.form, "_meta") and self.form._meta.exclude:
+            exclude.extend(self.form._meta.exclude)
+        exclude = exclude or None
+
+        can_delete = self.can_delete and self.has_delete_permission(request, obj)
+
+        queryset = self.model.objects.none()
+        if obj:
+            queryset = self.get_form_queryset(obj)
+
+        defaults = {
+            "form": self.form,
+            "formfield_callback": partial(self.formfield_for_dbfield, request=request),
+            "formset": self.formset,
+            "extra": self.get_extra(request, obj),
+            "can_delete": can_delete,
+            "can_order": False,
+            "fields": fields,
+            "min_num": self.get_min_num(request, obj),
+            "max_num": self.get_max_num(request, obj),
+            "exclude": exclude,
+            "queryset": queryset,
+            **kwargs,
+        }
+
+        if defaults["fields"] is None and not modelform_defines_fields(defaults["form"]):
+            defaults["fields"] = ALL_FIELDS
+
+        return nonrelated_inlineformset_factory(self.model, save_new_instance=self.save_new_instance, **defaults)
+
+
+class NonrelatedStackedInline(NonrelatedInlineMixin, admin.StackedInline):
+    pass
+
+
+class NonrelatedTabularInline(NonrelatedInlineMixin, admin.TabularInline):
+    pass

wbcore/apps.py

@@ -0,0 +1,17 @@
+from django.apps import AppConfig
+from django.db.models.signals import post_migrate
+
+from .management import create_wbcore_permissions
+
+
+class WBCoreConfig(AppConfig):
+    name = "wbcore"
+
+    def ready(self):
+        """
+        We load received after all apps are ready in order to be able to discover all subclasses
+        """
+        post_migrate.connect(
+            create_wbcore_permissions,
+            dispatch_uid="wbcore.management.create_wbcore_permissions",
+        )

wbcore/cache/buttons.py

@@ -0,0 +1,22 @@
+from django.utils.translation import gettext_lazy as _
+from rest_framework.reverse import reverse
+from wbcore.contrib.icons import WBIcon
+from wbcore.enums import RequestType
+from wbcore.metadata.configs import buttons as bt
+from wbcore.metadata.configs.identifiers import IdentifierViewConfig
+
+
+def add_clear_cache_button(sender, instance, request, view, pk=None, **kwargs):
+    if request.user.is_superuser and not instance:
+        cache_key = view._get_cache_key()
+        identifier = IdentifierViewConfig(view, request, instance=instance).get_metadata()
+        return bt.ActionButton(
+            method=RequestType.PATCH,
+            icon=WBIcon.DOWNLOAD.icon,
+            identifiers=(identifier,),
+            endpoint=reverse("wbcore:clear_cache", args=[cache_key], request=request),
+            action_label=_("Clear Cache"),
+            title=_("Clear Cache"),
+            label=_("Clear Cache"),
+            description_fields=_("Clear Cache"),
+        )

wbcore/cache/decorators.py

@@ -0,0 +1,29 @@
+from typing import Callable
+
+from ..signals.instance_buttons import add_extra_button
+from .buttons import add_clear_cache_button
+from .registry import periodic_cache_registry
+
+
+def cache_table(
+    timeout: int | Callable | None = None,
+    key_prefix: str | Callable | None = None,
+    periodic_caching: bool = False,
+    periodic_caching_view_kwargs: list[dict[str, str]] | Callable | None = None,
+    periodic_caching_get_parameters: list[dict[str, str]] | Callable | None = None,
+):
+    def _decorator(pandas_view_class):
+        setattr(pandas_view_class, "CACHE_ENABLED", True)
+        setattr(pandas_view_class, "CACHE_TIMEOUT", timeout)
+        setattr(pandas_view_class, "CACHE_KEY_PREFIX", key_prefix)
+        add_extra_button.connect(add_clear_cache_button, sender=pandas_view_class, weak=False)
+
+        if periodic_caching:
+            periodic_cache_registry.add(
+                pandas_view_class,
+                view_kwargs=periodic_caching_view_kwargs,
+                get_parameters=periodic_caching_get_parameters,
+            )
+        return pandas_view_class
+
+    return _decorator

wbcore/cache/mixins.py

@@ -0,0 +1,48 @@
+from functools import cached_property
+from typing import Any
+
+import pandas as pd
+from django.core.cache import cache
+from wbcore.utils.strings import camel_to_snake_case
+
+
+class CacheMixin:
+    extra_cache_kwargs: dict[str, Any]
+    CACHE_EMPTY_VALUE = pd.DataFrame()
+    CACHE_MAIN_KEY: str = "df"
+    CACHE_METHOD: str = "_get_dataframe"
+
+    @cached_property
+    def cache_enabled(self) -> bool:
+        return getattr(self, "CACHE_ENABLED", False)
+
+    def _get_cache_timeout(self) -> int | None:
+        cache_timeout = getattr(self, "CACHE_TIMEOUT", None)
+        if callable(cache_timeout):
+            return cache_timeout()
+        return cache_timeout
+
+    def _get_cache_key(self) -> str:
+        cache_key = camel_to_snake_case(self.__class__.__name__)
+        if cache_key_prefix := getattr(self, "CACHE_KEY_PREFIX", None):
+            if callable(cache_key_prefix):
+                cache_key_prefix = cache_key_prefix()
+            cache_key += "-" + cache_key_prefix
+        return cache_key
+
+    def deserialize_cache_results(self, cached_res: dict[str, Any]) -> Any:
+        res = cached_res.pop(self.CACHE_MAIN_KEY, self.CACHE_EMPTY_VALUE)
+        # we loop over the other cached kwargs and set them as class attributes
+        for k, v in cached_res.items():
+            setattr(self, k, v)
+        return res
+
+    def serialize_cache_results(self, res: Any) -> dict[str, Any]:
+        cached_res = {self.CACHE_MAIN_KEY: res}
+        cached_res.update(self.extra_cache_kwargs)
+        return cached_res
+
+    def _get_cached_res(self) -> Any:
+        if cached_res := cache.get(self._get_cache_key()):
+            return self.deserialize_cache_results(cached_res)
+        return self.CACHE_EMPTY_VALUE

wbcore/cache/registry.py

@@ -0,0 +1,90 @@
+import typing
+from contextlib import suppress
+from dataclasses import dataclass
+from typing import Callable, Generator
+
+from django.core.cache import cache
+from dynamic_preferences.models import global_preferences_registry
+from rest_framework.request import Request
+from rest_framework.test import APIRequestFactory, force_authenticate
+from wbcore.contrib.authentication.models import User
+from wbcore.filters.defaults import RequiredFilterMissing
+
+if typing.TYPE_CHECKING:
+    from wbcore.pandas.views import PandasAPIViewSet
+    from wbcore.viewsets import ChartViewSet
+
+
+@dataclass
+class CachedClass:
+    view_class: type["PandasAPIViewSet"] | type["ChartViewSet"]
+    view_kwargs: list[dict[str, str]] | Callable | None = None
+    get_parameters: list[dict[str, str]] | Callable | None = None
+
+    def _get_requests(self) -> Generator[Request, None, None]:
+        """
+        Given the stored list of GET parameters, returns a list of instantiated request with the system user as request.user
+
+        Returns:
+            A generator of DRF Request
+        """
+        system_user_email = global_preferences_registry.manager()["wbcore__system_user_email"]
+        get_parameters = self.get_parameters if self.get_parameters else [{}]
+        if callable(self.get_parameters):
+            get_parameters = get_parameters()
+
+        for get_parameter in get_parameters:
+            request = APIRequestFactory().get("", data=get_parameter)
+            user = User.objects.get(email=system_user_email)
+            force_authenticate(request, user=user)
+            request.user = user
+            yield Request(request)
+
+    def fetch_cache(self) -> typing.Any:
+        """
+        For every kwargs and requests, reset the cache and get the view dataframe. This hits under the hood the caching mechanism
+
+        Returns:
+            A list of generated dataframe
+        """
+        view_kwargs = self.view_kwargs if self.view_kwargs else [{}]
+        if callable(self.view_kwargs):
+            view_kwargs = view_kwargs()
+        res = []
+        for request in self._get_requests():
+            for kwargs in view_kwargs:
+                with suppress(RequiredFilterMissing):
+                    view = self.view_class(request=request, kwargs=kwargs)
+                    setattr(request, "parser_context", {"request": request, "view": view, "kwargs": kwargs})
+                    cache_key = view._get_cache_key()
+                    cache.delete(cache_key)
+                    res.append(view._get_dataframe())
+        return res
+
+
+class PeriodicCacheRegistry:
+    """
+    Registry to hold the api view classes that needs to recompute their cache periodically
+    """
+
+    classes = list[CachedClass]
+
+    def __init__(self):
+        self.classes = []
+
+    def add(
+        self,
+        view_class: type["PandasAPIViewSet"] | type["ChartViewSet"],
+        view_kwargs: list[dict[str, str]] | Callable | None = None,
+        get_parameters: list[dict[str, str]] | Callable | None = None,
+    ):
+        self.classes.append(
+            CachedClass(
+                view_class=view_class,
+                view_kwargs=view_kwargs,
+                get_parameters=get_parameters,
+            )
+        )
+
+
+periodic_cache_registry = PeriodicCacheRegistry()

wbcore/cache/views.py

@@ -0,0 +1,18 @@
+from django.core.cache import cache
+from django.http import HttpRequest
+from rest_framework import permissions, status
+from rest_framework.decorators import (
+    api_view,
+    authentication_classes,
+    permission_classes,
+)
+from rest_framework.response import Response
+from wbcore.contrib.authentication.authentication import JWTCookieAuthentication
+
+
+@api_view(["PATCH"])
+@permission_classes([permissions.IsAdminUser])
+@authentication_classes([JWTCookieAuthentication])
+def clear_cache(request: HttpRequest, cache_key: str, *args, **kwargs):
+    cache.delete(cache_key)
+    return Response(status=status.HTTP_204_NO_CONTENT)

wbcore/configs/__init__.py

@@ -0,0 +1,11 @@
+from wbcore.metadata.configs.display.configs import preset_config
+
+from .configs import (
+    markdown_config,
+    menu_calendar_config,
+    menu_config,
+    release_note_config,
+    share_config,
+    beta_button,
+    frontend_version,
+)

wbcore/configs/configs.py

@@ -0,0 +1,51 @@
+from django.conf import settings
+from django.utils.module_loading import import_string
+from rest_framework.request import Request
+from rest_framework.reverse import reverse
+from wbcore.configs.decorators import register_config
+from wbcore.shares.config import share_action_button
+
+
+@register_config
+def release_note_config(request: Request) -> tuple[str, dict[str, str]]:
+    return "release_notes", {
+        "endpoint": reverse("wbcore:releasenote-list", request=request),
+        "unread_release_notes": reverse("wbcore:releasenote-unread-count", request=request),
+    }
+
+
+@register_config
+def menu_config(request: Request) -> tuple[str, str]:
+    return "menu", reverse("wbcore:menu", request=request)
+
+
+@register_config
+def share_config(request: Request):
+    return "share", share_action_button(request=request).serialize(request)
+
+
+@register_config
+def markdown_config(request: Request) -> tuple[str, dict[str, str]]:
+    return "markdown", {"blockdiag": reverse("wbcore:blockdiag", request=request)}
+
+
+@register_config
+def menu_calendar_config(request: Request) -> tuple[str, str | None]:
+    menu_calendar = None
+    if settings.FRONTEND_MENU_CALENDAR:
+        menu_calendar = import_string(settings.FRONTEND_MENU_CALENDAR)(request=request)
+    return "menu_calendar", menu_calendar
+
+
+@register_config
+def beta_button(request: Request) -> tuple[str, dict] | None:
+    beta_url = settings.BETA_BUTTON_URL
+    if ((beta_version := settings.BETA_BUTTON_VERSION) or beta_url) and (beta_text := settings.BETA_BUTTON_TEXT):
+        if beta_version and not beta_url:
+            beta_url = f"{settings.CDN_BASE_ENDPOINT_URL}/{beta_version}/main.js"
+        return "beta_button", {"url": beta_url, "text": beta_text}
+
+
+@register_config
+def frontend_version(request: Request) -> tuple[str, str | None]:
+    return "frontend_version", getattr(settings, "FRONTEND_VERSION", None)

wbcore/configs/decorators.py

@@ -0,0 +1,11 @@
+from typing import Callable
+
+
+def register_config(func: Callable) -> Callable:
+    """
+    A decorator that wraps a function and adds `_is_config=True` to it. This is needed for the auto-discover
+    of all configs. This function should only be used in a module called configs, otherwise the auto-discover
+    functionality won't work.
+    """
+    setattr(func, "_is_config", True)
+    return func

wbcore/configs/registry.py

@@ -0,0 +1,35 @@
+from contextlib import suppress
+from importlib import import_module
+from inspect import getmembers
+from types import ModuleType
+from typing import Any, Iterable
+
+from django.conf import settings
+from rest_framework.request import Request
+
+
+class ConfigRegistry:
+    """
+    A class that is able to discover all functions that are wrapped in the `@register_config` decorator. This registry
+    should never be used from the outside and its sole purpose is to gather all functions, so they are returned
+    in the APIView of this module.
+    """
+
+    def __init__(self, request: Request, *args, **kwargs):
+        self.request = request
+        super().__init__(*args, **kwargs)
+
+    def discover_configs(self) -> Iterable[ModuleType]:
+        for app in settings.INSTALLED_APPS:
+            with suppress(ModuleNotFoundError):
+                module = import_module(f"{app}.configs")
+                yield module
+
+    def get_configs(self) -> Iterable[tuple[str, Any]]:
+        for module in self.discover_configs():
+            for member in getmembers(module, lambda member: hasattr(member, "_is_config")):
+                if res := member[1](request=self.request):
+                    yield res
+
+    def get_config_dict(self) -> dict[str, Any]:
+        return dict(self.get_configs())

wbcore/configs/views.py

@@ -0,0 +1,11 @@
+from rest_framework.request import Request
+from rest_framework.response import Response
+from rest_framework.views import APIView
+from wbcore.configs.registry import ConfigRegistry
+
+
+class ConfigAPIView(APIView):
+    permission_classes = []
+
+    def get(self, request: Request) -> Response:
+        return Response(ConfigRegistry(request=request).get_config_dict())

wbcore/configurations/__init__.py

@@ -0,0 +1 @@
+from .base import DevBaseConfiguration, ProductionBaseConfiguration

wbcore/configurations/base.py

@@ -0,0 +1,45 @@
+from configurations import Configuration, values
+from wbcore.configurations import configurations
+from wbcore.contrib.agenda.configurations import AgendaConfigurationMixin
+from wbcore.contrib.authentication.configurations import (
+    AuthenticationConfigurationMixin,
+)
+from wbcore.contrib.directory.configurations import DirectoryConfigurationMixin
+from wbcore.contrib.guardian.configurations import Guardian
+from wbcore.contrib.io.configurations import ImportExportBaseConfiguration
+from wbcore.contrib.notifications.configurations import NotificationConfiguration
+
+
+class DevBaseConfiguration(
+    AgendaConfigurationMixin,
+    AuthenticationConfigurationMixin,
+    ImportExportBaseConfiguration,
+    DirectoryConfigurationMixin,
+    NotificationConfiguration,
+    configurations.Base,
+    configurations.DevApps,
+    configurations.S3Media,
+    configurations.Network,
+    configurations.Restframework,
+    configurations.ConsoleEmail,
+    configurations.Templates,
+    configurations.Authentication,
+    configurations.DevMiddleware,
+    configurations.LocalStaticfiles,
+    Guardian,
+    configurations.WBCore,
+    configurations.Celery,
+    configurations.I18NL10N,
+    configurations.Maintenance,
+    configurations.Cache,
+    Configuration,
+):
+    DEFAULT_AUTO_FIELD = "django.db.models.AutoField"
+    DEV_USER = values.Value(None, environ_prefix=None)
+    ADD_REVERSION_ADMIN = True
+
+
+class ProductionBaseConfiguration(
+    configurations.Uvicorn, configurations.SSLNetwork, configurations.S3Staticfiles, DevBaseConfiguration
+):
+    pass

wbcore/configurations/configurations/__init__.py

@@ -0,0 +1,16 @@
+from .apps import Apps, DevApps
+from .authentication import Authentication
+from .base import Base
+from .celery import Celery, CeleryTest
+from .i18nl10n import I18NL10N
+from .mail import ConsoleEmail
+from .media import LocalMedia, S3Media
+from .middleware import DevMiddleware, Middleware
+from .network import Network, SSLNetwork
+from .rest_framework import Restframework
+from .static import LocalStaticfiles, S3Staticfiles
+from .templates import Templates
+from .uvicorn import Uvicorn
+from .wbcore import WBCore
+from .maintenance import Maintenance
+from .cache import Cache

wbcore/configurations/configurations/apps.py

@@ -0,0 +1,54 @@
+class Apps:
+    _BASE_APPS = [
+        "django.contrib.admin",
+        "django.contrib.auth",
+        "django.contrib.contenttypes",
+        "django.contrib.sessions",
+        "django.contrib.messages",
+        "django.contrib.staticfiles",
+        "django.contrib.sites",
+        "rest_framework",
+        "django_filters",
+        "dynamic_preferences",
+        "dynamic_preferences.users.apps.UserPreferencesConfig",
+        "django_extensions",
+        "corsheaders",
+        "reversion",
+        "reversion_compare",
+        "guardian",
+        "ordered_model",
+        "wbcore",
+        "wbcore.contrib.agenda",
+        "wbcore.contrib.directory",
+        "wbcore.contrib.authentication",
+        "wbcore.contrib.notifications",
+        "wbcore.contrib.io",
+        "wbcore.contrib.currency",
+        "wbcore.contrib.geography",
+        "wbcore.contrib.tags",
+        "wbcore.contrib.documents",
+        "wbcore.contrib.workflow",
+        "wbcore.contrib.color",
+        "wbcore.contrib.guardian",
+        "django_celery_beat",
+        "maintenance_mode",
+    ]
+
+    def _get_additional_and_wb_apps(self):
+        return getattr(self, "ADDITIONAL_APPS", []) + getattr(self, "WB_ENDPOINTS", [])
+
+    @property
+    def INSTALLED_APPS(self):
+        return self._BASE_APPS + self._get_additional_and_wb_apps()
+
+
+class DevApps(Apps):
+    @property
+    def INSTALLED_APPS(self):
+        apps = self._BASE_APPS
+
+        if self.DEBUG:
+            apps.append("debug_toolbar")
+
+        apps.extend(self._get_additional_and_wb_apps())
+        return apps