Dynamic Form Class

class DynForm(forms.BaseForm):
    """
        Given defined fields exclude,include,model, and widgets this class will attempt to build a form from a model definition
        like form_for_model/instance.  The only required field is model.  exclude,include, and widgets can be left off in which
        case all fields except the primary key field will be used with default widgets.
        
        exclude =[List of model field names] Can be empty or undefined which will exclude only the primary key field
        include =[List of model field names] Can be empty or undefined which will make it use all fields in model
        widgets = {'field': (widgetmodel,{widget args}),}
        formfields = {'field': (formfieldmodel,{formfield args}),}  the widgets dict above  will override any widgets specified 
            here.
        
        If you specify an 'include' list it's pointless to specify and 'exclude' list because only the fields in include will be used.
        'exclude' is really only useful if you want almost all the model fields except for one or two, which you'd put in the list
        and leave include empty or undefined to get all the other fields automatically.
        
        This not really a normal form, so some things may not work the same as you might expect.
        
        To emmulate form_for_model you'd basically do the bare minimum
        
            class MyForm(DynForm):
                model = MyModel
        
        Unbound form:
            form = AgentEditForm()
        Bound to a pk for the model defined, and will use that data to populate as initial if it exists.  
            form =  AgentEditForm(None,pk=5) # Agent.objects.get(pk=5)
        Bound to a pk, and processing POST
            form = AgentEditForm(request.POST,pk=5)  
            
        optional keyword arguments
            pk  -   primary key. Will fallback to None if pk not valid
            widget_kwargs  - Dictionary field keys, and a dict with keyword args
                for the fields widget used instead of those in form definition (models_def) 

        form.save()  -  
                If no primary key (pk) was given at form creation, or the pk was invalud a new object will 
                be created and the object will be returned.  Any keyword arguments passed to save will be 
                used to instantiate a new new instance for the model, but will be overridden by form data if 
                present.  This is to allow you to define values for required fields you excluded
                in the form definition. 
                
        ------------------------------------------------------------------------------------------------------------------------------------------------------
        Example form:
            class AgentReminderForm(DynForm):
                model= AgentReminder
                include_fields=['who','what','when','priority','notice','date']
                exclude_fields=[]
                widgets= {  'what': (forms.Textarea,{'attrs':{'rows':'5','cols':'10'},}),
                                    'notice': (forms.Select,{'choices': [('15','15 Minutes'),('60','1 Hour')]}), 
                    }
                formfields ={ 'when': (forms.DateTimeField,{'input_formats': ["%b-%d-%Y %I:%M:%S %p"] }) 
                    }

        ------------------------------------------------------------------------------------------------------------------------------------------------------
        In View:
            def myview(request,id=None)
            if request.POST:
                form =  AgentReminderForm(request.POST,pk=id)
                if form.is_valid():
                    form.save(date=datetime.now())
            else:
                form=AgentReminderForm(pk=id)
            ...
    """
    def __init__(self, *args, **kwargs):
        try:
            getattr(self,'include')
        except:
            self.include = []
        try:
            getattr(self,'exclude')
        except:
            self.exclude = []
        try:
            getattr(self,'widgets')
        except:
            self.widgets = {}
        try:
            getattr(self,'formfields')
        except:
            self.formfields = {}
        newkwargs = kwargs
        self.base_fields = {} # Since we are bypassing Form and using BaseForm
        if 'widget_kwargs' in kwargs:
            self.widget_kwargs = newkwargs.pop('widget_kwargs')
        else:
            self.widget_kwargs = {}
        self.primary_key=None
        if 'pk' in kwargs:
            self.primary_key = newkwargs.pop('pk')
            try:
                mi = self.model.objects.get(pk=self.primary_key)
            except:
                self.primary_key = None
        if self.primary_key:
            newinitial = mi.__dict__
            if 'initial' in newkwargs:
                newinitial.update(newkwargs['initial'])
            newkwargs['initial'] = newinitial
        super(DynForm,self).__init__(*args,**newkwargs)
        mm = self.model._meta   # grab the model info
        include = []
        if self.include:
            for field in mm.fields + mm.many_to_many:
                if field.attname in self.include:
                    include.append(field)
        else:
            include = mm.fields + mm.many_to_many
        self.exclude.append(mm.pk.attname)
        for f in include:
            if (f.attname not in self.exclude) and (f is not mm.pk.attname) :
                if f.attname in self.formfields:
                    formfield = self.formfields[f.attname][0]
                    ffargs = self.formfields[f.attname][1]
                else:
                    formfield = f.formfield
                    ffargs = {}
                # Handle Widgets    
                if f.attname in self.widget_kwargs: #use what was given at form instantiation
                    ffargs['widget'] =self.widgets[f.attname][0](**self.widget_kwargs[f.attname][1])
                elif f.attname in self.widgets: # use what was given at form definition
                    ffargs['widget'] =self.widgets[f.attname][0](**self.widgets[f.attname][1] )
                self.fields[f.attname] = formfield(**ffargs)
        self.base_fields=self.fields # don't actually need this, but just in case someone tries to treat as a normal form

    def save(self, **kwargs):
        if not self.is_valid():
            return None
        rel_wait = [] # start with no many to many relations to worry about
        q_wait = [] # start with no fields to queue until after initial save
        if self.primary_key is None: # treat as new
            pm = self.model(**kwargs)
            # since this is new, put any waiting fields in the rel_wait list
            for mf in pm.__class__._meta.many_to_many:
                rel_wait.append(mf.attname)
        else:
            pm = self.model.objects.get(pk=self.primary_key)
        for f in self.fields: 
            if f not in rel_wait:
                setattr(pm,f,self.clean_data[f])
            else:
                q_wait.append(f)
        pm.save() # Must save here, so relations work
        if len(q_wait) > 0:  # something is queued, and can now be added since the insert is done and pm has a pk     
            for f in q_wait:   # now that it's inserted we can take care of the waiting relations
                setattr(pm,f,self.clean_data[f])
            pm.save()
        return pm