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

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,20 +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)
 
@@ -71,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 "
@@ -79,36 +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)
 
@@ -122,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
@@ -164,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):
@@ -182,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 = {
@@ -198,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
@@ -313,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):
@@ -483,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
@@ -496,7 +470,7 @@ class DynamicModelChoiceMixin:
         initial_params=None,
         null_option=None,
         disabled_indicator=None,
-        brief_mode=True,
+        depth=0,
         *args,
         **kwargs,
     ):
@@ -505,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()
@@ -530,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

@@ -137,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):

nautobot/core/forms/utils.py

@@ -15,8 +15,6 @@ __all__ = (
     "parse_alphanumeric_range",
     "parse_numeric_range",
     "restrict_form_fields",
-    "parse_csv",
-    "validate_csv",
 )
 
 
@@ -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/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

nautobot/core/jobs/__init__.py

@@ -0,0 +1,75 @@
+from nautobot.core.celery import app, register_jobs
+from nautobot.extras.choices import LogLevelChoices
+from nautobot.extras.datasources import ensure_git_repository, git_repository_dry_run, refresh_datasource_content
+from nautobot.extras.jobs import Job, ObjectVar
+from nautobot.extras.models import GitRepository
+
+name = "System Jobs"
+
+
+class GitRepositorySync(Job):
+    """
+    System job to clone and/or pull a Git repository, then invoke `refresh_datasource_content()`.
+    """
+
+    repository = ObjectVar(
+        description="Git Repository to pull and refresh",
+        label="Git Repository",
+        model=GitRepository,
+    )
+
+    class Meta:
+        name = "Git Repository: Sync"
+        has_sensitive_variables = False
+
+    def run(self, repository):
+        job_result = self.job_result
+        user = job_result.user
+
+        job_result.log(
+            f'Creating/refreshing local copy of Git repository "{repository.name}"...',
+            logger=self.logger,
+        )
+
+        try:
+            ensure_git_repository(repository, job_result=job_result, logger=self.logger)
+            refresh_datasource_content("extras.gitrepository", repository, user, job_result, delete=False)
+            # Given that the above succeeded, tell all workers (including ourself) to call ensure_git_repository()
+            app.control.broadcast("refresh_git_repository", repository_pk=repository.pk, head=repository.current_head)
+        finally:
+            job_result.log(
+                f"Repository synchronization completed in {job_result.duration}",
+                level_choice=LogLevelChoices.LOG_INFO,
+                logger=self.logger,
+            )
+
+
+class GitRepositoryDryRun(Job):
+    """System Job to perform a dry run on a Git repository."""
+
+    repository = ObjectVar(
+        description="Git Repository to dry-run",
+        label="Git Repository",
+        model=GitRepository,
+    )
+
+    class Meta:
+        name = "Git Repository: Dry-Run"
+        has_sensitive_variables = False
+
+    def run(self, repository):
+        job_result = self.job_result
+        job_result.log(f'Performing a Dry Run on Git repository "{repository.name}"...', logger=self.logger)
+
+        try:
+            git_repository_dry_run(repository, job_result=job_result, logger=self.logger)
+        finally:
+            job_result.log(
+                f"Repository dry run completed in {job_result.duration}",
+                level_choice=LogLevelChoices.LOG_INFO,
+                logger=self.logger,
+            )
+
+
+jobs = [GitRepositorySync, GitRepositoryDryRun]
+register_jobs(*jobs)