nautobot 2.0.0a2__py3-none-any.whl → 2.0.0b1__py3-none-any.whl

nautobot/core/utils/data.py

@@ -2,6 +2,7 @@ from collections import OrderedDict, namedtuple
 from decimal import Decimal
 import uuid
 
+from django.core import validators
 from django.template import engines
 
 from nautobot.dcim import choices  # TODO move dcim.choices.CableLengthUnitChoices into core
@@ -66,6 +67,22 @@ def is_uuid(value):
     return False
 
 
+def is_url(value):
+    """
+    Validate whether a value is a URL.
+
+    Args:
+        value (str): String to validate.
+
+    Returns:
+        bool
+    """
+    try:
+        return validators.URLValidator()(value) is None
+    except validators.ValidationError:
+        return False
+
+
 def render_jinja2(template_code, context):
     """
     Render a Jinja2 template with the provided context. Return the rendered content.

nautobot/core/utils/deprecation.py

@@ -1,7 +1,6 @@
 """Utilities for handling deprecation of code and features."""
 
 import logging
-import sys
 import traceback
 import warnings
 
@@ -10,8 +9,8 @@ from nautobot.core.settings import LOG_DEPRECATION_WARNINGS
 logger = logging.getLogger(__name__)
 
 
-def class_deprecated_in_favor_of(replacement_class):
-    """Decorator to mark a class as deprecated and suggest a replacement class if it is subclassed from."""
+def class_deprecated(message):
+    """Decorator to mark a class as deprecated with a custom message about what to do instead of subclassing it."""
 
     def decorate(cls):
         def init_subclass(new_subclass):
@@ -25,30 +24,24 @@ def class_deprecated_in_favor_of(replacement_class):
                 stacklevel = 1
             warnings.warn(
                 f"Class {cls.__name__} is deprecated, and will be removed in a future Nautobot release. "
-                f"Instead of deriving {new_subclass.__name__} from {cls.__name__}, "
-                f"please migrate your code to inherit from class {replacement_class.__name__} instead.",
+                f"Instead of deriving {new_subclass.__name__} from {cls.__name__}, {message}.",
                 DeprecationWarning,
                 stacklevel=stacklevel,
             )
             if LOG_DEPRECATION_WARNINGS:
                 # Since DeprecationWarnings are silenced by default, also log a traditional warning.
-                # Note: logger.warning() only supports a `stacklevel` parameter in Python 3.8 and later
-                if sys.version_info >= (3, 8):
-                    logger.warning(
-                        f"Class {cls.__name__} is deprecated, and will be removed in a future Nautobot release. "
-                        f"Instead of deriving {new_subclass.__name__} from {cls.__name__}, "
-                        f"please migrate your code to inherit from class {replacement_class.__name__} instead.",
-                        stacklevel=stacklevel,
-                    )
-                else:
-                    # TODO: remove this case when we drop Python 3.7 support
-                    logger.warning(
-                        f"Class {cls.__name__} is deprecated, and will be removed in a future Nautobot release. "
-                        f"Instead of deriving {new_subclass.__name__} from {cls.__name__}, "
-                        f"please migrate your code to inherit from class {replacement_class.__name__} instead.",
-                    )
+                logger.warning(
+                    f"Class {cls.__name__} is deprecated, and will be removed in a future Nautobot release. "
+                    f"Instead of deriving {new_subclass.__name__} from {cls.__name__}, {message}.",
+                    stacklevel=stacklevel,
+                )
 
         cls.__init_subclass__ = classmethod(init_subclass)
         return cls
 
     return decorate
+
+
+def class_deprecated_in_favor_of(replacement_class):
+    """Decorator to mark a class as deprecated and suggest a replacement class if it is subclassed from."""
+    return class_deprecated(f"please migrate your code to inherit from class {replacement_class.__name__} instead")

nautobot/core/utils/filtering.py

@@ -64,18 +64,25 @@ def get_all_lookup_expr_for_field(model, field_name):
                     "name": build_lookup_label(name, field.lookup_expr),
                 }
             )
+        elif name == field_name and not name.startswith("has_"):
+            lookup_expr_choices.append(
+                {
+                    "id": name,
+                    "name": "exact",
+                }
+            )
 
     return lookup_expr_choices
 
 
-def get_filterset_field(filterset_class, field_name):
-    field = filterset_class().filters.get(field_name)
+def get_filterset_field(filterset, field_name):
+    field = filterset.filters.get(field_name)
     if field is None:
-        raise exceptions.FilterSetFieldNotFound(f"{field_name} is not a valid {filterset_class.__name__} field")
+        raise exceptions.FilterSetFieldNotFound(f"{field_name} is not a valid {type(filterset).__name__} field")
     return field
 
 
-def get_filterset_parameter_form_field(model, parameter):
+def get_filterset_parameter_form_field(model, parameter, filterset=None):
     """
     Return the relevant form field instance for a filterset parameter e.g DynamicModelMultipleChoiceField, forms.IntegerField e.t.c
     """
@@ -92,8 +99,9 @@ def get_filterset_parameter_form_field(model, parameter):
     )
     from nautobot.virtualization.models import VirtualMachine
 
-    filterset_class = get_filterset_for_model(model)
-    field = get_filterset_field(filterset_class, parameter)
+    if filterset is None or filterset.Meta.model != model:
+        filterset = get_filterset_for_model(model)()
+    field = get_filterset_field(filterset, parameter)
     form_field = field.field
 
     # TODO(Culver): We are having to replace some widgets here because multivalue_field_factory that generates these isn't smart enough
@@ -115,8 +123,13 @@ def get_filterset_parameter_form_field(model, parameter):
             form_attr["query_params"] = {"content_types": model._meta.label_lower}
 
         form_field = DynamicModelMultipleChoiceField(**form_attr)
-    elif isinstance(field, ContentTypeMultipleChoiceFilter):
-        plural_name = model._meta.verbose_name_plural
+    elif isinstance(
+        field, ContentTypeMultipleChoiceFilter
+    ):  # While there are other objects using `ContentTypeMultipleChoiceFilter`, the case where
+        # models that have sucha  filter and the `verbose_name_plural` has multiple words is ony one: "dynamic groups".
+        from nautobot.core.models.fields import slugify_dashes_to_underscores  # Avoid circular import
+
+        plural_name = slugify_dashes_to_underscores(model._meta.verbose_name_plural)
         try:
             form_field = MultipleContentTypeField(choices_as_strings=True, feature=plural_name)
         except KeyError:
@@ -125,7 +138,7 @@ def get_filterset_parameter_form_field(model, parameter):
             # In this case use queryset
             queryset_map = {
                 "tags": TaggableClassesQuery,
-                "job hooks": ChangeLoggedModelsQuery,
+                "job_hooks": ChangeLoggedModelsQuery,
                 "roles": RoleModelsQuery,
             }
             form_field = MultipleContentTypeField(
@@ -145,3 +158,34 @@ def get_filterset_parameter_form_field(model, parameter):
     css_classes = form_field.widget.attrs.get("class", "")
     form_field.widget.attrs["class"] = "form-control " + css_classes
     return form_field
+
+
+def get_filter_field_label(filter_field):
+    """
+    Return a label for a given field name and value.
+
+    Args:
+        field (Filter): The filter to get a label for
+
+    Returns:
+        (str): The label for the given field
+    """
+
+    if filter_field.label:
+        return filter_field.label
+    elif hasattr(filter_field, "relationship"):
+        return filter_field.relationship.get_label(side=filter_field.side)
+    elif hasattr(filter_field, "custom_field"):
+        return filter_field.custom_field.label
+    else:
+        return _field_name_to_display(filter_field.field_name)
+
+
+def _field_name_to_display(field_name):
+    """
+    Return a more human readable version of a field name.
+    """
+    field_name = field_name.replace("_custom_field_data__", "")
+    split_field = field_name.split("__") if "__" in field_name else field_name.split("_")
+    words = " ".join(split_field)
+    return words[0].upper() + words[1:]

nautobot/core/utils/git.py

@@ -69,17 +69,25 @@ class GitRepo:
         if url not in self.repo.remotes.origin.urls:
             self.repo.remotes.origin.set_url(url)
 
+    @property
+    def head(self):
+        """Current checked out repository head commit."""
+        return self.repo.head.commit.hexsha
+
     def fetch(self):
         self.repo.remotes.origin.fetch()
 
     def checkout(self, branch, commit_hexsha=None):
         """
         Check out the given branch, and optionally the specified commit within that branch.
+
+        Returns:
+            (str, bool): commit_hexsha the repo contains now, whether any change occurred
         """
         # Short-circuit logic - do we already have this commit checked out?
-        if commit_hexsha and commit_hexsha == self.repo.head.commit.hexsha:
+        if commit_hexsha and commit_hexsha == self.head:
             logger.debug(f"Commit {commit_hexsha} is already checked out.")
-            return commit_hexsha
+            return (commit_hexsha, False)
 
         self.fetch()
         if commit_hexsha:
@@ -92,7 +100,7 @@ class GitRepo:
                 raise RuntimeError(f"Requested to check out commit `{commit_hexsha}`, but it's not in branch {branch}!")
             logger.info(f"Checking out commit `{commit_hexsha}` on branch `{branch}`...")
             self.repo.git.checkout(commit_hexsha)
-            return commit_hexsha
+            return (commit_hexsha, True)
 
         if branch in self.repo.heads:
             branch_head = self.repo.heads[branch]
@@ -117,7 +125,7 @@ class GitRepo:
         self.repo.head.reset(f"origin/{branch}", index=True, working_tree=True)
         commit_hexsha = self.repo.head.reference.commit.hexsha
         logger.info(f"Latest commit on branch `{branch}` is `{commit_hexsha}`")
-        return commit_hexsha
+        return (commit_hexsha, True)
 
     def diff_remote(self, branch):
         logger.debug("Fetching from remote.")

nautobot/core/utils/lookup.py

@@ -85,7 +85,9 @@ def get_route_for_model(model, action, api=False):
     else:
         app_label = model._meta.app_label
     prefix = f"{app_label}{suffix}:{model._meta.model_name}"
-    sep = "_" if not api else "-"
+    sep = ""
+    if action != "":
+        sep = "_" if not api else "-"
     viewname = f"{prefix}{sep}{action}"
 
     if model._meta.app_label in settings.PLUGINS:

nautobot/core/utils/requests.py

@@ -1,119 +1,16 @@
-import copy
 import re
 
 from django import forms
-from django.contrib.auth import get_user_model
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ValidationError
 from django.http import QueryDict
-from django.utils.functional import SimpleLazyObject
 import django_filters
 
-from nautobot.core import constants, exceptions
+from nautobot.core import exceptions
 from nautobot.core.utils.filtering import get_filterset_field
 
 
-#
-# Fake request object
-#
-
-
-class NautobotFakeRequest:
-    """
-    A fake request object which is explicitly defined at the module level so it is able to be pickled. It simply
-    takes what is passed to it as kwargs on init and sets them as instance variables.
-    """
-
-    def __init__(self, _dict):
-        self.__dict__ = _dict
-
-    def _get_user(self):
-        """Lazy lookup function for self.user."""
-        if not self._cached_user:
-            User = get_user_model()
-            self._cached_user = User.objects.get(pk=self._user_pk)
-        return self._cached_user
-
-    def _init_user(self):
-        """Set up self.user as a lazy attribute, similar to a real Django Request object."""
-        self._cached_user = None
-        self.user = SimpleLazyObject(self._get_user)
-
-    def nautobot_serialize(self):
-        """
-        Serialize a JSON representation that is safe to pass to Celery.
-
-        This function is called from nautobot.core.celery.NautobotKombuJSONEncoder.
-        """
-        data = copy.deepcopy(self.__dict__)
-        # We don't want to try to pickle/unpickle or serialize/deserialize the actual User object,
-        # but make sure we do store its PK so that we can look it up on-demand after being deserialized.
-        user = data.pop("user")
-        data.pop("_cached_user", None)
-        if "_user_pk" not in data:
-            # We have a user but haven't stored its PK yet, so look it up and store it
-            data["_user_pk"] = user.pk
-        return data
-
-    @classmethod
-    def nautobot_deserialize(cls, data):
-        """
-        Deserialize a JSON representation that is safe to pass to Celery and return a NautobotFakeRequest instance.
-
-        This function is registered for usage by Celery in nautobot/core/celery/__init__.py
-        """
-        obj = cls(data)
-        obj._init_user()
-        return obj
-
-    def __getstate__(self):
-        """
-        Implement `pickle` serialization API.
-
-        It turns out that Celery uses pickle internally in apply_async()/send_job() even if we have configured Celery
-        to use JSON for all I/O (and we do, see settings.py), so we need to support pickle and JSON both.
-        """
-        return self.nautobot_serialize()
-
-    def __setstate__(self, state):
-        """
-        Implement `pickle` deserialization API.
-
-        It turns out that Celery uses pickle internally in apply_async()/send_job() even if we have configured Celery
-        to use JSON for all I/O (and we do, see settings.py), so we need to support pickle and JSON both.
-        """
-        # Generic __setstate__ behavior
-        self.__dict__.update(state)
-        # Set up lazy `self.user` attribute based on `state["_user_pk"]`
-        self._init_user()
-
-
-def copy_safe_request(request):
-    """
-    Copy selected attributes from a request object into a new fake request object. This is needed in places where
-    thread safe pickling of the useful request data is needed.
-
-    Note that `request.FILES` is explicitly omitted because they cannot be uniformly serialized.
-    """
-    meta = {
-        k: request.META[k]
-        for k in constants.HTTP_REQUEST_META_SAFE_COPY
-        if k in request.META and isinstance(request.META[k], str)
-    }
-
-    return NautobotFakeRequest(
-        {
-            "META": meta,
-            "POST": request.POST,
-            "GET": request.GET,
-            "user": request.user,
-            "path": request.path,
-            "id": getattr(request, "id", None),  # UUID assigned by middleware
-        }
-    )
-
-
-def convert_querydict_to_factory_formset_acceptable_querydict(request_querydict, filterset_class):
+def convert_querydict_to_factory_formset_acceptable_querydict(request_querydict, filterset):
     """
     Convert request QueryDict/GET into an acceptable factory formset QueryDict
     while discarding `querydict` params which are not part of `filterset_class` params
@@ -138,7 +35,7 @@ def convert_querydict_to_factory_formset_acceptable_querydict(request_querydict,
         ... }
     """
     query_dict = QueryDict(mutable=True)
-    filterset_class_fields = filterset_class().filters.keys()
+    filterset_class_fields = filterset.filters.keys()
 
     query_dict.setdefault("form-INITIAL_FORMS", 0)
     query_dict.setdefault("form-MIN_NUM_FORMS", 0)
@@ -151,15 +48,25 @@ def convert_querydict_to_factory_formset_acceptable_querydict(request_querydict,
     num = 0
     request_querydict = request_querydict.copy()
     request_querydict.pop("q", None)
-    for lookup_type, value in request_querydict.items():
+    for filter_field_name, value in request_querydict.items():
         # Discard fields without values
         if value:
-            if lookup_type in filterset_class_fields:
-                lookup_field = re.sub(r"__\w+", "", lookup_type)
-                lookup_value = request_querydict.getlist(lookup_type)
+            if filter_field_name in filterset_class_fields:
+                if hasattr(filterset.filters[filter_field_name], "relationship"):
+                    lookup_field = filter_field_name
+                else:
+                    # convert_querydict_to_factory_formset_acceptable_querydict expects to have a QueryDict as input
+                    # which means we may not have the exact field name as defined in the filterset class
+                    # it may contain a lookup expression (e.g. `name__ic`), so we need to strip it
+                    # this is so we can select the correct field in the formset for the "field" column
+                    # TODO: Since we likely need to instantiate the filterset class early in the request anyway
+                    # the filterset can handle the QueryDict conversion and we can just pass the QueryDict to the filterset
+                    # then use the FilterSet to de-dupe the field names
+                    lookup_field = re.sub(r"__\w+", "", filter_field_name)
+                lookup_value = request_querydict.getlist(filter_field_name)
 
                 query_dict.setlistdefault(lookup_field_placeholder % num, [lookup_field])
-                query_dict.setlistdefault(lookup_type_placeholder % num, [lookup_type])
+                query_dict.setlistdefault(lookup_type_placeholder % num, [filter_field_name])
                 query_dict.setlistdefault(lookup_value_placeholder % num, lookup_value)
                 num += 1
 
@@ -188,13 +95,13 @@ def ensure_content_type_and_field_name_in_query_params(query_params):
     return field_name, model
 
 
-def is_single_choice_field(filterset_class, field_name):
+def is_single_choice_field(filterset, field_name):
     # Some filter parameters do not accept multiple values, e.g DateTime, Boolean, Int fields and the q field, etc.
-    field = get_filterset_field(filterset_class, field_name)
+    field = get_filterset_field(filterset, field_name)
     return not isinstance(field, django_filters.MultipleChoiceFilter)
 
 
-def get_filterable_params_from_filter_params(filter_params, non_filter_params, filterset_class):
+def get_filterable_params_from_filter_params(filter_params, non_filter_params, filterset):
     """
     Remove any `non_filter_params` and fields that are not a part of the filterset from  `filter_params`
     to return only queryset filterable parameters.
@@ -202,7 +109,7 @@ def get_filterable_params_from_filter_params(filter_params, non_filter_params, f
     Args:
         filter_params(QueryDict): Filter param querydict
         non_filter_params(list): Non queryset filterable params
-        filterset_class: The FilterSet class
+        filterset: The FilterSet class
     """
     for non_filter_param in non_filter_params:
         filter_params.pop(non_filter_param, None)
@@ -216,7 +123,7 @@ def get_filterable_params_from_filter_params(filter_params, non_filter_params, f
             # If an exception is thrown, instead of throwing an exception, set `_is_single_choice_field` to 'False'
             # because the fields that were not discovered are still necessary.
             try:
-                _is_single_choice_field = is_single_choice_field(filterset_class, field)
+                _is_single_choice_field = is_single_choice_field(filterset, field)
             except exceptions.FilterSetFieldNotFound:
                 _is_single_choice_field = False
 

nautobot/core/views/__init__.py

@@ -34,6 +34,7 @@ from nautobot.extras.forms import GraphQLQueryForm
 
 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.
@@ -111,7 +112,6 @@ class HomeView(AccessMixin, TemplateView):
 
 class SearchView(View):
     def get(self, request):
-
         # No query
         if "q" not in request.GET:
             return render(
@@ -126,7 +126,6 @@ class SearchView(View):
         results = []
 
         if form.is_valid():
-
             # Build the list of (app_label, modelname) tuples, representing all models included in the global search,
             # based on the `app_config.searchable_models` list (if any) defined by each app
             searchable_models = []