source: geniuswebcore/geniusweb/protocol/session/mopac/phase/OptInPhase.py

# Generated from java by J2P
from __future__ import annotations
from geniusweb.actions.Action import Action
from geniusweb.actions.EndNegotiation import EndNegotiation
from geniusweb.actions.PartyId import PartyId
from geniusweb.actions.Votes import Votes
from geniusweb.inform.Agreements import Agreements
from geniusweb.inform.Inform import Inform
from geniusweb.inform.OptIn import OptIn
from geniusweb.protocol.ProtocolException import ProtocolException
from geniusweb.protocol.session.mopac.PartyStates import PartyStates
from geniusweb.protocol.session.mopac.phase.DefaultPhase import DefaultPhase
from geniusweb.protocol.session.mopac.phase.OfferPhase import OfferPhase
from geniusweb.protocol.session.mopac.phase.Phase import Phase
from geniusweb.voting.CollectedVotes import CollectedVotes
from geniusweb.voting.VotingEvaluator import VotingEvaluator
from typing import List
from typing import Optional
from typing import Type
from typing import cast


class OptInPhase(DefaultPhase):
 
 def __init__(self, votes:List[Votes], partyStates:PartyStates, deadline:int, evaluator:VotingEvaluator):
  '''
  The votes received in the {@link VotingPhase}

  '''
  
  self.__votes:List[Votes] = None
  super().__init__(partyStates,deadline,evaluator)
  if (votes is None):
   raise ValueError("votes must be not null")
  self.__votes=votes
 
 #Override
 def getInform(self) -> Inform:
  return OptIn(self.__votes)
 
 #Override
 def withAction(self,actor:PartyId,action:Action,now:int) -> Phase:
  try:
   self._checkAction(actor,action,now)
   if isinstance(action,Votes):
    self.__checkExtends(cast(Votes,action))
   return OptInPhase(self.__votes,self._partyStates.withAction(action),self._deadline,self._evaluator)
  except ProtocolException as e:
   return self.withException(e)
 
 def __checkExtends(self,newvotes:Votes) -> None:
  '''
  Check that this action extends previous action.
  
  @param newvotes new {@link Votes} just received
  @throws ProtocolException if this action does not correctly extend
                            previous vote.

  '''
  actor:PartyId = newvotes.getActor()
  prevVotes:Votes = [v  for v in self.__votes if v.getActor() == actor ][0]
  if not((newvotes.isExtending(prevVotes))):
   raise ProtocolException("New votes " + str(newvotes) + " does not extend previous vote " + str(prevVotes),actor)
 
 #Override
 def withException(self,e:ProtocolException) -> OptInPhase:
  return OptInPhase(self.__votes,self._partyStates.withException(e),self._deadline,self._evaluator)
 
 #Override
 def finish(self) -> OptInPhase:
  states:PartyStates = self._partyStates.finish()
  votesmap: Dict[PartyId, Votes] = \
     {votes.getActor() : votes for votes in states.getActionsOfType(Votes) }
  allvotes:CollectedVotes = CollectedVotes(votesmap,states.getPowers())
  newAgree:Agreements = self._evaluator.create(allvotes).getAgreements()
  #             }
  finalStates:PartyStates = states.withAgreement(newAgree)
  return OptInPhase(self.__votes,finalStates,self._deadline,self._evaluator)
 
 #Override
 def _checkedNext(self,newdeadline:int) -> OfferPhase:
  return OfferPhase(self._partyStates.flush(),newdeadline,self._evaluator)
 
 #Override
 def getAllowedActions(self) -> List[Type[Optional[Action]]]:
  return [Votes,EndNegotiation]
 
 def getVotes(self) -> List[Votes]:
  return list(self.__votes)