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

nautobot/core/constants.py

@@ -6,49 +6,31 @@ SEARCH_MAX_RESULTS = 15
 
 SEARCH_MAX_RESULTS = 15
 
-FILTER_CHAR_BASED_LOOKUP_MAP = dict(
-    n="exact",
-    ic="icontains",
-    nic="icontains",
-    iew="iendswith",
-    niew="iendswith",
-    isw="istartswith",
-    nisw="istartswith",
-    ie="iexact",
-    nie="iexact",
-    re="regex",
-    nre="regex",
-    ire="iregex",
-    nire="iregex",
-)
-
-FILTER_NUMERIC_BASED_LOOKUP_MAP = dict(n="exact", lte="lte", lt="lt", gte="gte", gt="gt")
-
-FILTER_NEGATION_LOOKUP_MAP = dict(n="exact")
-
-
-#
-# HTTP Request META safe copy
-#
-
-HTTP_REQUEST_META_SAFE_COPY = [
-    "CONTENT_LENGTH",
-    "CONTENT_TYPE",
-    "HTTP_ACCEPT",
-    "HTTP_ACCEPT_ENCODING",
-    "HTTP_ACCEPT_LANGUAGE",
-    "HTTP_HOST",
-    "HTTP_REFERER",
-    "HTTP_USER_AGENT",
-    "QUERY_STRING",
-    "REMOTE_ADDR",
-    "REMOTE_HOST",
-    "REMOTE_USER",
-    "REQUEST_METHOD",
-    "SERVER_NAME",
-    "SERVER_PORT",
-]
-
+FILTER_CHAR_BASED_LOOKUP_MAP = {
+    "n": "exact",
+    "ic": "icontains",
+    "nic": "icontains",
+    "iew": "iendswith",
+    "niew": "iendswith",
+    "isw": "istartswith",
+    "nisw": "istartswith",
+    "ie": "iexact",
+    "nie": "iexact",
+    "re": "regex",
+    "nre": "regex",
+    "ire": "iregex",
+    "nire": "iregex",
+}
+
+FILTER_NUMERIC_BASED_LOOKUP_MAP = {
+    "n": "exact",
+    "lte": "lte",
+    "lt": "lt",
+    "gte": "gte",
+    "gt": "gt",
+}
+
+FILTER_NEGATION_LOOKUP_MAP = {"n": "exact"}
 
 #
 # Factory defaults

nautobot/core/context_processors.py

@@ -34,8 +34,20 @@ def settings(request):
     Expose Django settings in the template context. Example: {{ settings.DEBUG }}
     """
 
+    use_new_ui = request.COOKIES.get("newui", False)
+
+    try:
+        view_class = request.resolver_match.func.view_class
+        use_new_ui = use_new_ui and getattr(view_class, "use_new_ui", False)
+    except AttributeError:
+        # Use this method to import the view class views that inherits from
+        # NautobotUIViewSet, as this views do not have the 'view_class' attribute.
+        if hasattr(request, "accepted_renderer"):
+            use_new_ui = use_new_ui and getattr(request.accepted_renderer, "use_new_ui", False)
+
     return {
         "settings": django_settings,
+        "root_template": "base_react.html" if use_new_ui else "base_django.html",
     }
 
 

nautobot/core/filters.py

@@ -12,7 +12,6 @@ from django_filters.constants import EMPTY_VALUES
 from django_filters.utils import get_model_field, resolve_field
 from drf_spectacular.types import OpenApiTypes
 from drf_spectacular.utils import extend_schema_field
-from taggit.managers import TaggableManager
 
 from nautobot.core import constants, forms
 from nautobot.core.forms import widgets
@@ -557,7 +556,7 @@ class BaseFilterSet(django_filters.FilterSet):
             models.URLField: {"filter_class": MultiValueCharFilter},
             models.UUIDField: {"filter_class": MultiValueUUIDFilter},
             core_fields.MACAddressCharField: {"filter_class": MultiValueMACAddressFilter},
-            TaggableManager: {"filter_class": TagFilter},
+            core_fields.TagsField: {"filter_class": TagFilter},
         }
     )
 
@@ -763,4 +762,5 @@ class NameSlugSearchFilterSet(django_filters.FilterSet):
     A base class for adding the search method to models which only expose the `name` and `slug` fields
     """
 
+    # TODO Modify and rename this class after slugs are removed from all models.
     q = SearchFilter(filter_predicates={"name": "icontains", "slug": "icontains"})

nautobot/core/forms/__init__.py

@@ -52,10 +52,8 @@ from nautobot.core.forms.utils import (
     expand_ipaddress_pattern,
     form_from_model,
     parse_alphanumeric_range,
-    parse_csv,
     parse_numeric_range,
     restrict_form_fields,
-    validate_csv,
 )
 from nautobot.core.forms.widgets import (
     APISelect,
@@ -125,7 +123,6 @@ __all__ = (
     "NUMERIC_EXPANSION_PATTERN",
     "NumericArrayField",
     "parse_alphanumeric_range",
-    "parse_csv",
     "parse_numeric_range",
     "PrefixFieldMixin",
     "restrict_form_fields",
@@ -141,5 +138,4 @@ __all__ = (
     "TableConfigForm",
     "TagFilterField",
     "TimePicker",
-    "validate_csv",
 )

nautobot/core/forms/fields.py

@@ -1,5 +1,3 @@
-import csv
-from io import StringIO
 import json
 import re
 
@@ -50,21 +48,22 @@ __all__ = (
 
 class CSVDataField(django_forms.CharField):
     """
-    A CharField (rendered as a Textarea) which accepts CSV-formatted data. It returns data as a two-tuple: The first
-    item is a dictionary of column headers, mapping field names to the attribute by which they match a related object
-    (where applicable). The second item is a list of dictionaries, each representing a discrete row of CSV data.
+    A CharField (rendered as a Textarea) which expects CSV-formatted data.
 
-    :param from_form: The form from which the field derives its validation rules.
+    Initial value is a list of headers corresponding to the required fields for the given serializer class.
+
+    This no longer actually does any CSV parsing or validation on its own,
+    as that is now handled by the NautobotCSVParser class and the REST API serializers.
+
+    Args:
+        required_field_names: List of field names representing required fields for this import.
     """
 
     widget = django_forms.Textarea
 
-    def __init__(self, from_form, *args, **kwargs):
-
-        form = from_form()
-        self.model = form.Meta.model
-        self.fields = form.fields
-        self.required_fields = [name for name, field in form.fields.items() if field.required]
+    def __init__(self, *args, required_field_names="", **kwargs):
+        self.required_field_names = required_field_names
+        kwargs.setdefault("required", False)
 
         super().__init__(*args, **kwargs)
 
@@ -72,7 +71,7 @@ class CSVDataField(django_forms.CharField):
         if not self.label:
             self.label = ""
         if not self.initial:
-            self.initial = ",".join(self.required_fields) + "\n"
+            self.initial = ",".join(self.required_field_names) + "\n"
         if not self.help_text:
             self.help_text = (
                 "Enter the list of column headers followed by one line per record to be imported, using "
@@ -80,37 +79,17 @@ class CSVDataField(django_forms.CharField):
                 "in double quotes."
             )
 
-    def to_python(self, value):
-        if value is None:
-            return None
-        reader = csv.reader(StringIO(value.strip()))
-        return forms.parse_csv(reader)
-
-    def validate(self, value):
-        if value is None:
-            return None
-        headers, _records = value
-        forms.validate_csv(headers, self.fields, self.required_fields)
-
-        return value
-
 
 class CSVFileField(django_forms.FileField):
     """
-    A FileField (rendered as a ClearableFileInput) which accepts a file containing CSV-formatted data. It returns
-    data as a two-tuple: The first item is a dictionary of column headers, mapping field names to the attribute
-    by which they match a related object (where applicable). The second item is a list of dictionaries, each
-    representing a discrete row of CSV data.
+    A FileField (rendered as a ClearableFileInput) which expects a file containing CSV-formatted data.
 
-    :param from_form: The form from which the field derives its validation rules.
+    This no longer actually does any CSV parsing or validation on its own,
+    as that is now handled by the NautobotCSVParser class and the REST API serializers.
     """
 
-    def __init__(self, from_form, *args, **kwargs):
-
-        form = from_form()
-        self.model = form.Meta.model
-        self.fields = form.fields
-        self.required_fields = [name for name, field in form.fields.items() if field.required]
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("required", False)
 
         super().__init__(*args, **kwargs)
 
@@ -124,37 +103,19 @@ class CSVFileField(django_forms.FileField):
             )
 
     def to_python(self, file):
+        """For parity with CSVDataField, this returns the CSV text rather than an UploadedFile object."""
         if file is None:
             return None
 
         file = super().to_python(file)
-        csv_str = file.read().decode("utf-8-sig").strip()
-        # Check if there is only one column of input
-        # If so a delimiter cannot be determined and it will raise an exception.
-        # In that case we will use csv.excel class
-        # Which defines the usual properties of an Excel-generated CSV file.
-        try:
-            dialect = csv.Sniffer().sniff(csv_str, delimiters=",")
-        except csv.Error:
-            dialect = csv.excel
-        reader = csv.reader(csv_str.splitlines(), dialect)
-        headers, records = forms.parse_csv(reader)
-
-        return headers, records
-
-    def validate(self, value):
-        if value is None:
-            return None
-
-        headers, _records = value
-        forms.validate_csv(headers, self.fields, self.required_fields)
-
-        return value
+        return file.read().decode("utf-8-sig").strip()
 
 
 class CSVChoiceField(django_forms.ChoiceField):
     """
     Invert the provided set of choices to take the human-friendly label as input, and return the database value.
+
+    Despite the name, this is no longer used in CSV imports since 2.0, but *is* used in JSON/YAML import of DeviceTypes.
     """
 
     STATIC_CHOICES = True
@@ -166,7 +127,10 @@ class CSVChoiceField(django_forms.ChoiceField):
 
 class CSVMultipleChoiceField(CSVChoiceField):
     """
-    A version of CSVChoiceField that supports and emits a list of choice values
+    A version of CSVChoiceField that supports and emits a list of choice values.
+
+    As with CSVChoiceField, the name is misleading, as this is no longer used for CSV imports, but is used for
+    JSON/YAML import of DeviceTypes still.
     """
 
     def to_python(self, value):
@@ -184,6 +148,9 @@ class CSVMultipleChoiceField(CSVChoiceField):
 class CSVModelChoiceField(django_forms.ModelChoiceField):
     """
     Provides additional validation for model choices entered as CSV data.
+
+    Note: class name is misleading; the subclass CSVContentTypeField (below) is also used in FilterSets, where it has
+    nothing to do with CSV data.
     """
 
     default_error_messages = {
@@ -200,6 +167,8 @@ class CSVModelChoiceField(django_forms.ModelChoiceField):
 class CSVContentTypeField(CSVModelChoiceField):
     """
     Reference a ContentType in the form `{app_label}.{model}`.
+
+    Note: class name is misleading; this field is also used in numerous FilterSets where it has nothing to do with CSV.
     """
 
     STATIC_CHOICES = True
@@ -315,6 +284,9 @@ class MultiValueCharField(django_forms.CharField):
 class CSVMultipleContentTypeField(MultipleContentTypeField):
     """
     Reference a list of `ContentType` objects in the form `{app_label}.{model}'.
+
+    Note: This is unused in Nautobot core at this time, but some apps (data-validation-engine) use this for non-CSV
+    purposes, similar to CSVContentTypeField above.
     """
 
     def prepare_value(self, value):
@@ -382,7 +354,7 @@ class ExpandableIPAddressField(django_forms.CharField):
             )
 
     def to_python(self, value):
-        # Hackish address family detection but it's all we have to work with
+        # Hackish address version detection but it's all we have to work with
         if "." in value and re.search(forms.IP4_EXPANSION_PATTERN, value):
             return list(forms.expand_ipaddress_pattern(value, 4))
         elif ":" in value and re.search(forms.IP6_EXPANSION_PATTERN, value):
@@ -485,7 +457,7 @@ class DynamicModelChoiceMixin:
     :param null_option: The string used to represent a null selection (if any)
     :param disabled_indicator: The name of the field which, if populated, will disable selection of the
         choice (optional)
-    :param brief_mode: Use the "brief" format (?brief=true) when making API requests (default)
+    :param depth: Nested serialization depth when making API requests (default: `0` or a flat representation)
     """
 
     filter = django_filters.ModelChoiceFilter  # 2.0 TODO(Glenn): can we rename this? pylint: disable=redefined-builtin
@@ -498,7 +470,7 @@ class DynamicModelChoiceMixin:
         initial_params=None,
         null_option=None,
         disabled_indicator=None,
-        brief_mode=True,
+        depth=0,
         *args,
         **kwargs,
     ):
@@ -507,7 +479,7 @@ class DynamicModelChoiceMixin:
         self.initial_params = initial_params or {}
         self.null_option = null_option
         self.disabled_indicator = disabled_indicator
-        self.brief_mode = brief_mode
+        self.depth = depth
 
         # to_field_name is set by ModelChoiceField.__init__(), but we need to set it early for reference
         # by widget_attrs()
@@ -532,9 +504,8 @@ class DynamicModelChoiceMixin:
         if self.disabled_indicator is not None:
             attrs["disabled-indicator"] = self.disabled_indicator
 
-        # Toggle brief mode
-        if not self.brief_mode:
-            attrs["data-full"] = "true"
+        # Toggle depth
+        attrs["data-depth"] = self.depth
 
         # Attach any static query parameters
         for key, value in self.query_params.items():

nautobot/core/forms/forms.py

@@ -7,7 +7,7 @@ from django.forms import formset_factory
 from django.urls import reverse
 import yaml
 
-from nautobot.core.utils.filtering import build_lookup_label, get_filterset_parameter_form_field
+from nautobot.core.utils.filtering import build_lookup_label, get_filterset_parameter_form_field, get_filter_field_label
 from nautobot.ipam import formfields
 
 __all__ = (
@@ -36,7 +36,6 @@ class AddressFieldMixin(forms.ModelForm):
     address = formfields.IPNetworkFormField()
 
     def __init__(self, *args, **kwargs):
-
         instance = kwargs.get("instance")
         initial = kwargs.get("initial", {}).copy()
 
@@ -138,7 +137,10 @@ class BulkRenameForm(forms.Form):
 
 class CSVModelForm(forms.ModelForm):
     """
-    ModelForm used for the import of objects in CSV format.
+    ModelForm used for the import of objects.
+
+    Note: the name is misleading as since 2.0 this is no longer used for CSV imports; however it *is* still used for
+    JSON/YAML imports of DeviceTypes and their component templates.
     """
 
     def __init__(self, *args, headers=None, **kwargs):
@@ -159,7 +161,6 @@ class PrefixFieldMixin(forms.ModelForm):
     prefix = formfields.IPNetworkFormField()
 
     def __init__(self, *args, **kwargs):
-
         instance = kwargs.get("instance")
         initial = kwargs.get("initial", {}).copy()
 
@@ -262,22 +263,21 @@ class DynamicFilterForm(BootstrapMixin, forms.Form):
         label="Value",
     )
 
-    def __init__(self, *args, filterset_class=None, **kwargs):
+    def __init__(self, *args, filterset=None, **kwargs):
         super().__init__(*args, **kwargs)
         from nautobot.core.forms import add_blank_choice  # Avoid circular import
 
         # cls.model is set at `dynamic_formset_factory()`
-        self.filterset_class = filterset_class or getattr(self, "filterset_class", None)
+        self.filterset = filterset or getattr(self, "filterset", None)
 
-        # Raise exception if `cls.filterset_class` not set and `filterset_class` not passed
-        if self.filterset_class is None:
-            raise AttributeError("'DynamicFilterForm' object requires `filterset_class` attribute")
+        # Raise exception if `cls.filterset` not set and `filterset` not passed
+        if self.filterset is None:
+            raise AttributeError("'DynamicFilterForm' object requires `filterset` attribute")
 
-        model = self.filterset_class._meta.model
+        model = self.filterset._meta.model
 
-        if self.filterset_class is not None:
-            filterset_class = self.filterset_class()
-            self.filterset_filters = filterset_class.filters
+        if self.filterset is not None:
+            self.filterset_filters = self.filterset.filters
             contenttype = model._meta.app_label + "." + model._meta.model_name
 
             # Configure fields: Add css class and set choices for lookup_field
@@ -296,9 +296,11 @@ class DynamicFilterForm(BootstrapMixin, forms.Form):
                     verbose_name = self.filterset_filters[lookup_type].lookup_expr
                     label = build_lookup_label(lookup_type, verbose_name)
                     self.fields["lookup_type"].choices = [(lookup_type, label)]
-                    self.fields["lookup_value"] = get_filterset_parameter_form_field(model, lookup_type)
+                    self.fields["lookup_value"] = get_filterset_parameter_form_field(
+                        model, lookup_type, filterset=self.filterset
+                    )
                 elif lookup_type and lookup_type not in self.filterset_filters:
-                    logger.warning(f"{lookup_type} is not a valid {filterset_class.__class__.__name__} field")
+                    logger.warning(f"{lookup_type} is not a valid {self.filterset.__class__.__name__} field")
 
             self.fields["lookup_type"].widget.attrs["data-query-param-field_name"] = json.dumps(["$lookup_field"])
             self.fields["lookup_type"].widget.attrs["data-contenttype"] = contenttype
@@ -312,26 +314,24 @@ class DynamicFilterForm(BootstrapMixin, forms.Form):
         else:
             logger.warning(f"FilterSet for {model.__class__} not found.")
 
-    @staticmethod
-    def capitalize(field):
-        field = field.replace("_custom_field_data__", "")
-        split_field = field.split("__") if "__" in field else field.split("_")
-        words = " ".join(split_field)
-        return words[0].upper() + words[1:]
-
     def _get_lookup_field_choices(self):
         """Get choices for lookup_fields i.e filterset parameters without a lookup expr"""
+        from nautobot.extras.filters.mixins import RelationshipFilter  # Avoid circular import
+
         filterset_without_lookup = (
-            (name, field.label or self.capitalize(field.field_name))
-            for name, field in self.filterset_filters.items()
-            if "__" not in name and name != "q"
+            (
+                name,
+                get_filter_field_label(filter_field),
+            )
+            for name, filter_field in self.filterset_filters.items()
+            if isinstance(filter_field, RelationshipFilter) or ("__" not in name and name != "q")
         )
         return sorted(filterset_without_lookup, key=lambda x: x[1])
 
 
-def dynamic_formset_factory(filterset_class, data=None, **kwargs):
+def dynamic_formset_factory(filterset, data=None, **kwargs):
     filter_form = DynamicFilterForm
-    filter_form.filterset_class = filterset_class
+    filter_form.filterset = filterset
 
     params = {
         "can_delete_extra": True,

nautobot/core/forms/utils.py

@@ -15,8 +15,6 @@ __all__ = (
     "parse_alphanumeric_range",
     "parse_numeric_range",
     "restrict_form_fields",
-    "parse_csv",
-    "validate_csv",
 )
 
 
@@ -85,15 +83,15 @@ def expand_alphanumeric_pattern(string):
             yield f"{lead}{i}{remnant}"
 
 
-def expand_ipaddress_pattern(string, family):
+def expand_ipaddress_pattern(string, ip_version):
     """
     Expand an IP address pattern into a list of strings. Examples:
       '192.0.2.[1,2,100-250]/24' => ['192.0.2.1/24', '192.0.2.2/24', '192.0.2.100/24' ... '192.0.2.250/24']
       '2001:db8:0:[0,fd-ff]::/64' => ['2001:db8:0:0::/64', '2001:db8:0:fd::/64', ... '2001:db8:0:ff::/64']
     """
-    if family not in [4, 6]:
-        raise Exception(f"Invalid IP address family: {family}")
-    if family == 4:
+    if ip_version not in [4, 6]:
+        raise ValueError(f"Invalid IP address version: {ip_version}")
+    if ip_version == 4:
         regex = forms.IP4_EXPANSION_PATTERN
         base = 10
     else:
@@ -103,10 +101,10 @@ def expand_ipaddress_pattern(string, family):
     parsed_range = parse_numeric_range(pattern, base)
     for i in parsed_range:
         if re.search(regex, remnant):
-            for string2 in expand_ipaddress_pattern(remnant, family):
-                yield "".join([lead, format(i, "x" if family == 6 else "d"), string2])
+            for string2 in expand_ipaddress_pattern(remnant, ip_version):
+                yield "".join([lead, format(i, "x" if ip_version == 6 else "d"), string2])
         else:
-            yield "".join([lead, format(i, "x" if family == 6 else "d"), remnant])
+            yield "".join([lead, format(i, "x" if ip_version == 6 else "d"), remnant])
 
 
 def add_blank_choice(choices):
@@ -139,56 +137,6 @@ def restrict_form_fields(form, user, action="view"):
             field.queryset = field.queryset.restrict(user, action)
 
 
-def parse_csv(reader):
-    """
-    Parse a csv_reader object into a headers dictionary and a list of records dictionaries. Raise an error
-    if the records are formatted incorrectly. Return headers and records as a tuple.
-    """
-    records = []
-    headers = {}
-
-    # Consume the first line of CSV data as column headers. Create a dictionary mapping each header to an optional
-    # "to" field specifying how the related object is being referenced. For example, importing a Device might use a
-    # `site.slug` header, to indicate the related site is being referenced by its slug.
-
-    for header in next(reader):
-        if "." in header:
-            field, to_field = header.split(".", 1)
-            headers[field] = to_field
-        else:
-            headers[header] = None
-
-    # Parse CSV rows into a list of dictionaries mapped from the column headers.
-    for i, row in enumerate(reader, start=1):
-        if len(row) != len(headers):
-            raise django_forms.ValidationError(f"Row {i}: Expected {len(headers)} columns but found {len(row)}")
-        row = [col.strip() for col in row]
-        record = dict(zip(headers.keys(), row))
-        records.append(record)
-
-    return headers, records
-
-
-def validate_csv(headers, fields, required_fields):
-    """
-    Validate that parsed csv data conforms to the object's available fields. Raise validation errors
-    if parsed csv data contains invalid headers or does not contain required headers.
-    """
-    # Validate provided column headers
-    for field, to_field in headers.items():
-        if field not in fields:
-            raise django_forms.ValidationError(f'Unexpected column header "{field}" found.')
-        if to_field and not hasattr(fields[field], "to_field_name"):
-            raise django_forms.ValidationError(f'Column "{field}" is not a related object; cannot use dots')
-        if to_field and not hasattr(fields[field].queryset.model, to_field):
-            raise django_forms.ValidationError(f'Invalid related object attribute for column "{field}": {to_field}')
-
-    # Validate required fields
-    for f in required_fields:
-        if f not in headers:
-            raise django_forms.ValidationError(f'Required column header "{f}" not found.')
-
-
 def add_field_to_filter_form_class(form_class, field_name, field_obj):
     """
     Attach a field to an existing filter form class.

nautobot/core/forms/widgets.py

@@ -156,7 +156,6 @@ class APISelect(SelectWithDisabled):
         self.attrs[key] = json.dumps(values, ensure_ascii=False)
 
     def get_context(self, name, value, attrs):
-
         # This adds null options to DynamicModelMultipleChoiceField selected choices
         # example <select ..>
         #           <option .. selected value="null">None</option>

nautobot/core/graphql/__init__.py

@@ -34,7 +34,7 @@ def execute_query(query, variables=None, request=None, user=None):
         return document.execute(context_value=request)
 
 
-def execute_saved_query(saved_query_slug, **kwargs):
+def execute_saved_query(saved_query_name, **kwargs):
     """Execute saved query from the ORM.
 
     Args:
@@ -46,7 +46,7 @@ def execute_saved_query(saved_query_slug, **kwargs):
     Returns:
         GraphQL Object: Result for query
     """
-    query = GraphQLQuery.objects.get(slug=saved_query_slug)
+    query = GraphQLQuery.objects.get(name=saved_query_name)
     return execute_query(query=query.query, **kwargs)
 
 

nautobot/core/graphql/schema.py

@@ -1,7 +1,6 @@
 """Schema module for GraphQL."""
 from collections import OrderedDict
 import logging
-import warnings
 
 from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
@@ -276,18 +275,7 @@ def extend_schema_type_computed_field(schema_type, model):
         prefix = f"{settings.GRAPHQL_COMPUTED_FIELD_PREFIX}_"
 
     for field in cfs:
-        field_name = f"{prefix}{str_to_var_name(field.slug)}"
-        if str_to_var_name(field.slug) != field.slug:
-            # 2.0 TODO: str_to_var_name is lossy, it may cause different fields to map to the same field_name
-            # In 2.0 we should simply omit fields whose slugs are invalid in GraphQL, instead of mapping them.
-            # We need to make sure that slug/key is unique in a data migration before we remove the warning
-            # See https://github.com/nautobot/nautobot/pull/3426 for detailed solution
-            warnings.warn(
-                f'Computed field "{field}" on {model._meta.verbose_name} does not have a GraphQL-safe slug '
-                f'("{field.slug}"); for now it will be mapped to the GraphQL name "{field_name}", '
-                "but in a future release this field may fail to appear in GraphQL.",
-                FutureWarning,
-            )
+        field_name = f"{prefix}{field.key}"
         resolver_name = f"resolve_{field_name}"
 
         if hasattr(schema_type, resolver_name):
@@ -303,7 +291,7 @@ def extend_schema_type_computed_field(schema_type, model):
         setattr(
             schema_type,
             resolver_name,
-            generate_computed_field_resolver(field.slug, resolver_name),
+            generate_computed_field_resolver(field.key, resolver_name),
         )
 
         schema_type._meta.fields[field_name] = graphene.Field.mounted(graphene.String())
@@ -376,24 +364,13 @@ def extend_schema_type_relationships(schema_type, model):
         for relationship in relationships:
             peer_side = RelationshipSideChoices.OPPOSITE[side]
 
-            # Generate the name of the attribute and the name of the resolver based on the slug of the relationship
+            # Generate the name of the attribute and the name of the resolver based on the key of the relationship
             # and based on the prefix
-            rel_name = f"{prefix}{str_to_var_name(relationship.slug)}"
+            rel_name = f"{prefix}{relationship.key}"
             # Handle non-symmetric relationships where the model can be either source or destination
             if not relationship.symmetric and relationship.source_type == relationship.destination_type:
                 rel_name = f"{rel_name}_{peer_side}"
             resolver_name = f"resolve_{rel_name}"
-            if str_to_var_name(relationship.slug) != relationship.slug:
-                # 2.0 TODO: str_to_var_name is lossy, it may cause different relationships to map to the same rel_name
-                # In 2.0 we should simply omit relations whose slugs are invalid in GraphQL, instead of mapping them.
-                # We need to make sure that slug/key is unique in a data migration before we remove the warning
-                # See https://github.com/nautobot/nautobot/pull/3426 for detailed solution
-                warnings.warn(
-                    f'Relationship "{relationship}" on {model._meta.verbose_name} does not have a GraphQL-safe slug '
-                    f'("{relationship.slug}"); for now it will be mapped to the GraphQL name "{rel_name}", '
-                    "but in a future release this relationship may fail to appear in GraphQL.",
-                    FutureWarning,
-                )
 
             if hasattr(schema_type, resolver_name):
                 # If a symmetric relationship, and this is destination side, we already added source side, expected