remove generating models

arthanson · arthanson · commit ef54f1c0839e · 2025-09-17T12:02:32.000-07:00
diff --git a/netbox_custom_objects/field_types.py b/netbox_custom_objects/field_types.py
@@ -408,20 +408,25 @@ def get_model_field(self, field, **kwargs):
             )
             custom_object_type = CustomObjectType.objects.get(pk=custom_object_type_id)
 
-            # For self-referential fields, use LazyForeignKey to defer resolution
-            model_name = f"{APP_LABEL}.{custom_object_type.get_table_model_name(custom_object_type.id)}"
-            # Generate a unique related_name to prevent reverse accessor conflicts
-            table_model_name = field.custom_object_type.get_table_model_name(field.custom_object_type.id).lower()
-            related_name = f"{table_model_name}_{field.name}_set"
-            f = LazyForeignKey(
-                model_name,
-                null=True,
-                blank=True,
-                on_delete=models.CASCADE,
-                related_name=related_name,
-                **field_kwargs
-            )
-            return f
+            # Check if this is a self-referential field
+            if custom_object_type.id == field.custom_object_type.id:
+                # For self-referential fields, use LazyForeignKey to defer resolution
+                model_name = f"{APP_LABEL}.{custom_object_type.get_table_model_name(custom_object_type.id)}"
+                # Generate a unique related_name to prevent reverse accessor conflicts
+                table_model_name = field.custom_object_type.get_table_model_name(field.custom_object_type.id).lower()
+                related_name = f"{table_model_name}_{field.name}_set"
+                f = LazyForeignKey(
+                    model_name,
+                    null=True,
+                    blank=True,
+                    on_delete=models.CASCADE,
+                    related_name=related_name,
+                    **field_kwargs
+                )
+                return f
+            else:
+                # For cross-referential fields, use skip_object_fields to avoid infinite loops
+                model = custom_object_type.get_model(skip_object_fields=True)
         else:
             # to_model = content_type.model_class()._meta.object_name
             to_ct = f"{content_type.app_label}.{to_model}"
@@ -453,19 +458,7 @@ def get_form_field(self, field, for_csv_import=False, **kwargs):
             )
             custom_object_type = CustomObjectType.objects.get(pk=custom_object_type_id)
 
-            # Check if we're in a recursion situation
-            generating_models = getattr(self, '_generating_models', set())
-            if generating_models and custom_object_type.id in generating_models:
-                # We're in a circular reference, don't call get_model() to prevent recursion
-                # Use a minimal approach or return a basic field
-                return DynamicModelChoiceField(
-                    queryset=custom_object_type.get_model(skip_object_fields=True).objects.all(),
-                    required=field.required,
-                    # Remove initial=field.default to allow Django to handle instance data properly
-                    selector=True,
-                )
-            else:
-                model = custom_object_type.get_model()
+            model = custom_object_type.get_model()
         else:
             # This is a regular NetBox model
             model = content_type.model_class()
@@ -775,20 +768,7 @@ def get_form_field(self, field, for_csv_import=False, **kwargs):
             )
             custom_object_type = CustomObjectType.objects.get(pk=custom_object_type_id)
 
-            # For cross-referential fields, use skip_object_fields to avoid infinite loops
-            # Check if we're in a recursion situation using the parameter or stored attribute
-            generating_models = getattr(self, '_generating_models', set())
-            if generating_models and custom_object_type.id in generating_models:
-                # We're in a circular reference, don't call get_model() to prevent recursion
-                # Use a minimal approach or return a basic field
-                return DynamicModelMultipleChoiceField(
-                    queryset=custom_object_type.get_model(skip_object_fields=True).objects.all(),
-                    required=field.required,
-                    # Remove initial=field.default to allow Django to handle instance data properly
-                    selector=True,
-                )
-            else:
-                model = custom_object_type.get_model(skip_object_fields=True)
+            model = custom_object_type.get_model(skip_object_fields=True)
         else:
             # This is a regular NetBox model
             model = content_type.model_class()
@@ -879,13 +859,7 @@ def after_model_generation(self, instance, model, field_name):
                 # Self-referential field - resolve to current model
                 to_model = model
             else:
-                # Cross-referential field - check for recursion before calling get_model()
-                generating_models = getattr(self, '_generating_models', set())
-                if generating_models and custom_object_type.id in generating_models:
-                    # We're in a circular reference, don't call get_model() to prevent recursion
-                    return
-                else:
-                    to_model = custom_object_type.get_model()
+                to_model = custom_object_type.get_model()
         else:
             to_ct = f"{content_type.app_label}.{content_type.model}"
             to_model = apps.get_model(to_ct)
@@ -930,14 +904,7 @@ def create_m2m_table(self, instance, model, field_name):
                     pk=custom_object_type_id
                 )
 
-                # Check if we're in a recursion situation
-                generating_models = getattr(self, '_generating_models', set())
-                if generating_models and custom_object_type.id in generating_models:
-                    # We're in a circular reference, don't call get_model() to prevent recursion
-                    # Use a minimal approach or skip this field
-                    return
-                else:
-                    to_model = custom_object_type.get_model()
+                to_model = custom_object_type.get_model()
             else:
                 to_model = content_type.model_class()
 
diff --git a/netbox_custom_objects/models.py b/netbox_custom_objects/models.py
@@ -229,15 +229,6 @@ def clear_model_cache(cls, custom_object_type_id=None):
         # Clear Django apps registry cache to ensure newly created models are recognized
         apps.get_models.cache_clear()
 
-        # Clear global recursion tracking when clearing cache
-        cls.clear_global_recursion_tracking()
-
-    @classmethod
-    def clear_global_recursion_tracking(cls):
-        """Clear the global recursion tracking set."""
-        if hasattr(cls, '_global_generating_models'):
-            cls._global_generating_models.clear()
-
     @classmethod
     def get_cached_model(cls, custom_object_type_id):
         """
@@ -314,7 +305,6 @@ def _fetch_and_generate_field_attrs(
         self,
         fields,
         skip_object_fields=False,
-        generating_models=None,
     ):
         field_attrs = {
             "_primary_field_id": -1,
@@ -338,17 +328,10 @@ def _fetch_and_generate_field_attrs(
             field_type = FIELD_TYPE_CLASS[field.type]()
             field_name = field.name
 
-            # Pass generating models set to field generation to prevent infinite loops
-            field_type._generating_models = generating_models
-
             # Check if we're in a recursion situation before generating the field
             # Use depth-based recursion control: allow self-referential fields at level 0, skip at deeper levels
             should_skip = False
 
-            # Calculate depth correctly: depth 0 is when we're generating the main model
-            # depth 1+ is when we're generating related models recursively
-            current_depth = len(generating_models) - 1 if generating_models else 0
-
             if field.type in [CustomFieldTypeChoices.TYPE_OBJECT, CustomFieldTypeChoices.TYPE_MULTIOBJECT]:
                 if field.related_object_type:
                     # Check if this field references the same CustomObjectType (self-referential)
@@ -366,23 +349,8 @@ def _fetch_and_generate_field_attrs(
                             if id_match:
                                 custom_object_type_id = int(id_match.group(1))
 
-                                if custom_object_type_id == self.id:
-                                    # This is a self-referential field
-                                    if current_depth == 0:
-                                        # At level 0, allow self-referential fields
-                                        should_skip = False
-                                    else:
-                                        # At deeper levels, skip self-referential fields to prevent infinite recursion
-                                        should_skip = True
-
-            if should_skip:
-                # Skip this field to prevent further recursion
-                field_attrs["_skipped_fields"].add(field.name)
-                continue
-
             field_attrs[field.name] = field_type.get_model_field(
                 field,
-                _generating_models=generating_models,  # Pass as prefixed parameter
             )
 
             # Add to field objects only if the field was successfully generated
@@ -493,7 +461,6 @@ def register_custom_object_search_index(self, model):
     def get_model(
         self,
         skip_object_fields=False,
-        _generating_models=None,
     ):
         """
         Generates a temporary Django model based on available fields that belong to
@@ -503,8 +470,6 @@ def get_model(
         :type fields: list
         :param skip_object_fields: Don't add object or multiobject fields to the model
         :type skip_object_fields: bool
-        :param _generating_models: Internal parameter to track models being generated
-        :type _generating_models: set
         :return: The generated model.
         :rtype: Model
         """
@@ -514,16 +479,6 @@ def get_model(
             model = self.get_cached_model(self.id)
             return model
 
-        # Circular reference detection using class-level tracking
-        if not hasattr(CustomObjectType, '_global_generating_models'):
-            CustomObjectType._global_generating_models = set()
-
-        if _generating_models is None:
-            _generating_models = CustomObjectType._global_generating_models
-
-        # Add this model to the set of models being generated
-        _generating_models.add(self.id)
-
         model_name = self.get_table_model_name(self.pk)
 
         # TODO: Add other fields with "index" specified
@@ -556,7 +511,6 @@ def get_model(
         field_attrs = self._fetch_and_generate_field_attrs(
             fields,
             skip_object_fields=skip_object_fields,
-            generating_models=_generating_models
         )
 
         attrs.update(**field_attrs)
@@ -589,9 +543,9 @@ def wrapped_post_through_setup(self, cls):
             TM.post_through_setup = original_post_through_setup
 
         # Register the main model with Django's app registry
-        if model_name in apps.all_models[APP_LABEL]:
+        if model_name.lower() in apps.all_models[APP_LABEL]:
             # Remove the existing model from all_models before registering the new one
-            del apps.all_models[APP_LABEL][model_name]
+            del apps.all_models[APP_LABEL][model_name.lower()]
 
         apps.register_model(APP_LABEL, model)
         '''
@@ -613,6 +567,7 @@ def wrapped_post_through_setup(self, cls):
         # Do the clear cache now that we have it in the cache so there
         # is no recursion.
         apps.clear_cache()
+        ContentType.objects.clear_cache()
 
         '''
         # Register the serializer for this model
@@ -624,16 +579,6 @@ def wrapped_post_through_setup(self, cls):
         # Register the global SearchIndex for this model
         self.register_custom_object_search_index(model)
 
-        # Clean up: remove this model from the set of models being generated
-        if _generating_models is not None:
-            _generating_models.discard(self.id)
-            # Also clean up from global tracking if this is the global set
-            if _generating_models is CustomObjectType._global_generating_models:
-                CustomObjectType._global_generating_models.discard(self.id)
-                # Clear global tracking when we're done to ensure clean state
-                if len(CustomObjectType._global_generating_models) == 0:
-                    CustomObjectType._global_generating_models.clear()
-
         return model
 
     def create_model(self):
