source: geniuswebcore/geniusweb/protocol/session/mopac/PartyStates.py@ 77

from typing import Set, List, Dict, TypeVar, Optional

from geniusweb.actions.Action import Action
from geniusweb.actions.EndNegotiation import EndNegotiation
from geniusweb.actions.PartyId import PartyId
from geniusweb.inform.Agreements import Agreements
from geniusweb.protocol.ProtocolException import ProtocolException
from geniusweb.utils import toTuple, val, toStr


class PartyStates:
        '''
        Invariant: contains the current state of all participating parties. A party
        either notYetActed, did action, reached an agreement, walked away or made a
        {@link ProtocolException}.
        <p>
        After a phase completes, the actions are filtered/handled to collect
        agreements and move remaining parties back to notYetActed.
        '''
        # all parties must be in exactly one state at all times.
        
        def __init__(self, powers:Dict[PartyId, int],
                        notYetActed:Optional[Set[PartyId]]=None,
                        actions: List[Action] =[],
                        agreements:Agreements = Agreements(),
                        walkedAway:List[PartyId]=[],
                        exceptions:Dict[PartyId, ProtocolException] ={}):
                '''
                notice: order of arguments, power is now first instead of last because
                python requires obligatory arguments first.
                '''
                if notYetActed!=None:
                        self._notYetActed = set(notYetActed) #type:ignore
                else:
                        self._notYetActed = set(powers.keys())
                self._actions = list(actions)
                self._agreements = agreements
                self._walkedAway = list(walkedAway)
                self._exceptions = dict(exceptions)
                self._powers = dict(powers)



        def WithAction(self,  action:Action)-> "PartyStates":
                '''
                @param action the action done by some party. The correctness of action,
                              particularly of {@link Action#getActor()}, must be correct.
                @return new state with party done given action. This just accepts any
                        given action and is not considering number of rounds, time or
                        whether an action is allowed.
                
                @throws IllegalArgumentException if party doing action already acted.
                                                 This is just a safety check as legality
                                                 of actions should be checked before
                                                 calling this.
                '''
                if not action.getActor() in self._notYetActed:
                        raise ValueError("actor already acted: " + str(action))
                if isinstance(action, EndNegotiation):
                        return self.WithWalkAway(action.getActor())
                newActions = list(self._actions)
                newActions.append(action)
                return PartyStates(self._powers, self._removeParty(action.getActor()), newActions,
                                self._agreements, self._walkedAway, self._exceptions)

        def WithAgreements(self, newAgree:Agreements )->"PartyStates" :
                '''
                 @param newAgree a new agreements to be merged with existing agreements.
                                 The parties in the agreement must have acted and thus in
                                 actions.
                 @return new PartyStates with agreeing parties removed from actions and
                         added to Agreements.
                '''
                parties = newAgree.getMap().keys()
                newActions = [act for act in self._actions if not act.getActor() in parties] 
                return PartyStates(self._powers, self._notYetActed, newActions,
                                self._agreements.With(newAgree), self._walkedAway, self._exceptions)


        def  WithWalkAway(self, actor:PartyId ) ->"PartyStates": 
                if not actor in self._notYetActed:
                        raise ValueError("actor already acted: " + str(actor))
                newWalkAway = list(self._walkedAway)
                newWalkAway.append(actor)
                return PartyStates(self._powers,self._removeParty(actor), self._actions, self._agreements,
                                newWalkAway, self._exceptions)

        def  WithException(self, e:ProtocolException ) -> "PartyStates":
                '''
                Move party from active to exceptions.
                
                @param e the exception that the party caused
                @return new PartyStates with party that caused the exception in the
                        exceptions list and removed from the active list. Nothing happens
                        if party is not active.
        '''
                if not e.getParty() in self._notYetActed:
                        # complex case. Party did valid action but now is messing around.
                        # Easiest seems to completely ignore it. CHECK.
                        return self;

                newExc = dict(self._exceptions)
                newExc[val(e.getParty())]= e
                return PartyStates(self._powers, self._removeParty(val(e.getParty())), 
                        self._actions, self._agreements,self._walkedAway, newExc)

        def  getNotYetActed(self)->Set[PartyId]:
                '''
                @return parties that have not yet acted

                '''
                return self._notYetActed

        def  getNegotiatingParties(self)-> Set[PartyId]:
                '''
                @return parties that are still in the negotiation. These are the parties
                        that not yet acted plus the ones that did an action.
                '''
                parties = set([ act.getActor() for act in self._actions ])
                
                parties = parties.union(self._notYetActed)
                return parties

        def _removeParty(self, party:PartyId )->Set[PartyId] :
                '''
                @param actor
                @return {@link #notYetActed} with actor removed
                 @throws IllegalArgumentException if party already acted (not in
                                                 {@link #notYetActed}).
        '''
                newActiveParties = set(self._notYetActed)
                if not party in newActiveParties:
                        raise ValueError(
                                        "Party " + str(party) + " is not active, can't be removed")
                newActiveParties.remove(party)
                return newActiveParties

        def getAgreements(self)->Agreements :
                return self._agreements

        def getPowers(self)->Dict[PartyId,int] :
                return dict(self._powers)

        def  getExceptions(self)->Dict[PartyId, ProtocolException]:
                return dict(self._exceptions)

        def finish(self)->"PartyStates": 
                '''
                @return new state where all {@link #notYetActed} are moved to the
                        exceptions list.
                '''
                newstate = self
                for party in self._notYetActed:
                        newstate = newstate.WithException(ProtocolException("Party did not act", party))
                return newstate

        def getActions(self)->List[Action] :
                return list(self._actions)

        def getWalkedAway(self)->List[PartyId] :
                '''
                @return all parties that walked away
                '''
                return list(self._walkedAway)

#       T=TypeVar("T", Action)
        def  getActionsOfType(self, typ) -> List:
                '''
                @param <T>  the type of objects requested
                @param typ the type of actions to extract. Must be of type T, needed
                            because of java's type erasure.
                
                @return all actions of requested type in this phase
                ''' 
                return [act for act in self._actions if isinstance(act, typ) ]

        def __repr__(self):
                return "PartyStates[" + str(list(self._notYetActed)) + "," + str(self._actions) + "," + \
                        str(self._agreements)+  "," + str(self._walkedAway) + "," + toStr(self._exceptions) + "]"

        def flush(self)->"PartyStates" :
                '''
                @return states with all parties that are in {@link #actions} moved back
                        to {@link #notYetActed}. This state is then ready for a next
                        phase.
                @throws IllegalStateException if {@link #notYetActed} is not empty
                '''
                if len(self._notYetActed)!=0:
                        raise ValueError(
                                        "Some parties did not yet act:" + str(self._notYetActed))
                return PartyStates(self._powers, self.getNegotiatingParties(), [],
                                self._agreements, self._walkedAway, self._exceptions)

        def __hash__(self):
                return hash((tuple(self._actions), self._agreements, toTuple(self._exceptions), 
                                        tuple(self._notYetActed), toTuple(self._powers), tuple(self._walkedAway)))

        def __eq__(self, other):
                return isinstance(other, self.__class__)\
                        and self._actions == other._actions \
                        and self._agreements == other._agreements \
                        and self._exceptions == other._exceptions \
                        and self._notYetActed == other._notYetActed \
                        and self._powers == other._powers \
                        and self._walkedAway == other._walkedAway