Ruff fixes

Author: bctiemann

netbox_custom_objects/field_types.py

@@ -35,10 +35,10 @@ class LazyForeignKey(ForeignKey):
 
     def __init__(self, to_model_name, *args, **kwargs):
         self._to_model_name = to_model_name
-        
+
         # Filter out our custom parameters before passing to Django's ForeignKey
         field_kwargs = {k: v for k, v in kwargs.items() if not k.startswith('_') and k != 'generating_models'}
-        
+
         super().__init__(to_model_name, *args, **field_kwargs)
 
     def contribute_to_class(self, cls, name, **kwargs):
@@ -84,7 +84,7 @@ def _safe_kwargs(self, **kwargs):
         Create a safe kwargs dict that can be passed to Django field constructors.
         This method automatically filters out any custom parameters.
         """
-        return {k: v for k, v in kwargs.items() 
+        return {k: v for k, v in kwargs.items()
                 if not k.startswith('_') and k != 'generating_models'}
 
     def get_annotated_form_field(self, field, enforce_visibility=True, **kwargs):
@@ -93,7 +93,7 @@ def get_annotated_form_field(self, field, enforce_visibility=True, **kwargs):
         form_field.label = str(field)
         # Set the field name so Django can properly bind it to the instance
         form_field.name = field.name
-        
+
         if field.description:
             form_field.help_text = render_markdown(field.description)
 
@@ -387,7 +387,7 @@ class ObjectFieldType(FieldType):
     def get_model_field(self, field, **kwargs):
         content_type = ContentType.objects.get(pk=field.related_object_type_id)
         to_model = content_type.model
-        
+
         # Extract our custom parameters and keep only Django field parameters
         generating_models = kwargs.pop('_generating_models', getattr(self, '_generating_models', set()))
         field_kwargs = {k: v for k, v in kwargs.items() if not k.startswith('_')}
@@ -401,16 +401,16 @@ def get_model_field(self, field, **kwargs):
                 "model", ""
             )
             custom_object_type = CustomObjectType.objects.get(pk=custom_object_type_id)
-            
+
             # 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)}"
                 f = LazyForeignKey(
                     model_name,
-                    null=True, 
-                    blank=True, 
-                    on_delete=models.CASCADE, 
+                    null=True,
+                    blank=True,
+                    on_delete=models.CASCADE,
                     **field_kwargs
                 )
                 return f
@@ -423,9 +423,9 @@ def get_model_field(self, field, **kwargs):
                     model_name = f"{APP_LABEL}.{custom_object_type.get_table_model_name(custom_object_type.id)}"
                     f = models.ForeignKey(
                         model_name,
-                        null=True, 
-                        blank=True, 
-                        on_delete=models.CASCADE, 
+                        null=True,
+                        blank=True,
+                        on_delete=models.CASCADE,
                         **field_kwargs
                     )
                     return f
@@ -435,11 +435,11 @@ def get_model_field(self, field, **kwargs):
             # to_model = content_type.model_class()._meta.object_name
             to_ct = f"{content_type.app_label}.{to_model}"
             model = apps.get_model(to_ct)
-        
+
         f = models.ForeignKey(
             model, null=True, blank=True, on_delete=models.CASCADE, **field_kwargs
         )
-        
+
         return f
 
     def get_form_field(self, field, for_csv_import=False, **kwargs):
@@ -458,7 +458,7 @@ def get_form_field(self, field, for_csv_import=False, **kwargs):
                 "model", ""
             )
             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:
@@ -737,7 +737,7 @@ def get_model_field(self, field, **kwargs):
         custom_object_type_id = content_type.model.replace("table", "").replace(
             "model", ""
         )
-        
+
         # Extract our custom parameters and keep only Django field parameters
         generating_models = kwargs.pop('_generating_models', getattr(self, '_generating_models', set()))
         field_kwargs = {k: v for k, v in kwargs.items() if not k.startswith('_')}
@@ -860,16 +860,16 @@ def after_model_generation(self, instance, model, field_name):
             # Update both source and target fields to point to the same model
             source_field = through_model._meta.get_field("source")
             target_field = through_model._meta.get_field("target")
-            
+
             # Resolve the foreign key fields to point to the actual model
             source_field.remote_field.model = model
             source_field.related_model = model
             target_field.remote_field.model = model
             target_field.related_model = model
-            
+
             # Also update the field's to attribute to point to the actual model
             field.to = model
-            
+
             return
 
         # For non-self-referential fields, we need to resolve the target model
@@ -884,7 +884,7 @@ def after_model_generation(self, instance, model, field_name):
                 "model", ""
             )
             custom_object_type = CustomObjectType.objects.get(pk=custom_object_type_id)
-            
+
             # For self-referential fields, we need to resolve them to the current model
             # This doesn't cause recursion because we're not calling get_model() again
             if custom_object_type.id == instance.custom_object_type.id:
@@ -941,7 +941,7 @@ def create_m2m_table(self, instance, model, field_name):
                 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:

netbox_custom_objects/models.py

@@ -220,7 +220,7 @@ 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()
 
@@ -355,15 +355,15 @@ def _fetch_and_generate_field_attrs(
 
             # 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)
@@ -375,13 +375,13 @@ def _fetch_and_generate_field_attrs(
                             # Extract the custom object type ID from the model name
                             # The model name format is "table{id}model" or similar
                             model_name = content_type.model
-                            
+
                             # Try to extract the ID from the model name
                             import re
                             id_match = re.search(r'table(\d+)model', model_name, re.IGNORECASE)
                             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:
@@ -408,17 +408,17 @@ def _fetch_and_generate_field_attrs(
             else:
                 # Not object/multiobject type
                 pass
-            
+
             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
             field_attrs["_field_objects"][field.id] = {
                 "field": field,
@@ -436,17 +436,17 @@ def _after_model_generation(self, attrs, model):
         all_field_objects = {}
         all_field_objects.update(attrs["_field_objects"])
         all_field_objects.update(attrs["_trashed_field_objects"])
-        
+
         # Get the set of fields that were skipped due to recursion
         skipped_fields = attrs.get("_skipped_fields", set())
-        
+
         for field_object in all_field_objects.values():
             field_name = field_object["name"]
-            
+
             # Skip fields that were skipped due to recursion
             if field_name in skipped_fields:
                 continue
-            
+
             # Only process fields that actually exist on the model
             # Fields might be skipped due to recursion prevention
             if hasattr(model._meta, 'get_field'):
@@ -456,7 +456,7 @@ def _after_model_generation(self, attrs, model):
                     field_object["type"].after_model_generation(
                         field_object["field"], model, field_name
                     )
-                except Exception as e:
+                except Exception:
                     # Field doesn't exist (likely skipped due to recursion), skip processing
                     continue
 
@@ -553,19 +553,19 @@ def get_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
         # Check if we're already generating this model (circular reference)
         if self.id in _generating_models:
             # We have a circular reference, return a minimal model to break the cycle
             return self._get_minimal_model(_generating_models)
-        
+
         # Check recursion depth to prevent infinite loops
         if len(_generating_models) > 1:
             # We're too deep in recursion, return a minimal model
             return self._get_minimal_model(_generating_models)
-        
+
         # Add this model to the set of models being generated
         _generating_models.add(self.id)
 
@@ -604,13 +604,13 @@ def get_model(
 
         # Pass the generating models set to field generation
         field_attrs = self._fetch_and_generate_field_attrs(
-            fields, 
+            fields,
             skip_object_fields=skip_object_fields,
             generating_models=_generating_models
         )
 
         attrs.update(**field_attrs)
-        
+
         # Track which fields were skipped due to recursion for after_model_generation
         if '_skipped_fields' not in attrs:
             attrs['_skipped_fields'] = set()
@@ -690,7 +690,7 @@ def _get_minimal_model(self, _generating_models=None):
         This breaks infinite recursion cycles by providing a basic model structure.
         """
         model_name = self.get_table_model_name(self.pk)
-        
+
         meta = type(
             "Meta",
             (),

netbox_custom_objects/views.py

@@ -525,29 +525,29 @@ def custom_init(self, *args, **kwargs):
         def custom_save(self, commit=True):
             # First save the instance to get the primary key
             instance = forms.NetBoxModelForm.save(self, commit=False)
-            
+
             if commit:
                 instance.save()
-                
+
                 # Handle M2M fields manually to ensure proper clearing and setting
                 for field_name, field_obj in self.custom_object_type_fields.items():
                     if field_obj.type == CustomFieldTypeChoices.TYPE_MULTIOBJECT:
                         # Get the current value from the form
                         current_value = self.cleaned_data.get(field_name, [])
-                        
+
                         # Get the field from the instance
                         instance_field = getattr(instance, field_name)
-                        
+
                         # Clear existing relationships and set new ones
                         if hasattr(instance_field, 'clear') and hasattr(instance_field, 'set'):
                             instance_field.clear()
-                            
+
                             if current_value:
                                 instance_field.set(current_value)
-                
+
                 # Save M2M relationships
                 self.save_m2m()
-            
+
             return instance
 
         form_class.__init__ = custom_init