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

nautobot/core/management/commands/build_ui.py

@@ -0,0 +1,255 @@
+import copy
+from importlib import import_module
+import json
+import os
+from pathlib import Path
+import re
+import shlex
+import subprocess
+
+from django.apps import apps
+from django.conf import settings
+from django.contrib.admindocs.views import simplify_regex
+from django.core.management.base import BaseCommand, CommandError
+import jinja2
+
+
+class Command(BaseCommand):
+    help = "Build the user interface for the Nautobot server environment and installed Nautobot Apps."
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--npm-install",
+            action="store_true",
+            dest="npm_install",
+            default=False,
+            help="Install UI packages.",
+        )
+        parser.add_argument(
+            "--no-render-apps",
+            action="store_false",
+            dest="render_apps",
+            default=True,
+            help="Do not render Nautobot App imports.",
+        )
+        parser.add_argument(
+            "--no-npm-build",
+            action="store_false",
+            dest="npm_build",
+            default=True,
+            help="Do not compile UI.",
+        )
+
+    def convert_django_url_regex_to_react_route_path(self, regex):
+        """
+        Converts a regular expression object to its equivalent react router path representation.
+
+        Args:
+            regex (re.Pattern): A regular expression object.
+
+        Example:
+            >>> pattern = re.compile('^other-models/(?P<pk>[^/.]+)/notes/$')
+            >>> convert_django_url_regex_to_react_route_path(pattern)
+            '/other-models/:pk/notes/'
+        """
+        pattern = str(regex.pattern)
+        path = simplify_regex(pattern).replace("<", ":").replace(">", "").replace("\\Z", "").replace("\\", "")
+        return path if path.endswith("/") else f"{path}/"
+
+    def get_app_component(self, file_path, route_name):
+        """
+        Obtains the view component for the given route name from the index.js file of the App.
+        This locates the `route_name` in the app configuration `routes_view_components` dict and
+        returns the View Component registered for the `route_name`.
+
+        Parameters:
+            file_path (str): The path to the JavaScript file to read from.
+            route_name (str): The name of the route to extract the view component for.
+
+        Returns:
+            str: The view component associated with the specified route name, or None if not found.
+
+        Example:
+            >>> get_app_component(file_path="/src/example_plugin/example_plugin/ui/index.js", route_name="example-plugin:examplemodel_list")
+            "ExampleModelListView"
+        """
+        try:
+            with open(file_path, "r") as f:
+                js_content = f.read()
+        except FileNotFoundError:
+            return None
+
+        # Construct a regular expression that matches the specified key and extracts the associated view component
+        pattern = rf'routes_view_components:\s*{{[^}}]*"{re.escape(route_name)}"\s*:\s*"([^"]+)"'
+        view_component_match = re.search(pattern, js_content)
+        return view_component_match[1] if view_component_match else None
+
+    def render_routes_imports(self, app_base_path, app_name, app_config):
+        """
+        Renders the imports for the React Router components of the App's URLs.
+
+        This method inspects the `urlpatterns` list of the `urls.py` module of the App and generates
+        a list of dictionaries representing the React Router components and their corresponding URL paths.
+
+        Args:
+            app_base_path (Path): The base path of the Django app.
+            app_name (str): The name of the Django app.
+            app_config (AppConfig): The configuration object of the Django app.
+
+        Returns:
+            List[Dict[str, str]]: A list of dictionaries representing the React Router components and their
+            corresponding URL paths.
+            Each dictionary has the following keys:
+            - "path": The URL path pattern.
+            - "component": The React component associated with the URL path.
+
+        Example:
+            >>> render_routes_imports("/src/example_plugin/", "example_plugin", <AppConfig instance>)
+            [
+                { "path": "example-plugin/", "component": "HomeView"},
+                { "path": "example-plugin/config/", "component": "ConfigView"},
+            ]
+        """
+        data = []
+        try:
+            module = import_module(f"{app_name}.urls")
+            base_url = app_config.base_url or app_config.label
+            for urlpattern in module.urlpatterns:
+                if component := self.get_app_component(
+                    app_base_path / "ui/index.js",
+                    f"{base_url}:{urlpattern.name}",
+                ):
+                    path_regex = urlpattern.pattern.regex
+                    url_path = self.convert_django_url_regex_to_react_route_path(path_regex)
+                    data.append({"path": base_url + url_path, "component": component})
+            return data
+        except (AttributeError, ModuleNotFoundError):
+            # If an app does not include its url.py file or urls.py does not include a urlpatterns, skip.
+            return data
+
+    def render_app_imports(self):
+        """Render `app_imports.js`, update `jsconfig.json` to map to the path for each and render `app_routes.json` to register all app routes."""
+        self.stdout.write(self.style.WARNING(">>> Rendering Nautobot App imports..."))
+
+        ui_dir = settings.NAUTOBOT_UI_DIR
+
+        router_file_path = Path(ui_dir, "src", "router.js")
+        app_routes_file_path = Path(ui_dir, "src", "app_routes.json")
+        jsconfig_file_path = Path(ui_dir, "jsconfig.paths.json")
+        jsconfig_base_file_path = Path(ui_dir, "jsconfig-base.json")
+        app_routes = {}
+
+        with open(jsconfig_base_file_path, "r", encoding="utf-8") as base_config_file:
+            jsconfig = json.load(base_config_file)
+
+        # We're going to modify this list if apps don't have a `ui` directory.
+        enabled_apps = copy.copy(settings.PLUGINS)
+
+        for app_class_path in settings.PLUGINS:
+            app_name = app_class_path.split(".")[-1]
+            app_config = apps.get_app_config(app_name)
+            abs_app_path = Path(app_config.path).resolve()
+            abs_app_ui_path = abs_app_path / "ui"
+            app_path = Path(os.path.relpath(abs_app_path, ui_dir))
+            app_ui_path = app_path / "ui"
+            if app_routes_imports := self.render_routes_imports(abs_app_path, app_name, app_config):
+                app_routes[app_name] = app_routes_imports
+
+            # Assert that an App has a UI folder.
+            if not abs_app_ui_path.exists():
+                self.stdout.write(self.style.ERROR(f"- App {app_name!r} does not publish a UI; Skipping..."))
+                enabled_apps.remove(app_class_path)
+                continue
+            self.stdout.write(self.style.SUCCESS(f"- App {app_name!r} imported"))
+
+            jsconfig["compilerOptions"]["paths"][f"@{app_name}/*"] = [f"{app_ui_path}/*"]
+
+        with open(jsconfig_file_path, "w", encoding="utf-8") as generated_config_file:
+            json.dump(jsconfig, generated_config_file, indent=4)
+
+        with open(app_routes_file_path, "w", encoding="utf-8") as app_routes_file:
+            json.dump(app_routes, app_routes_file, indent=4)
+
+        app_imports_final_file_path = Path(ui_dir, "src", "app_imports.js")
+        environment = jinja2.sandbox.SandboxedEnvironment(loader=jinja2.FileSystemLoader(ui_dir))
+        template = environment.get_template("app_imports.js.j2")
+        content = template.render(apps=enabled_apps)
+
+        with open(app_imports_final_file_path, "w", encoding="utf-8") as generated_import_file:
+            generated_import_file.write(content)
+
+        # Touch the router to attempt to trigger a server reload.
+        Path(router_file_path).touch()
+
+    def run_command(self, command, message, cwd=settings.NAUTOBOT_UI_DIR):
+        """
+        Run a `command`, displaying `message` and exit. This splits it for you and runs it.
+
+        Args:
+            command (str): The command to execute
+            message (str): Message to display when command is executed
+        """
+        self.stdout.write(self.style.WARNING(message))
+        self.stdout.write(f"Running '{command}' in '{cwd}'...")
+
+        try:
+            result = subprocess.run(
+                shlex.split(command),
+                check=False,
+                cwd=cwd,
+                env={**os.environ.copy()},
+                encoding="utf-8",
+                capture_output=True,
+            )
+        except FileNotFoundError as err:
+            raise CommandError(f"'{command}' failed with error: {err}")
+
+        if result.returncode:
+            self.stdout.write(self.style.NOTICE(result.stdout))
+            self.stderr.write(self.style.ERROR(result.stderr))
+            raise CommandError(f"'{command}' failed with exit code {result.returncode}")
+
+    def handle(self, *args, **options):
+        verbosity = options["verbosity"]
+
+        # NAUTOBOT_DEBUG is also set here so that `console.log` isn't suppressed when we want
+        # verbosity.
+        if verbosity > 1:
+            os.environ["NAUTOBOT_DEBUG"] = "1"
+
+        verbosity_map = {
+            0: "silent",
+            1: "notice",
+            2: "info",
+            3: "silly",  # MAXIMUM OVERDEBUG
+        }
+        loglevel = f"--loglevel {verbosity_map[verbosity]}"
+
+        if not os.path.exists(Path(settings.NAUTOBOT_UI_DIR)):
+            os.makedirs(Path(settings.NAUTOBOT_UI_DIR))
+
+        self.run_command(
+            f"cp -r {Path(settings.BASE_DIR, 'ui')}/. {Path(settings.NAUTOBOT_UI_DIR)}",
+            ">>> Copying UI source files...",
+        )
+
+        # Generate `app_imports.js`
+        if options["render_apps"]:
+            self.render_app_imports()
+
+        # Run `npm install` and keep it silent by default.
+        if options["npm_install"]:
+            args = f"install {loglevel} --no-progress"
+            self.run_command(f"npm {args}", ">>> Installing Nautobot UI dependencies...")
+
+        # Run `npm build` and keep it silent by default.
+        if options["npm_build"]:
+            args = f"run build {loglevel}"
+            self.run_command(f"npm {args}", ">>> Compiling Nautobot UI packages...")
+            self.run_command(
+                f"cp {Path(settings.NAUTOBOT_UI_DIR, 'build' ,'asset-manifest.json')} "
+                f"{Path(settings.NAUTOBOT_UI_DIR, 'build' , 'static', 'asset-manifest.json')}",
+                ">>> Copying built manifest...",
+            )
+
+        self.stdout.write(self.style.SUCCESS(">>> Nautobot UI build complete! 🎉"))

nautobot/core/management/commands/generate_test_data.py

@@ -185,15 +185,16 @@ Type 'yes' to continue, or 'no' to cancel: """
             call_command("flush", "--no-input")
 
         if options["cache_test_fixtures"] and os.path.exists(options["fixture_file"]):
+            self.stdout.write(self.style.WARNING(f"Loading factory data from file {options['fixture_file']}"))
             call_command("loaddata", options["fixture_file"])
         else:
             self._generate_factory_data(options["seed"])
 
             if options["cache_test_fixtures"]:
+                self.stdout.write(self.style.WARNING(f"Saving factory data to file {options['fixture_file']}"))
+
                 call_command(
                     "dumpdata",
-                    "--natural-foreign",
-                    "--natural-primary",
                     indent=2,
                     format="json",
                     exclude=["contenttypes", "auth.permission", "extras.job", "extras.customfield"],

nautobot/core/management/commands/post_upgrade.py

@@ -11,10 +11,10 @@ This will run the following management commands with default settings, in order:
 
 - migrate
 - trace_paths
+- build_ui --npm-install
 - collectstatic
 - remove_stale_contenttypes
 - clearsessions
-- invalidate all
 """
 
 
@@ -28,6 +28,13 @@ class Command(BaseCommand):
         return parser
 
     def add_arguments(self, parser):
+        parser.add_argument(
+            "--no-build-ui",
+            action="store_false",
+            dest="build_ui",
+            default=True,
+            help="Do not automatically build the user interface.",
+        )
         parser.add_argument(
             "--no-clearsessions",
             action="store_false",
@@ -42,13 +49,6 @@ class Command(BaseCommand):
             default=True,
             help="Do not automatically collect static files into a single location.",
         )
-        parser.add_argument(
-            "--no-invalidate-all",
-            action="store_false",
-            dest="invalidate_all",
-            default=True,
-            help="Do not automatically invalidate cache for entire application.",
-        )
         parser.add_argument(
             "--no-migrate",
             action="store_false",
@@ -74,41 +74,41 @@ class Command(BaseCommand):
     def handle(self, *args, **options):
         # Run migrate
         if options.get("migrate"):
-            print("Performing database migrations...")
+            self.stdout.write("Performing database migrations...")
             call_command(
                 "migrate",
                 interactive=False,
                 traceback=options["traceback"],
                 verbosity=options["verbosity"],
             )
-            print()
+            self.stdout.write()
 
         # Run trace_paths
         if options.get("trace_paths"):
-            print("Generating cable paths...")
+            self.stdout.write("Generating cable paths...")
             call_command("trace_paths", no_input=True)
-            print()
+            self.stdout.write()
+
+        # Run build
+        if options.get("build_ui"):
+            self.stdout.write("Building user interface...")
+            call_command("build_ui", npm_install=True)
+            self.stdout.write()
 
         # Run collectstatic
         if options.get("collectstatic"):
-            print("Collecting static files...")
+            self.stdout.write("Collecting static files...")
             call_command("collectstatic", interactive=False)
-            print()
+            self.stdout.write()
 
         # Run remove_stale_contenttypes
         if options.get("remove_stale_contenttypes"):
-            print("Removing stale content types...")
+            self.stdout.write("Removing stale content types...")
             call_command("remove_stale_contenttypes", interactive=False)
-            print()
+            self.stdout.write()
 
         # Run clearsessions
         if options.get("clearsessions"):
-            print("Removing expired sessions...")
+            self.stdout.write("Removing expired sessions...")
             call_command("clearsessions")
-            print()
-
-        # Run invalidate all
-        if options.get("invalidate_all"):
-            print("Invalidating cache...")
-            call_command("invalidate", "all")
-            print()
+            self.stdout.write()

nautobot/core/models/__init__.py

@@ -1,11 +1,13 @@
 import uuid
 
 from django.db import models
+from django.urls import NoReverseMatch, reverse
 from django.utils.functional import classproperty
 
 from nautobot.core.models.managers import BaseManager
 from nautobot.core.models.querysets import RestrictedQuerySet
 from nautobot.core.models.utils import construct_natural_key_slug
+from nautobot.core.utils.lookup import get_route_for_model
 
 
 class BaseModel(models.Model):
@@ -37,6 +39,29 @@ class BaseModel(models.Model):
         """
         return not self._state.adding
 
+    def get_absolute_url(self, api=False):
+        """
+        Return the canonical URL for this object in either the UI or the REST API.
+        """
+
+        # Iterate the pk-like fields and try to get a URL, or return None.
+        fields = ["pk", "slug"]  # TODO: Eventually all PKs
+        actions = ["retrieve", "detail", ""]  # TODO: Eventually all retrieve
+
+        for field in fields:
+            if not hasattr(self, field):
+                continue
+
+            for action in actions:
+                route = get_route_for_model(self, action, api=api)
+
+                try:
+                    return reverse(route, kwargs={field: getattr(self, field)})
+                except NoReverseMatch:
+                    continue
+
+        return AttributeError(f"Cannot find a URL for {self} ({self._meta.app_label}.{self._meta.model_name})")
+
     class Meta:
         abstract = True
 
@@ -48,7 +73,7 @@ class BaseModel(models.Model):
         which in effect enforces model validation prior to saving the instance, without having
         to manually make these calls seperately. This is a slight departure from Django norms,
         but is intended to offer an optional, simplified interface for performing this common
-        workflow. The intended use is for user defined Jobs and scripts run via the `nautobot-server nbshell`
+        workflow. The intended use is for user defined Jobs run via the `nautobot-server nbshell`
         command.
         """
         self.full_clean()

nautobot/core/models/fields.py

@@ -8,9 +8,11 @@ from django.db import models
 from django.utils.text import slugify
 from django_extensions.db.fields import AutoSlugField as _AutoSlugField
 from netaddr import AddrFormatError, EUI, mac_unix_expanded
+from taggit.managers import TaggableManager
 
 from nautobot.core.forms import fields, widgets
 from nautobot.core.models import ordering
+from nautobot.core.models.managers import TagsManager
 
 
 class mac_unix_expanded_uppercase(mac_unix_expanded):
@@ -184,10 +186,6 @@ class ForeignKeyLimitedByContentTypes(ForeignKeyWithAutoRelatedName):
         - the content-type to which the field is attached (e.g. `dcim.device`)
     """
 
-    def __init__(self, **kwargs):
-        kwargs.setdefault("null", True)
-        super().__init__(**kwargs)
-
     def get_limit_choices_to(self):
         return {"content_types": ContentType.objects.get_for_model(self.model)}
 
@@ -323,7 +321,7 @@ class JSONArrayField(models.JSONField):
                 # Assume we're deserializing
                 vals = json.loads(value)
                 value = [self.base_field.to_python(val) for val in vals]
-            except json.JSONDecodeError as e:
+            except (TypeError, json.JSONDecodeError) as e:
                 raise exceptions.ValidationError(e)
         return value
 
@@ -370,3 +368,24 @@ class JSONArrayField(models.JSONField):
                 **kwargs,
             }
         )
+
+
+class TagsField(TaggableManager):
+    """Override FormField method on taggit.managers.TaggableManager to match the Nautobot UI."""
+
+    def __init__(self, *args, **kwargs):
+        from nautobot.extras.models.tags import TaggedItem
+
+        kwargs.setdefault("through", TaggedItem)
+        kwargs.setdefault("manager", TagsManager)
+        kwargs.setdefault("ordering", ["name"])
+        super().__init__(*args, **kwargs)
+
+    def formfield(self, form_class=fields.DynamicModelMultipleChoiceField, **kwargs):
+        from nautobot.extras.models.tags import Tag
+
+        queryset = Tag.objects.get_for_model(self.model)
+        kwargs.setdefault("queryset", queryset)
+        kwargs.setdefault("required", False)
+        kwargs.setdefault("query_params", {"content_types": self.model._meta.label_lower})
+        return super().formfield(form_class=form_class, **kwargs)

nautobot/core/models/generics.py

@@ -1,13 +1,11 @@
 import logging
 
-from taggit.managers import TaggableManager, _TaggableManager
-
 from nautobot.extras.models.change_logging import ChangeLoggedModel
 from nautobot.extras.models.customfields import CustomFieldModel
 from nautobot.extras.models.mixins import DynamicGroupMixin, NotesMixin
 from nautobot.extras.models.relationships import RelationshipModel
-from nautobot.extras.models.tags import TaggedItem
 from nautobot.core.models import BaseModel
+from nautobot.core.models.fields import TagsField
 
 
 logger = logging.getLogger(__name__)
@@ -30,44 +28,6 @@ class OrganizationalModel(
         abstract = True
 
 
-# 2.0 TODO: remove this, force migration to the newer django-taggit API.
-class _NautobotTaggableManager(_TaggableManager):
-    """Extend _TaggableManager to work around a breaking API change between django-taggit 1.x and 2.x.
-
-    This is a bit confusing, as there's also a related `TaggableManager` class as well.
-    `TaggableManager` is the *model field* (subclass of `models.fields.related.RelatedField`),
-    while `_TaggableManager` is the *associated manager* (subclass of `models.Manager`).
-
-    For `TaggableManager`, we chose to monkey-patch rather than subclass to override its `formfield` method;
-    replacing it with a subclass would create database migrations for every PrimaryModel with a `tags` field.
-    In 2.0 we'll want to bite the bullet and make the cutover (#1633).
-
-    For `_TaggableManager`, we can subclass rather than monkey-patching because replacing it *doesn't* require
-    a database migration, and this is cleaner than a monkey-patch.
-    """
-
-    def set(self, *tags, through_defaults=None, **kwargs):
-        """
-        Patch model.tags.set() to be backwards-compatible with django-taggit 1.x and forward-compatible with later.
-
-        Both of these approaches are supported:
-
-        - tags.set("tag 1", "tag 2")  # django-taggit 1.x
-        - tags.set(["tag 1", "tag 2"])  # django-taggit 2.x and later
-        """
-        if len(tags) == 1 and not isinstance(tags[0], (self.through.tag_model(), str)):
-            # taggit 2.x+ style, i.e. `set([tag, tag, tag])`
-            tags = tags[0]
-        else:
-            # taggit 1.x style, i.e. `set(tag, tag, tag)`
-            # Note: logger.warning() only supports a `stacklevel` parameter in Python 3.8 and later
-            tags_unpacked = ", ".join([repr(tag) for tag in tags])
-            tags_list = list(tags)
-            message = "Deprecated `tags.set(%s)` was called, please change to `tags.set(%s)` instead"
-            logger.warning(message, tags_unpacked, tags_list, stacklevel=2)
-        return super().set(tags, through_defaults=through_defaults, **kwargs)
-
-
 class PrimaryModel(BaseModel, ChangeLoggedModel, CustomFieldModel, RelationshipModel, DynamicGroupMixin, NotesMixin):
     """
     Base abstract model for all primary models.
@@ -78,7 +38,7 @@ class PrimaryModel(BaseModel, ChangeLoggedModel, CustomFieldModel, RelationshipM
     tangible or logical resources on the network, or within the organization.
     """
 
-    tags = TaggableManager(through=TaggedItem, manager=_NautobotTaggableManager, ordering=["name"])
+    tags = TagsField()
 
     class Meta:
         abstract = True

nautobot/core/models/managers.py

@@ -1,4 +1,5 @@
 from django.db.models import Manager
+from taggit.managers import _TaggableManager
 
 
 class BaseManager(Manager):
@@ -43,3 +44,7 @@ class BaseManager(Manager):
                 raise self.model.DoesNotExist() from exc
 
         return self.get(**kwargs)
+
+
+class TagsManager(_TaggableManager, BaseManager):
+    """Manager class for model 'tags' fields."""

nautobot/core/models/name_color_content_types.py

@@ -1,7 +1,6 @@
 from django.contrib.contenttypes.models import ContentType
 from django.db import models
 from django.db.models import Q
-from django.urls import reverse
 
 from nautobot.core.choices import ColorChoices
 from nautobot.core.models import BaseManager, BaseModel
@@ -66,7 +65,6 @@ class NameColorContentTypesModel(
 
     objects = BaseManager.from_queryset(ContentTypeRelatedQuerySet)()
 
-    csv_headers = ["name", "color", "content_types", "description"]
     clone_fields = ["color", "content_types"]
 
     class Meta:
@@ -76,17 +74,5 @@ class NameColorContentTypesModel(
     def __str__(self):
         return self.name
 
-    def get_absolute_url(self):
-        ct = f"{self._meta.app_label}:{self._meta.model_name}"
-        return reverse(ct, args=[self.pk])
-
     def get_content_types(self):
         return ",".join(f"{ct.app_label}.{ct.model}" for ct in self.content_types.all())
-
-    def to_csv(self):
-        return (
-            self.name,
-            self.color,
-            self.get_content_types(),
-            self.description,
-        )

nautobot/core/models/tree_queries.py

@@ -1,3 +1,5 @@
+from django.core.cache import cache
+
 from tree_queries.models import TreeNode
 from tree_queries.query import TreeManager as TreeManager_
 from tree_queries.query import TreeQuerySet as TreeQuerySet_
@@ -41,16 +43,24 @@ class TreeModel(TreeNode):
 
     @property
     def display(self):
-        """By default, TreeModels display their full ancestry for clarity."""
+        """
+        By default, TreeModels display their full ancestry for clarity.
+
+        As this is an expensive thing to calculate, we cache it for a few seconds in the case of repeated lookups.
+        """
         if not hasattr(self, "name"):
             raise NotImplementedError("default TreeModel.display implementation requires a `name` attribute!")
-        display_str = ""
+        cache_key = f"{self.__class__.__name__}.{self.id}.display"
+        display_str = cache.get(cache_key, "")
+        if display_str:
+            return display_str
         try:
-            for ancestor in self.ancestors():
-                display_str += ancestor.name + " → "
+            if self.parent is not None:
+                display_str = self.parent.display + " → "
         except self.DoesNotExist:
             # Expected to occur at times during bulk-delete operations
             pass
         finally:
             display_str += self.name
+            cache.set(cache_key, display_str, 5)
             return display_str  # pylint: disable=lost-exception

nautobot/core/models/utils.py

@@ -1,12 +1,12 @@
-from itertools import count, groupby
 import json
+
+from itertools import count, groupby
 from urllib.parse import quote_plus, unquote_plus
 
 from django.apps import apps
 from django.core.exceptions import FieldDoesNotExist
 from django.core.serializers import serialize
 from django.utils.tree import Node
-from taggit.managers import _TaggableManager
 
 from nautobot.core.models.constants import NATURAL_KEY_SLUG_SEPARATOR
 
@@ -35,10 +35,9 @@ def is_taggable(obj):
     """
     Return True if the instance can have Tags assigned to it; False otherwise.
     """
-    if hasattr(obj, "tags"):
-        if issubclass(obj.tags.__class__, _TaggableManager):
-            return True
-    return False
+    from nautobot.core.models.managers import TagsManager
+
+    return hasattr(obj, "tags") and isinstance(obj.tags, TagsManager)
 
 
 def pretty_print_query(query):