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

nautobot/core/celery/__init__.py

@@ -2,17 +2,26 @@ import json
 import logging
 import os
 from pathlib import Path
+import pkgutil
+import shutil
+import sys
 
 from celery import Celery, shared_task, signals
+from celery.app.log import TaskFormatter
 from celery.fixups.django import DjangoFixup
+from celery.utils.log import get_logger
 from django.conf import settings
-from django.core.serializers.json import DjangoJSONEncoder
+from django.utils.functional import SimpleLazyObject
 from django.utils.module_loading import import_string
 from kombu.serialization import register
 from prometheus_client import CollectorRegistry, multiprocess, start_http_server
 
-logger = logging.getLogger(__name__)
+from nautobot.core.celery.control import discard_git_repository, refresh_git_repository  # noqa: F401
+from nautobot.core.celery.encoders import NautobotKombuJSONEncoder
+from nautobot.core.celery.log import NautobotDatabaseHandler
+
 
+logger = logging.getLogger(__name__)
 # The Celery documentation tells us to call setup on the app to initialize
 # settings, but we will NOT be doing that because of a chicken-and-egg problem
 # when bootstrapping the Django settings with `nautobot-server`.
@@ -25,7 +34,22 @@ logger = logging.getLogger(__name__)
 # NOT need to be called here.
 # nautobot.setup()
 
-app = Celery("nautobot", task_cls="nautobot.core.celery.task:NautobotTask")
+
+class NautobotCelery(Celery):
+    task_cls = "nautobot.core.celery.task:NautobotTask"
+
+    def register_task(self, task, **options):
+        """Override the default task name for job classes to allow app provided jobs to use the full module path."""
+        from nautobot.extras.jobs import Job
+
+        if issubclass(task, Job):
+            task = task()
+            task.name = task.registered_name
+
+        return super().register_task(task, **options)
+
+
+app = NautobotCelery("nautobot")
 
 # Using a string here means the worker doesn't have to serialize
 # the configuration object to child processes. Again, this is possible
@@ -43,7 +67,83 @@ DjangoFixup(app).install()
 app.autodiscover_tasks()
 
 
-@signals.worker_ready.connect()
+@signals.import_modules.connect
+def import_jobs_as_celery_tasks(sender, database_ready=True, **kwargs):
+    """
+    Import system Jobs into Celery as well as Jobs from JOBS_ROOT and GIT_ROOT.
+
+    Note that app-provided Jobs are automatically imported at startup time via NautobotAppConfig.ready()
+    """
+    logger.debug("Importing system Jobs")
+    sender.loader.import_task_module("nautobot.core.jobs")
+
+    jobs_root = settings.JOBS_ROOT
+    if jobs_root and os.path.exists(jobs_root):
+        if jobs_root not in sys.path:
+            sys.path.append(jobs_root)
+        for _, module_name, _ in pkgutil.iter_modules([jobs_root]):
+            try:
+                logger.debug("Importing Jobs from %s in JOBS_ROOT", module_name)
+                sender.loader.import_task_module(module_name)
+            except Exception as exc:
+                # logger.error(f"Unable to load module '{module_name}' from {jobs_root}: {exc:}")
+                logger.exception(exc)
+
+    git_root = settings.GIT_ROOT
+    if git_root and os.path.exists(git_root):
+        if git_root not in sys.path:
+            sys.path.append(git_root)
+
+        # We can't detect which Git directories we're *supposed* to auto-load Jobs from if we can't read GitRepository
+        # records from the DB, unfortunately.
+        # We work around this in JobModel.job_task to try later loading Git jobs on-the-fly if needed.
+        if database_ready:
+            from nautobot.extras.models import GitRepository
+
+            # Make sure there are no git clones in GIT_ROOT that *aren't* tracked by a GitRepository;
+            # for example, maybe a GitRepository was deleted while this worker process wasn't running?
+            for filename in os.listdir(git_root):
+                filepath = os.path.join(git_root, filename)
+                if (
+                    os.path.isdir(filepath)
+                    and os.path.isdir(os.path.join(filepath, ".git"))
+                    and not GitRepository.objects.filter(slug=filename).exists()
+                ):
+                    logger.warning("Deleting unmanaged (leftover?) Git repository clone at %s", filepath)
+                    shutil.rmtree(filepath)
+
+            # Make sure all GitRepository records that include Jobs have up-to-date git clones, and load their jobs
+            for repo in GitRepository.objects.all():
+                refresh_git_repository(state=None, repository_pk=repo.pk, head=repo.current_head)
+
+
+def add_nautobot_log_handler(logger_instance, log_format=None):
+    """Add NautobotDatabaseHandler to logger and update logger level filtering to send all log levels to our handler."""
+    if any(isinstance(h, NautobotDatabaseHandler) for h in logger_instance.handlers):
+        return
+    if logger_instance.level not in (logging.NOTSET, logging.DEBUG):
+        for handler in logger_instance.handlers:
+            handler.setLevel(logger_instance.level)
+    logger_instance.setLevel(logging.DEBUG)
+
+    if log_format is None:
+        log_format = app.conf.worker_task_log_format
+    handler = NautobotDatabaseHandler()
+    handler.setFormatter(TaskFormatter(log_format, use_color=False))
+    logger_instance.addHandler(handler)
+
+
+@signals.celeryd_after_setup.connect
+def setup_nautobot_job_logging(sender, instance, conf, **kwargs):
+    """Add nautobot database logging handler to celery stdout/stderr redirect logger and celery task logger."""
+    task_logger = get_logger("celery.task")
+    add_nautobot_log_handler(task_logger)
+    if conf.worker_redirect_stdouts:
+        redirect_logger = get_logger("celery.redirected")
+        add_nautobot_log_handler(redirect_logger)
+
+
+@signals.worker_ready.connect
 def setup_prometheus(**kwargs):
     """This sets up an HTTP server to serve prometheus metrics from the celery workers."""
     # Don't set up the server if the port is undefined
@@ -71,42 +171,6 @@ def setup_prometheus(**kwargs):
         logger.warning("Cannot export Prometheus metrics from worker, no available ports in range.")
 
 
-class NautobotKombuJSONEncoder(DjangoJSONEncoder):
-    """
-    Custom json encoder based on DjangoJSONEncoder that serializes objects that implement
-    the `nautobot_serialize()` method via the `__nautobot_type__` interface. This is useful
-    in passing special objects to and from Celery tasks.
-
-    This pattern should generally be avoided by passing pointers to persisted objects to the
-    Celery tasks and retrieving them from within the task execution. While this is always possible
-    for model instances (which covers 99% of use cases), for rare instances where it does not,
-    and the actual object must be passed, this pattern allows for encoding and decoding
-    of such objects.
-
-    It requires a conforming class to implement the instance method `nautobot_serialize()` which
-    returns a json serializable dictionary of the object representation. The class must also implement
-    the `nautobot_deserialize()` class method which takes the dictionary representation and returns
-    an actual instance of the class.
-    """
-
-    def default(self, obj):
-        if hasattr(obj, "nautobot_serialize"):
-            cls = obj.__class__
-            module = cls.__module__
-            qual_name = ".".join([module, cls.__qualname__])  # fully qualified dotted import path
-            logger.debug("Performing nautobot serialization on %s for type %s", obj, qual_name)
-            data = {"__nautobot_type__": qual_name}
-            data.update(obj.nautobot_serialize())
-            return data
-
-        elif isinstance(obj, set):
-            # Convert a set to a list for passing to and from a task
-            return list(obj)
-
-        else:
-            return DjangoJSONEncoder.default(self, obj)
-
-
 def nautobot_kombu_json_loads_hook(data):
     """
     In concert with the NautobotKombuJSONEncoder json encoder, this object hook method decodes
@@ -117,7 +181,7 @@ def nautobot_kombu_json_loads_hook(data):
         logger.debug("Performing nautobot deserialization for type %s", qual_name)
         cls = import_string(qual_name)  # fully qualified dotted import path
         if cls:
-            return cls.nautobot_deserialize(data)
+            return SimpleLazyObject(lambda: cls.objects.get(id=data["id"]))
         else:
             raise TypeError(f"Unable to import {qual_name} during nautobot deserialization")
     else:
@@ -148,3 +212,10 @@ register("nautobot_json", _dumps, _loads, content_type="application/x-nautobot-j
 #
 
 nautobot_task = shared_task
+
+
+def register_jobs(*jobs):
+    """Helper method to register jobs with Celery"""
+    for job in jobs:
+        logger.debug("Registering job %s.%s", job.__module__, job.__name__)
+        app.register_task(job)

nautobot/core/celery/backends.py

@@ -1,5 +1,6 @@
 from django_celery_results.backends import DatabaseBackend
 
+from nautobot.extras.constants import JOB_RESULT_CUSTOM_CELERY_KWARGS
 from nautobot.extras.models import JobResult
 
 
@@ -20,39 +21,44 @@ class NautobotDatabaseBackend(DatabaseBackend):
 
     def _get_extended_properties(self, request, traceback):
         """
-        Overload default so that `argsrepr` and `kwargsrepr` aren't used to construct `args` and
-        `kwargs`. Our need to properly (de)serialize `NautobotFakeRequest` facilitates this.
+        Overload default so that `argsrepr` and `kwargsrepr` aren't used to construct `args` and `kwargs`.
+        Also adds custom kwargs passed in on `apply_async` calls to track user, job model, scheduled job, etc.
         """
         extended_props = {
-            "periodic_task_name": None,
             "task_args": None,
             "task_kwargs": None,
+            "celery_kwargs": None,
+            "job_model_id": None,
+            "scheduled_job_id": None,
             "task_name": None,
             "traceback": None,
+            "user_id": None,
             "worker": None,
         }
         if request and self.app.conf.find_value_for_key("extended", "result"):
-
-            # Let's not dump/encode args/kwargs at all in fact.
+            # do not encode args/kwargs as we store these in a JSONField instead of TextField
             task_args = getattr(request, "args", None)
             task_kwargs = getattr(request, "kwargs", None)
 
-            # Encode input arguments
-            if task_args is not None:
-                _, _, task_args = self.encode_content(task_args)
+            properties = getattr(request, "properties", {}) or {}
+
+            # retrieve original "queue" kwarg from the request, celery stores it in delivery_info.routing_key
+            celery_kwargs = {"queue": request.delivery_info.get("routing_key", None)}
 
-            if task_kwargs is not None:
-                _, _, task_kwargs = self.encode_content(task_kwargs)
+            for kwarg_name in JOB_RESULT_CUSTOM_CELERY_KWARGS:
+                if kwarg_name in properties:
+                    celery_kwargs[kwarg_name] = properties[kwarg_name]
 
-            properties = getattr(request, "properties", {}) or {}
-            periodic_task_name = properties.get("periodic_task_name", None)
             extended_props.update(
                 {
-                    "periodic_task_name": periodic_task_name,
                     "task_args": task_args,
                     "task_kwargs": task_kwargs,
+                    "celery_kwargs": celery_kwargs,
+                    "job_model_id": properties.get("nautobot_job_job_model_id", None),
+                    "scheduled_job_id": properties.get("nautobot_job_scheduled_job_id", None),
                     "task_name": getattr(request, "task", None),
                     "traceback": traceback,
+                    "user_id": properties.get("nautobot_job_user_id", None),
                     "worker": getattr(request, "hostname", None),
                 }
             )

nautobot/core/celery/control.py

@@ -0,0 +1,46 @@
+import logging
+import os
+import shutil
+
+from celery.worker.control import control_command
+
+from django.conf import settings
+
+
+logger = logging.getLogger(__name__)
+
+
+@control_command(args=[("repository_pk", str), ("head", str)])
+def refresh_git_repository(state, repository_pk, head):
+    """
+    Celery worker control event to ensure that all active workers have the correct head for a given Git repository.
+    """
+    from nautobot.extras.datasources.git import ensure_git_repository, refresh_code_from_repository
+    from nautobot.extras.models import GitRepository
+
+    try:
+        repository = GitRepository.objects.get(pk=repository_pk)
+        # Refresh the repository on disk
+        ensure_git_repository(repository, head=head, logger=logger)
+        refresh_code_from_repository(repository.slug, consumer=state.consumer if state is not None else None)
+
+        return {"ok": {"head": repository.current_head}}
+    except Exception as exc:
+        logger.error("%s", exc)
+        return {"error": str(exc)}
+
+
+@control_command(args=["repository_slug", str])
+def discard_git_repository(state, repository_slug):
+    """
+    Celery worker control even to ensure that all active workers unload a given Git repository and delete it from disk.
+    """
+    from nautobot.extras.datasources.git import refresh_code_from_repository
+
+    filesystem_path = os.path.join(settings.GIT_ROOT, repository_slug)
+    if os.path.isdir(filesystem_path):
+        shutil.rmtree(filesystem_path)
+    # Unload any code from this repository
+    refresh_code_from_repository(
+        repository_slug, consumer=state.consumer if state is not None else None, skip_reimport=True
+    )

nautobot/core/celery/encoders.py

@@ -0,0 +1,53 @@
+import logging
+
+from rest_framework.utils.encoders import JSONEncoder
+
+
+logger = logging.getLogger(__name__)
+
+
+class NautobotKombuJSONEncoder(JSONEncoder):
+    """
+    Custom json encoder based on restframework's JSONEncoder that serializes objects that implement
+    the `nautobot_serialize()` method via the `__nautobot_type__` interface. This is useful
+    in passing special objects to and from Celery tasks.
+
+    This pattern should generally be avoided by passing pointers to persisted objects to the
+    Celery tasks and retrieving them from within the task execution. While this is always possible
+    for model instances (which covers 99% of use cases), for rare instances where it does not,
+    and the actual object must be passed, this pattern allows for encoding and decoding
+    of such objects.
+
+    It requires a conforming class to implement the instance method `nautobot_serialize()` which
+    returns a json serializable dictionary of the object representation. The class must also implement
+    the `nautobot_deserialize()` class method which takes the dictionary representation and returns
+    an actual instance of the class.
+    """
+
+    def default(self, obj):
+        # Import here to avoid django.core.exceptions.ImproperlyConfigured Error.
+        # Core App is not set up yet if we import this at the top of the file.
+        from nautobot.core.models import BaseModel
+        from nautobot.core.models.managers import TagsManager
+
+        if isinstance(obj, BaseModel):
+            cls = obj.__class__
+            module = cls.__module__
+            qual_name = ".".join([module, cls.__qualname__])  # fully qualified dotted import path
+            logger.debug("Performing nautobot serialization on %s for type %s", obj, qual_name)
+            data = {
+                "id": obj.id,
+                "__nautobot_type__": qual_name,
+                # TODO: change to natural key to provide additional context if object is deleted from the db
+                "display": getattr(obj, "display", str(obj)),
+            }
+            return data
+
+        elif isinstance(obj, set):
+            # Convert a set to a list for passing to and from a task
+            return list(obj)
+        elif isinstance(obj, TagsManager):
+            obj = obj.values_list("id", flat=True)
+            return obj
+        else:
+            return super().default(obj)

nautobot/core/celery/log.py

@@ -0,0 +1,38 @@
+import logging
+
+from celery import current_task
+from django.core.exceptions import ValidationError
+
+
+class NautobotDatabaseHandler(logging.Handler):
+    """Custom logging handler to log messages to JobLogEntry database entries."""
+
+    def emit(self, record):
+        if current_task is None:
+            return
+
+        from nautobot.extras.models.jobs import JobResult
+
+        try:
+            self.format(record)
+
+            try:
+                job_result = JobResult.objects.get(id=record.task_id)
+            except (ValidationError, JobResult.DoesNotExist):
+                # Both of these cases are very rare
+                # ValidationError - because the task_id might not a valid UUID
+                # JobResult.DoesNotExist - because we might not have a JobResult with that ID
+                return
+
+            # Skip recording the log entry if it has been marked as such
+            if getattr(record, "skip_db_logging", False):
+                return
+
+            job_result.log(
+                message=record.message,
+                level_choice=record.levelname.lower(),
+                obj=getattr(record, "object", None),
+                grouping=getattr(record, "grouping", record.funcName),
+            )
+        except Exception:
+            self.handleError(record)

nautobot/core/celery/schedulers.py

@@ -1,3 +1,4 @@
+from collections.abc import Mapping
 import logging
 
 from celery import current_app
@@ -38,11 +39,29 @@ class NautobotScheduleEntry(ModelEntry):
             )
             self._disable(model)
 
-        self.options = {}
-        if model.queue:
-            self.options["queue"] = model.queue
+        self.options = {"nautobot_job_scheduled_job_id": model.id, "headers": {}}
+
+        if model.user:
+            self.options["nautobot_job_user_id"] = model.user.id
+        else:
+            logger.error(
+                "Disabling schedule %s with missing user",
+                self.name,
+            )
+            self._disable(model)
+
+        if model.job_model:
+            self.options["nautobot_job_job_model_id"] = model.job_model.id
+        else:
+            logger.error(
+                "Disabling schedule %s with missing job model",
+                self.name,
+            )
+            self._disable(model)
+
+        if isinstance(model.celery_kwargs, Mapping):
+            self.options.update(model.celery_kwargs)
 
-        self.options["headers"] = {}
         self.total_run_count = model.total_run_count
         self.model = model
 

nautobot/core/celery/task.py

@@ -1,6 +1,6 @@
-from celery.utils.log import get_task_logger
 from celery import Task
 
+from nautobot.extras.jobs import get_task_logger
 
 logger = get_task_logger(__name__)
 
@@ -10,18 +10,3 @@ class NautobotTask(Task):
 
 
 Task = NautobotTask  # noqa: So that the class path resolves.
-
-
-# TODO(jathan): Remove this once this body of work is done. This is just useful for debugging but it
-# results int a lot of noise and slows things down.
-# from celery import signals
-# @signals.task_prerun.connect
-def debug_task_prerun(sender, task_id, task, args, kwargs, **extra):
-    logger.error(">>>    SENDER = %s", sender)
-    logger.error(">>>      TASK = %s", task)
-    logger.error(">>>   REQUEST = %s", task.request)
-    logger.error(">>>   TASK_NAME = %s", task.request.task)
-    logger.error(">>>   TASK_ID = %s", task_id)
-    logger.error(">>>      ARGS = %s", args)
-    logger.error(">>>    KWARGS = %s", kwargs)
-    logger.error(">>>     EXTRA = %s", extra)

nautobot/core/checks.py

@@ -6,12 +6,6 @@ from django.core.exceptions import ValidationError
 from django.core.validators import URLValidator
 
 
-E001 = Error(
-    "CACHEOPS_DEFAULTS['timeout'] value cannot be 0. To disable caching set CACHEOPS_ENABLED=False.",
-    id="nautobot.core.E001",
-    obj=settings,
-)
-
 E002 = Error(
     "'nautobot.core.authentication.ObjectPermissionBackend' must be included in AUTHENTICATION_BACKENDS",
     id="nautobot.core.E002",
@@ -42,20 +36,6 @@ W005 = Warning(
     obj=settings,
 )
 
-W006 = Warning(
-    "CACHEOPS_ENABLED is set to True but cacheops is no longer recommended in v1.5. It can still be used but may lead to "
-    "inaccurate data responses. Cacheops will be removed in a later release.",
-    id="nautobot.core.W006",
-    obj=settings,
-)
-
-
-@register(Tags.caches)
-def check_cache_timeout(app_configs, **kwargs):
-    if settings.CACHEOPS_DEFAULTS.get("timeout") == 0:
-        return [E001]
-    return []
-
 
 @register(Tags.security)
 def check_object_permissions_backend(app_configs, **kwargs):
@@ -96,13 +76,6 @@ def check_maintenance_mode(app_configs, **kwargs):
     return []
 
 
-@register(Tags.compatibility)
-def check_cacheops_enabled(app_configs, **kwargs):
-    if settings.CACHEOPS_ENABLED:
-        return [W006]
-    return []
-
-
 @register(Tags.security)
 def check_sanitizer_patterns(app_configs, **kwargs):
     errors = []

nautobot/core/choices.py

@@ -11,6 +11,27 @@ class ChoiceSetMeta(type):
         choices = getattr(cls, "CHOICES", ())
         return iter(choices)
 
+    def __getattribute__(cls, attr):
+        """
+        Overrides the default __getattribute__ method to provide custom behavior when accessing attributes of a ChoiceSet
+        instance. If the attribute name is an uppercase string and not equal to 'CHOICES', this method returns a new class
+        instance of the same type as the original attribute value, but with an additional 'label' property. This 'label'
+        property looks up the choice label for the given attribute value in the 'CHOICES' sequence and returns it.
+        """
+        value = super().__getattribute__(attr)
+        # Check if the attribute is a member of the CHOICES sequence and is uppercase;
+        # Mostly only ChoiceSet choices are uppercase
+        if attr != "CHOICES" and attr.isupper():
+            choices = cls.as_dict()
+
+            class Choice(value.__class__):
+                @property
+                def label(self):
+                    return choices.get(self)
+
+            return Choice(value)
+        return value
+
 
 class ChoiceSet(metaclass=ChoiceSetMeta):
     """
@@ -146,116 +167,3 @@ class ColorChoices(ChoiceSet):
         (COLOR_BLACK, "Black"),
         (COLOR_WHITE, "White"),
     )
-
-
-#
-# Button color choices
-#
-
-
-class ButtonColorChoices(ChoiceSet):
-    """
-    Map standard button color choices to Bootstrap color classes
-    """
-
-    DEFAULT = "default"
-    BLUE = "primary"
-    GREY = "secondary"
-    GREEN = "success"
-    RED = "danger"
-    YELLOW = "warning"
-    BLACK = "dark"
-
-    CHOICES = (
-        (DEFAULT, "Default"),
-        (BLUE, "Blue"),
-        (GREY, "Grey"),
-        (GREEN, "Green"),
-        (RED, "Red"),
-        (YELLOW, "Yellow"),
-        (BLACK, "Black"),
-    )
-
-
-class ButtonActionColorChoices(ChoiceSet):
-    """
-    Map standard button actions to Bootstrap color classes.
-    """
-
-    ADD = "success"
-    CANCEL = "default"
-    CLONE = "success"
-    CONFIGURE = "default"
-    CONNECT = "success"
-    DEFAULT = "default"
-    DELETE = "danger"
-    DISCONNECT = "info"
-    EDIT = "warning"
-    EXPORT = "success"
-    IMPORT = "primary"
-    INFO = "info"
-    SUBMIT = "primary"
-    SWAP = "primary"
-
-    CHOICES = (
-        (ADD, "Add"),
-        (CANCEL, "Cancel"),
-        (CLONE, "Clone"),
-        (CONFIGURE, "Configure"),
-        (CONNECT, "Connect"),
-        (DEFAULT, "Default"),
-        (DELETE, "Delete"),
-        (DISCONNECT, "Disconnect"),
-        (EDIT, "Edit"),
-        (EXPORT, "Export"),
-        (IMPORT, "Import"),
-        (INFO, "Info"),
-        (SUBMIT, "Submit"),
-        (SWAP, "Swap"),
-    )
-
-
-class ButtonActionIconChoices(ChoiceSet):
-    """
-    Map standard button actions to Material Design Icons classes.
-    """
-
-    ADD = "mdi-plus-thick"
-    ALERT = "mdi-alert"
-    ARROW_DOWN = "mdi-arrow-down-bold"
-    ARROW_UP = "mdi-arrow-up-bold"
-    CONFIGURE = "mdi-cogs"
-    CONNECT = "mdi-ethernet-cable"
-    DELETE = "mdi-trash-can-outline"
-    DISCONNECT = "mdi-ethernet-cable-off"
-    EDIT = "mdi-pencil"
-    EXPORT = "mdi-database-export-outline"
-    HELP = "mdi-help-circle"
-    INFO = "mdi-help-circle"
-    IMPORT = "mdi-database-import-outline"
-    LOCK = "mdi-lock"
-    MAGNIFY = "mdi-magnify"
-    NOTE = "mdi-note-text"
-    SWAP = "mdi-swap-vertical"
-    TRASH = "mdi-trash-can-outline"
-
-    CHOICES = (
-        (ADD, "Add"),
-        (ALERT, "Alert"),
-        (ARROW_DOWN, "Arrow Down"),
-        (ARROW_UP, "Arrow Up"),
-        (CONFIGURE, "Configure"),
-        (CONNECT, "Connect"),
-        (DELETE, "Delete"),
-        (DISCONNECT, "Disconnect"),
-        (EDIT, "Edit"),
-        (EXPORT, "Export"),
-        (HELP, "Help"),
-        (INFO, "Info"),
-        (IMPORT, "Import"),
-        (LOCK, "Lock"),
-        (MAGNIFY, "Magnify"),
-        (NOTE, "Note"),
-        (SWAP, "Swap"),
-        (TRASH, "Trash"),
-    )

nautobot/core/{cli.py → cli/__init__.py}

@@ -27,7 +27,7 @@ SETTINGS_ENVVAR = "NAUTOBOT_CONFIG"
 BASE_DIR = os.path.dirname(__file__)
 
 # File path of template used to generate config emitted by `init`
-CONFIG_TEMPLATE = os.path.join(BASE_DIR, "templates/nautobot_config.py.j2")
+CONFIG_TEMPLATE = os.path.join(BASE_DIR, "../templates/nautobot_config.py.j2")
 
 DESCRIPTION = """
 Nautobot server management utility.
@@ -148,7 +148,6 @@ def _configure_settings(config):
 
         # django-storages
         if settings.STORAGE_BACKEND.startswith("storages."):
-
             try:
                 import storages.utils
             except ModuleNotFoundError as e:

nautobot/core/cli/__main__.py

@@ -0,0 +1,3 @@
+from nautobot.core.cli import main
+
+main()