def test_get_all_arguments_by_statement(self):
argument_list = lib.get_all_arguments_by_statement(3)
self.assertEqual(len(argument_list), 4)
for argument in argument_list:
self.assertTrue(argument.uid in [4, 5, 6, 7])
self.assertEqual(len(lib.get_all_arguments_by_statement(70, True)), 2)
self.assertEqual(len(lib.get_all_arguments_by_statement(12, True)), 1)
self.assertEqual(lib.get_all_arguments_by_statement(-1), None)
def __find_position_for_conclusion_of_argument(current_arg, list_todos,
list_dones, positions):
"""
:param current_arg: Argument
:param list_todos: List of Arguments
:param list_dones: List of Argument.uids
:param positions: List of Statements - return value
:return:
"""
a = [arg.uid for arg in list_todos] if len(list_todos) > 0 else []
b = [p.uid for p in positions] if len(positions) > 0 else []
logger(
'PartialGraph',
'current_arg: {}, list_todos: {}, list_dones: {}, positions: {}'.
format(current_arg.uid, a, list_dones, b))
list_dones.append(current_arg.uid)
logger('PartialGraph', 'done ' + str(current_arg.uid))
if current_arg.conclusion_uid is None:
db_target = DBDiscussionSession.query(Argument).get(
current_arg.argument_uid)
return __find_position_for_conclusion_of_argument(
db_target, list_todos, list_dones, positions)
db_statement = DBDiscussionSession.query(Statement).get(
current_arg.conclusion_uid)
if db_statement.is_position:
if db_statement not in positions:
logger(
'PartialGraph',
'conclusion of {} is a position (statement {})'.format(
current_arg.uid, db_statement.uid))
positions.append(db_statement)
else:
# just append arguments, where the conclusion is in the premise
db_tmps = get_all_arguments_by_statement(current_arg.conclusion_uid)
db_arguments = [
arg for arg in db_tmps
if arg.conclusion_uid != current_arg.conclusion_uid
]
for arg in db_arguments:
if arg.uid not in list_dones and arg not in list_todos:
list_todos.append(arg)
logger('PartialGraph', 'append todo ' + str(arg.uid))
# next argument
if len(list_todos) > 0:
current_arg = list_todos[0]
del list_todos[0]
logger('PartialGraph', 'next ' + str(current_arg.uid))
return __find_position_for_conclusion_of_argument(
current_arg, list_todos, list_dones, positions)
logger('PartialGraph', 'return')
return positions
def get_text_for_argument(request):
statement = int(request.matchdict["statement_uid"])
args = get_all_arguments_by_statement(statement)
return list(
map(
lambda arg: {
"uid": arg.uid,
"text": get_text_for_argument_uid(arg.uid)
}, args))
def __bend_objects_of_review(db_review):
"""
If an argument is a duplicate, we have to bend the objects of argument, which are no duplicates
:param db_review: Review
:return: None
"""
LOG.debug("Review %s with duplicate %s and Original %s", db_review.uid, db_review.duplicate_statement_uid,
db_review.original_statement_uid)
db_statement = DBDiscussionSession.query(Statement).get(db_review.duplicate_statement_uid)
db_statement.set_disabled(True)
DBDiscussionSession.add(db_statement)
# do we need a new position
db_dupl_statement = DBDiscussionSession.query(Statement).get(db_review.duplicate_statement_uid)
db_orig_statement = DBDiscussionSession.query(Statement).get(db_review.original_statement_uid)
if db_dupl_statement.is_position and not db_orig_statement.is_position:
LOG.debug("Duplicate is startpoint, but original one is not")
DBDiscussionSession.add(
RevokedDuplicate(review=db_review.uid, bend_position=True, statement=db_orig_statement.uid))
db_orig_statement.set_position(True)
# getting all argument where the duplicated statement is used
all_arguments = get_all_arguments_by_statement(db_review.duplicate_statement_uid, True)
for argument in all_arguments:
text = 'Statement {db_review.duplicate_statement_uid} was used in argument {argument.uid}'
used = False
# recalibrate conclusion
if argument.conclusion_uid == db_review.duplicate_statement_uid:
LOG.debug("%s, bend conclusion from %s to %s", text, argument.conclusion_uid,
db_review.original_statement_uid)
argument.set_conclusion(db_review.original_statement_uid)
DBDiscussionSession.add(argument)
DBDiscussionSession.add(RevokedDuplicate(review=db_review.uid, conclusion_of_argument=argument.uid))
used = True
# recalibrate premises
db_premises = DBDiscussionSession.query(Premise).filter_by(premisegroup_uid=argument.premisegroup_uid).all()
for premise in db_premises:
if premise.statement_uid == db_review.duplicate_statement_uid:
LOG.debug("%s, bend premise %s from %s to %s", text, premise.uid, premise.statement_uid,
db_review.original_statement_uid)
premise.set_statement(db_review.original_statement_uid)
DBDiscussionSession.add(premise)
DBDiscussionSession.add(RevokedDuplicate(review=db_review.uid, premise=premise.uid))
used = True
if not used:
LOG.warning("Nothing was bend - undercut from %s to %s", argument.uid, argument.argument_uid)
DBDiscussionSession.flush()
transaction.commit()
def __find_position_for_conclusion_of_argument(current_arg, list_todos,
list_dones, positions):
"""
:param current_arg: Argument
:param list_todos: List of Arguments
:param list_dones: List of Argument.uids
:param positions: List of Statements - return value
:return:
"""
a = [arg.uid for arg in list_todos] if len(list_todos) > 0 else []
b = [p.uid for p in positions] if len(positions) > 0 else []
LOG.debug("Current_arg: %s, list_todos: %s, list_dones: %s, positions: %s",
current_arg.uid, a, list_dones, b)
list_dones.append(current_arg.uid)
LOG.debug("Done %s", current_arg.uid)
if current_arg.conclusion_uid is None:
db_target = DBDiscussionSession.query(Argument).get(
current_arg.argument_uid)
return __find_position_for_conclusion_of_argument(
db_target, list_todos, list_dones, positions)
db_statement = DBDiscussionSession.query(Statement).get(
current_arg.conclusion_uid)
if db_statement.is_position:
if db_statement not in positions:
LOG.debug("Conclusion of %s is a position (statement %s)",
current_arg.uid, db_statement.uid)
positions.append(db_statement)
else:
# just append arguments, where the conclusion is in the premise
db_tmps = get_all_arguments_by_statement(current_arg.conclusion_uid)
db_arguments = [
arg for arg in db_tmps
if arg.conclusion_uid != current_arg.conclusion_uid
]
for arg in db_arguments:
if arg.uid not in list_dones and arg not in list_todos:
list_todos.append(arg)
LOG.debug("Append todo %s", arg.uid)
# next argument
if len(list_todos) > 0:
current_arg = list_todos[0]
del list_todos[0]
LOG.debug("Next %s", current_arg.uid)
return __find_position_for_conclusion_of_argument(
current_arg, list_todos, list_dones, positions)
return positions
def get_partial_graph_for_statement(uid: int, db_issue: Issue, path: str):
"""
Returns the partial graph where the statement is embedded
:param uid: Statement.uid
:param db_issue: Issue
:param path: Users history
:return: dict()
"""
logger('PartialGraph',
'main with uid {} and path {}'.format(uid,
path.split('?')[0]))
path = path.split('?')[0]
if db_issue and len(path) > 1:
path = path.split(db_issue.slug)[1]
# if we have a attitude, we are asking for supporting/attacking a conclusion
if 'attitude' in path:
db_statement = DBDiscussionSession.query(Statement).get(uid)
if not db_statement:
return get_d3_data(db_issue)
uid = db_statement.uid
# special case - dont know branche
if 'justify' in path and '/dontknow' in path:
db_argument = DBDiscussionSession.query(Argument).get(uid)
db_premise = DBDiscussionSession.query(Premise).filter_by(
premisegroup_uid=db_argument.premisegroup_uid).first()
uid = db_premise.statement_uid
# if there is no justify, we have an argument
if 'justify' not in path and len(path) > 1:
db_argument = DBDiscussionSession.query(Argument).get(uid)
db_premise = DBDiscussionSession.query(Premise).filter_by(
premisegroup_uid=db_argument.premisegroup_uid).first()
uid = db_premise.statement_uid
db_arguments = get_all_arguments_by_statement(uid)
if db_arguments is None or len(db_arguments) == 0:
return get_d3_data(db_issue,
[DBDiscussionSession.query(Statement).get(uid)], [])
current_arg = db_arguments[0]
del db_arguments[0]
db_positions = __find_position_for_conclusion_of_argument(
current_arg, db_arguments, [], [])
logger('PartialGraph',
'positions are: ' + str([pos.uid for pos in db_positions]))
graph_arg_lists = __climb_graph_down(db_positions)
return __return_d3_data(graph_arg_lists, db_issue)
def __remove_user_from_arguments_with_statement(db_statement, db_user):
"""
Calls revoke_content(...) for all arguments, where the Statement.uid is used
:param db_statement: Statement
:param db_user: User
:return: None
"""
logger('QueryHelper', '{} with user{}'.format(db_statement.uid,
db_user.uid))
db_arguments = get_all_arguments_by_statement(db_statement.uid, True)
for arg in db_arguments:
if arg.author_uid == db_user.uid:
revoke_author_of_argument_content(arg, db_user)
def __remove_user_from_arguments_with_statement(db_statement: Statement,
db_user: User):
"""
Calls revoke_content(...) for all arguments, where the Statement.uid is used
:param db_statement: Statement
:param db_user: User
:return: None
"""
LOG.debug("%s with user %s", db_statement.uid, db_user.uid)
db_arguments = get_all_arguments_by_statement(db_statement.uid, True)
for arg in db_arguments:
if arg.author_uid == db_user.uid:
revoke_author_of_argument_content(arg, db_user)
def __climb_graph_down(db_positions):
"""
:param db_positions:
:return:
"""
graph_arg_lists = {}
for pos in db_positions:
args = get_all_arguments_by_statement(pos.uid)
LOG.debug("Position %s is present in args %s", pos.uid,
[arg.uid for arg in args])
uid = args[0].uid
del args[0]
todos = [arg.uid for arg in args]
graph = __get_argument_net(uid, todos, [], [])
graph_arg_lists[str(pos.uid)] = graph
return graph_arg_lists
def __climb_graph_down(db_positions):
"""
:param db_positions:
:return:
"""
logger('PartialGraph', str([pos.uid for pos in db_positions]))
graph_arg_lists = {}
for pos in db_positions:
args = get_all_arguments_by_statement(pos.uid)
logger(
'PartialGraph', 'Position {} is present in arg: {}'.format(
pos.uid, [arg.uid for arg in args]))
uid = args[0].uid
del args[0]
todos = [arg.uid for arg in args]
graph = __get_argument_net(uid, todos, [], [])
graph_arg_lists[str(pos.uid)] = graph
return graph_arg_lists
def __append_todos_for_getting_argument_net_with_premises(
uid, db_argument, list_todos, list_dones):
"""
:param uid:
:param db_argument:
:param list_todos:
:param list_dones:
:return:
"""
db_premises = DBDiscussionSession.query(Premise).filter(
Premise.premisegroup_uid == db_argument.premisegroup_uid,
Premise.is_disabled == False).all()
db_premise_args = []
for premise in db_premises:
args = get_all_arguments_by_statement(premise.statement_uid)
db_premise_args += args if args is not None else []
# get new todos
LOG.debug("Premises args: %s", [arg.uid for arg in db_premise_args])
for arg in db_premise_args:
if arg.uid not in list_todos and arg.uid not in list_dones and arg.uid != uid:
list_todos.append(arg.uid)
def __bend_objects_of_duplicate_review(db_review):
"""
If an argument is a duplicate, we have to bend the objects of argument, which are no duplicates
:param db_review: Review
:return: None
"""
msg = 'Review {} with dupl {} and oem {}'.format(
db_review.uid, db_review.duplicate_statement_uid,
db_review.original_statement_uid)
logger('review.opinions', msg)
db_statement = DBDiscussionSession.query(Statement).get(
db_review.duplicate_statement_uid)
db_statement.set_disabled(True)
DBDiscussionSession.add(db_statement)
# TODO SINGLE STATEMENT SET DISABLE
# do we need a new position
db_dupl_statement = DBDiscussionSession.query(Statement).get(
db_review.duplicate_statement_uid)
db_orig_statement = DBDiscussionSession.query(Statement).get(
db_review.original_statement_uid)
if db_dupl_statement.is_position and not db_orig_statement.is_position:
logger('review.opinions',
'Duplicate is startpoint, but original one is not')
DBDiscussionSession.add(
RevokedDuplicate(review=db_review.uid,
bend_position=True,
statement=db_orig_statement.uid))
db_orig_statement.set_position(True)
# getting all argument where the duplicated statement is used
all_arguments = get_all_arguments_by_statement(
db_review.duplicate_statement_uid, True)
for argument in all_arguments:
text = 'Statement {} was used in argument {}'.format(
db_review.duplicate_statement_uid, argument.uid)
used = False
# recalibrate conclusion
if argument.conclusion_uid == db_review.duplicate_statement_uid:
tmp = '{}, bend conclusion from {} to {}'.format(
text, argument.conclusion_uid,
db_review.original_statement_uid)
logger('review.opinions', tmp)
argument.set_conclusion(db_review.original_statement_uid)
DBDiscussionSession.add(argument)
DBDiscussionSession.add(
RevokedDuplicate(review=db_review.uid,
conclusion_of_argument=argument.uid))
used = True
# recalibrate premises
db_premises = DBDiscussionSession.query(Premise).filter_by(
premisegroup_uid=argument.premisegroup_uid).all()
for premise in db_premises:
if premise.statement_uid == db_review.duplicate_statement_uid:
tmp = '{}, bend premise {} from {} to {}'.format(
text, premise.uid, premise.statement_uid,
db_review.original_statement_uid)
logger('review.opinions', tmp)
premise.set_statement(db_review.original_statement_uid)
DBDiscussionSession.add(premise)
DBDiscussionSession.add(
RevokedDuplicate(review=db_review.uid,
premise=premise.uid))
used = True
if not used:
logger('review.opinions',
'Nothing was bend - undercut from {} to {}'.format(
argument.uid, argument.argument_uid),
error=True)
DBDiscussionSession.flush()
transaction.commit()
def __get_subpage_dict_for_optimization(session, application_url, db_user,
translator):
"""
Setup the subpage for the optimization queue
:param session: session of current webserver request
:param application_url: current url of the app
:param db_user: User
:param translator: Translator
:return: dict()
"""
logger('ReviewSubpagerHelper', 'main')
db_reviews, already_seen, already_reviewed, first_time = __get_all_allowed_reviews_for_user(
session, 'already_seen_optimization', db_user, ReviewOptimization,
LastReviewerOptimization)
extra_info = ''
# if we have no reviews, try again with fewer restrictions
if not db_reviews:
already_seen = list()
extra_info = 'already_seen' if not first_time else ''
db_reviews = DBDiscussionSession.query(ReviewOptimization).filter(
ReviewOptimization.is_executed == False,
ReviewOptimization.detector_uid != db_user.uid)
if len(already_reviewed) > 0:
db_reviews = db_reviews.filter(
~ReviewOptimization.uid.in_(already_reviewed))
db_reviews = db_reviews.all()
if not db_reviews:
return {
'stats': None,
'text': None,
'reason': None,
'issue': None,
'context': [],
'extra_info': None,
'session': session
}
rnd_review = db_reviews[random.randint(0, len(db_reviews) - 1)]
if rnd_review.statement_uid is None:
db_argument = DBDiscussionSession.query(Argument).get(
rnd_review.argument_uid)
text = get_text_for_argument_uid(db_argument.uid)
issue = DBDiscussionSession.query(Issue).get(
db_argument.issue_uid).title
parts = __get_text_parts_of_argument(db_argument)
context = [text]
else:
db_statement = DBDiscussionSession.query(Statement).get(
rnd_review.statement_uid)
text = db_statement.get_text()
issue = DBDiscussionSession.query(Issue).get(
db_statement.issue_uid).title
parts = [
__get_part_dict('statement', text, 0, rnd_review.statement_uid)
]
context = []
args = get_all_arguments_by_statement(rnd_review.statement_uid)
if args:
context = [
get_text_for_argument_uid(arg.uid).replace(
text, '<span class="text-info"><strong>{}</strong></span>'.
format(text)) for arg in args
]
reason = translator.get(_.argumentFlaggedBecauseOptimization)
stats = __get_stats_for_review(rnd_review, translator.get_lang(),
application_url)
already_seen.append(rnd_review.uid)
session['already_seen_optimization'] = already_seen
return {
'stats': stats,
'text': text,
'reason': reason,
'issue': issue,
'extra_info': extra_info,
'context': context,
'parts': parts,
'session': session
}
def get_queue_information(self, db_user: User, session: Session,
application_url: str, translator: Translator):
"""
Setup the subpage for the optimization queue
:param db_user: User
:param session: session of current webserver request
:param application_url: current url of the app
:param translator: Translator
:return: dict()
"""
LOG.debug("Setting up the sub-page for the optimization-queue")
all_rev_dict = get_all_allowed_reviews_for_user(
session, f'already_seen_{self.key}', db_user, ReviewOptimization,
LastReviewerOptimization)
extra_info = ''
# if we have no reviews, try again with fewer restrictions
if not all_rev_dict['reviews']:
all_rev_dict['already_seen_reviews'] = list()
extra_info = 'already_seen' if not all_rev_dict[
'first_time'] else ''
db_reviews = DBDiscussionSession.query(ReviewOptimization).filter(
ReviewOptimization.is_executed == False,
ReviewOptimization.detector_uid != db_user.uid)
if len(all_rev_dict['already_voted_reviews']) > 0:
db_reviews = db_reviews.filter(~ReviewOptimization.uid.in_(
all_rev_dict['already_voted_reviews']))
all_rev_dict['reviews'] = db_reviews.all()
if not all_rev_dict['reviews']:
return {
'stats': None,
'text': None,
'reason': None,
'issue_titles': None,
'context': [],
'extra_info': None,
'session': session
}
rnd_review = random.choice(all_rev_dict['reviews'])
if rnd_review.statement_uid is None:
db_argument = DBDiscussionSession.query(Argument).get(
rnd_review.argument_uid)
text = get_text_for_argument_uid(db_argument.uid)
issue_titles = [
DBDiscussionSession.query(Issue).get(
db_argument.issue_uid).title
]
parts = self.__get_text_parts_of_argument(db_argument)
context = [text]
else:
db_statement = DBDiscussionSession.query(Statement).get(
rnd_review.statement_uid)
text = db_statement.get_text()
issue_titles = [
issue.title for issue in get_issues_for_statement_uids(
[rnd_review.statement_uid])
]
parts = [
self.__get_part_dict('statement', text, 0,
rnd_review.statement_uid)
]
context = []
args = get_all_arguments_by_statement(rnd_review.statement_uid)
if args:
html_wrap = '<span class="text-info"><strong>{}</strong></span>'
context = [
get_text_for_argument_uid(arg.uid).replace(
text, html_wrap.format(text)) for arg in args
]
reason = translator.get(_.argumentFlaggedBecauseOptimization)
stats = get_reporter_stats_for_review(rnd_review,
translator.get_lang(),
application_url)
all_rev_dict['already_seen_reviews'].append(rnd_review.uid)
session[f'already_seen_{self.key}'] = all_rev_dict[
'already_seen_reviews']
return {
'stats': stats,
'text': text,
'reason': reason,
'issue_titles': issue_titles,
'extra_info': extra_info,
'context': context,
'parts': parts,
'session': session
}
