Generate a list of possible forms for the current lemma

        :returns: List of possible forms for the current lemma
        :rtype: [str]
494139
def possible_forms(self):
        
        forms = []
        for morph in self.modele().morphos():
            for desinence in self.modele().desinences(morph):
                radicaux = self.radical(desinence.numRad())
                if isinstance(radicaux, Radical):
                    forms.append(radicaux.gr() + desinence.gr())
                else:
                    for rad in radicaux:
                        forms.append(rad.gr() + desinence.gr())
        return list(set(forms))
400504
def get_forms(self):
        
        forms = {}
        objects = self.get_objects()
        initial = self.get_initial()
        form_kwargs = self.get_form_kwargs()
        for key, form_class in six.iteritems(self.form_classes):
            forms[key] = form_class(instance=objects[key], initial=initial[key], **form_kwargs[key])
        return forms
1121061
def params(self):
        
        params = FormsDict()
        for key, value in self.query.iterallitems():
            params[key] = value
        for key, value in self.forms.iterallitems():
            params[key] = value
        return params
1061925
def gene_forms(self):
        
        q = self.session.query(distinct(models.ChemGeneIxnGeneForm.gene_form))
        return [x[0] for x in q.all()]
47355
def _lemmatise_roman_numerals(self, form, pos=False, get_lemma_object=False):
        
        if estRomain(form):
            _lemma = Lemme(
                cle=form, graphie_accentuee=form, graphie=form, parent=self, origin=0, pos="a",
                modele=self.modele("inv")
            )
            yield Lemmatiseur.format_result(
                form=form,
                lemma=_lemma,
                with_pos=pos,
                raw_obj=get_lemma_object
            )

        if form.upper() != form:
            yield from self._lemmatise_roman_numerals(form.upper(), pos=pos, get_lemma_object=get_lemma_object)
28226
def are_forms_valid(self, forms):
        
        for form in six.itervalues(forms):
            if not form.is_valid():
                return False
        return True
1346091
def form_valid(self, forms):
        
        for key, form in forms.items():
            setattr(self, '{}_object'.format(key), form.save())
        return super(MultipleModelFormMixin, self).form_valid(forms)
769526
def params(self):
        
        params = MultiDict(self.GET)
        for key, value in self.forms.iterallitems():
            params[key] = value
        return params
541681
def get_context_data(self, **kwargs):
        
        context = {}
        if 'forms' not in kwargs:
            context['forms'] = self.get_forms()
        else:
            context['forms'] = kwargs['forms']
        return context
690283
def __get_formulas(self):
        
        array = self._get_target().getFormulaArray()
        return tuple(itertools.chain.from_iterable(array))
7682
def generate_query(self):
        
        query = Q()
        ORed = []
        for form in self._non_deleted_forms:
            if not hasattr(form, 'cleaned_data'):
                continue
            if form.cleaned_data['field'] == "_OR":
                ORed.append(query)
                query = Q()
            else:
                query = query & form.make_query()
        if ORed:
            if query:  # add last query for OR if any
                ORed.append(query)
            query = reduce(operator.or_, ORed)
        return query
769904
def lemmatise(self, f, pos=False, get_lemma_object=False, lower=True):
        
        if lower:
            # We do not run numeral on lower
            yield from self._lemmatise_roman_numerals(f, pos=pos, get_lemma_object=get_lemma_object)

            # We run on the lower version
            if f.lower() != f:
                yield from self.lemmatise(f.lower(), pos=pos, get_lemma_object=get_lemma_object, lower=False)

        f = deramise(f)
        yield from self._lemmatise(f, pos=pos, get_lemma_object=get_lemma_object)
        yield from self._lemmatise_assims(f, pos=pos, get_lemma_object=get_lemma_object)
        yield from self._lemmatise_desassims(f, pos=pos, get_lemma_object=get_lemma_object)
        yield from self._lemmatise_contractions(f, pos=pos, get_lemma_object=get_lemma_object)

        yield from self._lemmatise_suffixe(f, pos=pos, get_lemma_object=get_lemma_object)
533540
def getInitialLiveForms(self):
        
        liveForms = []
        if self._defaultStuff:
            for values in self._defaultStuff:
                liveForms.append(self._makeDefaultLiveForm(values))
        else:
            # or only one, for the first new thing
            liveForms.append(
                self._makeALiveForm(
                    self.parameters, self._newIdentifier(), False))
        return liveForms
814152
def get_form_kwargs(self):
        '''  '''
        kwargs = super(InvoiceNotificationView, self).get_form_kwargs()
        kwargs['invoices'] = self.toNotify
        return kwargs
789360
def get_form(self, form_class=None):
        '''
        
        '''
        formobj = super(GenModify, self).get_form(form_class)

        # Set requested group to this form
        selfgroups = getattr(self, "form_groups", None)
        if selfgroups:
            if type(selfgroups) == list:
                formobj.__groups__ = lambda: selfgroups
            else:
                formobj.__groups__ = selfgroups
        else:
            selfgroups = getattr(self, "__groups__", None)
            if selfgroups:
                formobj.__groups__ = selfgroups

        # Return the new updated form
        return formobj
1101816
def labels(self):
        
        all_labels = set(self.token_patterns.keys())
        all_labels.update(self.phrase_patterns.keys())
        return tuple(all_labels)
880722
def current_parameters(self):
        
        current = []
        for core_param in range(len(self.q)):
            for approx_param in range(self.q[core_param].param_no):
                current.append(self.q[core_param].vi_return_param(approx_param))
        return np.array(current)