nautobot 2.2.5__py3-none-any.whl → 2.2.7__py3-none-any.whl

nautobot/core/utils/git.py

@@ -3,6 +3,7 @@
 from collections import namedtuple
 import logging
 import os
+import string
 
 from git import Repo
 
@@ -34,8 +35,8 @@ GIT_ENVIRONMENT = {
 
 def swap_status_initials(data):
     """Swap Git status initials with its equivalent."""
-    initial, text = data.split("\t")
-    return GitDiffLog(status=GIT_STATUS_MAP.get(initial), text=text)
+    initial, text = data.split("\t", 1)
+    return GitDiffLog(status=GIT_STATUS_MAP.get(initial[0]), text=text)
 
 
 def convert_git_diff_log_to_list(logs):
@@ -93,69 +94,140 @@ class GitRepo:
         """
         Check out the given branch, and optionally the specified commit within that branch.
 
+        Args:
+            branch (str): A branch name, a tag name, or a (possibly abbreviated) commit identifier.
+            commit_hexsha (str): A specific (possibly abbreviated) commit identifier.
+
+        If `commit_hexsha` is specified and `branch` is either a tag or a commit identifier, they must match.
+        If `commit_hexsha` is specified and `branch` is a branch name, it must contain the specified commit.
+
         Returns:
-            (str, bool): commit_hexsha the repo contains now, whether any change occurred
+            (str, bool): commit_hexsha the repo contains now, and whether any change occurred
         """
         # Short-circuit logic - do we already have this commit checked out?
-        if commit_hexsha and commit_hexsha == self.head:
+        if commit_hexsha and self.head.startswith(commit_hexsha):
             logger.debug(f"Commit {commit_hexsha} is already checked out.")
-            return (commit_hexsha, False)
+            return (self.head, False)
+        # User might specify the commit as a "branch" name...
+        if not commit_hexsha and set(branch).issubset(string.hexdigits) and self.head.startswith(branch):
+            logger.debug("Commit %s is already checked out.", branch)
+            return (self.head, False)
 
         self.fetch()
-        if commit_hexsha:
-            # Sanity check - GitPython doesn't provide a handy API for this so we just call a raw Git command:
-            # $ git branch origin/<branch> --remotes --contains <commit>
-            # prints the branch name if it DOES contain the commit, and nothing if it DOES NOT contain the commit.
-            # Since we did a `fetch` and not a `pull` above, we need to check for the commit in the remote origin
-            # branch, not the local (not-yet-updated) branch.
-            if branch not in self.repo.git.branch(f"origin/{branch}", "--remotes", "--contains", commit_hexsha):
-                raise RuntimeError(f"Requested to check out commit `{commit_hexsha}`, but it's not in branch {branch}!")
-            logger.info(f"Checking out commit `{commit_hexsha}` on branch `{branch}`...")
-            self.repo.git.checkout(commit_hexsha)
-            return (commit_hexsha, True)
-
-        if branch in self.repo.heads:
-            branch_head = self.repo.heads[branch]
-        else:
-            try:
-                branch_head = self.repo.create_head(branch, self.repo.remotes.origin.refs[branch])
-                branch_head.set_tracking_branch(self.repo.remotes.origin.refs[branch])
-            except IndexError as git_error:
-                logger.error(
-                    "Branch %s does not exist at %s. %s", branch, next(iter(self.repo.remotes.origin.urls)), git_error
-                )
-                raise BranchDoesNotExist(
-                    f"Please create branch '{branch}' in upstream and try again."
-                    f" If this is a new repo, please add a commit before syncing. {git_error}"
+        # Is `branch` actually a branch, a tag, or a commit? Heuristics:
+        is_branch = branch in self.repo.remotes.origin.refs
+        is_tag = branch in self.repo.tags
+        maybe_commit = set(branch).issubset(string.hexdigits)
+        logger.debug(
+            "Branch %s --> is_branch: %s, is_tag: %s, maybe_commit: %s",
+            branch,
+            is_branch,
+            is_tag,
+            maybe_commit,
+        )
+
+        if is_branch:
+            if commit_hexsha:
+                # Sanity check - GitPython doesn't provide a handy API for this so we just call a raw Git command:
+                # $ git branch origin/<branch> --remotes --contains <commit>
+                # prints the branch name if it DOES contain the commit, and nothing if it DOES NOT contain the commit.
+                # Since we did a `fetch` and not a `pull` above, we need to check for the commit in the remote origin
+                # branch, not the local (not-yet-updated) branch.
+                if branch not in self.repo.git.branch(f"origin/{branch}", "--remotes", "--contains", commit_hexsha):
+                    raise RuntimeError(
+                        f"Requested to check out commit {commit_hexsha}, but it's not part of branch {branch}!"
+                    )
+                logger.info("Checking out commit %s on branch %s...", commit_hexsha, branch)
+                self.repo.git.checkout(commit_hexsha)
+                return (self.head, True)
+
+            if branch in self.repo.heads:
+                branch_head = self.repo.heads[branch]
+            else:
+                try:
+                    branch_head = self.repo.create_head(branch, self.repo.remotes.origin.refs[branch])
+                    branch_head.set_tracking_branch(self.repo.remotes.origin.refs[branch])
+                except IndexError as git_error:
+                    logger.error(
+                        "Branch %s does not exist at %s. %s",
+                        branch,
+                        next(iter(self.repo.remotes.origin.urls)),
+                        git_error,
+                    )
+                    raise BranchDoesNotExist(
+                        f"Please create branch '{branch}' in upstream and try again."
+                        f" If this is a new repo, please add a commit before syncing. {git_error}"
+                    )
+
+            logger.info("Checking out latest commit on branch %s...", branch)
+            branch_head.checkout()
+            # No specific commit hash was given, so make sure we get the latest from origin
+            # We would use repo.remotes.origin.pull() here, but that will fail in the case where someone has
+            # force-pushed to the upstream repo since the last time we did a pull. To be safe, we reset instead.
+            self.repo.head.reset(f"origin/{branch}", index=True, working_tree=True)
+            logger.info("Latest commit on branch `%s` is `%s`", branch, self.head)
+            return (self.head, True)
+
+        if is_tag:
+            tag = self.repo.tags[branch]
+            if commit_hexsha:
+                # Sanity check
+                if not tag.commit.hexsha.startswith(commit_hexsha):
+                    raise RuntimeError(
+                        f"Requested to check out tag {branch} and commit {commit_hexsha} together, "
+                        f"but tag {branch} is actually commit {tag.commit.hexsha}!"
+                    )
+            logger.info("Checking out tag %s...", branch)
+            self.repo.git.checkout(branch)
+            return (self.head, True)
+
+        if maybe_commit:
+            # Sanity check
+            if commit_hexsha and not (commit_hexsha.startswith(branch) or branch.startswith(commit_hexsha)):
+                raise RuntimeError(
+                    f"Requested to check out both {branch} and {commit_hexsha} together, "
+                    f"but {branch} is neither a branch, a tag, nor the same commit hash!"
                 )
 
-        logger.info(f"Checking out latest commit on branch `{branch}`...")
-        branch_head.checkout()
-        # No specific commit hash was given, so make sure we get the latest from origin
-        # We would use repo.remotes.origin.pull() here, but that will fail in the case where someone has
-        # force-pushed to the upstream repo since the last time we did a pull. To be safe, we reset instead.
-        self.repo.head.reset(f"origin/{branch}", index=True, working_tree=True)
-        commit_hexsha = self.repo.head.reference.commit.hexsha
-        logger.info(f"Latest commit on branch `{branch}` is `{commit_hexsha}`")
-        return (commit_hexsha, True)
+            logger.info("Checking out commit %s...", branch)
+            self.repo.git.checkout(branch)
+            return (self.head, True)
+
+        # Fallthru
+        raise BranchDoesNotExist(
+            f"{branch} does not appear to be an existing branch, tag, or possible commit hash. "
+            "Please check your upstream repository and the data you are using."
+        )
 
     def diff_remote(self, branch):
         logger.debug("Fetching from remote.")
         self.fetch()
-
-        try:
-            self.repo.remotes.origin.refs[branch]
-        except IndexError as git_error:
-            logger.error(
-                "Branch %s does not exist at %s. %s", branch, next(iter(self.repo.remotes.origin.urls)), git_error
-            )
+        # Is `branch` actually a branch, a tag, or a commit? Heuristics:
+        is_branch = branch in self.repo.remotes.origin.refs
+        is_tag = branch in self.repo.tags
+        maybe_commit = set(branch).issubset(string.hexdigits)
+        logger.debug(
+            "Branch %s --> is_branch: %s, is_tag: %s, maybe_commit: %s",
+            branch,
+            is_branch,
+            is_tag,
+            maybe_commit,
+        )
+
+        if not is_branch and not is_tag and not maybe_commit:
+            logger.error("Branch %s does not exist at %s", branch, next(iter(self.repo.remotes.origin.urls)))
             raise BranchDoesNotExist(
                 f"Please create branch '{branch}' in upstream and try again."
-                f" If this is a new repo, please add a commit before syncing. {git_error}"
+                f" If this is a new repo, please add a commit before syncing."
             )
 
-        logger.debug("Getting diff between local branch and remote branch")
-        diff = self.repo.git.diff("--name-status", f"origin/{branch}")
+        if is_branch:
+            logger.debug("Getting diff between local branch and remote branch")
+            diff = self.repo.git.diff("--name-status", f"origin/{branch}")
+        else:
+            logger.debug("Getting diff between local state and specified tag or commit")
+            diff = self.repo.git.diff("--name-status", branch)
+
         if diff:  # if diff is not empty
             return convert_git_diff_log_to_list(diff)
         logger.debug("No Difference")

nautobot/core/utils/module_loading.py

@@ -24,6 +24,15 @@ def _temporarily_add_to_sys_path(path):
         sys.path = old_sys_path
 
 
+def clear_module_from_sys_modules(module_name):
+    """
+    Remove the module and all its submodules from sys.modules.
+    """
+    for name in list(sys.modules.keys()):
+        if name == module_name or name.startswith(f"{module_name}."):
+            del sys.modules[name]
+
+
 def import_modules_privately(path, module_path=None, ignore_import_errors=True):
     """
     Import modules from the filesystem without adding the path permanently to `sys.path`.
@@ -69,7 +78,7 @@ def import_modules_privately(path, module_path=None, ignore_import_errors=True):
                     continue
 
             if discovered_module_name in sys.modules:
-                del sys.modules[discovered_module_name]
+                clear_module_from_sys_modules(discovered_module_name)
 
             try:
                 if not is_package:
@@ -81,7 +90,6 @@ def import_modules_privately(path, module_path=None, ignore_import_errors=True):
                     spec.loader.exec_module(module)
                 else:
                     module = importlib.import_module(discovered_module_name)
-
                 importlib.reload(module)
             except Exception as exc:
                 logger.error("Unable to load module %s from %s: %s", discovered_module_name, path, exc)

nautobot/dcim/factory.py

@@ -708,6 +708,6 @@ class ControllerManagedDeviceGroupFactory(PrimaryModelFactory):
     name = UniqueFaker("word")
     parent = factory.Maybe("has_parent", random_instance(ControllerManagedDeviceGroup), None)
     controller = factory.LazyAttribute(
-        lambda o: o.parent.controller if o.parent else Controller.objects.order_by("?").first()
+        lambda o: o.parent.controller if o.parent else factory.random.randgen.choice(Controller.objects.all())
     )
     weight = factory.Faker("pyint", min_value=1, max_value=1000)

nautobot/dcim/tests/test_models.py

@@ -1854,12 +1854,14 @@ class SoftwareVersionTestCase(ModelTestCases.BaseModelTestCase):
 
         # Only return the device types with a direct m2m relationship to the version's software image files
         device_type = DeviceType.objects.filter(software_image_files__isnull=False).first()
+        self.assertIsNotNone(device_type)
         self.assertQuerysetEqualAndNotEmpty(
             qs.get_for_object(device_type), qs.filter(software_image_files__device_types=device_type)
         )
 
         # Only return the software version set on the device's software_version foreign key
         device = Device.objects.filter(software_version__isnull=False).first()
+        self.assertIsNotNone(device)
         self.assertQuerysetEqualAndNotEmpty(qs.get_for_object(device), [device.software_version])
 
         # Only return the software version set on the inventory item's software_version foreign key

nautobot/extras/datasources/git.py

@@ -136,7 +136,7 @@ def get_repo_from_url_to_path_and_from_branch(repository_record):
 
 def ensure_git_repository(repository_record, logger=None, head=None):  # pylint: disable=redefined-outer-name
     """Ensure that the given Git repo is present, up-to-date, and has the correct branch selected.
-    Note that this function may be called independently of the `GitRepositoryiSync` job,
+    Note that this function may be called independently of the `GitRepositorySync` job,
     such as to ensure that different Nautobot instances and/or worker instances all have a local copy of the same HEAD.
     Args:
       repository_record (GitRepository): Repository to ensure the state of.
@@ -224,126 +224,127 @@ def refresh_git_config_contexts(repository_record, job_result, delete=False):
 def update_git_config_contexts(repository_record, job_result):
     """Refresh any config contexts provided by this Git repository."""
     config_context_path = os.path.join(repository_record.filesystem_path, "config_contexts")
-    if not os.path.isdir(config_context_path):
-        return
-
     managed_config_contexts = set()
     managed_local_config_contexts = defaultdict(set)
 
-    # First, handle the "flat file" case - data files in the root config_context_path,
-    # whose metadata is expressed purely within the contents of the file:
-    for file_name in os.listdir(config_context_path):
-        if not os.path.isfile(os.path.join(config_context_path, file_name)):
-            continue
-        msg = f"Loading config context from `{file_name}`"
-        logger.info(msg)
-        job_result.log(msg, grouping="config contexts")
-        try:
-            with open(os.path.join(config_context_path, file_name), "r") as fd:
-                # The data file can be either JSON or YAML; since YAML is a superset of JSON, we can load it regardless
-                context_data = yaml.safe_load(fd)
-
-            # A file can contain one config context dict or a list thereof
-            if isinstance(context_data, dict):
-                context_name = import_config_context(context_data, repository_record, job_result)
-                managed_config_contexts.add(context_name)
-            elif isinstance(context_data, list):
-                for context_data_entry in context_data:
-                    context_name = import_config_context(context_data_entry, repository_record, job_result)
-                    managed_config_contexts.add(context_name)
-            else:
-                raise RuntimeError("data must be a dict or list of dicts")
-
-        except Exception as exc:
-            msg = f"Error in loading config context data from `{file_name}`: {exc}"
-            logger.error(msg)
-            job_result.log(msg, level_choice=LogLevelChoices.LOG_ERROR, grouping="config contexts")
-
-    # Next, handle the "filter/name" directory structure case - files in <filter_type>/<name>.(json|yaml)
-    for filter_type in (
-        "locations",
-        "device_types",
-        "roles",
-        "platforms",
-        "cluster_groups",
-        "clusters",
-        "tenant_groups",
-        "tenants",
-        "tags",
-        "dynamic_groups",
-        "device_redundancy_groups",
-    ):
-        if os.path.isdir(os.path.join(repository_record.filesystem_path, filter_type)):
-            msg = (
-                f'Found "{filter_type}" directory in the repository root. If this is meant to contain config contexts, '
-                "it should be moved into a `config_contexts/` subdirectory."
-            )
-            logger.warning(msg)
-            job_result.log(msg, level_choice=LogLevelChoices.LOG_WARNING, grouping="config contexts")
-
-        dir_path = os.path.join(config_context_path, filter_type)
-        if not os.path.isdir(dir_path):
-            continue
-
-        for file_name in os.listdir(dir_path):
-            name = os.path.splitext(file_name)[0]
-            msg = f'Loading config context, filter `{filter_type} = [name: "{name}"]`, from `{filter_type}/{file_name}`'
+    if os.path.isdir(config_context_path):
+        # First, handle the "flat file" case - data files in the root config_context_path,
+        # whose metadata is expressed purely within the contents of the file:
+        for file_name in os.listdir(config_context_path):
+            if not os.path.isfile(os.path.join(config_context_path, file_name)):
+                continue
+            msg = f"Loading config context from `{file_name}`"
             logger.info(msg)
             job_result.log(msg, grouping="config contexts")
             try:
-                with open(os.path.join(dir_path, file_name), "r") as fd:
-                    # Data file can be either JSON or YAML; since YAML is a superset of JSON, we can load it regardless
+                with open(os.path.join(config_context_path, file_name), "r") as fd:
+                    # The data file can be either JSON or YAML; since YAML is a superset of JSON, we load it regardless
                     context_data = yaml.safe_load(fd)
 
-                # Unlike the above case, these files always contain just a single config context record
-
-                # Add the implied filter to the context metadata
-                if filter_type == "device_types":
-                    context_data.setdefault("_metadata", {}).setdefault(filter_type, []).append({"model": name})
+                # A file can contain one config context dict or a list thereof
+                if isinstance(context_data, dict):
+                    context_name = import_config_context(context_data, repository_record, job_result)
+                    managed_config_contexts.add(context_name)
+                elif isinstance(context_data, list):
+                    for context_data_entry in context_data:
+                        context_name = import_config_context(context_data_entry, repository_record, job_result)
+                        managed_config_contexts.add(context_name)
                 else:
-                    context_data.setdefault("_metadata", {}).setdefault(filter_type, []).append({"name": name})
+                    raise RuntimeError("data must be a dict or list of dicts")
 
-                context_name = import_config_context(context_data, repository_record, job_result)
-                managed_config_contexts.add(context_name)
             except Exception as exc:
                 msg = f"Error in loading config context data from `{file_name}`: {exc}"
                 logger.error(msg)
                 job_result.log(msg, level_choice=LogLevelChoices.LOG_ERROR, grouping="config contexts")
 
-    # Finally, handle device- and virtual-machine-specific "local" context in (devices|virtual_machines)/<name>.(json|yaml)
-    for local_type in ("devices", "virtual_machines"):
-        if os.path.isdir(os.path.join(repository_record.filesystem_path, local_type)):
-            msg = (
-                f'Found "{local_type}" directory in the repository root. If this is meant to contain config contexts, '
-                "it should be moved into a `config_contexts/` subdirectory."
-            )
-            logger.warning(msg)
-            job_result.log(msg, level_choice=LogLevelChoices.LOG_WARNING, grouping="config contexts")
+        # Next, handle the "filter/name" directory structure case - files in <filter_type>/<name>.(json|yaml)
+        for filter_type in (
+            "locations",
+            "device_types",
+            "roles",
+            "platforms",
+            "cluster_groups",
+            "clusters",
+            "tenant_groups",
+            "tenants",
+            "tags",
+            "dynamic_groups",
+            "device_redundancy_groups",
+        ):
+            if os.path.isdir(os.path.join(repository_record.filesystem_path, filter_type)):
+                msg = (
+                    f'Found "{filter_type}" directory in the repository root. If this is meant to contain config contexts, '
+                    "it should be moved into a `config_contexts/` subdirectory."
+                )
+                logger.warning(msg)
+                job_result.log(msg, level_choice=LogLevelChoices.LOG_WARNING, grouping="config contexts")
 
-        dir_path = os.path.join(config_context_path, local_type)
-        if not os.path.isdir(dir_path):
-            continue
+            dir_path = os.path.join(config_context_path, filter_type)
+            if not os.path.isdir(dir_path):
+                continue
 
-        for file_name in os.listdir(dir_path):
-            device_name = os.path.splitext(file_name)[0]
-            msg = f"Loading local config context for `{device_name}` from `{local_type}/{file_name}`"
-            logger.info(msg)
-            job_result.log(msg, grouping="local config contexts")
-            try:
-                with open(os.path.join(dir_path, file_name), "r") as fd:
-                    context_data = yaml.safe_load(fd)
+            for file_name in os.listdir(dir_path):
+                name = os.path.splitext(file_name)[0]
+                msg = (
+                    f'Loading config context, filter `{filter_type} = [name: "{name}"]`, '
+                    f"from `{filter_type}/{file_name}`"
+                )
+                logger.info(msg)
+                job_result.log(msg, grouping="config contexts")
+                try:
+                    with open(os.path.join(dir_path, file_name), "r") as fd:
+                        # Data file can be either JSON or YAML; since YAML is a superset of JSON, we load it regardless
+                        context_data = yaml.safe_load(fd)
+
+                    # Unlike the above case, these files always contain just a single config context record
+
+                    # Add the implied filter to the context metadata
+                    if filter_type == "device_types":
+                        context_data.setdefault("_metadata", {}).setdefault(filter_type, []).append({"model": name})
+                    else:
+                        context_data.setdefault("_metadata", {}).setdefault(filter_type, []).append({"name": name})
 
-                import_local_config_context(
-                    local_type,
-                    device_name,
-                    context_data,
-                    repository_record,
+                    context_name = import_config_context(context_data, repository_record, job_result)
+                    managed_config_contexts.add(context_name)
+                except Exception as exc:
+                    msg = f"Error in loading config context data from `{file_name}`: {exc}"
+                    logger.error(msg)
+                    job_result.log(msg, level_choice=LogLevelChoices.LOG_ERROR, grouping="config contexts")
+
+        # Finally, handle device- and VM-specific "local" context in (devices|virtual_machines)/<name>.(json|yaml)
+        for local_type in ("devices", "virtual_machines"):
+            if os.path.isdir(os.path.join(repository_record.filesystem_path, local_type)):
+                msg = (
+                    f'Found "{local_type}" directory in the repository root. If this is meant to contain '
+                    "config contexts, it should be moved into a `config_contexts/` subdirectory."
                 )
-                managed_local_config_contexts[local_type].add(device_name)
-            except Exception as exc:
-                msg = f"Error in loading local config context from `{local_type}/{file_name}`: {exc}"
-                logger.error(msg)
-                job_result.log(msg, level_choice=LogLevelChoices.LOG_ERROR, grouping="local config contexts")
+                logger.warning(msg)
+                job_result.log(msg, level_choice=LogLevelChoices.LOG_WARNING, grouping="config contexts")
+
+            dir_path = os.path.join(config_context_path, local_type)
+            if not os.path.isdir(dir_path):
+                continue
+
+            for file_name in os.listdir(dir_path):
+                device_name = os.path.splitext(file_name)[0]
+                msg = f"Loading local config context for `{device_name}` from `{local_type}/{file_name}`"
+                logger.info(msg)
+                job_result.log(msg, grouping="local config contexts")
+                try:
+                    with open(os.path.join(dir_path, file_name), "r") as fd:
+                        context_data = yaml.safe_load(fd)
+
+                    import_local_config_context(
+                        local_type,
+                        device_name,
+                        context_data,
+                        repository_record,
+                    )
+                    managed_local_config_contexts[local_type].add(device_name)
+                except Exception as exc:
+                    msg = f"Error in loading local config context from `{local_type}/{file_name}`: {exc}"
+                    logger.error(msg)
+                    job_result.log(msg, level_choice=LogLevelChoices.LOG_ERROR, grouping="local config contexts")
 
     # Delete any prior contexts that are owned by this repository but were not created/updated above
     delete_git_config_contexts(
@@ -599,39 +600,38 @@ def refresh_git_config_context_schemas(repository_record, job_result, delete=Fal
 def update_git_config_context_schemas(repository_record, job_result):
     """Refresh any config context schemas provided by this Git repository."""
     config_context_schema_path = os.path.join(repository_record.filesystem_path, "config_context_schemas")
-    if not os.path.isdir(config_context_schema_path):
-        return
 
     managed_config_context_schemas = set()
 
-    for file_name in os.listdir(config_context_schema_path):
-        if not os.path.isfile(os.path.join(config_context_schema_path, file_name)):
-            continue
-        msg = (f"Loading config context schema from `{file_name}`",)
-        logger.info(msg)
-        job_result.log(msg, grouping="config context schemas")
-        try:
-            with open(os.path.join(config_context_schema_path, file_name), "r") as fd:
-                # The data file can be either JSON or YAML; since YAML is a superset of JSON, we can load it regardless
-                context_schema_data = yaml.safe_load(fd)
-
-            # A file can contain one config context dict or a list thereof
-            if isinstance(context_schema_data, dict):
-                context_name = import_config_context_schema(context_schema_data, repository_record, job_result)
-                managed_config_context_schemas.add(context_name)
-            elif isinstance(context_schema_data, list):
-                for context_schema in context_schema_data:
-                    if isinstance(context_schema, dict):
-                        context_name = import_config_context_schema(context_schema, repository_record, job_result)
-                        managed_config_context_schemas.add(context_name)
-                    else:
-                        raise RuntimeError("each item in list data must be a dict")
-            else:
-                raise RuntimeError("data must be a dict or a list of dicts")
-        except Exception as exc:
-            msg = f"Error in loading config context schema data from `{file_name}`: {exc}"
-            logger.error(msg)
-            job_result.log(msg, level_choice=LogLevelChoices.LOG_ERROR, grouping="config context schemas")
+    if os.path.isdir(config_context_schema_path):
+        for file_name in os.listdir(config_context_schema_path):
+            if not os.path.isfile(os.path.join(config_context_schema_path, file_name)):
+                continue
+            msg = (f"Loading config context schema from `{file_name}`",)
+            logger.info(msg)
+            job_result.log(msg, grouping="config context schemas")
+            try:
+                with open(os.path.join(config_context_schema_path, file_name), "r") as fd:
+                    # The data file can be either JSON or YAML; since YAML is a superset of JSON, we load it regardless
+                    context_schema_data = yaml.safe_load(fd)
+
+                # A file can contain one config context dict or a list thereof
+                if isinstance(context_schema_data, dict):
+                    context_name = import_config_context_schema(context_schema_data, repository_record, job_result)
+                    managed_config_context_schemas.add(context_name)
+                elif isinstance(context_schema_data, list):
+                    for context_schema in context_schema_data:
+                        if isinstance(context_schema, dict):
+                            context_name = import_config_context_schema(context_schema, repository_record, job_result)
+                            managed_config_context_schemas.add(context_name)
+                        else:
+                            raise RuntimeError("each item in list data must be a dict")
+                else:
+                    raise RuntimeError("data must be a dict or a list of dicts")
+            except Exception as exc:
+                msg = f"Error in loading config context schema data from `{file_name}`: {exc}"
+                logger.error(msg)
+                job_result.log(msg, level_choice=LogLevelChoices.LOG_ERROR, grouping="config context schemas")
 
     # Delete any prior contexts that are owned by this repository but were not created/updated above
     delete_git_config_context_schemas(
@@ -835,12 +835,10 @@ def update_git_export_templates(repository_record, job_result):
             job_result.log(msg, level_choice=LogLevelChoices.LOG_WARNING, grouping="export templates")
 
     export_template_path = os.path.join(repository_record.filesystem_path, "export_templates")
-    if not os.path.isdir(export_template_path):
-        return
+    managed_export_templates = {}
 
     git_repository_content_type = ContentType.objects.get_for_model(GitRepository)
 
-    managed_export_templates = {}
     for model_content_type, file_path in files_from_contenttype_directories(
         export_template_path, job_result, "export templates"
     ):

nautobot/extras/datasources/utils.py

@@ -15,6 +15,9 @@ def files_from_contenttype_directories(base_path, job_result, log_grouping):
     Returns:
         (Tuple[ContentType, file_path]): A tuple of the ContentType and the file path.
     """
+    if not os.path.isdir(base_path):
+        return
+
     for app_label in os.listdir(base_path):
         app_label_path = os.path.join(base_path, app_label)
         if not os.path.isdir(app_label_path):

nautobot/extras/filters/__init__.py

@@ -902,6 +902,7 @@ class JobButtonFilterSet(BaseFilterSet):
         fields = (
             "content_types",
             "name",
+            "enabled",
             "text",
             "job",
             "weight",