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

nautobot/extras/management/commands/runjob.py

@@ -1,33 +1,30 @@
 import json
 import time
-import uuid
 
 from django.contrib.auth import get_user_model
 from django.core.management.base import BaseCommand, CommandError
-from django.test.client import RequestFactory
 from django.utils import timezone
 
-from nautobot.core.utils.requests import copy_safe_request
 from nautobot.extras.choices import LogLevelChoices, JobResultStatusChoices
 from nautobot.extras.models import Job, JobLogEntry, JobResult
-from nautobot.extras.jobs import get_job, run_job
-from nautobot.extras.utils import get_job_content_type
+from nautobot.extras.jobs import get_job
 
 
 class Command(BaseCommand):
     help = "Run a job (script, report) to validate or update data in Nautobot"
 
     def add_arguments(self, parser):
-        parser.add_argument("job", help="Job in the class path form: `<grouping_name>/<module_name>/<JobClassName>`")
+        parser.add_argument("job", help="Job in the Python module form: `<module_name>.<JobClassName>`")
         parser.add_argument(
-            "--commit",
+            "--profile",
             action="store_true",
-            help="Commit changes to DB (defaults to dry-run if unset). --username is mandatory if using this argument",
+            help="Run cProfile on the job execution and write the result to the disk under /tmp.",
         )
         parser.add_argument(
             "-u",
             "--username",
             help="User account to impersonate as the requester of this job",
+            required=True,
         )
         parser.add_argument(
             "-l",
@@ -38,30 +35,17 @@ class Command(BaseCommand):
         parser.add_argument("-d", "--data", type=str, help="JSON string that populates the `data` variable of the job.")
 
     def handle(self, *args, **options):
-        if "/" not in options["job"]:
-            raise CommandError(
-                'Job must be specified in the class path form: "<grouping_name>/<module_name>/<JobClassName>"'
-            )
+        if "." not in options["job"]:
+            raise CommandError('Job must be specified in the Python module form: "<module_name>.<JobClassName>"')
         job_class = get_job(options["job"])
         if not job_class:
             raise CommandError(f'Job "{options["job"]}" not found')
 
-        user = None
-        request = None
-        if options["commit"] and not options["username"]:
-            # Job execution with commit=True uses change_logging(), which requires a user as the author of any changes
-            raise CommandError("--username is mandatory when --commit is used")
-
-        if options["username"]:
-            User = get_user_model()
-            try:
-                user = User.objects.get(username=options["username"])
-            except User.DoesNotExist as exc:
-                raise CommandError("No such user") from exc
-
-            request = RequestFactory().request(SERVER_NAME="nautobot_server_runjob")
-            request.id = uuid.uuid4()
-            request.user = user
+        User = get_user_model()
+        try:
+            user = User.objects.get(username=options["username"])
+        except User.DoesNotExist as exc:
+            raise CommandError("No such user") from exc
 
         data = {}
         try:
@@ -70,38 +54,15 @@ class Command(BaseCommand):
         except json.decoder.JSONDecodeError as error:
             raise CommandError(f"Invalid JSON data:\n{str(error)}")
 
-        job_content_type = get_job_content_type()
+        job_model = Job.objects.get_for_class_path(options["job"])
 
         # Run the job and create a new JobResult
-        self.stdout.write(f"[{timezone.now():%H:%M:%S}] Running {job_class.class_path}...")
+        self.stdout.write(f"[{timezone.now():%H:%M:%S}] Running {options['job']}...")
 
         if options["local"]:
-            job = Job.objects.get_for_class_path(job_class.class_path)
-            job_result = JobResult.objects.create(
-                name=job.class_path,
-                obj_type=job_content_type,
-                user=user,
-                job_model=job,
-                task_id=uuid.uuid4(),
-            )
-            run_job(
-                data=data,
-                request=copy_safe_request(request) if request else None,
-                commit=options["commit"],
-                job_result_pk=job_result.pk,
-            )
-            job_result.refresh_from_db()
-
+            job_result = JobResult.execute_job(job_model, user, profile=options["profile"], **data)
         else:
-            job_result = JobResult.enqueue_job(
-                run_job,
-                job_class.class_path,
-                job_content_type,
-                user,
-                data=data,
-                request=copy_safe_request(request) if request else None,
-                commit=options["commit"],
-            )
+            job_result = JobResult.enqueue_job(job_model, user, profile=options["profile"], **data)
 
             # Wait on the job to finish
             while job_result.status not in JobResultStatusChoices.READY_STATES:
@@ -112,13 +73,14 @@ class Command(BaseCommand):
         groups = set(JobLogEntry.objects.filter(job_result=job_result).values_list("grouping", flat=True))
         for group in sorted(groups):
             logs = JobLogEntry.objects.filter(job_result__pk=job_result.pk, grouping=group)
-            success_count = logs.filter(log_level=LogLevelChoices.LOG_SUCCESS).count()
+            debug_count = logs.filter(log_level=LogLevelChoices.LOG_DEBUG).count()
             info_count = logs.filter(log_level=LogLevelChoices.LOG_INFO).count()
             warning_count = logs.filter(log_level=LogLevelChoices.LOG_WARNING).count()
-            failure_count = logs.filter(log_level=LogLevelChoices.LOG_FAILURE).count()
+            error_count = logs.filter(log_level=LogLevelChoices.LOG_ERROR).count()
+            critical_count = logs.filter(log_level=LogLevelChoices.LOG_CRITICAL).count()
 
             self.stdout.write(
-                f"\t{group}: {success_count} success, {info_count} info, {warning_count} warning, {failure_count} failure"
+                f"\t{group}: {debug_count} debug, {info_count} info, {warning_count} warning, {error_count} error, {critical_count} critical"
             )
 
             for log_entry in logs:
@@ -137,15 +99,15 @@ class Command(BaseCommand):
                 else:
                     self.stdout.write(f"\t\t{status}: {log_entry.message}")
 
-        if job_result.data["output"]:
-            self.stdout.write(job_result.data["output"])
+        if job_result.result:
+            self.stdout.write(job_result.result)
 
         if job_result.status == JobResultStatusChoices.STATUS_FAILURE:
             status = self.style.ERROR("FAILURE")
         else:
             status = self.style.SUCCESS("SUCCESS")
-        self.stdout.write(f"[{timezone.now():%H:%M:%S}] {job_class.class_path}: {status}")
+        self.stdout.write(f"[{timezone.now():%H:%M:%S}] {options['job']}: {status}")
 
         # Wrap things up
-        self.stdout.write(f"[{timezone.now():%H:%M:%S}] {job_class.class_path}: Duration {job_result.duration}")
+        self.stdout.write(f"[{timezone.now():%H:%M:%S}] {options['job']}: Duration {job_result.duration}")
         self.stdout.write(f"[{timezone.now():%H:%M:%S}] Finished")

nautobot/extras/managers.py

@@ -20,7 +20,11 @@ class JobResultManager(BaseManager.from_queryset(RestrictedQuerySet), TaskResult
         task_name=None,
         task_args=None,
         task_kwargs=None,
+        celery_kwargs=None,
+        job_model_id=None,
+        scheduled_job_id=None,
         worker=None,
+        user_id=None,
         using=None,
         content_type=None,
         content_encoding=None,
@@ -39,15 +43,20 @@ class JobResultManager(BaseManager.from_queryset(RestrictedQuerySet), TaskResult
 
         Args:
             task_id (uuid): UUID of task.
-            periodic_task_name (str): Celery periodic task name.
+            periodic_task_name (str): Celery periodic task name. (not used by Nautobot)
             task_name (str): Celery task name.
-            task_args (list): JSON-serialized task arguments.
-            task_kwargs (dict): JSON-serialized task kwargs.
-            result (str): JSON-serialized return value of the task, or an exception instance raised
+            task_args (list): Task arguments.
+            task_kwargs (dict): Task kwargs.
+            celery_kwargs (dict): Celery kwargs (kwargs passed to apply_async).
+            job_model_id (uuid): UUID of the Job model instance of the task being run.
+            scheduled_job_id (uuid): UUID of the ScheduledJob model instance that initiated
+                this task, or None if not scheduled.
+            result (obj): Return value of the task, or an exception instance raised
                 by the task.
             status (str): Task status. See `JobResultStatusChoices` for a list of possible status
                 values.
             worker (str): Worker that executes the task.
+            user_id (uuid): UUID of the user that initiated the task.
             using (str): Django database connection to use.
             traceback (str): Traceback string taken at the point of exception (only passed if the
                 task failed).
@@ -66,14 +75,28 @@ class JobResultManager(BaseManager.from_queryset(RestrictedQuerySet), TaskResult
             "traceback": traceback,
             "meta": meta,
             "date_done": None,
-            "periodic_task_name": periodic_task_name,
             "task_name": task_name,
             "task_args": task_args,
             "task_kwargs": task_kwargs,
+            "celery_kwargs": celery_kwargs,
+            "job_model_id": job_model_id,
+            "scheduled_job_id": scheduled_job_id,
+            "user_id": user_id,
             "worker": worker,
         }
-
-        obj, created = self.using(using).get_or_create(task_id=task_id, defaults=fields)
+        from nautobot.extras.models.jobs import Job
+
+        # Need to have a try/except block here
+        # because sometimes job_model_id will be None.
+        try:
+            job = Job.objects.get(id=job_model_id)
+            if job.has_sensitive_variables:
+                del fields["task_args"]
+                del fields["task_kwargs"]
+        except Job.DoesNotExist:
+            pass
+
+        obj, created = self.using(using).get_or_create(id=task_id, defaults=fields)
 
         if not created:
             # Make sure `date_done` is allowed to stay null until the task reacheas a ready state.

nautobot/extras/migrations/0058_jobresult_add_time_status_idxs.py

@@ -0,0 +1,38 @@
+# Generated by Django 3.2.18 on 2023-05-01 18:36
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("extras", "0057_jobbutton"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="jobresult",
+            name="completed",
+            field=models.DateTimeField(blank=True, db_index=True, null=True),
+        ),
+        migrations.AlterField(
+            model_name="jobresult",
+            name="created",
+            field=models.DateTimeField(auto_now_add=True, db_index=True),
+        ),
+        migrations.AddIndex(
+            model_name="jobresult",
+            index=models.Index(fields=["-created"], name="extras_jobresult_rcreated_idx"),
+        ),
+        migrations.AddIndex(
+            model_name="jobresult",
+            index=models.Index(fields=["-completed"], name="extras_jr_rcompleted_idx"),
+        ),
+        migrations.AddIndex(
+            model_name="jobresult",
+            index=models.Index(fields=["status", "-created"], name="extras_jr_statrcreate_idx"),
+        ),
+        migrations.AddIndex(
+            model_name="jobresult",
+            index=models.Index(fields=["status", "-completed"], name="extras_jr_statrcompl_idx"),
+        ),
+    ]

nautobot/extras/migrations/{0058_joblogentry_scheduledjob_webhook_data_migration.py → 0059_joblogentry_scheduledjob_webhook_data_migration.py}

@@ -22,7 +22,7 @@ def null_webhook_fields_to_empty(apps, schema_editor):
 
 class Migration(migrations.Migration):
     dependencies = [
-        ("extras", "0057_jobbutton"),
+        ("extras", "0058_jobresult_add_time_status_idxs"),
     ]
 
     operations = [

nautobot/extras/migrations/{0059_alter_joblogentry_scheduledjob_webhook_fields.py → 0060_alter_joblogentry_scheduledjob_webhook_fields.py}

@@ -5,7 +5,7 @@ from django.db import migrations, models
 
 class Migration(migrations.Migration):
     dependencies = [
-        ("extras", "0058_joblogentry_scheduledjob_webhook_data_migration"),
+        ("extras", "0059_joblogentry_scheduledjob_webhook_data_migration"),
     ]
 
     operations = [

nautobot/extras/migrations/{0060_role_and_alter_status.py → 0061_role_and_alter_status.py}

@@ -12,7 +12,7 @@ import nautobot.extras.utils
 class Migration(migrations.Migration):
     dependencies = [
         ("contenttypes", "0002_remove_content_type_name"),
-        ("extras", "0059_alter_joblogentry_scheduledjob_webhook_fields"),
+        ("extras", "0060_alter_joblogentry_scheduledjob_webhook_fields"),
     ]
 
     operations = [
@@ -37,12 +37,6 @@ class Migration(migrations.Migration):
                     models.JSONField(blank=True, default=dict, encoder=django.core.serializers.json.DjangoJSONEncoder),
                 ),
                 ("name", models.CharField(max_length=100, unique=True)),
-                (
-                    "slug",
-                    nautobot.core.models.fields.AutoSlugField(
-                        blank=True, max_length=100, populate_from="name", unique=True
-                    ),
-                ),
                 ("color", nautobot.core.models.fields.ColorField(default="9e9e9e", max_length=6)),
                 ("description", models.CharField(blank=True, max_length=200)),
                 ("weight", models.PositiveSmallIntegerField(blank=True, null=True)),

nautobot/extras/migrations/{0061_collect_roles_from_related_apps_roles.py → 0062_collect_roles_from_related_apps_roles.py}

@@ -1,6 +1,8 @@
 # Generated by Django 3.2.16 on 2022-11-19 23:15
 
 from collections import namedtuple
+import logging
+
 from django.db import migrations, models
 
 from nautobot.core.choices import ColorChoices
@@ -22,12 +24,14 @@ color_map = {
     "success": ColorChoices.COLOR_GREEN,
 }
 
+logger = logging.getLogger(__name__)
+
 
 def create_equivalent_roles_of_virtualmachine_device_role(apps):
     """Create equivalent roles for the VirtualMachine DeviceRole."""
     DeviceRole = apps.get_model("dcim", "DeviceRole")
     roles_to_create = DeviceRole.objects.filter(vm_role=True)
-    bulk_create_roles(apps, roles_to_create, ["virtualization.virtualmachine"])
+    create_roles(apps, roles_to_create, ["virtualization.virtualmachine"])
 
 
 def create_equivalent_roles_of_related_role_model(apps):
@@ -43,7 +47,7 @@ def create_equivalent_roles_of_related_role_model(apps):
         related_role_model_class = apps.get_model(app_name, model_class)
 
         roles_to_create = related_role_model_class.objects.all()
-        bulk_create_roles(apps, roles_to_create, related_role_model.implemented_by)
+        create_roles(apps, roles_to_create, related_role_model.implemented_by)
 
 
 def create_equivalent_roles_of_ipaddress_role_choices(apps):
@@ -54,11 +58,11 @@ def create_equivalent_roles_of_ipaddress_role_choices(apps):
         color = IPAddressRoleChoices.CSS_CLASSES[value]
         choiceset = ChoicesQuerySet(name=label, slug=value, color=color_map[color], description="")
         roles_to_create.append(choiceset)
-    bulk_create_roles(apps, roles_to_create, ["ipam.ipaddress"])
+    create_roles(apps, roles_to_create, ["ipam.ipaddress"])
 
 
-def bulk_create_roles(apps, roles_to_create, content_types):
-    """Bulk create role and set its contenttypes"""
+def create_roles(apps, roles_to_create, content_types):
+    """Create/retrieve Role records as needed and set their contenttypes."""
     Role = apps.get_model("extras", "Role")
     ContentType = apps.get_model("contenttypes", "ContentType")
     ObjectChange = apps.get_model("extras", "ObjectChange")
@@ -71,36 +75,32 @@ def bulk_create_roles(apps, roles_to_create, content_types):
         # No sense fetching this if we don't have an old role content type
         new_role_ct = ContentType.objects.get_for_model(Role)
 
-    # Exclude roles whose names are already exists from bulk create.
-    existing_roles = Role.objects.values_list("name", flat=True)
-    roles_instances = [
-        (
-            data,
-            Role(
-                name=data.name,
-                slug=data.slug,
-                description=data.description,
-                color=getattr(data, "color", color_map["default"]),
-                weight=getattr(data, "weight", None),
-            ),
+    for old_role in roles_to_create:
+        new_role, created = Role.objects.get_or_create(
+            name=old_role.name,
+            defaults={
+                "description": old_role.description,
+                "color": getattr(old_role, "color", color_map["default"]),
+                "weight": getattr(old_role, "weight", None),
+            },
         )
-        for data in roles_to_create
-        if data.name not in existing_roles
-    ]
-    if roles_instances:
-        for old_role, new_role in roles_instances:
-            # TODO: We need to handle new role collisions
-            new_role.save()
-            if old_role_ct:
-                # Move over existing object change records to the new role we created
-                ObjectChange.objects.filter(changed_object_type=old_role_ct, changed_object_id=old_role.pk).update(
-                    changed_object_type=new_role_ct, changed_object_id=new_role.pk
-                )
+        if created:
+            logger.info(f'Created Role "{new_role.name}"')
+        if old_role_ct and hasattr(old_role, "pk"):
+            # Move over existing object change records to the new role we created
+            updated_count = ObjectChange.objects.filter(
+                changed_object_type=old_role_ct, changed_object_id=old_role.pk
+            ).update(changed_object_type=new_role_ct, changed_object_id=new_role.pk)
+            logger.info(
+                f'Updated {updated_count} ObjectChanges from the existing "{old_role.name}" {old_role._meta.label}'
+            )
 
     # This is for all of the change records for roles which no longer exist
     if old_role_ct:
-        # TODO: Should we null out the changed_object_id?
-        ObjectChange.objects.filter(changed_object_type=old_role_ct).update(changed_object_type=new_role_ct)
+        updated_count = ObjectChange.objects.filter(changed_object_type=old_role_ct).update(
+            changed_object_type=new_role_ct
+        )
+        logger.info(f"Updated {updated_count} leftover ObjectChanges from deleted {old_role_ct.model} records.")
 
     roles = Role.objects.filter(name__in=[roles.name for roles in roles_to_create])
 
@@ -125,11 +125,12 @@ def populate_roles_from_related_app_roles(apps, schema_editor):
 def clear_populated_roles(apps, schema_editor):
     Role = apps.get_model("extras", "Role")
     Role.objects.all().delete()
+    # TODO: currently we do NOT recreate DeviceRole/RackRole records, nor do we revert ObjectChange records.
 
 
 class Migration(migrations.Migration):
     dependencies = [
-        ("extras", "0060_role_and_alter_status"),
+        ("extras", "0061_role_and_alter_status"),
     ]
 
     operations = [

nautobot/extras/migrations/{0062_alter_role_options.py → 0063_alter_role_options.py}

@@ -5,7 +5,7 @@ from django.db import migrations
 
 class Migration(migrations.Migration):
     dependencies = [
-        ("extras", "0061_collect_roles_from_related_apps_roles"),
+        ("extras", "0062_collect_roles_from_related_apps_roles"),
     ]
 
     operations = [

nautobot/extras/migrations/{0063_alter_configcontext_and_add_new_role.py → 0064_alter_configcontext_and_add_new_role.py}

@@ -5,7 +5,7 @@ from django.db import migrations, models
 
 class Migration(migrations.Migration):
     dependencies = [
-        ("extras", "0062_alter_role_options"),
+        ("extras", "0063_alter_role_options"),
     ]
 
     operations = [

nautobot/extras/migrations/0065_configcontext_data_migrations.py

@@ -0,0 +1,44 @@
+# Generated by Django 3.2.16 on 2022-11-25 11:45
+
+from django.db import migrations
+from nautobot.extras.utils import migrate_role_data
+
+
+def migrate_data_from_legacy_roles_to_new_roles(apps, schema):
+    """Migrate ConfigContext data from legacy_roles to new_roles."""
+    ConfigContext = apps.get_model("extras", "ConfigContext")
+    DeviceRole = apps.get_model("dcim", "DeviceRole")
+    Role = apps.get_model("extras", "Role")
+    migrate_role_data(
+        model_to_migrate=ConfigContext,
+        from_role_field_name="legacy_roles",
+        from_role_model=DeviceRole,
+        to_role_field_name="new_roles",
+        to_role_model=Role,
+        is_m2m_field=True,
+    )
+
+
+def reverse_role_data_migrate(apps, schema):
+    """Migrate ConfigContext data from new_roles to legacy_roles."""
+    ConfigContext = apps.get_model("extras", "ConfigContext")
+    DeviceRole = apps.get_model("dcim", "DeviceRole")
+    Role = apps.get_model("extras", "Role")
+    migrate_role_data(
+        model_to_migrate=ConfigContext,
+        from_role_field_name="new_roles",
+        from_role_model=Role,
+        to_role_field_name="legacy_roles",
+        to_role_model=DeviceRole,
+        is_m2m_field=True,
+    )
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("extras", "0064_alter_configcontext_and_add_new_role"),
+    ]
+
+    operations = [
+        migrations.RunPython(migrate_data_from_legacy_roles_to_new_roles, reverse_role_data_migrate),
+    ]

nautobot/extras/migrations/{0065_rename_configcontext_role.py → 0066_rename_configcontext_role.py}

@@ -5,7 +5,7 @@ from django.db import migrations
 
 class Migration(migrations.Migration):
     dependencies = [
-        ("extras", "0064_configcontext_data_migrations"),
+        ("extras", "0065_configcontext_data_migrations"),
     ]
 
     operations = [

nautobot/extras/migrations/{0066_jobresult__add_celery_fields.py → 0067_jobresult__add_celery_fields.py}

@@ -9,10 +9,26 @@ import nautobot.extras.utils
 class Migration(migrations.Migration):
     dependencies = [
         ("contenttypes", "0002_remove_content_type_name"),
-        ("extras", "0065_rename_configcontext_role"),
+        ("extras", "0066_rename_configcontext_role"),
     ]
 
     operations = [
+        migrations.RemoveIndex(
+            model_name="jobresult",
+            name="extras_jobresult_rcreated_idx",
+        ),
+        migrations.RemoveIndex(
+            model_name="jobresult",
+            name="extras_jr_rcompleted_idx",
+        ),
+        migrations.RemoveIndex(
+            model_name="jobresult",
+            name="extras_jr_statrcreate_idx",
+        ),
+        migrations.RemoveIndex(
+            model_name="jobresult",
+            name="extras_jr_statrcompl_idx",
+        ),
         migrations.AlterModelOptions(
             name="jobresult",
             options={"get_latest_by": "date_created", "ordering": ["-date_created"]},
@@ -55,7 +71,9 @@ class Migration(migrations.Migration):
         migrations.AddField(
             model_name="jobresult",
             name="task_kwargs",
-            field=models.JSONField(blank=True, encoder=nautobot.core.celery.NautobotKombuJSONEncoder, null=True),
+            field=models.JSONField(
+                blank=True, default=dict, encoder=nautobot.core.celery.encoders.NautobotKombuJSONEncoder
+            ),
         ),
         migrations.AddField(
             model_name="jobresult",
@@ -89,4 +107,20 @@ class Migration(migrations.Migration):
             name="status",
             field=models.CharField(db_index=True, default="PENDING", max_length=30),
         ),
+        migrations.AddIndex(
+            model_name="jobresult",
+            index=models.Index(fields=["-date_created"], name="extras_jobresult_rcreated_idx"),
+        ),
+        migrations.AddIndex(
+            model_name="jobresult",
+            index=models.Index(fields=["-date_done"], name="extras_jr_rdone_idx"),
+        ),
+        migrations.AddIndex(
+            model_name="jobresult",
+            index=models.Index(fields=["status", "-date_created"], name="extras_jr_statrcreate_idx"),
+        ),
+        migrations.AddIndex(
+            model_name="jobresult",
+            index=models.Index(fields=["status", "-date_done"], name="extras_jr_statrdone_idx"),
+        ),
     ]

nautobot/extras/migrations/{0067_created_datetime.py → 0068_created_datetime.py}

@@ -5,7 +5,7 @@ from django.db import migrations, models
 
 class Migration(migrations.Migration):
     dependencies = [
-        ("extras", "0066_jobresult__add_celery_fields"),
+        ("extras", "0067_jobresult__add_celery_fields"),
     ]
 
     operations = [

nautobot/extras/migrations/{0068_remove_site_and_region_attributes_from_config_context.py → 0069_remove_site_and_region_attributes_from_config_context.py}

@@ -6,7 +6,7 @@ from django.db import migrations
 class Migration(migrations.Migration):
     dependencies = [
         ("dcim", "0030_migrate_region_and_site_data_to_locations"),
-        ("extras", "0067_created_datetime"),
+        ("extras", "0068_created_datetime"),
     ]
 
     operations = [

nautobot/extras/migrations/{0069_replace_related_names.py → 0070_replace_related_names.py}

@@ -10,7 +10,7 @@ class Migration(migrations.Migration):
     dependencies = [
         migrations.swappable_dependency(settings.AUTH_USER_MODEL),
         ("contenttypes", "0002_remove_content_type_name"),
-        ("extras", "0068_remove_site_and_region_attributes_from_config_context"),
+        ("extras", "0069_remove_site_and_region_attributes_from_config_context"),
     ]
 
     operations = [

nautobot/extras/migrations/{0070_rename_model_fields.py → 0071_rename_model_fields.py}

@@ -5,7 +5,7 @@ from django.db import migrations
 
 class Migration(migrations.Migration):
     dependencies = [
-        ("extras", "0069_replace_related_names"),
+        ("extras", "0070_replace_related_names"),
     ]
 
     operations = [