Add session files base concept.
This commit is contained in:
parent
58fb9fb188
commit
359f858c39
9 changed files with 162 additions and 93 deletions
|
|
@ -3,7 +3,7 @@
|
|||
from . import knowledge_evaluation
|
||||
|
||||
from . import depth_meter
|
||||
import logging
|
||||
from .session.org_mode import global_session as session
|
||||
import re
|
||||
import copy
|
||||
|
||||
|
|
@ -20,9 +20,9 @@ def to_tokens(text):
|
|||
def make_template(knowledge_base, tokens, parsed):
|
||||
matcher = list(tokens)
|
||||
template = list(parsed)
|
||||
logging.debug(" -- MK TEMPLATE --")
|
||||
logging.debug("MATCHR: {}".format(matcher))
|
||||
logging.debug("TEMPLT: {}".format(template))
|
||||
session().annotate(" -- MK TEMPLATE --")
|
||||
session().annotate("MATCHR: {}".format(matcher))
|
||||
session().annotate("TEMPLT: {}".format(template))
|
||||
for i in range(len(matcher)):
|
||||
word = matcher[i]
|
||||
if word in template:
|
||||
|
|
@ -59,11 +59,11 @@ def get_lower_levels(parsed):
|
|||
|
||||
# TODO: probably optimize this, it creates lots of unnecessary tuples
|
||||
def replace_position(tree, position, new_element):
|
||||
logging.debug("REPLACE POSITIONS:")
|
||||
logging.debug(" TREE : {}".format(tree))
|
||||
logging.debug("POSITION: {}".format(position))
|
||||
logging.debug("NEW ELEM: {}".format(new_element))
|
||||
logging.debug("------------------")
|
||||
session().annotate("REPLACE POSITIONS:")
|
||||
session().annotate(" TREE : {}".format(tree))
|
||||
session().annotate("POSITION: {}".format(position))
|
||||
session().annotate("NEW ELEM: {}".format(new_element))
|
||||
session().annotate("------------------")
|
||||
|
||||
def aux(current_tree, remaining_route):
|
||||
if len(remaining_route) == 0:
|
||||
|
|
@ -78,7 +78,7 @@ def replace_position(tree, position, new_element):
|
|||
)
|
||||
|
||||
result = aux(tree, position)
|
||||
logging.debug("-RESULT: {}".format(result))
|
||||
session().annotate("-RESULT: {}".format(result))
|
||||
return result
|
||||
|
||||
|
||||
|
|
@ -90,37 +90,37 @@ def integrate_language(knowledge_base, example):
|
|||
tokens = to_tokens(text)
|
||||
|
||||
while True:
|
||||
logging.debug("P: {}".format(resolved_parsed))
|
||||
session().annotate("P: {}".format(resolved_parsed))
|
||||
lower_levels = get_lower_levels(resolved_parsed)
|
||||
logging.debug("Lower: {}".format(lower_levels))
|
||||
session().annotate("Lower: {}".format(lower_levels))
|
||||
if len(lower_levels) == 0:
|
||||
break
|
||||
|
||||
for position, atom in lower_levels:
|
||||
logging.debug("\x1b[1mSelecting\x1b[0m: {}".format(atom))
|
||||
session().annotate("\x1b[1mSelecting\x1b[0m: {}".format(atom))
|
||||
similar = get_similar_tree(knowledge_base, atom, tokens)
|
||||
remix, (start_bounds, end_bounds) = build_remix_matrix(knowledge_base, tokens, atom, similar)
|
||||
|
||||
after_remix = apply_remix(tokens[len(start_bounds):-len(end_bounds)], remix)
|
||||
logging.debug("--FIND MIX--")
|
||||
logging.debug("-MIX- | {}".format(remix))
|
||||
logging.debug("-FRM- | {}".format(tokens))
|
||||
logging.debug("-AFT- | {}".format(after_remix))
|
||||
session().annotate("--FIND MIX--")
|
||||
session().annotate("-MIX- | {}".format(remix))
|
||||
session().annotate("-FRM- | {}".format(tokens))
|
||||
session().annotate("-AFT- | {}".format(after_remix))
|
||||
|
||||
logging.debug("--- TEMPLATE ---")
|
||||
session().annotate("--- TEMPLATE ---")
|
||||
|
||||
_, matcher, result = make_template(knowledge_base, after_remix, atom)
|
||||
logging.debug("Tx: {}".format(after_remix))
|
||||
logging.debug("Mx: {}".format(matcher))
|
||||
logging.debug("Rx: {}".format(result))
|
||||
logging.debug("Sx: {}".format(start_bounds))
|
||||
logging.debug("Ex: {}".format(end_bounds))
|
||||
session().annotate("Tx: {}".format(after_remix))
|
||||
session().annotate("Mx: {}".format(matcher))
|
||||
session().annotate("Rx: {}".format(result))
|
||||
session().annotate("Sx: {}".format(start_bounds))
|
||||
session().annotate("Ex: {}".format(end_bounds))
|
||||
|
||||
|
||||
assert(len(after_remix) + len(start_bounds) + len(end_bounds) == len(tokens))
|
||||
logging.debug( " +-> {}".format(after_remix))
|
||||
session().annotate( " +-> {}".format(after_remix))
|
||||
subquery_type = knowledge_evaluation.get_subquery_type(knowledge_base.knowledge, atom)
|
||||
logging.debug(r" \-> <{}>".format(subquery_type))
|
||||
session().annotate(r" \-> <{}>".format(subquery_type))
|
||||
|
||||
# Clean remaining tokens
|
||||
new_tokens = list(tokens)
|
||||
|
|
@ -133,16 +133,16 @@ def integrate_language(knowledge_base, example):
|
|||
tokens = new_tokens
|
||||
|
||||
resolved_parsed = replace_position(resolved_parsed, position, offset)
|
||||
logging.debug("RP: {}".format(resolved_parsed))
|
||||
logging.debug("AT: {}".format(atom))
|
||||
logging.debug("#########")
|
||||
session().annotate("RP: {}".format(resolved_parsed))
|
||||
session().annotate("AT: {}".format(atom))
|
||||
session().annotate("#########")
|
||||
|
||||
|
||||
tokens, matcher, result = make_template(knowledge_base, tokens, resolved_parsed)
|
||||
logging.debug("T: {}".format(tokens))
|
||||
logging.debug("M: {}".format(matcher))
|
||||
logging.debug("R: {}".format(result))
|
||||
logging.debug("---")
|
||||
session().annotate("T: {}".format(tokens))
|
||||
session().annotate("M: {}".format(matcher))
|
||||
session().annotate("R: {}".format(result))
|
||||
session().annotate("---")
|
||||
return tokens, matcher, result
|
||||
|
||||
|
||||
|
|
@ -180,8 +180,8 @@ def get_possible_remixes(knowledge_base, matcher, similar_matcher):
|
|||
|
||||
matrix = []
|
||||
for element in matcher:
|
||||
logging.debug("- {}".format(element))
|
||||
logging.debug("+ {}".format(similar_matcher))
|
||||
session().annotate("- {}".format(element))
|
||||
session().annotate("+ {}".format(similar_matcher))
|
||||
if element in similar_matcher or isinstance(element, dict):
|
||||
if isinstance(element, dict):
|
||||
indexes = all_matching_indexes(knowledge_base, similar_matcher, element)
|
||||
|
|
@ -298,12 +298,12 @@ def get_similar_tree(knowledge_base, atom, tokens):
|
|||
return None
|
||||
|
||||
for i, possibility in enumerate(sorted_possibilities):
|
||||
logging.debug('---- POSSIBILITY #{} ----'.format(i))
|
||||
session().annotate('---- POSSIBILITY #{} ----'.format(i))
|
||||
similar_matcher, similar_result, similar_result_resolved, _, _ = possibility
|
||||
logging.debug('AST: {}'.format(similar_result))
|
||||
logging.debug('Based on: {}'.format(similar_matcher))
|
||||
logging.debug('Results on: {}'.format(similar_result_resolved))
|
||||
logging.debug('---------------------')
|
||||
session().annotate('AST: {}'.format(similar_result))
|
||||
session().annotate('Based on: {}'.format(similar_matcher))
|
||||
session().annotate('Results on: {}'.format(similar_result_resolved))
|
||||
session().annotate('---------------------')
|
||||
|
||||
return sorted_possibilities[0]
|
||||
|
||||
|
|
@ -382,9 +382,9 @@ def get_fit(knowledge, tokens, remaining_recursions=parameters.MAX_RECURSIONS):
|
|||
|
||||
if result is not None:
|
||||
results.append(result)
|
||||
logging.debug("XXX {}".format(result))
|
||||
session().annotate("XXX {}".format(result))
|
||||
|
||||
logging.debug(' - ' + '\n - '.join(map(str, results)))
|
||||
session().annotate(' - ' + '\n - '.join(map(str, results)))
|
||||
if len(results) > 0:
|
||||
return results[0]
|
||||
|
||||
|
|
@ -419,7 +419,7 @@ def resolve_fit(knowledge, fit, remaining_recursions):
|
|||
return None
|
||||
|
||||
minitokens, miniast = minifit
|
||||
logging.debug(" AST | {}".format(miniast))
|
||||
session().annotate(" AST | {}".format(miniast))
|
||||
subproperty = knowledge_evaluation.resolve(knowledge.knowledge, minitokens, miniast)
|
||||
fitted.append(subproperty)
|
||||
|
||||
|
|
@ -429,17 +429,17 @@ def resolve_fit(knowledge, fit, remaining_recursions):
|
|||
def match_fit(knowledge, tokens, matcher, ast, remaining_recursions):
|
||||
segment_possibilities = [([], tokens)] # Matched tokens, remaining tokens
|
||||
indent = ' ' * (parameters.MAX_RECURSIONS - remaining_recursions)
|
||||
logging.debug(indent + 'T> {}'.format(tokens))
|
||||
logging.debug(indent + 'M> {}'.format(matcher))
|
||||
session().annotate(indent + 'T> {}'.format(tokens))
|
||||
session().annotate(indent + 'M> {}'.format(matcher))
|
||||
for minisegment in matcher:
|
||||
possibilities_after_round = []
|
||||
logging.debug(indent + "MS {}".format(minisegment))
|
||||
session().annotate(indent + "MS {}".format(minisegment))
|
||||
for matched_tokens, remaining_tokens in segment_possibilities:
|
||||
if len(remaining_tokens) < 1:
|
||||
continue
|
||||
|
||||
logging.debug(indent + "RT {}".format(remaining_tokens[0]))
|
||||
logging.debug(indent + "DEF {}".format(is_definite_minisegment(minisegment)))
|
||||
session().annotate(indent + "RT {}".format(remaining_tokens[0]))
|
||||
session().annotate(indent + "DEF {}".format(is_definite_minisegment(minisegment)))
|
||||
if is_definite_minisegment(minisegment):
|
||||
# What if not match -----<
|
||||
if match_token(knowledge, remaining_tokens[0], minisegment):
|
||||
|
|
@ -455,10 +455,10 @@ def match_fit(knowledge, tokens, matcher, ast, remaining_recursions):
|
|||
matched_tokens + [(minisegment, remaining_tokens[:i])],
|
||||
remaining_tokens[i:]
|
||||
))
|
||||
logging.debug(indent + "## PA {}".format(possibilities_after_round))
|
||||
session().annotate(indent + "## PA {}".format(possibilities_after_round))
|
||||
else:
|
||||
segment_possibilities = possibilities_after_round
|
||||
logging.debug(">>>> {}".format(len(segment_possibilities)))
|
||||
session().annotate(">>>> {}".format(len(segment_possibilities)))
|
||||
|
||||
fully_matched_segments = [(matched, remaining)
|
||||
for (matched, remaining)
|
||||
|
|
@ -467,11 +467,11 @@ def match_fit(knowledge, tokens, matcher, ast, remaining_recursions):
|
|||
|
||||
resolved_fits = []
|
||||
for fit, _ in fully_matched_segments:
|
||||
logging.debug(indent + "::: {}".format(fit)) # REMIXES HAVE TO BE APPLIED BEFORE!!!
|
||||
session().annotate(indent + "::: {}".format(fit)) # REMIXES HAVE TO BE APPLIED BEFORE!!!
|
||||
|
||||
logging.debug(indent + '*' * 20)
|
||||
session().annotate(indent + '*' * 20)
|
||||
for fit, _ in fully_matched_segments:
|
||||
logging.debug(indent + "::: {}".format(fit)) # REMIXES HAVE TO BE APPLIED BEFORE!!!
|
||||
session().annotate(indent + "::: {}".format(fit)) # REMIXES HAVE TO BE APPLIED BEFORE!!!
|
||||
resolved_fit = resolve_fit(knowledge, fit, remaining_recursions)
|
||||
if resolved_fit is not None:
|
||||
resolved_fits.append(resolved_fit)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue