Realizations.py 6.52 KB
#! /usr/bin/python
# -*- coding: utf-8 -*-

from collections import defaultdict

from syntax.models import Schema, Position
from syntax.models_phrase import PhraseType, Gender, Number
from semantics.models import Frame
from connections.models import ArgumentConnection, SchemaHook, RealisationDescription

from importer.RealizationDescriptions import get_phrase_description, select_phrase_description, get_realisation_description
import importer.WalentyXML

class ArgumentRealization:

    def __init__(self, argument, position, phrases):
        self._argument = argument
        self._position = position
        self._phrases = phrases
        self._phrase_descriptions = dict()
        self._description = None
        # gender and number of the nominal head of the description phrase
        # used for determining gender of verb form, controlled adjps etc.
        # when generating realisation description
        self._gender = None
        self._number = None

    @classmethod
    def fromTree(cls, tree, arguments, all_phrases):
        argument = arguments[tree._children[0]._children[0]._attrs['sameAs'][1:]]
        phrases = []
        for subtree in tree._children[1]._children[0]._children:
            phrases.append(all_phrases[subtree._attrs['sameAs'][1:]])
        position = phrases[0]._position
        return cls(argument, position, phrases)

    def store(self, subentry, frame, schema, alternation, controller_grammar=None):
        argument = self._argument.get(frame)
        connection, _ = ArgumentConnection.objects.get_or_create(argument=argument)
        position = Position.objects.get(id=self._position._db_id)
        for phrase_obj in self._phrases:
            phrase = PhraseType.objects.get(text_rep=str(phrase_obj))
            description, gender, number = get_phrase_description(subentry, argument, self._position, phrase_obj, controller_grammar=controller_grammar)
            self._phrase_descriptions[phrase_obj] = (description, gender, number)
            hook = SchemaHook(subentry=subentry,
                              schema=schema,
                              position=position,
                              phrase_type=phrase,
                              alternation=alternation,
                              description=description)
            hook.save()
            connection.schema_connections.add(hook)
        self._description, self._gender, self._number = select_phrase_description(self._position, self._phrase_descriptions)

    def matches(self, phrases):
        for phrase in phrases:
            if phrase not in self._phrases:
                return False
        return True

# np. ‹*oczy* ciskają *gromy*› – frazy z dwóch pozycji jako realizacja „argumentu” Lemma
# rozbicie na dwie realizacje arg., bo realizacja arg. ma przypisaną pozycję.
def split_argument_realisation_tree(tree):
    # def __init__(self, name, attrs, parent)
    arg_node, phrases_node = tree._children
    phrases_by_position = defaultdict(list)
    for phrase in phrases_node._children[0]._children:
        position_id = phrase._attrs['sameAs'].split('.')[2]
        phrases_by_position[position_id].append(phrase)
    ret = []
    for position_id, phrs in phrases_by_position.items():
        new_tree = importer.WalentyXML.XMLNode(tree._name, tree._attrs, tree._parent)
        new_tree.addChild(arg_node)
        new_phrases_node = importer.WalentyXML.XMLNode(phrases_node._name, phrases_node._attrs, new_tree)
        new_coll_node = importer.WalentyXML.XMLNode(phrases_node._children[0]._name, phrases_node._children[0]._attrs, new_phrases_node)
        for phr in phrs:
            new_coll_node.addChild(phr)
            phr._parent = new_coll_node
        new_phrases_node.addChild(new_coll_node)
        new_tree.addChild(new_phrases_node)
        ret.append(new_tree)
    return ret

class FrameRealization:

    def __init__(self, frame, schema, argument_realizations):
        self._frame = frame
        self._schema = schema
        self._argument_realizations = argument_realizations
        
    @classmethod
    def fromTree(cls, tree, arguments, phrases):
        argument_realizations = []
        for subtree in tree._children[0]._children[0]._children:
            for subtree2 in split_argument_realisation_tree(subtree):
                argument_realizations.append(ArgumentRealization.fromTree(subtree2, arguments, phrases))
        frame = argument_realizations[0]._argument._frame
        schema = argument_realizations[0]._phrases[0]._position._schema
        return cls(frame, schema, argument_realizations)

    def store(self, entry):
        alternation = 1
        frame = Frame.objects.get(id=self._frame._db_id)
        schema = Schema.objects.get(id=self._schema._db_id)
        for argument in frame.sorted_arguments():
            realizations = ArgumentConnection.objects.filter(argument=argument)
            for realization in realizations.all():
                connections = realization.schema_connections
                for connection in connections.all():
                    if connection.schema.id == schema.id:
                        if connection.alternation >= alternation:
                            alternation = connection.alternation + 1
        subentry = self._schema.getSubentry(entry)
        controllers, non_controllers = [], []
        for ar in self._argument_realizations:
            (controllers if ar._position.isController() else non_controllers).append(ar)
        # during storing, gender and number is determined, so first store the controller
        # argument realisations to use those for controllee descriptions
        controller_grammar = {}
        for ar in controllers:
            ar.store(subentry, frame, schema, alternation)
            controller_grammar[ar._position] = (ar._gender, ar._number)
        print('**************************', controller_grammar)
        for ar in non_controllers:
            ar.store(subentry, frame, schema, alternation, controller_grammar=controller_grammar)
        description = get_realisation_description(self, subentry, self._schema.getAspect())
        print('================================', description)
        RealisationDescription.objects.create(frame=frame,
                                              schema=schema,
                                              alternation=alternation,
                                              description=description)

    def findMatchingArgument(self, phrases):
        for ar in self._argument_realizations:
            if ar.matches(phrases):
                return ar._argument
        return None