how to add a different model form to modelformset_factory

class Project(models.Model):
   description = models.CharField(max_length = 50, blank = True, null = True)
status = models.IntegerField(choices = STATUS_CHOICES,
   default = 4)
owner = models.ForeignKey(staff, on_delete = models.CASCADE, blank = True, null = True)
   ...

   class Update(models.Model):
   project = models.ForeignKey(Project, on_delete = models.CASCADE)
notes = models.CharField(max_length = 50, blank = True, null = True)
update_date = models.DateTimeField(
   default = timezone.now, editable = False)
added_by = models.CharField(max_length = 35, blank = True)

class CreateUpdateForm(ModelForm):
   class Meta:
   model = Update
fields = ('notes')

class EditProjectForm(ModelForm)
class Meta:
   model = Project
fields = ('__all__')

def mds_projects(request):
   project_formset = modelformset_factory(Project, form = EditProjectForm, extra = 0)

if request.method == 'POST':
   formset = project_formset(request.POST, request.FILES)
if formset.is_valid():
   for f in formset:
   project = f.save(commit = False)

update_form = CreateUpdateForm(request.POST, request.FILES)
if update_form.is_valid():
   update = update_form.save(commit = False)
update.project = project
project.save()
update.save()
else:
   print(update_form.errors)
return redirect('MDS_Projects')
else:
   print(formset.errors)
else:
   projects = Project.objects.filter(dept = 'Assistive Technology')
formset = project_formset(queryset = projects)
update_form = updateForm()
return render(request, 'MDSprojectsB.html', {
   'formset': formset,
   'update_form': update_form
})

>>> from django.forms
import ModelForm
   >>>
   from myapp.models
import Article

# Create the form class. >>>
class ArticleForm(ModelForm):
   ...class Meta:
   ...model = Article
   ...fields = ['pub_date', 'headline', 'content', 'reporter']

# Creating a form to add an article. >>>
   form = ArticleForm()

# Creating a form to change an existing article. >>>
   article = Article.objects.get(pk = 1) >>>
   form = ArticleForm(instance = article)

from django.db
import models
from django.forms
import ModelForm

TITLE_CHOICES = [
   ('MR', 'Mr.'),
   ('MRS', 'Mrs.'),
   ('MS', 'Ms.'),
]

class Author(models.Model):
   name = models.CharField(max_length = 100)
title = models.CharField(max_length = 3, choices = TITLE_CHOICES)
birth_date = models.DateField(blank = True, null = True)

def __str__(self):
   return self.name

class Book(models.Model):
   name = models.CharField(max_length = 100)
authors = models.ManyToManyField(Author)

class AuthorForm(ModelForm):
   class Meta:
   model = Author
fields = ['name', 'title', 'birth_date']

class BookForm(ModelForm):
   class Meta:
   model = Book
fields = ['name', 'authors']

from django
import forms

class AuthorForm(forms.Form):
   name = forms.CharField(max_length = 100)
title = forms.CharField(
   max_length = 3,
   widget = forms.Select(choices = TITLE_CHOICES),
)
birth_date = forms.DateField(required = False)

class BookForm(forms.Form):
   name = forms.CharField(max_length = 100)
authors = forms.ModelMultipleChoiceField(queryset = Author.objects.all())

from django.core.exceptions
import NON_FIELD_ERRORS
from django.forms
import ModelForm

class ArticleForm(ModelForm):
   class Meta:
   error_messages = {
      NON_FIELD_ERRORS: {
         'unique_together': "%(model_name)s's %(field_labels)s are not unique.",
      }
   }

>>> from myapp.models
import Article
   >>>
   from myapp.forms
import ArticleForm

# Create a form instance from POST data. >>>
   f = ArticleForm(request.POST)

# Save a new Article object from the form 's data. >>>
   new_article = f.save()

# Create a form to edit an existing Article, but use
# POST data to populate the form. >>>
   a = Article.objects.get(pk = 1) >>>
   f = ArticleForm(request.POST, instance = a) >>>
   f.save()

# Create a form instance with POST data. >>>
   f = AuthorForm(request.POST)

# Create, but don 't save the new author instance. >>>
   new_author = f.save(commit = False)

# Modify the author in some way. >>>
   new_author.some_field = 'some_value'

# Save the new instance. >>>
   new_author.save()

# Now, save the many - to - many data
for the form. >>>
   f.save_m2m()

class GeeksModel(models.Model):
   title = models.CharField(max_length = 200)
description = models.TextField()

from django.forms
import formset_factory
GeeksFormSet = modelformset_factory(GeeksModel)

Field_name = models.FieldType(attributes)

Field_name = models.FieldType(attributes)

# models.py
from django.db
import models

class Bird(models.Model):
   common_name = models.CharField(max_length = 250)
scientific_name = models.CharField(max_length = 250)

def __str__(self):
   return self.common_name

# project level urls.py
from django.contrib
import admin
from django.urls
import path, include

urlpatterns = [
   path('admin/', admin.site.urls),
   path('', include('birds.urls')),
]

# app level urls.py
from django.urls
import path
from.views
import BirdAddView, BirdListView

urlpatterns = [
   path('add', BirdAddView.as_view(), name = "add_bird"),
   path('', BirdListView.as_view(), name = "bird_list")
]

# forms.py
from django.forms
import ModelForm
from.models
import Bird

# A regular form, not a formset
class BirdForm(ModelForm):
   class Meta:
   model = Bird
fields = [common_name, scientific_name]

# forms.py
from django.forms
import modelformset_factory
from.models
import Bird

BirdFormSet = modelformset_factory(
   Bird, fields = ("common_name", "scientific_name"), extra = 1
)

pip install pipenv
pipenv shell
pipenv install django

django - admin startproject DjangoFormset. /

python manage.py startapp codebase
python manage.py migrate
python manage.py runserver

INSTALLED_APPS = [
   'django.contrib.admin',
   'django.contrib.auth',
   'django.contrib.contenttypes',
   'django.contrib.sessions',
   'django.contrib.messages',
   'django.contrib.staticfiles',

   'codebase'
]

from django.db
import models

# adding the model
class ModelFormSetModel(models.Model):
   name = models.CharField(max_length = 200)
email = models.CharField(max_length = 200)
department = models.TextField()

# the name of the model that will be showing in the admin panel
class Meta:
   verbose_name_plural = 'data'

#so it will use emaill to reference a particular data
def __str__(self):
   return self.email

from.models
import ModelFormsetModel
from django.forms
import modelformset_factory

DjangoFormset = modelformset_factory(ModelFormsetModel, fields = '__all__')

from django.shortcuts
import render

#importing the model
from.models
import ModelFormSetModel

# importing django modelformset_factory used
for modelformset
from django.forms
import modelformset_factory

def home(request):
   #displaying the neccessary fields needed to be displayed on the frontend
DjangoFormSet = modelformset_factory(ModelFormSetModel, fields = ['name', 'email', 'department'])
# refrencing the DjangoFormset as a method
formset = DjangoFormSet()

# Add the formset to context dictionary
context = {
   'formset': formset
}

return render(request, "app/home.html", context)

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Django ModelFormSets</title>
</head>
<body>   
    <form method="POST" enctype="multipart/form-data">
        <!-- csrf token  -->
        {% csrf_token %}
        <!-- displaying the form from the backend -->
        {{ formset.as_p }}
        <input type="submit" value="Submit">
    </form>
</body>
</html>