Django

class Folder(Timestamped):
    name = models.CharField(max_length=50)
    depth = models.PositiveIntegerField(default=0)
    parents = models.ManyToManyField("self", through='FolderParent',
                                      through_fields=('source', 'target'),
                                      symmetrical=False, blank=True)



    class Meta:
        default_related_name = 'folders'
        verbose_name = 'folder'
        verbose_name_plural = 'folders'

    def __str__(self):
        return f"{self.name}"

    def get_depth(self):
        """
        Recursively calculates the depth of the folder in the tree structure.
        """
        depth = 0
        # Traverse up the tree to the root node
        parent_folders = self.parents.all()
        while parent_folders:
            depth += 1
            parent_folder = parent_folders.first()
            parent_folders = parent_folder.parents.all()
        if depth != self.depth:
            self.depth = depth
            self.save()
        return depth

    def get_ancestors(self):
        """
        Recursively gets a list of ancestor folders in the tree structure.
        """
        ancestors = []
        parent_folders = self.parents.all()
        while parent_folders:
            parent_folder = parent_folders.first()
            ancestors.append(parent_folder)
            parent_folders = parent_folder.parents.all()
        return reversed(ancestors)

    def get_breadcrumb(self):
        """
        Returns a list of ancestor folders and the current folder, 
        representing the breadcrumb for the current folder.
        """
        breadcrumb = list(self.get_ancestors())
        breadcrumb.append(self)
        return breadcrumb


class FolderParent(Timestamped):
    source = models.ForeignKey(Folder, on_delete=models.CASCADE,
                               related_name='folder_parent')
    target = models.ForeignKey(Folder, on_delete=models.CASCADE,
                               related_name='folder_child')

    class Meta:
        constraints = [
            models.UniqueConstraint(fields=['source', 'target'], name="folderparent")
        ]
        indexes = [
            models.Index(fields=['source', 'target']),
        ]

from django.http import JsonResponse, HttpResponseBadRequest, Http404
from django.apps import apps
from django.views.decorators.http import require_http_methods

@require_http_methods(["DELETE"])
def delete_item(request):
    item_id = request.GET.get('id')
    if not item_id:
        return JsonResponse({'error': 'Missing ID parameter.'}, status=400)

    model_name = request.GET.get('model')
    app_name = request.GET.get('app')

    if not model_name or not app_name:
        return JsonResponse({'error': 'Missing model or app parameter.'}, status=400)

    try:
        model_obj = apps.get_model(app_label=app_name, model_name=model_name)
    except LookupError:
        return JsonResponse({'error': 'Invalid model or app parameter.'}, status=400)

    try:
        item = model_obj.objects.get(id=item_id)
        item.delete()
        return JsonResponse({'message': 'Item deleted successfully.'}, status=200)
    except model_obj.DoesNotExist:
        raise Http404("Item does not exist.")

from vscode market place install  python,django,beautify

in your python virtual environment install packages

autopep8
pylint
pylint-django


in vscode  settings.json add 

{
    "emmet.includeLanguages": {
        "django-html": "html"
    },
    "python.PythonPath": ".venv\\scripts\\python.exe",
    "editor.formatOnSave": true,
    "python.formatting.provider": "autopep8",
    "python.linting.enabled": true,
    "python.linting.lintOnSave": true,
    "files.associations": {
        "**/templates/*.html": "django-html",
        "**/templates/*": "django-txt",
        "**/requirements{/**,*}.{txt,in}": "pip-requirements",
        "*.html": "html"
    },
}

from django import template
from django.utils.html import format_html
from django.utils.safestring import mark_safe
register = template.Library()


@register.simple_tag
def get_boolean_img(value):
    if value:
        return format_html(mark_safe('<i class="bi bi-check-lg"></i>'))
    return format_html(mark_safe('<i class="bi bi-x"></i>'))

const { parallel, src, dest, watch, series } = require('gulp');
const gulp = require("gulp");
let rename = require("gulp-rename");
const cleanCSS = require('gulp-clean-css');
const minify = require('gulp-minify');
let wrap = require('gulp-wrap');
let declare = require('gulp-declare');
let concat = require('gulp-concat');
let exec = require('child_process').exec;
const browsersync = require('browser-sync').create();
let spawn = require('child_process').spawn;

function css(){
  return gulp.src([
        './static/src/css/*.css'])
     .pipe(concat('site.css'))
     .pipe(cleanCSS({compatibility: 'ie8'}))
     .pipe(rename({extname:'.min.css'}))
     .pipe(gulp.dest('./static/build/css'))
     .pipe(browsersync.reload({
       stream: true
     }))
}

function vendor(){
  return gulp.src([
        './static/src/js/jquery-3.6.0.min.js',
        './static/src/js/popper.min.js',
        './static/src/js/bootstrap.min.js',
        './static/src/js/django_ajax.js',
        './static/src/js/site.js',
      ])
     .pipe(concat('site.js'))
     .pipe(minify())
     .pipe(gulp.dest('./static/build/js'))
     .pipe(browsersync.reload({
       stream: true
      }))
}


function browsersyncServe(cb){
  browsersync.init({
          notify: false,
          proxy: "localhost:8000"
  });
  browsersync.watch('static/src/css/**/*.css', series(css));
  browsersync.watch('static/src/js/**/*.js', series(vendor));
  browsersync.watch('templates/**/*.html', browsersync.reload);
  browsersync.watch('templates/*.html', browsersync.reload);
  cb();
}


function runServer(){
  var cmd = spawn('venv/Scripts/python.exe', ['manage.py', 'runserver'], {stdio: 'inherit'});
  cmd.on('close', function(code) {
    console.log('runServer exited with code ' + code);
    cb(code);
  });
}

exports.css = css;
exports.vendor = vendor;
exports.runServer = runServer;
exports.browsersyncServe = browsersyncServe;
exports.default = parallel(css, vendor, runServer, browsersyncServe);