django-unfold 0.46.0__py3-none-any.whl → 0.48.0__py3-none-any.whl

unfold/sites.py

@@ -1,5 +1,6 @@
+import copy
 from http import HTTPStatus
-from typing import Any, Callable, Dict, List, Optional, Union
+from typing import Any, Callable, Optional, Union
 from urllib.parse import parse_qs, urlparse
 
 from django.contrib.admin import AdminSite
@@ -13,6 +14,8 @@ from django.utils.functional import lazy
 from django.utils.module_loading import import_string
 from django.views.decorators.cache import never_cache
 
+from unfold.dataclasses import DropdownItem, Favicon
+
 try:
     from django.contrib.auth.decorators import login_not_required
 except ImportError:
@@ -21,7 +24,6 @@ except ImportError:
         return func
 
 
-from .dataclasses import Favicon
 from .settings import get_config
 from .utils import hex_to_rgb
 from .widgets import CHECKBOX_CLASSES, INPUT_CLASSES
@@ -39,16 +41,7 @@ class UnfoldAdminSite(AdminSite):
         if self.login_form is None:
             self.login_form = AuthenticationForm
 
-        if get_config(self.settings_name)["SITE_TITLE"]:
-            self.site_title = get_config(self.settings_name)["SITE_TITLE"]
-
-        if get_config(self.settings_name)["SITE_HEADER"]:
-            self.site_header = get_config(self.settings_name)["SITE_HEADER"]
-
-        if get_config(self.settings_name)["SITE_URL"]:
-            self.site_url = get_config(self.settings_name)["SITE_URL"]
-
-    def get_urls(self) -> List[URLPattern]:
+    def get_urls(self) -> list[URLPattern]:
         extra_urls = []
 
         if hasattr(self, "extra_urls") and callable(self.extra_urls):
@@ -69,69 +62,47 @@ class UnfoldAdminSite(AdminSite):
 
         return urlpatterns
 
-    def each_context(self, request: HttpRequest) -> Dict[str, Any]:
+    def each_context(self, request: HttpRequest) -> dict[str, Any]:
         context = super().each_context(request)
 
-        context.update(
-            {
-                "form_classes": {
-                    "text_input": INPUT_CLASSES,
-                    "checkbox": CHECKBOX_CLASSES,
-                },
-                "site_logo": self._get_mode_images(
-                    get_config(self.settings_name)["SITE_LOGO"], request
-                ),
-                "site_icon": self._get_mode_images(
-                    get_config(self.settings_name)["SITE_ICON"], request
-                ),
-                "site_symbol": self._get_value(
-                    get_config(self.settings_name)["SITE_SYMBOL"], request
-                ),
-                "site_favicons": self._process_favicons(
-                    request, get_config(self.settings_name)["SITE_FAVICONS"]
-                ),
-                "show_history": get_config(self.settings_name)["SHOW_HISTORY"],
-                "show_view_on_site": get_config(self.settings_name)[
-                    "SHOW_VIEW_ON_SITE"
-                ],
-                "show_languages": get_config(self.settings_name)["SHOW_LANGUAGES"],
-                "show_back_button": get_config(self.settings_name)["SHOW_BACK_BUTTON"],
-                "colors": self._process_colors(
-                    get_config(self.settings_name)["COLORS"]
-                ),
-                "border_radius": get_config(self.settings_name).get(
-                    "BORDER_RADIUS", "6px"
-                ),
-                "tab_list": self.get_tabs_list(request),
-                "styles": [
-                    self._get_value(style, request)
-                    for style in get_config(self.settings_name)["STYLES"]
-                ],
-                "theme": get_config(self.settings_name).get("THEME"),
-                "scripts": [
-                    self._get_value(script, request)
-                    for script in get_config(self.settings_name)["SCRIPTS"]
-                ],
-                "sidebar_show_all_applications": get_config(self.settings_name)[
-                    "SIDEBAR"
-                ].get("show_all_applications"),
-                "sidebar_show_search": get_config(self.settings_name)["SIDEBAR"].get(
-                    "show_search"
-                ),
-                "sidebar_navigation": self.get_sidebar_list(request)
-                if self.has_permission(request)
-                else [],
-            }
-        )
-
-        environment = get_config(self.settings_name)["ENVIRONMENT"]
+        sidebar_config = self._get_config("SIDEBAR", request)
+        data = {
+            "form_classes": {
+                "text_input": INPUT_CLASSES,
+                "checkbox": CHECKBOX_CLASSES,
+            },
+            "site_title": self._get_config("SITE_TITLE", request),
+            "site_header": self._get_config("SITE_HEADER", request),
+            "site_subheader": self._get_config("SITE_SUBHEADER", request),
+            "site_dropdown": self._get_site_dropdown_items("SITE_DROPDOWN", request),
+            "site_url": self._get_config("SITE_URL", request),
+            "site_logo": self._get_theme_images("SITE_LOGO", request),
+            "site_icon": self._get_theme_images("SITE_ICON", request),
+            "site_symbol": self._get_config("SITE_SYMBOL", request),
+            "site_favicons": self._get_favicons("SITE_FAVICONS", request),
+            "show_history": self._get_config("SHOW_HISTORY", request),
+            "show_view_on_site": self._get_config("SHOW_VIEW_ON_SITE", request),
+            "show_languages": self._get_config("SHOW_LANGUAGES", request),
+            "show_back_button": self._get_config("SHOW_BACK_BUTTON", request),
+            "theme": self._get_config("THEME", request),
+            "border_radius": self._get_config("BORDER_RADIUS", request),
+            "colors": self._get_colors("COLORS", request),
+            "environment": self._get_config("ENVIRONMENT", request),
+            "tab_list": self.get_tabs_list(request),
+            "styles": self._get_list("STYLES", request),
+            "scripts": self._get_list("SCRIPTS", request),
+            "sidebar_show_all_applications": self._get_value(
+                sidebar_config.get("show_all_applications"), request
+            ),
+            "sidebar_show_search": self._get_value(
+                sidebar_config.get("show_search"), request
+            ),
+            "sidebar_navigation": self.get_sidebar_list(request)
+            if self.has_permission(request)
+            else [],
+        }
 
-        if environment and isinstance(environment, str):
-            try:
-                callback = import_string(environment)
-                context.update({"environment": callback(request)})
-            except ImportError:
-                pass
+        context.update(data)
 
         if hasattr(self, "extra_context") and callable(self.extra_context):
             return self.extra_context(context, request)
@@ -139,7 +110,7 @@ class UnfoldAdminSite(AdminSite):
         return context
 
     def index(
-        self, request: HttpRequest, extra_context: Optional[Dict[str, Any]] = None
+        self, request: HttpRequest, extra_context: Optional[dict[str, Any]] = None
     ) -> TemplateResponse:
         app_list = self.get_app_list(request)
 
@@ -164,7 +135,7 @@ class UnfoldAdminSite(AdminSite):
         )
 
     def toggle_sidebar(
-        self, request: HttpRequest, extra_context: Optional[Dict[str, Any]] = None
+        self, request: HttpRequest, extra_context: Optional[dict[str, Any]] = None
     ) -> HttpResponse:
         if "toggle_sidebar" not in request.session:
             request.session["toggle_sidebar"] = True
@@ -174,7 +145,7 @@ class UnfoldAdminSite(AdminSite):
         return HttpResponse(status=HTTPStatus.OK)
 
     def search(
-        self, request: HttpRequest, extra_context: Optional[Dict[str, Any]] = None
+        self, request: HttpRequest, extra_context: Optional[dict[str, Any]] = None
     ) -> TemplateResponse:
         query = request.GET.get("s").lower()
         app_list = super().get_app_list(request)
@@ -209,7 +180,7 @@ class UnfoldAdminSite(AdminSite):
     @method_decorator(never_cache)
     @login_not_required
     def login(
-        self, request: HttpRequest, extra_context: Optional[Dict[str, Any]] = None
+        self, request: HttpRequest, extra_context: Optional[dict[str, Any]] = None
     ) -> HttpResponse:
         extra_context = {} if extra_context is None else extra_context
         image = self._get_value(
@@ -233,7 +204,7 @@ class UnfoldAdminSite(AdminSite):
         return super().login(request, extra_context)
 
     def password_change(
-        self, request: HttpRequest, extra_context: Optional[Dict[str, Any]] = None
+        self, request: HttpRequest, extra_context: Optional[dict[str, Any]] = None
     ) -> HttpResponse:
         from django.contrib.auth.views import PasswordChangeView
 
@@ -250,9 +221,11 @@ class UnfoldAdminSite(AdminSite):
         request.current_app = self.name
         return PasswordChangeView.as_view(**defaults)(request)
 
-    def get_sidebar_list(self, request: HttpRequest) -> List[Dict[str, Any]]:
-        navigation = get_config(self.settings_name)["SIDEBAR"].get("navigation", [])
-        tabs = get_config(self.settings_name)["TABS"]
+    def get_sidebar_list(self, request: HttpRequest) -> list[dict[str, Any]]:
+        navigation = self._get_value(
+            self._get_config("SIDEBAR", request).get("navigation"), request
+        )
+        tabs = self._get_value(self._get_config("TABS", request), request) or []
         results = []
 
         for group in navigation:
@@ -307,8 +280,11 @@ class UnfoldAdminSite(AdminSite):
 
         return results
 
-    def get_tabs_list(self, request: HttpRequest) -> List[Dict[str, Any]]:
-        tabs = get_config(self.settings_name)["TABS"]
+    def get_tabs_list(self, request: HttpRequest) -> list[dict[str, Any]]:
+        tabs = copy.deepcopy(self._get_config("TABS", request))
+
+        if not tabs:
+            return []
 
         for tab in tabs:
             allowed_items = []
@@ -321,29 +297,19 @@ class UnfoldAdminSite(AdminSite):
                 if isinstance(item["link"], Callable):
                     item["link_callback"] = lazy(item["link"])(request)
 
-                item["active"] = self._get_is_active(
-                    request, item.get("link_callback") or item["link"], True
-                )
+                if "active" not in item:
+                    item["active"] = self._get_is_active(
+                        request, item.get("link_callback") or item["link"], True
+                    )
+                else:
+                    item["active"] = self._get_value(item["active"], request)
+
                 allowed_items.append(item)
 
             tab["items"] = allowed_items
 
         return tabs
 
-    def _get_mode_images(
-        self, images: Union[Dict[str, callable], callable, str], request: HttpRequest
-    ) -> Union[Dict[str, str], str, None]:
-        if isinstance(images, dict):
-            if "light" in images and "dark" in images:
-                return {
-                    "light": self._get_value(images["light"], request),
-                    "dark": self._get_value(images["dark"], request),
-                }
-
-            return None
-
-        return self._get_value(images, request)
-
     def _call_permission_callback(
         self, callback: Union[str, Callable, None], request: HttpRequest
     ) -> bool:
@@ -363,21 +329,7 @@ class UnfoldAdminSite(AdminSite):
 
         return False
 
-    def _get_value(
-        self, instance: Union[str, Callable, None], *args: Any
-    ) -> Optional[str]:
-        if instance is None:
-            return None
-
-        if isinstance(instance, str):
-            return instance
-
-        if isinstance(instance, Callable):
-            return instance(*args)
-
-        return None
-
-    def _replace_values(self, target: Dict, source: Dict, request: HttpRequest):
+    def _replace_values(self, target: dict, source: dict, request: HttpRequest):
         for key in source.keys():
             if source[key] is not None and callable(source[key]):
                 target[key] = source[key](request)
@@ -386,31 +338,6 @@ class UnfoldAdminSite(AdminSite):
 
         return target
 
-    def _process_favicons(
-        self, request: HttpRequest, favicons: List[Dict]
-    ) -> List[Favicon]:
-        return [
-            Favicon(
-                href=self._get_value(item["href"], request),
-                rel=item.get("rel"),
-                sizes=item.get("sizes"),
-                type=item.get("type"),
-            )
-            for item in favicons
-        ]
-
-    def _process_colors(
-        self, colors: Dict[str, Dict[str, str]]
-    ) -> Dict[str, Dict[str, str]]:
-        for name, weights in colors.items():
-            for weight, value in weights.items():
-                if value[0] != "#":
-                    continue
-
-                colors[name][weight] = " ".join(str(item) for item in hex_to_rgb(value))
-
-        return colors
-
     def _get_is_active(
         self, request: HttpRequest, link: str, is_tab: bool = False
     ) -> bool:
@@ -424,7 +351,7 @@ class UnfoldAdminSite(AdminSite):
         if link_path == request.path == index_path:
             return True
 
-        if link_path in request.path and link_path != index_path:
+        if link_path != "" and link_path in request.path and link_path != index_path:
             query_params = parse_qs(urlparse(link).query)
             request_params = parse_qs(request.GET.urlencode())
 
@@ -437,3 +364,112 @@ class UnfoldAdminSite(AdminSite):
             return True
 
         return False
+
+    def _get_config(self, key: str, *args) -> Any:
+        config = get_config(self.settings_name)
+
+        if key in config and config[key]:
+            return self._get_value(config[key], *args)
+
+    def _get_theme_images(
+        self, key: str, *args: Any
+    ) -> Union[dict[str, str], str, None]:
+        images = self._get_config(key, *args)
+
+        if isinstance(images, dict):
+            if "light" in images and "dark" in images:
+                return {
+                    "light": self._get_value(images["light"], *args),
+                    "dark": self._get_value(images["dark"], *args),
+                }
+
+            return None
+
+        return images
+
+    def _get_colors(self, key: str, *args) -> dict[str, dict[str, str]]:
+        colors = self._get_config(key, *args)
+
+        def rgb_to_values(value: str) -> str:
+            return " ".join(
+                list(
+                    map(
+                        str.strip,
+                        value.removeprefix("rgb(").removesuffix(")").split(","),
+                    )
+                )
+            )
+
+        def hex_to_values(value: str) -> str:
+            return " ".join(str(item) for item in hex_to_rgb(value))
+
+        for name, weights in colors.items():
+            weights = self._get_value(weights, *args)
+            colors[name] = weights
+
+            for weight, value in weights.items():
+                if value[0] == "#":
+                    colors[name][weight] = hex_to_values(value)
+                elif value.startswith("rgb"):
+                    colors[name][weight] = rgb_to_values(value)
+
+        return colors
+
+    def _get_list(self, key: str, *args) -> list[Any]:
+        items = get_config(self.settings_name)[key]
+
+        if isinstance(items, list):
+            return [self._get_value(item, *args) for item in items]
+
+        return []
+
+    def _get_favicons(self, key: str, *args) -> list[Favicon]:
+        favicons = self._get_config(key, *args)
+
+        if not favicons:
+            return []
+
+        return [
+            Favicon(
+                href=self._get_value(item["href"], *args),
+                rel=item.get("rel"),
+                sizes=item.get("sizes"),
+                type=item.get("type"),
+            )
+            for item in favicons
+        ]
+
+    def _get_site_dropdown_items(self, key: str, *args) -> list[dict[str, Any]]:
+        items = self._get_config(key, *args)
+
+        if not items:
+            return []
+
+        return [
+            DropdownItem(
+                title=item.get("title"),
+                link=self._get_value(item["link"], *args),
+                icon=item.get("icon"),
+            )
+            for item in items
+        ]
+
+    def _get_value(
+        self, value: Union[str, Callable, lazy, None], *args: Any
+    ) -> Optional[str]:
+        if value is None:
+            return None
+
+        if isinstance(value, str):
+            try:
+                callback = import_string(value)
+                return callback(*args)
+            except ImportError:
+                pass
+
+            return value
+
+        if isinstance(value, Callable):
+            return value(*args)
+
+        return value