nautobot 2.3.15b1__py3-none-any.whl → 2.4.0__py3-none-any.whl

nautobot/core/ui/utils.py

@@ -0,0 +1,36 @@
+from django.template import Context
+from django.template.loader import get_template
+
+
+def flatten_context(context) -> dict:
+    """
+    If the given context is already a dict, return it unmodified; if it is a Context, flatten it to a dict.
+
+    This is working around a bug (not sure if in Django or in our code) where, if a `Context`'s `dicts` contain
+    a `RequestContext`, calling `Context.flatten()` throws an exception.
+    """
+    if isinstance(context, dict):
+        return context
+    flat = {}
+    for d in context.dicts:
+        if isinstance(d, dict):
+            flat.update(d)
+        else:
+            flat.update(flatten_context(d))
+    return flat
+
+
+def render_component_template(template_path: str, context: Context, **kwargs) -> str:
+    """
+    Render the template located at the given path with the given context, possibly augmented via additional kwargs.
+
+    Args:
+        template_path (str): Path to the template to render, for example `"components/tab/label_wrapper.html"`.
+        context (Context): Rendering context for the template
+        **kwargs (dict): Additional key/value pairs to extend the context with for this specific template.
+
+    Examples:
+        >>> render_component_template(self.label_wrapper_template_path, context, tab_id=self.tab_id, label="Hello")
+    """
+    with context.update(kwargs):
+        return get_template(template_path).render(flatten_context(context))

nautobot/core/urls.py

@@ -1,14 +1,17 @@
 from django.conf import settings
+from django.http import HttpResponse, HttpResponseNotFound
 from django.urls import include, path
 from django.views.generic import TemplateView
 from django.views.static import serve
 
 from nautobot.core.views import (
+    AboutView,
     CustomGraphQLView,
     get_file_with_authorization,
     HomeView,
     NautobotMetricsView,
     NautobotMetricsViewAuth,
+    RenderJinjaView,
     SearchView,
     StaticMediaFailureView,
     ThemePreviewView,
@@ -26,6 +29,7 @@ from .admin import admin_site
 urlpatterns = [
     # Base views
     path("", HomeView.as_view(), name="home"),
+    path("about/", AboutView.as_view(), name="about"),
     path("search/", SearchView.as_view(), name="search"),
     # Login/logout
     path("login/", LoginView.as_view(), name="login"),
@@ -41,6 +45,7 @@ urlpatterns = [
     path("user/", include("nautobot.users.urls")),
     path("users/", include("nautobot.users.urls", "users")),
     path("virtualization/", include("nautobot.virtualization.urls")),
+    path("wireless/", include("nautobot.wireless.urls")),
     # API
     path("api/", include("nautobot.core.api.urls")),
     # GraphQL
@@ -68,10 +73,20 @@ urlpatterns = [
     ),
     # Celery worker status page
     path("worker-status/", WorkerStatusView.as_view(), name="worker_status"),
+    # Jinja template renderer tool
+    path("render-jinja-template/", RenderJinjaView.as_view(), name="render_jinja_template"),
     # Templated css file
     path(
         "template.css", TemplateView.as_view(template_name="template.css", content_type="text/css"), name="template_css"
     ),
+    # The response is conditional as opposed to wrapping the path() call in an if statement to be able to test the setting with current test setup
+    path(
+        "robots.txt",
+        lambda x: HttpResponse("User-Agent: *\nDisallow: /", content_type="text/plain")
+        if settings.PUBLISH_ROBOTS_TXT
+        else HttpResponseNotFound(),
+        name="robots_txt",
+    ),
 ]
 
 

nautobot/core/utils/config.py

@@ -1,12 +1,39 @@
 """Helper code for loading values that may be defined in settings.py/nautobot_config.py *or* in django-constance."""
 
+import contextlib
+import logging
+
 from constance import config
 from django.conf import settings
+from django.core.exceptions import ObjectDoesNotExist
+from django.db import OperationalError, ProgrammingError
+
+logger = logging.getLogger(__name__)
+
 
+def get_settings_or_config(variable_name, fallback=None):
+    """
+    Get a value from Django settings (if specified there) or Constance configuration (otherwise).
 
-def get_settings_or_config(variable_name):
-    """Get a value from Django settings (if specified there) or Constance configuration (otherwise)."""
+    The fallback value is returned *only* if the requested variable cannot be found at all - this is an error case,
+    and will generate warning logs.
+    """
     # Explicitly set in settings.py or nautobot_config.py takes precedence, for now
     if hasattr(settings, variable_name):
         return getattr(settings, variable_name)
-    return getattr(config, variable_name)
+    # django-constance 4.x removed some built-in error handling here, so we have to do it ourselves now
+    with contextlib.suppress(ObjectDoesNotExist, OperationalError, ProgrammingError):
+        return getattr(config, variable_name)
+    logger.warning(
+        'Configuration "%s" is not in settings, and could not read from the Constance database table '
+        "(perhaps not initialized yet?)",
+        variable_name,
+    )
+    if variable_name in settings.CONSTANCE_CONFIG:
+        default = settings.CONSTANCE_CONFIG[variable_name][0]
+        logger.warning('Using default value of "%s" from Constance configuration for "%s"', default, variable_name)
+        return default
+    logger.warning(
+        'Constance configuration does not include an entry for "%s" - must return %s', variable_name, fallback
+    )
+    return fallback

nautobot/core/utils/lookup.py

@@ -10,6 +10,7 @@ from django.contrib.contenttypes.models import ContentType
 from django.db.models import Model
 from django.urls import get_resolver, resolve, reverse, URLPattern, URLResolver
 from django.utils.module_loading import import_string
+from django.views.generic.base import RedirectView
 
 
 def get_changes_for_model(model):
@@ -315,7 +316,7 @@ def get_created_and_last_updated_usernames_for_model(instance):
     return created_by, last_updated_by
 
 
-def get_url_patterns(urlconf=None, patterns_list=None, base_path="/"):
+def get_url_patterns(urlconf=None, patterns_list=None, base_path="/", ignore_redirects=False):
     """
     Recursively yield a list of registered URL patterns.
 
@@ -326,6 +327,7 @@ def get_url_patterns(urlconf=None, patterns_list=None, base_path="/"):
             Default if unspecified is the `url_patterns` attribute of the given `urlconf` module.
         base_path (str): String to prepend to all URL patterns yielded.
             Default if unspecified is the string `"/"`.
+        ignore_redirects (bool): If True, skip URL patterns that correspond to RedirectViews.
 
     Yields:
         (str): Each URL pattern defined in the given urlconf and its descendants
@@ -384,10 +386,18 @@ def get_url_patterns(urlconf=None, patterns_list=None, base_path="/"):
 
     for item in patterns_list:
         if isinstance(item, URLPattern):
+            if (
+                ignore_redirects
+                and hasattr(item.callback, "view_class")
+                and issubclass(item.callback.view_class, RedirectView)
+            ):
+                continue
             yield base_path + str(item.pattern)
         elif isinstance(item, URLResolver):
             # Recurse!
-            yield from get_url_patterns(urlconf, item.url_patterns, base_path + str(item.pattern))
+            yield from get_url_patterns(
+                urlconf, item.url_patterns, base_path + str(item.pattern), ignore_redirects=ignore_redirects
+            )
 
 
 def get_url_for_url_pattern(url_pattern):

nautobot/core/utils/querysets.py

@@ -0,0 +1,64 @@
+import logging
+
+from django.db import NotSupportedError
+
+logger = logging.getLogger(__name__)
+
+
+def maybe_select_related(queryset, select_fields):
+    """Attempt to perform a select_related() on the given queryset, but fail gracefully if not permitted."""
+    model = queryset.model
+
+    # Django doesn't allow .select_related() on a QuerySet that had .values()/.values_list() applied, or
+    # one that has had union()/intersection()/difference() applied.
+    # We can detect and avoid these cases the same way that Django itself does.
+    if queryset._fields is not None:
+        logger.debug(
+            "NOT applying select_related(%s) to %s QuerySet as it includes .values()/.values_list()",
+            select_fields,
+            model.__name__,
+        )
+    elif queryset.query.combinator:
+        logger.debug(
+            "NOT applying select_related(%s) to %s QuerySet as it is a combinator query",
+            select_fields,
+            model.__name__,
+        )
+    else:
+        logger.debug("Applying .select_related(%s) to %s QuerySet", select_fields, model.__name__)
+        # Belt and suspenders - we should have avoided any error cases above, but be safe anyway:
+        try:
+            queryset = queryset.select_related(*select_fields)
+        except (TypeError, ValueError, NotSupportedError) as exc:
+            logger.warning(
+                "Unexpected error when trying to .select_related() on %s QuerySet: %s",
+                model.__name__,
+                exc,
+            )
+
+    return queryset
+
+
+def maybe_prefetch_related(queryset, prefetch_fields):
+    """Attempt to perform a select_related() on the given queryset, but fail gracefully if not permitted."""
+    model = queryset.model
+
+    if queryset.query.combinator:
+        logger.debug(
+            "NOT applying prefetch_related(%s) to %s QuerySet as it is a combinator query",
+            prefetch_fields,
+            model.__name__,
+        )
+    else:
+        logger.debug("Applying .prefetch_related(%s) to %s QuerySet", prefetch_fields, model.__name__)
+        # Belt and suspenders - we should have avoided any error cases above, but be safe anyway:
+        try:
+            queryset = queryset.prefetch_related(*prefetch_fields)
+        except (AttributeError, TypeError, ValueError, NotSupportedError) as exc:
+            logger.warning(
+                "Unexpected error when trying to .prefetch_related() on %s QuerySet: %s",
+                model.__name__,
+                exc,
+            )
+
+    return queryset

nautobot/core/utils/requests.py

@@ -141,22 +141,35 @@ def get_filterable_params_from_filter_params(filter_params, non_filter_params, f
     return final_filter_params
 
 
-def normalize_querydict(querydict, form_class=None):
+def normalize_querydict(querydict, form_class=None, filterset=None):
     """
-    Convert a QueryDict to a normal, mutable dictionary, preserving list values. For example,
+    Converts a QueryDict into a standard, mutable dictionary while preserving multiple values as lists.
 
-        QueryDict('foo=1&bar=2&bar=3&baz=')
+    Example:
+        A QueryDict like:
+            QueryDict('foo=1&bar=2&bar=3&baz=')
 
-    becomes:
+        Converts to:
+            {'foo': '1', 'bar': ['2', '3'], 'baz': ''}
 
-        {'foo': '1', 'bar': ['2', '3'], 'baz': ''}
+    This function ensures that fields with multiple values are handled correctly, as QueryDict
+    does not inherently preserve multiple values as lists.
 
-    This function is necessary because QueryDict does not provide any built-in mechanism which preserves multiple
-    values.
-
-    A `form_class` can be provided as a way to hint which query parameters should be treated as lists.
+    Args:
+        querydict (QueryDict): The QueryDict to be normalized.
+        form_class (forms.Form, optional): A form class to identify fields that should be treated as
+            lists (e.g., `MultipleChoiceField` or `ModelMultipleChoiceField`).
+        filterset (django_filters.FilterSet, optional): A FilterSet instance to identify filters that
+            should preserve multiple values as lists (e.g., non-single-choice fields).
+
+    Raises:
+        AttributeError: If both `form_class` and `filterset` are provided.
     """
+    if form_class and filterset:
+        raise AttributeError("Either form_class or filterset_class is to be provided not both")
+
     result = {}
+
     if querydict:
         for key, value_list in querydict.lists():
             if len(value_list) > 1:
@@ -171,6 +184,8 @@ def normalize_querydict(querydict, form_class=None):
             ):
                 # Even though there's only a single value in the querydict for this key, the form wants it as a list
                 result[key] = value_list
+            elif filterset is not None and filterset.filters.get(key) and not is_single_choice_field(filterset, key):
+                result[key] = value_list
             else:
                 # Only a single value in the querydict for this key, and no guidance otherwise, so make it single
                 result[key] = value_list[0]

nautobot/core/views/__init__.py

@@ -1,4 +1,5 @@
 import contextlib
+import datetime
 import logging
 import os
 import platform
@@ -45,6 +46,7 @@ from nautobot.core.celery import app
 from nautobot.core.constants import SEARCH_MAX_RESULTS
 from nautobot.core.forms import SearchForm
 from nautobot.core.releases import get_latest_release
+from nautobot.core.utils.config import get_settings_or_config
 from nautobot.core.utils.lookup import get_route_for_model
 from nautobot.core.utils.permissions import get_permission_for_model
 from nautobot.extras.forms import GraphQLQueryForm
@@ -56,7 +58,6 @@ logger = logging.getLogger(__name__)
 
 class HomeView(AccessMixin, TemplateView):
     template_name = "home.html"
-    use_new_ui = True
 
     def render_additional_content(self, request, context, details):
         # Collect all custom data using callback functions.
@@ -479,3 +480,49 @@ def get_file_with_authorization(request, *args, **kwargs):
     get_object_or_404(queryset, file=request.GET.get("name"))
 
     return get_file(request, *args, **kwargs)
+
+
+class AboutView(AccessMixin, TemplateView):
+    """
+    Nautobot About View which displays general information about Nautobot and contact details
+    for Network to Code.
+    """
+
+    template_name = "about.html"
+
+    def get(self, request, *args, **kwargs):
+        # Redirect user to login page if not authenticated
+        if not request.user.is_authenticated:
+            return self.handle_no_permission()
+        # Check whether a new release is available. (Only for staff/superusers.)
+        new_release = None
+        if request.user.is_staff or request.user.is_superuser:
+            latest_release, release_url = get_latest_release()
+            if isinstance(latest_release, version.Version):
+                current_version = version.parse(settings.VERSION)
+                if latest_release > current_version:
+                    new_release = {
+                        "version": str(latest_release),
+                        "url": release_url,
+                    }
+
+        # Support contract state
+        support_expiration_date = get_settings_or_config("NTC_SUPPORT_CONTRACT_EXPIRATION_DATE")
+        support_contract_active = support_expiration_date and support_expiration_date >= datetime.date.today()
+
+        context = self.get_context_data()
+        context.update(
+            {
+                "new_release": new_release,
+                "support_contract_active": support_contract_active,
+                "support_expiration_date": support_expiration_date,
+            }
+        )
+
+        return self.render_to_response(context)
+
+
+class RenderJinjaView(LoginRequiredMixin, TemplateView):
+    """Render a Jinja template with context data."""
+
+    template_name = "utilities/render_jinja2.html"