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)