Walenty / ShellValier

from random import randint

from django import forms

from django.db.models import OneToOneField, ForeignKey, CharField, ManyToManyField, Q

from crispy_forms.helper import FormHelper
import crispy_forms.bootstrap as bootstrap
import crispy_forms.layout as layout

from connections.models import Entry, POS, Status, SchemaHook
from syntax.models import (
    Schema, SchemaOpinion, InherentSie, Negativity, Predicativity, Aspect,
    Position, SyntacticFunction, Control, PredicativeControl,
)
from syntax.models_phrase import PhraseType, EmptyAttributes

from semantics.models import (
    Frame, FrameOpinion,
    Argument, SemanticRole, RoleAttribute,
    PredefinedSelectionalPreference, RelationalSelectionalPreference,
)

from meanings.models import Synset

from .form_fields.generic_fields import (
    RangeFilter,
    RegexFilter,
    ModelChoiceFilter,
    MultipleChoiceFilter,
    ModelMultipleChoiceFilter,
    OperatorField,
    SwitchField,
)

from .form_fields.specialised_fields import (
    PhraseoFilter,
    PhraseTypeFilter,
    ArgumentFilter,
    PredefinedPreferenceFilter,
    RelationalPreferenceFilter,
    #SynsetPreferenceFilter,
)

from .form_fields.query_managers import SingleValueQueryManager

# TODO better to import this from the importer, the web app should not be aware of the importer! :)
from importer.PhraseAttributes import attrs_helpers

from . import polish_strings


# TODO get_queries probably needs refactoring now that QueryForm is subclassed
class QueryForm(forms.Form):
    
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper = FormHelper()
        self.helper.form_class = 'form-horizontal'
        self.helper.label_class = 'col-sm-2'
        self.helper.field_class = 'col-sm-10'
        self.helper.attrs = { 'data_formtype' : 'unknown' }
    
    @staticmethod
    def get_child_form_prefix(child_form):
        raise NotImplementedError
    
    def get_queries(self):
        queries = []
        for key, value in self.cleaned_data.items():
            #print('========', key, value)
            if value and not key.startswith('operator') and not key.startswith('filter'):
                #if filter_type is not None and key.split('_')[0] != filter_type:
                #    continue
                form_field = self.fields[key]
                operator_key = 'operator_{}'.format(key)
                # TODO conjunction variable is only needed if filter_type is None?
                conjunction = self.cleaned_data.get(operator_key)
                if conjunction is None:
                    conjunction = form_field.query_manager.default_conjunction
                queries += form_field.query_manager.make_queries(value, conjunction)
        return queries
    
    @classmethod
    def make_field(cls, field_name):
        field_object = cls.base_fields[field_name]
        return field_object.layout(field_name)

def or_button(button_label):
    return bootstrap.StrictButton('+ Lub ({})'.format(button_label), css_class='or-button btn-sm btn-info')

def remove_button(label):
    return bootstrap.StrictButton(label, css_class='remove-button btn-sm btn-warning')

def and_or_form_creator(button_label, field_name=None, data_add=None, *args, **kwargs):
    add_button = None
    data_add = 'switch' if data_add is None else data_add
    if field_name is not None:
        add_button = bootstrap.FieldWithButtons(field_name, bootstrap.StrictButton('+ Dodaj', css_class='add-button btn-sm btn-success', data_add=data_add, *args, **kwargs))
    else:
        add_button = bootstrap.StrictButton('+ {}'.format(button_label), css_class='add-button btn-sm btn-success', data_add=data_add, *args, **kwargs)
    return [
        #layout.HTML('<div class="and-or-forms py-1 pl-1 mb-1 border-top border-bottom border-danger" data-formtype="{}">'.format(data_add)),
        layout.HTML('<div class="and-or-forms py-1 pl-1 mb-1" data-formtype="{}">'.format(data_add)),
        add_button,
        or_button(button_label),
        layout.HTML('</div>'),
    ]
    

'''
class MainEntryForm(QueryForm):

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.helper.form_method = 'get'
        # TODO remove if this form is to be used with different views
        self.helper.form_action = 'entries:get_entries'
        self.helper.form_id = 'main-form'
        self.helper.attrs = { 'data_formtype' : 'entry-main' }
        self.model_class = Entry
        
        components = []
        components.append(layout.Submit('main-submit', 'Filtruj'))
        self.helper.layout = layout.Layout(*components)
    
    @staticmethod
    def get_child_form_prefix(child_form):
        if child_form.model_class == Schema:
            return 'subentries__schemata__in'
        if child_form.model_class == Frame:
            return 'subentries__schema_hooks__argument_connections__argument__frame__in'
        raise KeyError(type(child_form))
'''

class EntryForm(QueryForm):

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        #self.helper.form_method = 'get'
        # TODO remove if this form is to be used with different views
        self.helper.form_action = 'entries:get_entries'
        self.helper.form_id = 'main-form'
        self.helper.attrs = { 'data_formtype' : 'entry' }
        self.model_class = Entry
        
        entry_components = [
            self.make_field('lemma'),
            self.make_field('pos'),
            self.make_field('phraseology'),
            self.make_field('status'),
        ]
        
        schema_components = [
            self.make_field('num_schemata'),
        ] + \
        and_or_form_creator('Schemat', data_add='schema') + \
        [
            self.make_field('filter_schemata'),
        ] + \
        and_or_form_creator('Fraza', field_name='phrase_type', data_prefix='phrase_')
        
        frame_components = [
            self.make_field('num_frames'),
        ] + \
        and_or_form_creator('Rama', data_add='frame') + \
        [
            self.make_field('filter_frames'),
        ]
        
        components = [
            layout.Fieldset('Własności haseł', *entry_components),
            layout.Fieldset('Własności składniowe', *schema_components),
            layout.Fieldset('Własności semantyczne', *frame_components),
            layout.Submit('main-submit', 'Filtruj'),
            layout.Reset('main-reset', 'Wyczyść'),
        ]
        
        self.helper.layout = layout.Layout(*components)
    
    lemma = RegexFilter(
        label='Lemat',
        lookup='name',
        max_length=200,
        autocomplete='lemma',
    )
    pos = ModelMultipleChoiceFilter(
        label='Część mowy',
        queryset=POS.objects.exclude(tag='unk'),
        key='tag',
        human_values=polish_strings.POS,
        lookup='pos',
    )
    phraseology = PhraseoFilter()
    status = ModelMultipleChoiceFilter(
        label ='Status',
        queryset=Status.objects.all().order_by('-priority'),
        key = 'key',
        lookup='status',
    )
    num_schemata = RangeFilter(
        label='Liczba schematów',
        lookup='schemata_count',
    )
    num_frames = RangeFilter(
        label='Liczba ram',
        lookup='frames_count',
    )
    phrase_type = PhraseTypeFilter(help_text='Typ frazy występujący w haśle.')
    filter_schemata = SwitchField('Ukryj niepasujące schematy')
    filter_frames = SwitchField('Ukryj niepasujące ramy')
    
    @staticmethod
    def get_child_form_prefix(child_form):
        if child_form.model_class == Schema:
            return 'subentries__schemata__in'
        if child_form.model_class == PhraseType:
            return 'subentries__schemata__positions__phrase_types__in'
        if child_form.model_class == Frame:
            return 'subentries__schema_hooks__argument_connections__argument__frame__in'
        raise KeyError(type(child_form))


# for forms that can appear multiple times in the query consrtuctor field
# (e.g. a phrase form), create a separate form class for each form ‘instance’,
# with globally unique field names to ensure proper javascript behaviour
# and retrieving the field values in views
class FormFactory(object):
    
    @staticmethod
    def unique_number():
        return randint(1000, 12345678)
    
    @staticmethod
    def unique_name(field_name, unique_number):
        return '{}_{}'.format(field_name, unique_number)
    
    @staticmethod
    def make_helper_attrs(form_type, unique_number):
        return { 'data_formtype' : form_type , 'data_formnumber' : unique_number }
    
    @staticmethod
    def make_layout(title, components):
        return layout.Layout(layout.Fieldset(
            '{} <button class="btn remove-button btn-sm btn-warning" type="button">Usuń</button>'.format(title),
            *components
        ))
    
    @classmethod    
    def get_form(cls, unique_number=None, *args, **kwargs):
        unique_number = cls.unique_number() if unique_number is None else unique_number
        form_class = cls.make_form_class(n=unique_number)
        for field_name, field_maker in cls.field_makers:
            form_class.base_fields[FormFactory.unique_name(field_name, unique_number)] = field_maker()
        return form_class(*args, **kwargs)
    
    # n – unique number for this form used for creating globally unique field names
    @classmethod
    def make_form_class(cls, n):
        raise NotImplementedError

class SchemaFormFactory(FormFactory):
    
    field_makers = (
        (
            'opinion',
            lambda: ModelMultipleChoiceFilter(
                label='Opinia o schemacie',
                queryset=SchemaOpinion.objects.all(),
                key='key',
                human_values=polish_strings.SCHEMA_OPINION,
                lookup='opinion',
                #initial=SchemaOpinion.objects.filter(key__in=('col', 'vul')),
            )
        ), 
        #(
        #    'operator_opinion',
        #    lambda: OperatorField()
        #),
        (
            'type',
            lambda: MultipleChoiceFilter(
                label='Typ',
                choices=((False, 'zwykły'), (True, 'frazeologiczny'),),
                lookup='phraseologic',
            )
        ),
        #(
        #    'operator_type',
        #    lambda: OperatorField()
        #),
        (
            'sie',
            lambda: ModelMultipleChoiceFilter(
                label='Zwrotność',
                queryset=InherentSie.objects.all().order_by('-priority'),
                key='name',
                human_values=polish_strings.TRUE_FALSE_YES_NO,
                lookup='inherent_sie',
            )
        ),
        #(
        #    'operator_sie',
        #    lambda: OperatorField()
        #),
        #(
        #    'neg',
        #    lambda: ModelMultipleChoiceFilter(
        #        label='Negatywność',
        #        queryset=Negativity.objects.exclude(name='').order_by('-priority'),
        #        key='name',
        #        human_values=polish_strings.NEGATION,
        #        entry_lookup='subentries__negativity',
        #        # both Schema and Entry have the same related name for Subentry:
        #        # can use the same lookup path
        #        object_lookup=None,
        #    )
        #),
        #(
        #    'operator_neg',
        #    lambda: OperatorField()
        #),
        #(
        #    'pred',
        #    lambda: ModelMultipleChoiceFilter(
        #        label='Predykatywność',
        #        queryset=Predicativity.objects.all().order_by('-priority'),
        #        key='name',
        #        human_values=polish_strings.TRUE_FALSE_YES_NO,
        #        entry_lookup='subentries__predicativity',
        #        # both Schema and Entry have the same related name for Subentry:
        #        # can use the same lookup path
        #        object_lookup=None,
        #    )
        #),
        #(
        #    'operator_pred',
        #    lambda: OperatorField()
        #),
        #(
        #    'aspect',
        #    lambda: ModelMultipleChoiceFilter(
        #        label='Aspekt',
        #        queryset=Aspect.objects.exclude(name='').exclude(name='_').order_by('-priority'),
        #        key='name',
        #        human_values=polish_strings.ASPECT,
        #        entry_lookup='subentries__aspect',
        #        # both Schema and Entry have the same related name for Subentry:
        #        # can use the same lookup path
        #        object_lookup=None,
        #    )
        #),
        #(
        #    'operator_aspect',
        #    lambda: OperatorField()
        #),
        #phrase = RegexFilter(
        #label='Fraza',
        #max_length=200,
        ##initial='np.* !& !np.* | xp.*',
        #lookup='positions__phrase_types__text_rep',
        #additional_operators=True,
        #autocomplete='phrasetype',
        #)
        #(
        #    'num_positions',
        #    lambda: RangeFilter(
        #        label='Liczba pozycyj',
        #        entry_lookup='subentries__schemata__positions_count',
        #        object_lookup='positions_count',
        #    )
        #),
        #(
        #    'num_phrase_types',
        #    lambda: RangeFilter(
        #        label='Liczba typów fraz w pozycji',
        #        entry_lookup='subentries__schemata__positions__phrases_count',
        #        object_lookup='positions__phrases_count',
        #    )
        #),
    )
    
    @classmethod
    def make_form_class(cls, n):

        class SchemaForm(QueryForm):

            def __init__(self, *args, **kwargs):
                super().__init__(*args, **kwargs)
                self.helper.attrs = cls.make_helper_attrs('schema', n)
                self.model_class = Schema
                
                components = [
                    #remove_button('Usuń schemat'),
                    self.make_field(cls.unique_name('opinion', n)),
                    #self.make_field(cls.unique_name('operator_opinion', n)),
                    self.make_field(cls.unique_name('type', n)),
                    self.make_field(cls.unique_name('sie', n)),
                    #self.make_field(cls.unique_name('phrase', n)),
                ] + \
                    and_or_form_creator('Pozycja', data_add='position')
                self.helper.layout = cls.make_layout('Schemat składniowy', components)
            
            @staticmethod
            def get_child_form_prefix(child_form):
                if child_form.model_class == Position:
                    return 'positions__in'
                raise KeyError(type(child_form))
        
        return SchemaForm


class PositionFormFactory(FormFactory):
    
    field_makers = (
        (
            'gram_function',
            lambda: ModelMultipleChoiceFilter(
                label='Funkcja gramatyczna',
                queryset=SyntacticFunction.objects.all(),
                key='name',
                lookup='function',
            )
        ),
        (
            'control',
            lambda: ModelMultipleChoiceFilter(
                label='Kontrola',
                queryset=Control.objects.all(),
                key='name',
                lookup='control',
            )
        ),
        (
            'pred_control',
            lambda: ModelMultipleChoiceFilter(
                label='Kontrola predykatywna',
                queryset=PredicativeControl.objects.all(),
                key='name',
                lookup='pred_control',
            )
        ),
        (
            'phrase_type',
            lambda: PhraseTypeFilter(help_text='Typ frazy występujący na pozycji.')
        ),
    )
    
    @classmethod
    def make_form_class(cls, n):
        
        class PositionForm(QueryForm):

            def __init__(self, *args, **kwargs):
                super().__init__(*args, **kwargs)
                self.helper.attrs = cls.make_helper_attrs('position', n)
                self.model_class = Position
                
                components = [
                    self.make_field(cls.unique_name('gram_function', n)),
                    self.make_field(cls.unique_name('control', n)),
                    self.make_field(cls.unique_name('pred_control', n)),
                ] + \
                    and_or_form_creator('Fraza', field_name=(cls.unique_name('phrase_type', n)), data_prefix='phrase_')
                self.helper.layout = cls.make_layout('Pozycja schematu', components)
            
            @staticmethod
            def get_child_form_prefix(child_form):
                if child_form.model_class == PhraseType:
                    return 'phrase_types__in'
                raise KeyError(type(child_form))
        
        return PositionForm


class LexFormFactory(FormFactory):
    
    field_makers = (
        (
            'lex_type',
            lambda: PhraseTypeFilter(lex=True, help_text='Typ składniowy frazeologizmu.')
        ),
    )

    @classmethod
    def make_form_class(cls, n):

        class LexForm(QueryForm):

            def __init__(self, *args, **kwargs):
                super().__init__(*args, **kwargs)
                self.helper.attrs = cls.make_helper_attrs('lex', n)
                self.model_class = PhraseType
                
                components = and_or_form_creator('Typ frazeologizmu', field_name=cls.unique_name('lex_type', n), data_prefix='phrase_lex')
                self.helper.layout = cls.make_layout('Frazeologizm', components)
        
        return LexForm

class FrameFormFactory(FormFactory):
    
    field_makers = (
        (
            'opinion',
            lambda: ModelMultipleChoiceFilter(
                label='Opinia',
                queryset=FrameOpinion.objects.exclude(key='unk'),
                key='key',
                human_values=polish_strings.FRAME_OPINION,
                lookup='opinion',
            )
        ),
        #(
        #    'operator_opinion',
        #    lambda: OperatorField()
        #),
        (
            'num_arguments',
            lambda: RangeFilter(
                label='Liczba argumentów',
                lookup='arguments_count',
            )
        ),
        (
            'num_preferences',
            lambda: RangeFilter(
                label='Liczba preferencyj selekcyjnych argumentu',
                lookup='argument__preferences_count',
            )
        ),
        # TODO move this to the entry form
        #filter_frame_ = SwitchField('Filtruj ramy')
    )
    
    @classmethod
    def make_form_class(cls, n):
    
        class FrameForm(QueryForm):

            def __init__(self, *args, **kwargs):
                super().__init__(*args, **kwargs)
                self.helper.attrs = cls.make_helper_attrs('frame', n)
                self.model_class = Frame
                
                components = [
                    self.make_field(cls.unique_name('opinion', n)),
                    #self.make_field(cls.unique_name('operator_opinion', n)),
                    self.make_field(cls.unique_name('num_arguments', n)),
                    self.make_field(cls.unique_name('num_preferences', n)),
                ] + \
                    and_or_form_creator('Argument', data_add='argument')
                self.helper.layout = cls.make_layout('Rama semantyczna', components)
        
        return FrameForm


class ArgumentFormFactory(FormFactory):
    
    field_makers = (
        (
            'role',
            lambda: ArgumentFilter(),
        ),
        (
            'preference_type',
            lambda: forms.ChoiceField(
                label='Preferencja selekcyjna',
                choices=(('predefined', 'Predefinowana grupa znaczeń'), ('relational', 'Wyrażona przez relację'), ('synset', 'Wyrażona przez jednostkę leksykalną Słowosieci')),
                required=False,
            )
        ),
        (
            'phrase_type',
            lambda: PhraseTypeFilter(help_text='Typ frazy, przez którą może być realizowany argument.')
        ),
    )
    
    @classmethod
    def make_form_class(cls, n):

        class ArgumentForm(QueryForm):

            def __init__(self, *args, **kwargs):
                super().__init__(*args, **kwargs)
                self.helper.attrs = cls.make_helper_attrs('argument', n)
                self.model_class = Argument
                
                components = [
                    self.make_field(cls.unique_name('role', n)),
                ] + \
                    and_or_form_creator('Preferencja selekcyjna', field_name=cls.unique_name('preference_type', n)) + \
                    and_or_form_creator('Pozycja', data_add='position') + \
                    and_or_form_creator('Fraza', field_name=cls.unique_name('phrase_type', n), data_prefix='phrase_')
                self.helper.layout = cls.make_layout('Argument ramy', components)
        
        return ArgumentForm


class PredefinedPreferenceFormFactory(FormFactory):
    
    field_makers = (
        (
            'predefined',
            lambda: PredefinedPreferenceFilter()
        ),
    )
    
    @classmethod
    def make_form_class(cls, n):

        class PredefinedPreferenceForm(QueryForm):

            def __init__(self, *args, **kwargs):
                super().__init__(*args, **kwargs)
                self.helper.attrs = cls.make_helper_attrs('predefined', n)
                self.model_class = PredefinedSelectionalPreference
                
                components = [
                    self.make_field(cls.unique_name('predefined', n)),
                ]
                self.helper.layout = cls.make_layout('Preferencja predefiniowana', components)
        
        return PredefinedPreferenceForm
            

class RelationalPreferenceFormFactory(FormFactory):
    
    field_makers = (
        (
            'relational',
            lambda: RelationalPreferenceFilter()
        ),
    )
    
    @classmethod
    def make_form_class(cls, n):

        class RelationalPreferenceForm(QueryForm):

            def __init__(self, *args, **kwargs):
                super().__init__(*args, **kwargs)
                self.helper.attrs = cls.make_helper_attrs('relational', n)
                self.model_class = RelationalSelectionalPreference
                
                components = [
                    self.make_field(cls.unique_name('relational', n)),
                ]
                self.helper.layout = cls.make_layout('Preferencja – relacja', components)
        
        return RelationalPreferenceForm
            

class SynsetPreferenceFormFactory(FormFactory):
    
    field_makers = (
        (
            'synset',
            #lambda: SynsetPreferenceFilter()
            lambda: RegexFilter(
                label='Jednostka leksykalna',
                max_length=200,
                lookup='lexical_units__text_rep',
                autocomplete='lu'
            )
        ),
    )
    
    @classmethod
    def make_form_class(cls, n):

        class SynsetPreferenceForm(QueryForm):

            def __init__(self, *args, **kwargs):
                super().__init__(*args, **kwargs)
                self.helper.attrs = cls.make_helper_attrs('synset', n)
                # TODO
                self.model_class = Synset
                
                components = [
                    self.make_field(cls.unique_name('synset', n)),
                ]
                self.helper.layout = cls.make_layout('Preferencja – Słowosieć', components)
        
        return SynsetPreferenceForm
    

class PhraseAttributesFormFactory(FormFactory):
    
    # field types are dynamic here
    field_makers = None
    
    qm = SingleValueQueryManager(lookup='main_type__name')

    @classmethod
    def make_form_class(cls, n, model, lex_model, phrase_type):
        fields = list(filter(lambda x: type(x) in (OneToOneField, ForeignKey, CharField, ManyToManyField) and not x.name.endswith('_ptr'), model._meta.get_fields()))
        if lex_model is not None:
            lex_fields = list(filter(lambda x: type(x) in (OneToOneField, ForeignKey, CharField, ManyToManyField) and not x.name.endswith('_ptr'), lex_model._meta.get_fields()))
        else:
            lex_fields = []
        all_fields = [(f, 'phrase_{}'.format(f.name)) for f in fields] + [(f, 'lex_phrase_{}'.format(f.name)) for f in lex_fields]
        
        class AttributesForm(QueryForm):

            def __init__(self, *args, **kwargs):
                super().__init__(*args, **kwargs)
                self.helper.attrs = cls.make_helper_attrs('phrase_{}'.format(phrase_type), n)
                self.helper.form_id = 'phrase-form'
                self.model_class = PhraseType
                
                components = []
                for _, name in all_fields:
                    uniq_name = cls.unique_name(name, n)
                    if name.endswith('_lexes'):
                        flds = and_or_form_creator('Fraza', field_name=uniq_name, data_prefix='phrase_lex')
                    elif name.endswith('_lex'):
                        flds = and_or_form_creator('Fraza', field_name=uniq_name, data_prefix='phrase_lex')
                    elif name.endswith('_phrase'):
                        flds = and_or_form_creator('Fraza', field_name=uniq_name, data_prefix='phrase_')
                    else:
                        flds = [self.make_field(uniq_name)]
                    components += flds
                pt = polish_strings.PHRASE_TYPE[phrase_type]
                header = pt.capitalize() if phrase_type in polish_strings.NO_PHRASE_NAME else 'Fraza {}'.format(pt)
                if lex_model:
                    header += ' (frazeologizm)'
                self.helper.layout = cls.make_layout(
                    header,
                    #'{} {}'.format('Frazeologizm' if lex_model else 'Fraza', polish_strings.PHRASE_TYPE[phrase_type]),
                    components
                )
            
            # add a phrase type query
            def get_queries(self):
                return super().get_queries() + cls.qm.make_queries(phrase_type, None)
        
        
        for field, name in all_fields:
            #print('***', name, field.name, type(field))
            if field.name == 'lexes':
                form_field = PhraseTypeFilter(help_text='Fraza składowa frazeologizmu porównawczego.', lex=True)
            elif field.name == 'lex':
                form_field = PhraseTypeFilter(help_text='Fraza realizująca frazeologizm.')
            elif field.name == 'phrase':
                form_field = PhraseTypeFilter(help_text='Typ składniowy frazeologizmu.')
            elif type(field) == CharField:
                # TODO other autocompletes?
                autocomplete = 'fixed' if field.name == 'text' else None
                form_field = RegexFilter(
                    label=polish_strings.PHRASE_ATTRIBUTE.get(field.name, field.name),
                    lookup='attributes__{}attributes__{}'.format(phrase_type, field.name),
                    max_length=200,
                    autocomplete=autocomplete,
                )
            else:
                queryset_q = Q(('{}{}attributes__isnull'.format('lex' if name.startswith('lex') else '', phrase_type), False))
                form_field = ModelMultipleChoiceFilter(
                    label=polish_strings.PHRASE_ATTRIBUTE.get(field.name, field.name),
                    queryset=type(field.related_model()).objects.filter(queryset_q).distinct(),
                    key='name',
                    lookup='attributes__{}attributes__{}'.format(phrase_type, field.name),
            )
            AttributesForm.base_fields[cls.unique_name(name, n)] = form_field
        
        return AttributesForm

    '''
    @staticmethod
    def PhraseAttributesForm(phrase_type, *args, **kwargs):
        lex = phrase_type.startswith('lex')
        phrase_type = phrase_type[3:] if lex else phrase_type
        if phrase_type in attrs_helpers:
            helper = attrs_helpers[phrase_type]
            cls, lex_cls = helper.attrs_cls, helper.lex_attrs_cls
            if lex:
                assert(lex_cls is not None)
                return PhraseAttributesFormFactory.get_attributes_form(cls, lex_cls, phrase_type, *args, **kwargs)
            else:
                return PhraseAttributesFormFactory.get_attributes_form(cls, None, phrase_type, *args, **kwargs)
        return PhraseAttributesFormFactory.get_attributes_form(EmptyAttributes, None, phrase_type)
    '''
    
    @classmethod    
    def get_form(cls, phrase_type, unique_number=None, *args, **kwargs):
        unique_number = cls.unique_number() if unique_number is None else unique_number
        lex = phrase_type.startswith('lex')
        phrase_type = phrase_type[3:] if lex else phrase_type
        form_class = None
        if phrase_type in attrs_helpers:
            helper = attrs_helpers[phrase_type]
            attrs_cls, lex_attrs_cls = helper.attrs_cls, helper.lex_attrs_cls
            if lex:
                assert(lex_attrs_cls is not None)
                form_class = cls.make_form_class(unique_number, attrs_cls, lex_attrs_cls, phrase_type)
            else:
                form_class = cls.make_form_class(unique_number, attrs_cls, None, phrase_type)
        if form_class is None:
            form_class = cls.make_form_class(unique_number, EmptyAttributes, None, phrase_type)
        return form_class(*args, **kwargs)