Ejemplo n.º 1
0
    def su_update_sentiment_when_proposal_becomes_active(
            params, step, sL, s, _input, **kwargs):
        network = s["network"]
        policy_output_passthru = s["policy_output"]

        report = {}
        for idx in policy_output_passthru[
                "proposal_idxs_with_enough_conviction"]:
            for participant_idx, proposal_idx, _ in find_in_edges_of_type_for_proposal(
                    network, idx, "support"):
                edge = network.edges[participant_idx, proposal_idx]
                if edge["affinity"] == 1:
                    sentiment_old = network.nodes[participant_idx][
                        "item"].sentiment
                    sentiment_new = sentiment_old + config.sentiment_bonus_proposal_becomes_active
                    sentiment_new = 1 if sentiment_new > 1 else sentiment_new
                    network.nodes[participant_idx][
                        "item"].sentiment = sentiment_new

                    report[participant_idx] = {
                        "proposal_idx": proposal_idx,
                        "sentiment_old": sentiment_old,
                        "sentiment_new": sentiment_new
                    }

        if params.get("debug"):
            for i in report:
                print(
                    "ParticipantExits: Participant {} changed his sentiment from {} to {} because Proposal {} became active"
                    .format(i, report[i]["sentiment_old"],
                            report[i]["sentiment_new"],
                            report[i]["proposal_idx"]))
        return "network", network
Ejemplo n.º 2
0
    def su_update_sentiment_when_proposal_becomes_failed_or_completed(params, step, sL, s, _input, **kwargs):
        network = s["network"]
        policy_output_passthru = s["policy_output"]

        proposal_status_delta = {
            "failed": config.sentiment_bonus_proposal_becomes_failed,
            "succeeded": config.sentiment_bonus_proposal_becomes_completed,
        }
        report = {}
        for status, delta in proposal_status_delta.items():
            for idx in policy_output_passthru[status]:
                for participant_idx, proposal_idx, _ in find_in_edges_of_type_for_proposal(network, idx, "support"):
                    edge = network.edges[participant_idx, proposal_idx]
                    # Update the participant sentiment if he/she is the proposal creator
                    # or if participant has staked on the proposal (tokens > 0)
                    if edge["support"].is_author or edge["support"].tokens > 0:
                        sentiment_old = network.nodes[participant_idx]["item"].sentiment
                        sentiment_new = sentiment_old + (edge["support"].affinity * delta)
                        sentiment_new = np.clip(sentiment_new, a_min=0., a_max=1.)
                        network.nodes[participant_idx]["item"].sentiment = sentiment_new

                        report[participant_idx] = {
                            "proposal_idx": proposal_idx,
                            "sentiment_old": sentiment_old,
                            "sentiment_new": sentiment_new,
                            "status": status
                        }

        if params.get("debug"):
            for i in report:
                print(
                    "ParticipantExits: Participant {} changed his sentiment from {} to {} because Proposal {} became {}".format(i, report[i]["sentiment_old"], report[i]["sentiment_new"], report[i]["proposal_idx"], report[i]["status"]))
        return "network", network
    def test_find_in_edges_of_type_for_proposal(self):
        """
        Ensure that only edges of the specified type are included in the answer
        """
        self.network = setup_support_edges(self.network)
        self.network = setup_conflict_edges(self.network, rate=1)

        s_edges = find_in_edges_of_type_for_proposal(self.network, 9,
                                                     "support")
        s_edges_expected = [(0, 9, 'support'), (2, 9, 'support'),
                            (4, 9, 'support'), (6, 9, 'support'),
                            (8, 9, 'support')]
        self.assertEqual(s_edges, s_edges_expected)

        c_edges = find_in_edges_of_type_for_proposal(self.network, 9,
                                                     "conflict")
        c_edges_expected = [(1, 9, 'conflict'), (3, 9, 'conflict'),
                            (5, 9, 'conflict'), (7, 9, 'conflict')]
        self.assertEqual(c_edges, c_edges_expected)