def test_odliczona_kwota(self):
a = automat.Automat(automat.LISTA_NOMINALOW)
b = automat.Bilet(50, "ulgowy", 240)
a.dodaj_bilet(b)
a.wrzuc_monety(200)
a.wrzuc_monety(20, 2)
self.assertEqual(a.zaplac(), {x: 0 for x in a.nominaly})
def main():
"""Uruchamia aplikację, ustawia niezbędne elementy"""
automat = aut.Automat(aut.OBSLUGIWANE_NOMINALY)
automat.wczytaj_monety('PLN')
app = Application(automat)
app.mainloop()
def test_nieudane_wydanie_reszty(self):
a = automat.Automat(automat.LISTA_NOMINALOW)
b = automat.Bilet(60, "ulgowy", 240)
a.dodaj_bilet(b)
a.wrzuc_monety(500)
wrzucone = a.wrzucone.copy()
zwrocone = a.zaplac()
self.assertEqual(zwrocone, wrzucone)
def test_udane_wydanie_reszty(self):
a = automat.Automat(automat.LISTA_NOMINALOW)
b = automat.Bilet(50, "ulgowy", 240)
a.napelnij(2)
a.dodaj_bilet(b)
a.wrzuc_monety(500)
reszta = a.zaplac()
self.assertEqual(a.suma_monet(reszta), 260)
def __init__(self, input):
self.index = 0
self.str = input
self.line = 1
# vytvorime prazdny automat
self.aut = automat.Automat()
# cekame dve oteveraci slozene zavorky
token = self.getToken()
self.tShould(token, ['('])
token = self.getToken()
self.tShould(token, ['{'])
# nacteme stavy do automatu
self.states()
# cekame carku a oteviraci zavorku
token = self.getToken()
self.tShould(token, [','])
token = self.getToken()
self.tShould(token, ['{'])
# nacteme abecedu
self.alphabet()
# cekame carku a oteviraci zavorku
token = self.getToken()
self.tShould(token, [','])
token = self.getToken()
self.tShould(token, ['{'])
# nacteme pravidla
self.rules()
# cekame carku a startovaci stav
token = self.getToken()
self.tShould(token, [','])
token = self.getToken()
if token.type != 'id':
raise ValueError("Missing start state", 40)
else:
self.aut.setStart(token.string)
#cekame carku a oteviraci zavorku
token = self.getToken()
self.tShould(token, [','])
token = self.getToken()
self.tShould(token, ['{'])
self.terminating()
# cekame konec oteviraci zavorky a konec
token = self.getToken()
self.tShould(token, [')'])
token = self.getToken()
self.tShould(token, [''])
def test_operacje_naprzemian(self):
a = automat.Automat(automat.LISTA_NOMINALOW)
a.dodaj_bilet(automat.Bilet(60, "ulgowy", 240))
a.wrzuc_monety(500)
a.wrzuc_monety(10)
a.dodaj_bilet(automat.Bilet(40, "normalny", 380))
a.wrzuc_monety(100)
a.wrzuc_monety(10)
zwrocone = a.zaplac()
self.assertEqual(zwrocone, {x: 0 for x in a.nominaly})
def __init__(self, master=None, ile_monet=100):
"""
Inicjalizuje okno aplikacji oraz widgety zawierające się w nim.
:param master: Rodzic okna
:param ile_monet: Liczba początkowa monet w automacie.
"""
tk.Frame.__init__(self, master)
self.grid(sticky=tk.N + tk.S + tk.E + tk.W)
self.wrzucanie_monet = False
self.automat = automat.Automat(automat.LISTA_NOMINALOW)
self.automat.napelnij(ile_monet)
self.do_zaplaty = tk.IntVar(value=self.automat.do_zaplaty())
self.wplacone = tk.IntVar(value=self.automat.suma_monet())
self.do_zaplaty_string = tk.StringVar(
value='{:.2f}zł'.format(self.do_zaplaty.get() / 100))
self.wplacone_string = tk.StringVar(
value='{:.2f}zł'.format(self.wplacone.get() / 100))
self.do_zaplaty_desc_label = tk.Label(self,
text="Kwota do zapłaty:",
font=tk_font.Font(size=11),
anchor='w')
self.wplacone_desc_label = tk.Label(self,
text="Kwota wpłacona:",
font=tk_font.Font(size=11),
anchor='w')
self.do_zaplaty_label = tk.Label(self,
textvariable=self.do_zaplaty_string)
self.wplacone_label = tk.Label(self, textvariable=self.wplacone_string)
self.bilety_label = []
self.bilety_spinbox = []
self.bilety_count = {
typ: {
f'{bilet[0]},{int(bilet[1] / (i + 1))}': tk.IntVar(value=0)
for bilet in zip(automat.DLUGOSC_BILETU_MINUTY,
automat.CENA_BILETU)
}
for i, typ in enumerate(automat.TYP_BILETU)
}
self.wrzuc_monety_button = tk.Button(self,
text="Wrzuć monety",
command=self.wrzuc_monety_action)
self.zaplac_button = tk.Button(self,
text="Zapłać",
command=self.zaplac)
self.zakoncz_button = tk.Button(self,
text="Zakończ",
command=self.quit)
self.create_widgets()
def determinitzar():
""" Procés de determinització """
AUTOMAT_DETERMINITZAT = automat.Automat()
def afegir_estat(llista_estats, inicial=False):
""" Crea el nou estat de l'Automat determinitzat i les seves noves transicions"""
if AUTOMAT_DETERMINITZAT.get_estat(str(llista_estats)) is not None:
return 0
estats_a_tractar = remove_duplicats(llista_estats)
conjunt_estats = trobar_conjunt(estats_a_tractar)
estat_a_afegir = str(conjunt_estats)
final = es_final(conjunt_estats)
AUTOMAT_DETERMINITZAT.afegir_estat(estat_a_afegir, final=final, inicial=inicial)
transicions = get_transicions_dels_estats(conjunt_estats)
for lletra in transicions:
afegir_estat(transicions[lletra])
AUTOMAT_DETERMINITZAT.afegir_transicio(estat_a_afegir, lletra, str(transicions[lletra]))
def afegir_estat_buit():
""" És important per determinitzar, afegir l'estat buit quan un estat no té una transició d'una lletra """
AUTOMAT_DETERMINITZAT.afegir_estat('buit')
for lletra in AUTOMAT_DETERMINITZAT.alphabet():
AUTOMAT_DETERMINITZAT.afegir_transicio('buit', lletra, 'buit')
nom_estats_inicials = nom_llista_estats(AUTOMAT_ENTRADA.get_estats_inicials())
afegir_estat(nom_estats_inicials, inicial=True)
# Mirem que tots els estats tinguin totes les transicions, en cas contrari s'afegeixen i s'envien al conjunt buit.
for estat in AUTOMAT_DETERMINITZAT.get_all_estats():
for lletra in AUTOMAT_DETERMINITZAT.alphabet():
if lletra not in estat.transicions.keys():
if AUTOMAT_DETERMINITZAT.get_estat('buit') is None:
afegir_estat_buit()
AUTOMAT_DETERMINITZAT.afegir_transicio(estat.nom, lletra, 'buit')
print('\t--- IMPRESSIO PER PANTALLA DE L\'AUTOMAT DETERMINITZAT---')
AUTOMAT_DETERMINITZAT.show()
# En cas de voler-lo utilitzar, el retornarem
return AUTOMAT_DETERMINITZAT
def parse(self, input):
"""Read and parse automat."""
self.index = 0
self.str = input
self._line = 1
self._pos = 0
self._charLine = 1
self._charPos = 0
while True:
# wait for keyword
token = self._getToken()
self._tShould(token, ['id', ''])
keyword = token.string
if token.type == '':
break
token = self._getToken()
self._tShould(token, ['='])
if keyword == 'grammar':
if self.grammar is not False:
raise ValueError("Grammar is defined twice in this file.",
3)
# new empty grammar
self.grammar = grammar.Grammar()
# wait for opening brackets
token = self._getToken()
self._tShould(token, ['('])
token = self._getToken()
self._tShould(token, ['{'])
# load non-terminals
self._loadIdsArr(self.grammar.addNonTerminal)
# comma and opening bracket
token = self._getToken()
self._tShould(token, [','])
token = self._getToken()
self._tShould(token, ['{'])
# load terminals
self._loadCharArr(self.grammar.addTerminal)
# comma and opening bracket
token = self._getToken()
self._tShould(token, [','])
token = self._getToken()
self._tShould(token, ['{'])
# load rules
self._loadGrammarRules()
# comma and one character
token = self._getToken()
self._tShould(token, [','])
token = self._getToken()
self._tShould(token, ['id'])
self.grammar.setStartSymbol(token.string)
# closing bracket and comma - end of grammar
token = self._getToken()
self._tShould(token, [')'])
elif keyword == 'automaton':
if self.grammar is False:
raise ValueError(
"Automaton must " + " be defined after grammar.", 3)
if self.automaton is not False:
raise ValueError("Automaton is defined twice.", 3)
self.automaton = True
# new empty automat
aut = automat.Automat()
# automat alphabet are terminals and nonterminals from grammar
for symbol in self.grammar.nonterminals:
aut.addAlpha(symbol)
for symbol in self.grammar.terminals:
aut.addAlpha(symbol)
# wait for opening brackets
token = self._getToken()
self._tShould(token, ['('])
token = self._getToken()
self._tShould(token, ['{'])
# load states
self._loadIdsArr(aut.addState)
# comma and opening bracket
token = self._getToken()
self._tShould(token, [','])
token = self._getToken()
self._tShould(token, ['{'])
# load rules
self._loadAutomatRules(aut)
# comma and start state
token = self._getToken()
self._tShould(token, [','])
token = self._getToken()
if token.type != 'id':
raise ValueError("Missing automat start state", 3)
else:
aut.setStart(token.string)
# comma and opening bracket
token = self._getToken()
self._tShould(token, [','])
token = self._getToken()
self._tShould(token, ['{'])
self._loadIdsArr(aut.setTerminating)
# closing bracket and nothing
token = self._getToken()
self._tShould(token, [')'])
if not self.aut:
self.aut = aut
else:
aut.join(self.aut)
self.aut = aut
elif keyword == 'precedence':
if self.grammar is False:
raise ValueError(
"Precedence must be defined after" + " grammar.", 3)
if self.prec is not False:
raise ValueError("Precedence is defined twice.", 3)
self.prec = PrecedenceTable()
token = self._getToken()
self._tShould(token, ['('])
while self.loadPrecedenceRules():
pass
elif keyword == 'levels':
if self.grammar is False:
raise ValueError(
"Levels must be defined after" + " grammar.", 3)
if self.levels is not False:
raise ValueError("Levels are defined twice.", 3)
self.levels = True
token = self._getToken()
self._tShould(token, ['{'])
aut = automat.Automat()
# automat alphabet are terminals and nonterminals from grammar
for symbol in self.grammar.nonterminals:
aut.addAlpha(symbol)
for symbol in self.grammar.terminals:
aut.addAlpha(symbol)
start = '0'
aut.addState(start)
aut.setStart(start)
stringNum = 0
charNum = 0
while True:
lastState = start
token = self._getToken()
self._tShould(token, ['}', ';', 'str'])
if token.type == '}':
break
else:
while True:
if token.type == ';':
aut.setTerminating(lastState)
break
newState = str(stringNum) + "-" + str(charNum)
aut.addState(newState)
aut.addRule(lastState, token.string, newState)
lastState = newState
token = self._getToken()
self._tShould(token, ['str', ';'])
charNum += 1
stringNum += 1
if not self.aut:
self.aut = aut
else:
self.aut.join(aut)
else:
raise ValueError("Undefined keyword '" + keyword + "'", 3)
if self.grammar is False:
raise ValueError("No grammar specified in grammar input file.", 3)
def setUp(self):
self.automat = aut.Automat(aut.OBSLUGIWANE_NOMINALY)
self.automat.wczytaj_monety('PLN')
def test_niecalkowita_ilosc_monet(self):
a = automat.Automat(automat.LISTA_NOMINALOW)
check = a.wrzuc_monety(1, 2.5)
self.assertFalse(check)
def test_ujemna_ilosc_monet(self):
a = automat.Automat(automat.LISTA_NOMINALOW)
check = a.wrzuc_monety(1, -2)
self.assertFalse(check)
def test_dwa_rozne_bilety(self):
a = automat.Automat(automat.LISTA_NOMINALOW)
a.dodaj_bilet(automat.Bilet(60, "ulgowy", 240))
a.dodaj_bilet(automat.Bilet(60, "normalny", 480))
self.assertEqual(a.do_zaplaty(), 240 + 480)
def test_wrzucanie_po_1gr_1(self):
a = automat.Automat(automat.LISTA_NOMINALOW)
for _ in range(100):
a.wrzuc_monety(1)
self.assertEqual(a.suma_monet(), 100)
for estat in AUTOMAT_DETERMINITZAT.get_all_estats():
for lletra in AUTOMAT_DETERMINITZAT.alphabet():
if lletra not in estat.transicions.keys():
if AUTOMAT_DETERMINITZAT.get_estat('buit') is None:
afegir_estat_buit()
AUTOMAT_DETERMINITZAT.afegir_transicio(estat.nom, lletra, 'buit')
print('\t--- IMPRESSIO PER PANTALLA DE L\'AUTOMAT DETERMINITZAT---')
AUTOMAT_DETERMINITZAT.show()
# En cas de voler-lo utilitzar, el retornarem
return AUTOMAT_DETERMINITZAT
if __name__ == "__main__":
AUTOMAT_ENTRADA = automat.Automat()
print('\t----- ESTATS -----')
ESTATS = get_estats()
for estat in ESTATS:
AUTOMAT_ENTRADA.afegir_estat(estat)
cadena_estats_inicials = input('Introdueix els estats inicials separats per un espai: ')
ESTATS_INICIALS = get_set_estats(cadena_estats_inicials)
for nom_inicial in ESTATS_INICIALS:
estat_inicial = AUTOMAT_ENTRADA.get_estat(nom_inicial)
estat_inicial.inicial = True
cadena_estats_finals = input('Introdueix els estats finals separats per un espai: ')
ESTATS_FINALS = get_set_estats(cadena_estats_finals)
for nom_final in ESTATS_FINALS:
estat_final = AUTOMAT_ENTRADA.get_estat(nom_final)