#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!

from enum import Enum


class Student:
    class Status(Enum):
        FullTime = "FullTime"
        PartTime = "PartTime"

        def __str__(self):
            return self.value

    class Grade(Enum):
        High = "High"

        def __str__(self):
            return self.value

    class RelationshipStatus(Enum):
        Single = "Single"
        Married = "Married"
        Divorced = "Divorced"

        def __str__(self):
            return self.value

    def __init__(self):
        pass

    def delete(self):
        pass

#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!

from enum import Enum


class X:
    class Colour(Enum):
        Red = "Red"
        Blue = "Blue"
        Green = "Green"

        def __str__(self):
            return self.value

    class Sm(Enum):
        s1 = "s1"
        s2 = "s2"

        def __str__(self):
            return self.value

    MY_CONST = 100
    xsByMyName = {}

    def __init__(self, aDefaultAttr):
        self._myName = None
        self._defaultAttr = aDefaultAttr
        self._sm = None
        self._deleted = False
        if not self.setMyName("name"):
            raise RuntimeError("Cannot create due to duplicate myName. See https://manual.umple.org?RE003ViolationofUniqueness.html")
        self.setSm(__class__.Sm.s1)

    def setMyName(self, aMyName):
        anOldMyName = self._myName
        if anOldMyName is not None and anOldMyName == aMyName:
            return True
        if __class__.hasWithMyName(aMyName):
            return False
        self._myName = aMyName
        if anOldMyName is not None:
            __class__.xsByMyName.pop(anOldMyName, None)
        __class__.xsByMyName[aMyName] = self
        return True

    def setDefaultAttr(self, aDefaultAttr):
        self._defaultAttr = aDefaultAttr
        return True

    def getMyName(self):
        return self._myName

    @staticmethod
    def getWithMyName(aMyName):
        return __class__.xsByMyName.get(aMyName)

    @staticmethod
    def hasWithMyName(aMyName):
        return __class__.getWithMyName(aMyName) is not None

    def getDefaultAttr(self):
        return self._defaultAttr

    def getSmFullName(self):
        answer = str(self._sm)
        return answer

    def getSm(self):
        return self._sm

    def goToS2(self):
        if self._deleted:
            return False
        wasEventProcessed = False
        aSm = self._sm
        if aSm is __class__.Sm.s1:
            self.setSm(__class__.Sm.s2)
            wasEventProcessed = True
        return wasEventProcessed

    def setSm(self, aSm):
        self._sm = aSm

    def delete(self):
        self._deleted = True
        if __class__.xsByMyName.get(self._myName) is self:
            del __class__.xsByMyName[self._myName]

    def __str__(self):
        return (super().__str__() + "["
                + "myName:" + str(self.getMyName()) + ","
                + "defaultAttr:" + str(self.getDefaultAttr())
                + "]")

#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!

from enum import Enum


class C1:
    class Status(Enum):
        Married = "Married"
        Single = "Single"
        Divorced = "Divorced"

        def __str__(self):
            return self.value

    class Gender(Enum):
        Male = "Male"
        Female = "Female"

        def __str__(self):
            return self.value

    def __init__(self, aStatus, aGender):
        self._status = aStatus
        self._gender = aGender

    def setStatus(self, aStatus):
        self._status = aStatus
        return True

    def setGender(self, aGender):
        self._gender = aGender
        return True

    def getStatus(self):
        return self._status

    def getGender(self):
        return self._gender

    def delete(self):
        pass

    def __str__(self):
        return (super().__str__() + "["
                + "]"
                + "\n  status=" + ("null" if self.getStatus() is None else "this" if self.getStatus() is self else str(self.getStatus()).replace("  ", "    "))
                + "\n  gender=" + ("null" if self.getGender() is None else "this" if self.getGender() is self else str(self.getGender()).replace("  ", "    ")))

#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!

from enum import Enum


class C2:
    class Status(Enum):
        Married = "Married"
        Single = "Single"
        Divorced = "Divorced"

        def __str__(self):
            return self.value

    class Gender(Enum):
        Male = "Male"
        Female = "Female"

        def __str__(self):
            return self.value

    def __init__(self, aStatus, aGender):
        self._status = aStatus
        self._gender = aGender

    def setStatus(self, aStatus):
        self._status = aStatus
        return True

    def setGender(self, aGender):
        self._gender = aGender
        return True

    def getStatus(self):
        return self._status

    def getGender(self):
        return self._gender

    def delete(self):
        pass

    def __str__(self):
        return (super().__str__() + "["
                + "]"
                + "\n  status=" + ("null" if self.getStatus() is None else "this" if self.getStatus() is self else str(self.getStatus()).replace("  ", "    "))
                + "\n  gender=" + ("null" if self.getGender() is None else "this" if self.getGender() is self else str(self.getGender()).replace("  ", "    ")))

#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!

from enum import Enum


class C1:
    class Status(Enum):
        Married = "Married"
        Single = "Single"
        Divorced = "Divorced"

        def __str__(self):
            return self.value

    def __init__(self, aStatus):
        self._status = aStatus

    def setStatus(self, aStatus):
        self._status = aStatus
        return True

    def getStatus(self):
        return self._status

    def delete(self):
        pass

    def __str__(self):
        return (super().__str__() + "["
                + "]"
                + "\n  status=" + ("null" if self.getStatus() is None else "this" if self.getStatus() is self else str(self.getStatus()).replace("  ", "    ")))

#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!

from enum import Enum


class C2:
    class Status(Enum):
        Married = "Married"
        Single = "Single"
        Divorced = "Divorced"

        def __str__(self):
            return self.value

    class Gender(Enum):
        Male = "Male"
        Female = "Female"

        def __str__(self):
            return self.value

    def __init__(self, aGender, aStatus):
        self._gender = aGender
        self._status = aStatus

    def setGender(self, aGender):
        self._gender = aGender
        return True

    def setStatus(self, aStatus):
        self._status = aStatus
        return True

    def getGender(self):
        return self._gender

    def getStatus(self):
        return self._status

    def delete(self):
        pass

    def __str__(self):
        return (super().__str__() + "["
                + "]"
                + "\n  gender=" + ("null" if self.getGender() is None else "this" if self.getGender() is self else str(self.getGender()).replace("  ", "    "))
                + "\n  status=" + ("null" if self.getStatus() is None else "this" if self.getStatus() is self else str(self.getStatus()).replace("  ", "    ")))

#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!

from enum import Enum


class X1:
    class Month(Enum):
        January = "January"
        February = "February"
        March = "March"

        def __str__(self):
            return self.value

    def __init__(self, aMonth):
        self._month = aMonth

    def setMonth(self, aMonth):
        self._month = aMonth
        return True

    def getMonth(self):
        return self._month

    def delete(self):
        pass

    def __str__(self):
        return (super().__str__() + "["
                + "]"
                + "\n  month=" + ("null" if self.getMonth() is None else "this" if self.getMonth() is self else str(self.getMonth()).replace("  ", "    ")))

#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!

from enum import Enum


class X2:
    class Fruit(Enum):
        Apple = "Apple"
        Orange = "Orange"

        def __str__(self):
            return self.value

    def __init__(self, aT):
        self._t = aT

    def setT(self, aT):
        self._t = aT
        return True

    def getT(self):
        return self._t

    def delete(self):
        pass

    def __str__(self):
        return (super().__str__() + "["
                + "]"
                + "\n  t=" + ("null" if self.getT() is None else "this" if self.getT() is self else str(self.getT()).replace("  ", "    ")))

#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!


class X:
    def __init__(self):
        pass

    def delete(self):
        pass

#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!


class X2:
    def __init__(self):
        pass

    def delete(self):
        pass

#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!

from enum import Enum


class X:
    class Month(Enum):
        Jan = "Jan"
        Feb = "Feb"
        Mar = "Mar"

        def __str__(self):
            return self.value

    def __init__(self):
        pass

    def delete(self):
        pass

    def displayMonth(self, m):
        # line 6 "../EnumerationTest_7.ump"
        return(m.toString())
        # end line

#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!

from enum import Enum


class Y:
    class Month(Enum):
        Jan = "Jan"
        Feb = "Feb"
        Mar = "Mar"

        def __str__(self):
            return self.value

    class Sm(Enum):
        s1 = "s1"
        s2 = "s2"

        def __str__(self):
            return self.value

    def __init__(self):
        self._sm = None
        self._deleted = False
        self.setSm(__class__.Sm.s1)
        if self._deleted:
            return

    def getSmFullName(self):
        answer = str(self._sm)
        return answer

    def getSm(self):
        return self._sm

    def goToS2(self, m):
        if self._deleted:
            return False
        wasEventProcessed = False
        aSm = self._sm
        if aSm is __class__.Sm.s1:
            print("null" if m is None else str(m))
            if self._deleted:
                return True
            self.setSm(__class__.Sm.s2)
            wasEventProcessed = True
        return wasEventProcessed

    def setSm(self, aSm):
        self._sm = aSm

    def delete(self):
        self._deleted = True

#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!

from enum import Enum


class Z:
    class Month(Enum):
        Jan = "Jan"
        Feb = "Feb"
        Mar = "Mar"

        def __str__(self):
            return self.value

    def __init__(self):
        pass

    def delete(self):
        pass

    def getBirthMonth(self):
        # line 20 "../EnumerationTest_7.ump"
        return self.Month.Jan
        # end line

#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!

from enum import Enum


class A:
    class Month(Enum):
        O = "O"
        P = "P"
        Q = "Q"

        def __str__(self):
            return self.value

    def __init__(self, aM, aP):
        self._m = aM
        self._p = aP

    def setM(self, aM):
        self._m = aM
        return True

    def setP(self, aP):
        self._p = aP
        return True

    def getM(self):
        return self._m

    def getP(self):
        return self._p

    def delete(self):
        pass

    def __str__(self):
        return (super().__str__() + "["
                + "]"
                + "\n  m=" + ("null" if self.getM() is None else "this" if self.getM() is self else str(self.getM()).replace("  ", "    "))
                + "\n  p=" + ("null" if self.getP() is None else "this" if self.getP() is self else str(self.getP()).replace("  ", "    ")))

#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!


class Bar:
    def __init__(self):
        self._foos = []

    def getFoo(self, index):
        return self._foos[index]

    def getFoos(self):
        return tuple(self._foos)

    def numberOfFoos(self):
        return len(self._foos)

    def hasFoos(self):
        return len(self._foos) > 0

    def indexOfFoo(self, aFoo):
        return next((i for i, x in enumerate(self._foos) if x is aFoo), -1)

    @staticmethod
    def minimumNumberOfFoos():
        return 0

    def addFoo1(self, aMyBaz, aMyStr):
        from Foo import Foo
        return Foo(aMyBaz, aMyStr, self)

    def addFoo2(self, aFoo):
        if any(x is aFoo for x in self._foos):
            return False
        existingBar = aFoo.getBar()
        isNewBar = existingBar is not None and existingBar is not self
        if isNewBar:
            if not aFoo.setBar(self):
                return False
        else:
            self._foos.append(aFoo)
        return True

    def addFoo(self, *args, **kwargs):
        from Foo import Foo
        bound = __class__._bindArguments(("aFoo",), False, args, kwargs)
        if bound is not None and (bound[0] is None or isinstance(bound[0], Foo)):
            return __class__.addFoo2(self, *bound)
        bound = __class__._bindArguments(("aMyBaz", "aMyStr"), False, args, kwargs)
        if bound is not None and (bound[1] is None or isinstance(bound[1], str)):
            return __class__.addFoo1(self, *bound)
        raise TypeError("No method matches provided parameters")

    def removeFoo(self, aFoo):
        if aFoo.getBar() is self:
            return False
        index = next((i for i, x in enumerate(self._foos) if x is aFoo), -1)
        if index >= 0:
            del self._foos[index]
        return True

    def addFooAt(self, aFoo, index):
        if not self.addFoo2(aFoo):
            return False
        if index < 0:
            index = 0
        if index > self.numberOfFoos():
            index = self.numberOfFoos() - 1
        del self._foos[next((i for i, x in enumerate(self._foos) if x is aFoo), -1)]
        self._foos.insert(index, aFoo)
        return True

    def addOrMoveFooAt(self, aFoo, index):
        if not any(x is aFoo for x in self._foos):
            return self.addFooAt(aFoo, index)
        if index < 0:
            index = 0
        if index > self.numberOfFoos():
            index = self.numberOfFoos() - 1
        del self._foos[next((i for i, x in enumerate(self._foos) if x is aFoo), -1)]
        self._foos.insert(index, aFoo)
        return True

    def delete(self):
        for i in range(len(self._foos), 0, -1):
            aFoo = self._foos[i - 1]
            aFoo.delete()

    @staticmethod
    def _bindArguments(names, varargs, args, kwargs):
        if len(args) > len(names) and not varargs:
            return None
        bound = list(args[:len(names)])
        for name in names[len(bound):]:
            if name not in kwargs:
                return None
            bound.append(kwargs[name])
        if len(kwargs) != len(names) - min(len(args), len(names)):
            return None
        if varargs:
            bound.append(args[len(names):])
        return bound

#PLEASE DO NOT EDIT THIS CODE
#This code was generated using the UMPLE 1.38.0.8942.247e17422 modeling language!


class Driver:
    def __init__(self):
        self._driverSchedules = []

    def getDriverSchedule(self, index):
        return self._driverSchedules[index]

    def getDriverSchedules(self):
        return tuple(self._driverSchedules)

    def numberOfDriverSchedules(self):
        return len(self._driverSchedules)

    def hasDriverSchedules(self):
        return len(self._driverSchedules) > 0

    def indexOfDriverSchedule(self, aDriverSchedule):
        return next((i for i, x in enumerate(self._driverSchedules) if x is aDriverSchedule), -1)

    @staticmethod
    def minimumNumberOfDriverSchedules():
        return 0

    def addDriverSchedule1(self, aShift, aStatus):
        from enumerations.DriverSchedule import DriverSchedule
        return DriverSchedule(aShift, aStatus, self)

    def addDriverSchedule2(self, aDriverSchedule):
        if any(x is aDriverSchedule for x in self._driverSchedules):
            return False
        existingDriver = aDriverSchedule.getDriver()
        isNewDriver = existingDriver is not None and existingDriver is not self
        if isNewDriver:
            if not aDriverSchedule.setDriver(self):
                return False
        else:
            self._driverSchedules.append(aDriverSchedule)
        return True

    def addDriverSchedule(self, *args, **kwargs):
        from enumerations.DriverSchedule import DriverSchedule
        bound = __class__._bindArguments(("aDriverSchedule",), False, args, kwargs)
        if bound is not None and (bound[0] is None or isinstance(bound[0], DriverSchedule)):
            return __class__.addDriverSchedule2(self, *bound)
        bound = __class__._bindArguments(("aShift", "aStatus"), False, args, kwargs)
        if bound is not None:
            return __class__.addDriverSchedule1(self, *bound)
        raise TypeError("No method matches provided parameters")

    def removeDriverSchedule(self, aDriverSchedule):
        if aDriverSchedule.getDriver() is self:
            return False
        index = next((i for i, x in enumerate(self._driverSchedules) if x is aDriverSchedule), -1)
        if index >= 0:
            del self._driverSchedules[index]
        return True

    def addDriverScheduleAt(self, aDriverSchedule, index):
        if not self.addDriverSchedule2(aDriverSchedule):
            return False
        if index < 0:
            index = 0
        if index > self.numberOfDriverSchedules():
            index = self.numberOfDriverSchedules() - 1
        del self._driverSchedules[next((i for i, x in enumerate(self._driverSchedules) if x is aDriverSchedule), -1)]
        self._driverSchedules.insert(index, aDriverSchedule)
        return True

    def addOrMoveDriverScheduleAt(self, aDriverSchedule, index):
        if not any(x is aDriverSchedule for x in self._driverSchedules):
            return self.addDriverScheduleAt(aDriverSchedule, index)
        if index < 0:
            index = 0
        if index > self.numberOfDriverSchedules():
            index = self.numberOfDriverSchedules() - 1
        del self._driverSchedules[next((i for i, x in enumerate(self._driverSchedules) if x is aDriverSchedule), -1)]
        self._driverSchedules.insert(index, aDriverSchedule)
        return True

    def delete(self):
        for i in range(len(self._driverSchedules), 0, -1):
            aDriverSchedule = self._driverSchedules[i - 1]
            aDriverSchedule.delete()

    @staticmethod
    def _bindArguments(names, varargs, args, kwargs):
        if len(args) > len(names) and not varargs:
            return None
        bound = list(args[:len(names)])
        for name in names[len(bound):]:
            if name not in kwargs:
                return None
            bound.append(kwargs[name])
        if len(kwargs) != len(names) - min(len(args), len(names)):
            return None
        if varargs:
            bound.append(args[len(names):])
        return bound