source: geniuswebcore/geniusweb/protocol/session/learn/LearnSettings.py

from typing import List
from uuid import UUID

from tudelft_utilities_logging.Reporter import Reporter

from geniusweb.deadline.Deadline import Deadline
from geniusweb.protocol.session.SessionProtocol import SessionProtocol
from geniusweb.protocol.session.SessionSettings import SessionSettings
from geniusweb.protocol.session.TeamInfo import TeamInfo
from geniusweb.references.PartyWithProfile import PartyWithProfile


class LearnSettings(SessionSettings):
        '''
        Settings for learn protocol.
        '''

        def __init__(self, participants:List[TeamInfo] , deadline:Deadline) :
                '''
                @param participants the list of {@link PartyWithProfile} in clockwise
                        order. There must be at least 2 to run the SAOP
                        protocol. But SAOP can be initialized with less, for
                        use in TournamentSettings.
                        <table>
                        <caption>Required parameters</caption>
                        <tr>
                        <td>persistentstate</td>
                        <td>a {@link FileLocation}, serialized as json eg
                        <code>"b29f3bf5-1dc4-499e-a676-7b2dbb864a03"</code> ,
                        where the party's persistant state is stored; this
                        must match the persistantstate used in earlier calls
                        for e.g. {@link SAOPSettings}.</td>
                        </tr>
                
                        <tr>
                        <td>negotiationdata</td>
                        <td>a List of {@link FileLocation}s, serialized as
                        json, matching the negotiationdata used in earlier
                        calls for eg {@link SAOPSettings}.</td>
                        </tr>
                        </table>
                @param deadline     the deadline of the negotiation.
                '''
                self._participants = participants
                self._deadline = deadline
                if participants == None:
                        raise ValueError("participants must not be null")
                if deadline == None:
                        raise ValueError("deadline must not be null")

                for pwithp in self.getAllParties():
                        params = pwithp.getParty().getParameters()
                        statestr = params.get("persistentstate")
                        if not isinstance(statestr , str):
                                raise ValueError(
                                                "persistentstate parameter containing UUID string is required, but found "\
                                                                + str(statestr))
                        # check that it contains a UUID. Don't store it, we don't need
                        # it.
                        UUID(statestr)

                        # and check the negotiationdata
                        negotiationsstr = params.get("negotiationdata")
                        if not isinstance(negotiationsstr, list):
                                raise ValueError(
                                        "negotiationdata parameter containing a List is required")

                        for negostr in  negotiationsstr:
                                if not isinstance(negostr,str):
                                        raise ValueError(
                                                "The list in negotiationdata must contain UUID strings but found "\
                                                        + str(negostr))
                                UUID(negostr)

        def getMaxRunTime(self)->float:
                return self._deadline.getDuration() / 1000.

        def getProtocol(self, logger:Reporter )->SessionProtocol :
                from geniusweb.protocol.session.learn.LearnState import LearnState
                from geniusweb.protocol.session.learn.Learn import Learn
                return Learn(LearnState([],[],None, self), logger)

        def getTeams(self)->List[TeamInfo] :
                return list(self._participants)

        def getParticipants(self) -> List[TeamInfo] :
                return list(self._participants)

        def getDeadline(self)->Deadline :
                '''
                @return the deadline for this negotiation
                '''
                return self._deadline

        def getAllParties(self)->List[PartyWithProfile] :
                return  [particip.getParties()[0]
                         for particip in self._participants ]

        def getTeamSize(self)->int:
                return 1

        def __repr__(self):
                return "LearnSettings" + str(self._participants) +\
                        "," + str(self._deadline) + "]"

        def __hash__(self):
                return hash((self._deadline, tuple(self._participants)))

        
        def __eq__(self, other) -> bool:
                return isinstance(other, self.__class__) and \
                        self._participants == other._participants and \
                        self._deadline==other._deadline 

        def With(self, team:TeamInfo)->SessionSettings :
                if team.getSize() != 1:
                        raise ValueError(
                                        "Team must be size 1 but found " + str(team))
                newparts = list(self._participants)
                newparts.append(team)
                return LearnSettings(newparts, self._deadline)