def get_undermines_for_argument_uid(argument_uid, is_supportive=False):
"""
Returns all uid's of undermines for the argument.
:return argument_uid: UID of the argument
:return is_supportive: Boolean
:return: array with dict() with id (of argument) and text.
"""
# logger('RelationHelper', 'get_undermines_for_argument_uid', 'main with argument_uid ' + str(self.argument_uid))
if not is_integer(argument_uid):
return None
if int(argument_uid) < 1:
return None
db_arguments = get_enabled_arguments_as_query()
db_attacked_argument = db_arguments.filter_by(uid=argument_uid).first()
if not db_attacked_argument:
return []
db_premises = get_enabled_premises_as_query()
db_attacked_premises = db_premises \
.filter_by(premisegroup_uid=db_attacked_argument.premisegroup_uid) \
.order_by(Premise.premisegroup_uid.desc()).all()
premises_as_statements_uid = set()
for premise in db_attacked_premises:
premises_as_statements_uid.add(premise.statement_uid)
if len(premises_as_statements_uid) == 0:
return []
return __get_undermines_for_premises(premises_as_statements_uid, is_supportive)
def __set_rebut_or_support(
premisegroup_uid: int, current_argument: Argument, db_user: User,
db_issue: Issue,
is_supportive: bool) -> Tuple[Union[Argument, bool], bool]:
db_arguments = get_enabled_arguments_as_query()
db_argument = db_arguments.filter(
Argument.premisegroup_uid == premisegroup_uid,
Argument.is_supportive == True,
Argument.conclusion_uid == current_argument.conclusion_uid).first()
if db_argument:
return db_argument, True
else:
db_tmp = DBDiscussionSession.query(Premise).filter_by(
premisegroup_uid=premisegroup_uid).all()
if any([
p.statement_uid == current_argument.conclusion_uid
for p in db_tmp
]):
return False, False
new_argument = Argument(premisegroup=premisegroup_uid,
is_supportive=is_supportive,
author=db_user.uid,
issue=db_issue.uid,
conclusion=current_argument.conclusion_uid)
DBDiscussionSession.add(new_argument)
DBDiscussionSession.flush()
transaction.commit()
return new_argument, False
def get_supports_for_argument_uid(argument_uid):
"""
Returns all uid's of supports for the argument.
:return argument_uid: UID of the argument
:return: array with dict() with id (of argumet) and text
"""
if not is_integer(argument_uid):
return None
if int(argument_uid) < 1:
return None
return_array = []
given_supports = set()
db_arguments = get_enabled_arguments_as_query()
db_argument = db_arguments.filter_by(
uid=argument_uid).join(PremiseGroup).first()
if not db_argument:
return []
db_arguments_premises = DBDiscussionSession.query(Premise).filter_by(
premisegroup_uid=db_argument.premisegroup_uid).all()
for arguments_premises in db_arguments_premises:
db_arguments = get_enabled_arguments_as_query()
db_supports = db_arguments.filter(
Argument.conclusion_uid == arguments_premises.statement_uid,
Argument.is_supportive == True).join(PremiseGroup).all()
if not db_supports:
continue
for support in db_supports:
if support.premisegroup_uid not in given_supports:
tmp_dict = dict()
tmp_dict['id'] = support.uid
tmp_dict['text'] = support.get_premisegroup_text()
return_array.append(tmp_dict)
given_supports.add(support.premisegroup_uid)
return [] if len(return_array) == 0 else return_array
def get_array_for_dont_know_reaction(self, argument_uid, db_user, gender):
"""
Prepares the dict with all items for the third step, where a supportive argument will be presented.
:param argument_uid: Argument.uid
:param db_user: User
:param gender: m, f or n
:return:
"""
LOG.debug("Entering get_array_for_dont_know_reaction")
slug = self.db_issue.slug
statements_array = []
db_arguments = get_enabled_arguments_as_query()
db_argument = db_arguments.filter_by(uid=argument_uid).first()
if not db_argument:
return {'elements': statements_array, 'extras': {'cropped_list': False}}
# set real argument in history
tmp_path = self.path.replace('/justify/{}/d'.format(db_argument.conclusion_uid),
'/justify/{}/d'.format(argument_uid))
_um = UrlManager(slug, history=tmp_path)
if db_user and db_user.nickname != nick_of_anonymous_user: # add seen by if the statement is visible
add_seen_argument(argument_uid, db_user)
rel_dict = get_relation_text_dict_with_substitution(self.lang, False, is_dont_know=True, gender=gender)
relation = Relations.UNDERMINE.value
url = self.__get_dont_know_item_for_undermine(db_argument, Attitudes.DISAGREE, _um)
d = self.__create_answer_dict(relation, [{'title': rel_dict[relation + '_text'], 'id': relation}], relation,
url)
statements_array.append(d)
relation = Relations.SUPPORT.value
url = self.__get_dont_know_item_for_support(argument_uid, _um)
d = self.__create_answer_dict(relation, [{'title': rel_dict[relation + '_text'], 'id': relation}], relation,
url)
statements_array.append(d)
relation = Relations.UNDERCUT.value
url = self.__get_dont_know_item_for_undercut(argument_uid, Attitudes.AGREE, _um)
d = self.__create_answer_dict(relation, [{'title': rel_dict[relation + '_text'], 'id': relation}], relation,
url)
statements_array.append(d)
relation = Relations.REBUT.value
url = self.__get_dont_know_item_for_rebut(db_argument, Attitudes.DISAGREE, _um)
d = self.__create_answer_dict(relation, [{'title': rel_dict[relation + '_text'], 'id': relation}], relation,
url)
statements_array.append(d)
return {'elements': statements_array, 'extras': {'cropped_list': False}}
def __get_arguments_based_on_attack(self, attack_type, argument_uid):
"""
Returns list of statements, which attack the argument by the given attack
:param attack_type: String
:param argument_uid: argument.uid
:return: [Argument]
"""
db_argument = get_enabled_arguments_as_query().filter_by(uid=argument_uid).first()
db_arguments = []
db_arguments_not_disabled = get_enabled_arguments_as_query()
if attack_type == Relations.UNDERMINE:
db_premises = DBDiscussionSession.query(Premise).filter_by(
premisegroup_uid=db_argument.premisegroup_uid).all()
for premise in db_premises:
arguments = db_arguments_not_disabled.filter(Argument.conclusion_uid == premise.statement_uid,
Argument.is_supportive == False,
Argument.issue_uid == self.db_issue.uid).all()
db_arguments = db_arguments + arguments
elif attack_type == Relations.UNDERCUT:
db_arguments = db_arguments_not_disabled.filter(Argument.argument_uid == argument_uid,
Argument.is_supportive == False,
Argument.issue_uid == self.db_issue.uid).all()
elif attack_type == Relations.REBUT:
db_arguments = db_arguments_not_disabled.filter(Argument.conclusion_uid == db_argument.conclusion_uid,
Argument.argument_uid == db_argument.argument_uid,
Argument.is_supportive == False,
Argument.issue_uid == self.db_issue.uid).all()
elif attack_type == Relations.SUPPORT:
db_arguments = db_arguments_not_disabled.filter(Argument.conclusion_uid == db_argument.conclusion_uid,
Argument.argument_uid == db_argument.argument_uid,
Argument.is_supportive == db_argument.is_supportive,
Argument.issue_uid == self.db_issue.uid).all()
return db_arguments
def set_new_undermine_or_support_for_pgroup(premisegroup_uid: int,
current_argument: Argument,
is_supportive: bool, db_user: User,
db_issue: Issue):
"""
Inserts a new undermine or support with the given parameters.
:param premisegroup_uid: premisegroup_uid
:param current_argument: Argument
:param is_supportive: Boolean
:param db_user: User
:param issue: Issue.uid
:return: Argument, Boolean if the argument is a duplicate
"""
already_in = []
# all premises out of current pgroup
db_premises = DBDiscussionSession.query(Premise).filter_by(
premisegroup_uid=current_argument.premisegroup_uid).all()
for premise in db_premises:
new_arguments = []
db_arguments = get_enabled_arguments_as_query()
db_argument = db_arguments.filter(
Argument.premisegroup_uid == premisegroup_uid,
Argument.is_supportive == True,
Argument.conclusion_uid == premise.statement_uid).first()
if db_argument:
continue
db_tmp = DBDiscussionSession.query(Premise).filter_by(
premisegroup_uid=premisegroup_uid).all()
if any([p.statement_uid == premise.statement_uid for p in db_tmp]):
return False
new_arguments.append(
Argument(premisegroup=premisegroup_uid,
is_supportive=is_supportive,
author=db_user.uid,
issue=db_issue.uid,
conclusion=premise.statement_uid))
if len(new_arguments) > 0:
DBDiscussionSession.add_all(new_arguments)
DBDiscussionSession.flush()
transaction.commit()
already_in += new_arguments
rnd = random.randint(0, len(already_in) - 1)
return already_in[rnd]
def __get_undermines_for_premises(premises_as_statements_uid, is_supportive=False):
"""
Querys all undermines for the given statements
:param premises_as_statements_uid:
:param is_supportive
:return: [{id, text}]
"""
return_array = []
given_undermines = set()
for s_uid in premises_as_statements_uid:
db_arguments = get_enabled_arguments_as_query()
db_undermines = db_arguments.filter(Argument.is_supportive == is_supportive,
Argument.conclusion_uid == s_uid).all()
__add_to_return_array(return_array, db_undermines, given_undermines)
return return_array
def get_arguments_by_conclusion(statement_uid: int,
is_supportive: bool) -> List[Argument]:
"""
Returns all arguments by their conclusion
:param statement_uid: Statement.uid
:param is_supportive: Boolean
:return: [Argument]
"""
db_arguments = get_enabled_arguments_as_query()
db_arguments = db_arguments.filter(
Argument.is_supportive == is_supportive,
Argument.conclusion_uid == statement_uid).all()
if not db_arguments:
return []
return db_arguments
def get_references_for_argument(uid, main_page):
"""
Returns all references for the premises group of given argument
:param uid: uid of the argument
:param main_page: current overview page
:return: dict
"""
LOG.debug("%s", uid)
if not is_integer(uid):
return {}, {}
db_arguments = get_enabled_arguments_as_query()
db_argument = db_arguments.filter_by(uid=uid).first()
if not db_argument:
return {}, {}
db_premises = get_enabled_premises_as_query()
db_premises = db_premises.filter_by(
premisegroup_uid=db_argument.premisegroup_uid).all()
data = {}
text = {}
for premise in db_premises:
tmp_uid = premise.statement_uid
references_array = __get_references_for_statement(tmp_uid,
main_page)[tmp_uid]
data[premise.statement_uid] = references_array
text[premise.statement_uid] = premise.get_text()
if db_argument.conclusion_uid is not None:
tmp_uid = db_argument.conclusion_uid
references_array = __get_references_for_statement(tmp_uid,
main_page)[tmp_uid]
data[tmp_uid] = references_array
db_statement = DBDiscussionSession.query(Statement).get(tmp_uid)
text[tmp_uid] = db_statement.get_text()
else:
d, t = get_references_for_argument(db_argument.argument_uid, main_page)
data.update(d)
text.update(t)
return data, text
def __get_attack_or_support_for_justification_of_argument_uid(argument_uid, is_supportive):
"""
Querys all
:param argument_uid: Argument.uid
:param is_supportive: Boolean
:return: [{id, text}] or 0
"""
return_array = []
db_arguments = get_enabled_arguments_as_query()
db_related_arguments = db_arguments.filter(Argument.is_supportive == is_supportive,
Argument.argument_uid == argument_uid).all()
given_relations = set()
if not db_related_arguments:
return None
__add_to_return_array(return_array, db_related_arguments, given_relations)
return return_array
def __get_rebuts_for_arguments_conclusion_uid(db_argument):
"""
Returns a list with dict(). They contain id and text of the rebuttal's pgroups
:return argument_uid: UID of the argument
:param db_argument: Argument
:return: [dict()]
"""
return_array = []
given_rebuts = set()
db_arguments = get_enabled_arguments_as_query()
db_rebuts = db_arguments.filter(Argument.is_supportive == (not db_argument.is_supportive),
Argument.conclusion_uid == db_argument.conclusion_uid).all()
for rebut in db_rebuts:
if rebut.premisegroup_uid not in given_rebuts:
given_rebuts.add(rebut.premisegroup_uid)
tmp_dict = dict()
tmp_dict['id'] = rebut.uid
text = rebut.get_premisegroup_text()
tmp_dict['text'] = start_with_capital(text)
return_array.append(tmp_dict)
return return_array
def get_rebuts_for_argument_uid(argument_uid):
"""
Returns all uid's of rebuts for the argument.
:return argument_uid: UID of the argument
:return: array with dict() with id (of argumet) and text.
"""
if not is_integer(argument_uid):
return None
if int(argument_uid) < 1:
return None
# logger('RelationHelper', 'get_rebuts_for_argument_uid', 'main ' + str(self.argument_uid))
db_arguments = get_enabled_arguments_as_query()
db_argument = db_arguments.filter_by(uid=int(argument_uid)).first()
if not db_argument:
return None
if db_argument.conclusion_uid is not None:
return __get_rebuts_for_arguments_conclusion_uid(db_argument)
else:
return get_undercuts_for_argument_uid(argument_uid)
def get_d3_data(db_issue: Issue, all_statements=None, all_arguments=None):
"""
Given an issue, create an dictionary and return it
:param db_issue: Current issue
:param all_statements:
:param all_arguments:
:return: dictionary
"""
a = [a.uid
for a in all_statements] if all_statements is not None else 'all'
b = [b.uid for b in all_arguments] if all_arguments is not None else 'all'
LOG.debug("Return D3 data. Statements: %s, arguments: %s", a, b)
edge_type = 'arrow'
nodes_array = []
edges_array = []
extras_dict = {}
LOG.debug("Titel: %s", db_issue.title)
db_textversions: List[TextVersion] = DBDiscussionSession.query(
TextVersion).all()
if all_statements is None:
issues_statements_uids = [
el.statement_uid
for el in DBDiscussionSession.query(StatementToIssue).filter_by(
issue_uid=db_issue.uid).all()
]
all_statements = get_enabled_statement_as_query().filter(
Statement.uid.in_(issues_statements_uids)).all()
if all_arguments is None:
all_arguments = get_enabled_arguments_as_query().filter_by(
issue_uid=db_issue.uid).all()
# issue
node_dict = __get_node_dict(uid='issue',
label=db_issue.info,
node_type='issue',
timestamp=db_issue.date.timestamp)
nodes_array.append(node_dict)
all_node_ids = ['issue']
# for each statement a node will be added
all_ids, nodes, edges, extras = __prepare_statements_for_d3_data(
all_statements, db_textversions, edge_type)
all_node_ids += all_ids
nodes_array += nodes
edges_array += edges
extras_dict.update(extras)
# for each argument edges will be added as well as the premises
all_ids, nodes, edges, extras = __prepare_arguments_for_d3_data(
all_arguments, edge_type)
all_node_ids += all_ids
nodes_array += nodes
edges_array += edges
extras_dict.update(extras)
error = __sanity_check_of_d3_data(all_node_ids, edges_array)
d3_dict = {
'nodes': nodes_array,
'edges': edges_array,
'extras': extras_dict
}
return d3_dict, error
def test_get_enabled_arguments_as_query(self):
query_len = get_enabled_arguments_as_query().count()
res_len = DBDiscussionSession.query(Argument).filter_by(is_disabled=False).count()
self.assertEqual(res_len, query_len)
