class Agenda(object):
__dato = {}
__persistencia = Persistencia("marcos.json")
def abrir(self):
self.__dato = self.__persistencia.preparar()
if (self.__dato == "Error al leer el archivo"):
return False
return True
def guardar(self, nombre, tel, email):
self.__dato[nombre] = {email: tel}
print self.__dato
self.__persistencia.grabar(self.__dato)
return self.__dato
def buscar(self, nombre):
return self.__dato.get(nombre, "error nombre no ingresado")
def eliminar(self, nombre):
try:
self.__dato.pop(nombre)
except ValueError:
return False
self.__persistencia.grabar(self.__dato)
return True
def __init__(self): self.jogoIniciado = False self.partidaIniciada = False self.salvouNoRanking = False self.tamX =800 self.tamY = 600 self.persistencia = Persistencia() self.ranking = self.persistencia.lerArquivo()
class TestPersistencia(unittest.TestCase):
def setUp(self):
self.tablero = TableroCelular(4, 5)
self.tablero.rellenar_matriz_al_azar(6)
self.tablero2 = TableroCelular(5,6)
self.tablero.rellenar_matriz_al_azar(15)
self.persistencia = Persistencia()
def test_cargar_y_guardar_mostrar_matriz(self):
print('TEST-GUARDADO-1')
self.persistencia.guardar('juego.s', self.tablero.matriz, 'tablero1')
print('TEST-GUARDADO-2')
self.persistencia.guardar('tablero.s', self.tablero2.matriz, 'tablero2')
print('TEST-CARGAR-MATRIZ')
print('Clave tablero1')
print(self.persistencia.cargar('juego.s', 'tablero1'))
print('Clave tablero2')
print(self.persistencia.cargar('tablero.s', 'tablero2'))
def menu(self):
while True:
try:
numero1 = self.leer_entero('Ingrese modo de juego: \n'
'1- Modo normal \n'
'2- Modo vida estatica \n'
'3- Salir \n')
self.persistencia = Persistencia()
self.tablero = TableroCelular(0, 0)
if numero1 == 1:
'''MODO NORMAL'''
self.creacion_de_tableros()
elif numero1 == 2:
while True:
try:
'''MODO VIDA ESTATICA'''
cargar = self.leer_entero(
'Desea cargar algun modo de vida estatico pasado?: \n'
'1- si \n'
'2- no,continuar \n')
if cargar == 2:
self.modo_estatico()
return self.menu()
elif cargar == 1:
direccion = self.leer_teclado(
'Ingrese ruta del archivo sin comillas: ')
clave = self.leer_teclado(
'Ingrese posicion de guardado sin comillas: '
)
lista_posicion_tablero = self.persistencia.cargar_vida_estatica(
direccion, clave)
self.modo_estatico_cargado(
lista_posicion_tablero[0],
lista_posicion_tablero[1])
else:
raise NumeroNoEstaEnMenu
except PatronesMayoresALaDimencion:
print("Ingresar patron mas chico")
except (KeyboardInterrupt, EOFError):
condicion = self.leer_entero(
'Desea guardar el ultimo punto del modo de vida estatico? 1-Si 2-Salir'
)
if condicion == 1:
ruta = self.leer_teclado(
'Ingrese la ruta del archivo sin comillas:'
)
clave = self.leer_teclado(
'Ingrese la clave para guardar el tablero sin comillas:'
)
self.persistencia.guardar_vida_estatica_tupla(
ruta, self.posicion_tupla_actual,
self.tablero.matriz, clave)
return self.menu()
elif condicion == 2:
return self.menu()
except NumeroNoEstaEnMenu:
print('Por favor, elegí 1 o 2.')
except FileNotFoundError:
print(
'Archivo no encontrado. Ingresar ruta valida.')
except TypeError:
print('Ingrese una posición de carga valida.')
except KeyError:
print(
'Ingresar una clave valida en un archivo correcto.'
)
except PermissionError:
print('Ingrese una ruta valida.')
elif numero1 == 3:
print('El Programa se cerro correctamente!')
break
else:
raise NumeroNoEstaEnMenu
except (NumeroNoEstaEnMenu):
print('Por favor, ingrese un numero del 1 al 3.')
except (KeyboardInterrupt, EOFError):
print('Error atrapado de Ctrl-C')
class Menu(object):
def menu(self):
while True:
try:
numero1 = self.leer_entero('Ingrese modo de juego: \n'
'1- Modo normal \n'
'2- Modo vida estatica \n'
'3- Salir \n')
self.persistencia = Persistencia()
self.tablero = TableroCelular(0, 0)
if numero1 == 1:
'''MODO NORMAL'''
self.creacion_de_tableros()
elif numero1 == 2:
while True:
try:
'''MODO VIDA ESTATICA'''
cargar = self.leer_entero(
'Desea cargar algun modo de vida estatico pasado?: \n'
'1- si \n'
'2- no,continuar \n')
if cargar == 2:
self.modo_estatico()
return self.menu()
elif cargar == 1:
direccion = self.leer_teclado(
'Ingrese ruta del archivo sin comillas: ')
clave = self.leer_teclado(
'Ingrese posicion de guardado sin comillas: '
)
lista_posicion_tablero = self.persistencia.cargar_vida_estatica(
direccion, clave)
self.modo_estatico_cargado(
lista_posicion_tablero[0],
lista_posicion_tablero[1])
else:
raise NumeroNoEstaEnMenu
except PatronesMayoresALaDimencion:
print("Ingresar patron mas chico")
except (KeyboardInterrupt, EOFError):
condicion = self.leer_entero(
'Desea guardar el ultimo punto del modo de vida estatico? 1-Si 2-Salir'
)
if condicion == 1:
ruta = self.leer_teclado(
'Ingrese la ruta del archivo sin comillas:'
)
clave = self.leer_teclado(
'Ingrese la clave para guardar el tablero sin comillas:'
)
self.persistencia.guardar_vida_estatica_tupla(
ruta, self.posicion_tupla_actual,
self.tablero.matriz, clave)
return self.menu()
elif condicion == 2:
return self.menu()
except NumeroNoEstaEnMenu:
print('Por favor, elegí 1 o 2.')
except FileNotFoundError:
print(
'Archivo no encontrado. Ingresar ruta valida.')
except TypeError:
print('Ingrese una posición de carga valida.')
except KeyError:
print(
'Ingresar una clave valida en un archivo correcto.'
)
except PermissionError:
print('Ingrese una ruta valida.')
elif numero1 == 3:
print('El Programa se cerro correctamente!')
break
else:
raise NumeroNoEstaEnMenu
except (NumeroNoEstaEnMenu):
print('Por favor, ingrese un numero del 1 al 3.')
except (KeyboardInterrupt, EOFError):
print('Error atrapado de Ctrl-C')
def creacion_de_tableros(self):
while True:
try:
numero2 = self.leer_entero(
'Elija una opción para crear el tablero: \n'
'1- Patron al azar \n'
'2- Crear tablero manualmente \n'
'3- Cargar tablero \n'
'4- Volver al menu \n')
if numero2 == 1:
'''MODO NORMAL - PATRON AL AZAR'''
fila = self.leer_entero(
'Ingrese el tamaño de la fila de la matriz:')
columna = self.leer_entero(
'Ingrese el tamaño de la columna de la matriz:')
while True:
try:
self.tablero = TableroCelular(fila, columna)
cantidad_de_celulas = self.leer_entero(
'Ingrese la cantidad de celulas vivas:')
self.tablero.rellenar_matriz_al_azar(
cantidad_de_celulas)
# MODO
self.modo_normal()
break
except IndexError:
print(
'La cantidad de celdas vivas tiene que ser hasta '
+ str(
len(self.tablero.matriz) *
len(self.tablero.matriz)))
elif numero2 == 2:
'''MODO NORMAL - CREAR MANUALMENTE'''
fila = self.leer_entero(
'Ingrese el tamaño de la fila de la matriz:')
columna = self.leer_entero(
'Ingrese el tamaño de la columna de la matriz:')
self.tablero = TableroCelular(fila, columna)
while True:
'''COMENZAR JUEGO'''
numero2_2_1 = self.leer_entero('Ingrese accion: \n'
'1- Modificar celda \n'
'2- Comenzar juego \n')
if numero2_2_1 == 1:
try:
fila = self.leer_entero('Ingrese fila: ')
columna = self.leer_entero('Ingrese columna: ')
estado = self.leer_teclado(
'Ingrese estado "*" viva o "-" muerta (Sin comillas): '
)
self.tablero.rellenar_matriz_manualmente(
fila, columna, estado)
except IndexError:
print(
'Ingrese fila o columna correcta entre 0 y '
+ str(len(self.tablero.matriz) - 1))
except ValorCelularNoValido:
print(
'Ingresar - o * en el valor_de_la_matriz')
# MODO
elif numero2_2_1 == 2:
self.modo_normal()
break
else:
raise NumeroNoEstaEnMenu
elif numero2 == 3:
'''MODO NORMAL - CARGAR'''
while True:
try:
direccion = self.leer_teclado(
'Ingrese ruta del archivo sin comillas: ')
clave = self.leer_teclado(
'Ingrese posicion de guardado sin comillas: ')
self.tablero.matriz = self.persistencia.cargar(
direccion, clave)
# MODO
self.modo_normal()
break
except FileNotFoundError:
print(
'Archivo no encontrado. Ingresar ruta valida.')
except TypeError:
print('Ingrese una posición de carga valida.')
except KeyError:
print(
'Ingresar una clave valida en un archivo correcto.'
)
except PermissionError:
print('Ingrese una ruta valida.')
elif numero2 == 4:
break
else:
raise NumeroNoEstaEnMenu
except NumeroNoEstaEnMenu:
print('Por favor, ingrese un numero del 1 al 4.')
def modo_normal(self):
while True:
try:
self.tablero.imprimir_tablero()
numero_de_modo_normal = self.leer_entero(
'Ingrese una accion: \n'
'1- Siguiente paso \n'
'2- Modificar tablero \n'
'3- Guardar tablero \n'
'4- Volver \n')
if numero_de_modo_normal == 1:
'''MODO NORMAL - SIGUIENTE PASO'''
self.tablero.mutar_celulas_modo_normal()
elif numero_de_modo_normal == 2:
'''MODIFICAR TABLERO'''
while True:
try:
fila = self.leer_entero(
'Ingrese posicion de fila:')
columna = self.leer_entero(
'Ingrese posicion de columna:')
valor = self.leer_teclado(
'Ingrese "*" o "-"(Sin comillas):')
self.tablero.rellenar_matriz_manualmente(
fila, columna, valor)
break
except IndexError:
print(
"Por favor ingrese un numero de fila comprendido entre 0 y "
+ str(len(self.tablero.matriz)) +
"y columna comprendido entre 0 y " +
str(len(self.tablero.matriz[0])))
except Exception:
print(Exception)
elif numero_de_modo_normal == 3:
'''GUARDAR TABLERO'''
while True:
try:
tablero = self.tablero.matriz
ruta = self.leer_teclado(
'Ingrese la ruta del archivo sin comillas:')
clave = self.leer_teclado(
'Ingrese la clave para guardar el tablero sin comillas:'
)
self.persistencia.guardar(ruta, tablero, clave)
break
except Exception:
print('Fallo la ruta del teclado')
elif numero_de_modo_normal == 4:
break
else:
raise NumeroNoEstaEnMenu
except NumeroNoEstaEnMenu:
print('Por favor ingrese un numero del 1 al 4')
def modo_estatico(self):
fila = self.leer_entero('Ingrese el tamaño de la fila de la matriz:')
columna = self.leer_entero(
'Ingrese el tamaño de la columna de la matriz:')
patrones = self.leer_entero('Cantidad de celdas vivas:')
self.tablero = TableroCelular(fila, columna)
dimencion_de_tablero = fila * columna
lista_tuplas = []
cantidad_tableros = 0
if (patrones <= dimencion_de_tablero):
for x in combinations(range(dimencion_de_tablero), patrones):
self.posicion_tupla_actual = x
self.tablero.matriz = self.tablero.matriz_nueva(fila, columna)
self.tablero.contador_vidas_estaticas = 0
self.tablero.diccionario_de_celdas = {}
encontro = True
contador = 0
for posicion_tupla in x: # este for rellena los vivos con las combinaciones
coordenadas = (posicion_tupla //
len(self.tablero.matriz[0]),
posicion_tupla %
len(self.tablero.matriz[0]))
self.tablero.rellenar_matriz_manualmente(
coordenadas[0], coordenadas[1], '*')
self.tablero.mutar_celulas()
if self.tablero.matriz_antigua == self.tablero.matriz:
self.tablero.imprimir_tablero()
cantidad_tableros += 1
print('--------------------------------------')
if cantidad_tableros > 0:
print('Se encontraron ' + str(cantidad_tableros) +
' tableros estáticos.')
else:
print('No se encontraron tableros estáticos.')
else:
raise PatronesMayoresALaDimencion
def modo_estatico_cargado(self, posicion_tupla_guardada, tablero):
empezar = False
self.tablero.matriz = tablero
fila = len(self.tablero.matriz)
columna = len(self.tablero.matriz[0])
contador_vivos = 0
patrones = len(posicion_tupla_guardada)
dimencion_de_tablero = fila * columna
cantidad_tableros = 0
if (patrones <= dimencion_de_tablero):
for x in combinations(range(dimencion_de_tablero), patrones):
self.tablero.matriz = self.tablero.matriz_nueva(fila, columna)
self.tablero.contador_vidas_estaticas = 0
self.tablero.diccionario_de_celdas = {}
if x == posicion_tupla_guardada:
empezar = True
for posicion_tupla in x: # este for rellena los vivos con las combinaciones
coordenadas = (posicion_tupla //
len(self.tablero.matriz[0]),
posicion_tupla %
len(self.tablero.matriz[0]))
self.tablero.rellenar_matriz_manualmente(
coordenadas[0], coordenadas[1], '*')
if empezar:
self.tablero.mutar_celulas()
if self.tablero.matriz_antigua == self.tablero.matriz:
self.tablero.imprimir_tablero()
cantidad_tableros += 1
print('--------------------------------------')
if cantidad_tableros > 0:
print('Se encontraron ' + str(cantidad_tableros) +
' tableros estáticos.')
else:
print('No se encontraron tableros estáticos.')
else:
raise PatronesMayoresALaDimencion
def leer_teclado(self, texto):
while True:
try:
ingresado = str(input(texto))
break
except (EOFError, KeyboardInterrupt):
print('Error atrapado de Ctrl-C')
return ingresado
def leer_entero(self, texto):
while True:
try:
ingresado = eval(input(texto))
if type(ingresado) == int:
return ingresado
else:
raise Exception
except (Exception, ValueError):
print('Por favor ingrese un numero entero')
except (EOFError, KeyboardInterrupt):
print('Error atrapado de Ctrl-C')
def resolucoes(self, buffer, arquivo, arq1, criticas, contarq, data_e_hora,
arqres, perc):
print(
'ARQUIVO========================================================>',
arquivo, '(CARGOS)', perc, '%')
################# PROCESSA CABEÇALHO DO DIARIO ################
diario_pattern = re.compile('Ano\s([A-Z]*)\s•\sN\w\s([0-9]*)')
diario_edicao = diario_pattern.search(buffer)
diario_suplemento_pattern = re.compile(
'Diário Oficial do Município do Rio de Janeiro\s\|\s\w*\s\w*\s\|\s\w*\s\w*\s\|\s(Suplemento)'
)
diario_suplemento = diario_suplemento_pattern.search(buffer)
if diario_suplemento:
tipo = 'SUPLEMENTAR' #Suplemento
else:
tipo = 'NORMAL' #Normal
util = Util()
diario = Diario()
if (diario_edicao.group(1)):
diario.anoromano = '{: <6}'.format(((diario_edicao.group(1))))
diario.ano = (util.converteRomano(diario_edicao.group(1)))
diario.numero = '{:0>6}'.format((diario_edicao.group(2)))
diario.tipo = '{: <12}'.format((tipo))
if (diario.ano < 26):
print("Diário anterior a 2013:",
"Ano:",
diario.ano,
"Arquivo:",
arquivo.upper(),
file=criticas)
else:
diario.anoromano = 'XXXXXX'
diario.ano = 'XXXXXX'
diario.numero = 'XXXXXX'
diario.tipo = 'XXXXXXXXXXXX'
print('', file=arq1)
print('(PUC-RIO/TECMF) ::PROCESSAMENTO DO DIÁRIO::',
'ANO:',
diario.ano,
'No.:',
diario.numero,
'TIPO:',
diario.tipo,
'* RIO DE JANEIRO * ARQUIVO:',
arquivo.upper(),
'SEQ.:',
'{:0>4}'.format(contarq),
' ',
data_e_hora,
file=arq1)
print('', file=arq1)
#############################################################
resolucao_pattern = re.compile(
r'^(\*RESOLUÇÕES|RESOLUÇÕES|RESOLUÇOES|RESOLUÇÃO|RESOLUÇAO|PORTARIAS|DECRETO RIO|PORTARIA)\s*(.)*\s*“P”.*',
re.M)
contador = 1
cont = -1
inicio = []
bloco = []
servidor = []
tamanho = len(buffer)
for resolucao in resolucao_pattern.finditer(buffer):
inicio.append(resolucao.start())
contador = contador + 1
inicio.append(tamanho)
for i in range(len(inicio) - 1):
bloco.append(inicio[i + 1] - inicio[i])
buffer_local = buffer[inicio[i]:inicio[i] + bloco[i]]
###### Resolução #####
resolucao1_pattern = re.compile(
r'^(?P<resolucao1>\*RESOLUÇÕES|RESOLUÇÕES|RESOLUÇOES|RESOLUÇÃO|RESOLUÇAO|PORTARIAS|DECRETO RIO|PORTARIA)\s*(.)*\s*“P”(?P<detalhe_resolucao1>.*)',
re.M)
resolucao1 = resolucao1_pattern.search(buffer_local)
if (resolucao1):
Tipo = '{: <11}'.format(resolucao1.group('resolucao1'))
Detalhe = resolucao1.group('detalhe_resolucao1')
else:
#print('Não casou resolucao1')
Tipo = 'SEM TIPO'
Detalhe = 'SEM DETALHE'
#####################
#### Gestor #####
gestor_pattern = re.compile(
r'(?P<gestor>[O|A]*\s(SECRETÁRI[O|A]+|PROCURADOR[A]*|PREFEITO[A]*|COORDENADOR[A]*)[A-ZÁÚÍÃÓÇÊÉ\s-]+)'
)
gestor = gestor_pattern.search(buffer_local)
if (gestor):
Gestor = gestor.group('gestor')
else:
Gestor = 'SEM GESTOR'
#print('-----FIM DO BLOCO-----')
###### Fim Gestor
################################# RESOLUÇÕES COMPOSTAS #############################
persistencia = Persistencia()
if ((resolucao1.group('resolucao1') == '*RESOLUÇÕES')
or (resolucao1.group('resolucao1') == 'RESOLUÇÕES')
or (resolucao1.group('resolucao1') == 'RESOLUÇOES')
or (resolucao1.group('resolucao1') == 'RESOLUCOES')
or (resolucao1.group('resolucao1') == 'PORTARIAS')):
servidor = LayoutAtos.atos_nomeacoes(self, buffer_local,
Detalhe)
util = Util()
ato = Ato()
for i in range(len(servidor)):
ato.numero = '{:0>4}'.format(servidor[i].numero)
ato.nome = '{: <50}'.format((servidor[i].nome).replace(
'\n', ' ').replace(' ', ' ').strip(" "))
ato.diaResolucao = '{:0>2}'.format(
servidor[i].diaResolucao)
ato.mesResolucao = '{:0>2}'.format(
servidor[i].mesResolucao)
ato.anoResolucao = servidor[i].anoResolucao
ato.dataResolucao = ato.diaResolucao + '/' + ato.mesResolucao + '/' + ato.anoResolucao
ato.dia = '{:0>2}'.format(servidor[i].dia)
ato.mes = util.retornaMes(servidor[i].mes.replace(' ', ''))
ato.ano = servidor[i].ano
ato.dataEfeito = ato.dia + '/' + ato.mes + '/' + ato.ano
ato.matricula = '{: <12}'.format(
servidor[i].matricula.replace('.', ''))
#ato.cargo = '{: <48}'.format(servidor[i].cargo.upper()).replace('\n', ' ')
ato.cargo = '{: <48}'.format(
(servidor[i].cargo.upper()).replace('\n', ' ').replace(
' ', ' ').replace('- ', '').strip(" "))
ato.CPF = '{: <13}'.format(
servidor[i].CPF) #vER ESTA REGRA!!!!!
ato.tipocargo = servidor[i].tipocargo
ato.simbolo = '{: <6}'.format(servidor[i].simbolo.replace(
'\n', ''))
print(ato.CPF,
Tipo,
ato.numero,
ato.dataResolucao,
'NOMEAR ',
ato.matricula,
ato.nome,
ato.dataEfeito,
ato.cargo,
ato.simbolo,
ato.tipocargo,
file=arq1)
persistencia.insert(ato.matricula, ato.nome,
ato.dataResolucao, 'NOMEAR',
ato.dataEfeito, ato.cargo,
ato.tipocargo, ato.simbolo)
servidor = LayoutAtos.atos_designacoes(self, buffer_local,
Detalhe)
ato = Ato()
for i in range(len(servidor)):
ato.numero = '{:0>4}'.format(servidor[i].numero)
ato.nome = '{: <50}'.format((servidor[i].nome).replace(
'\n', ' ').replace(' ', ' ').strip(" "))
ato.diaResolucao = '{:0>2}'.format(
servidor[i].diaResolucao)
ato.mesResolucao = '{:0>2}'.format(
servidor[i].mesResolucao)
ato.anoResolucao = servidor[i].anoResolucao
ato.dataResolucao = ato.diaResolucao + '/' + ato.mesResolucao + '/' + ato.anoResolucao
ato.dia = '{:0>2}'.format(servidor[i].dia)
ato.mes = util.retornaMes(servidor[i].mes.replace(' ', ''))
ato.ano = servidor[i].ano
ato.dataEfeito = ato.dia + '/' + ato.mes + '/' + ato.ano
ato.matricula = '{: <12}'.format(
servidor[i].matricula.replace('.', ''))
ato.cargo = '{: <48}'.format(
(servidor[i].cargo.upper()).replace('\n', ' ').replace(
' ', ' ').replace('- ', '').strip(" "))
ato.CPF = '{: <13}'.format(
servidor[i].CPF) #vER ESTA REGRA!!!!!
ato.tipocargo = servidor[i].tipocargo
ato.simbolo = '{: <6}'.format(servidor[i].simbolo.replace(
'\n', ''))
print(ato.CPF,
Tipo,
ato.numero,
ato.dataResolucao,
'DESIGNAR ',
ato.matricula,
ato.nome,
ato.dataEfeito,
ato.cargo,
ato.simbolo,
ato.tipocargo,
file=arq1)
persistencia.insert(ato.matricula, ato.nome,
ato.dataResolucao, 'DESIGNAR',
ato.dataEfeito, ato.cargo,
ato.tipocargo, ato.simbolo)
servidor = LayoutAtos.atos_dispensas(self, buffer_local,
Detalhe)
ato = Ato()
util = Util()
for i in range(len(servidor)):
ato.numero = '{:0>4}'.format(servidor[i].numero)
ato.nome = '{: <50}'.format((servidor[i].nome).replace(
'\n', ' ').replace(' ', ' ').strip(" "))
ato.diaResolucao = '{:0>2}'.format(
servidor[i].diaResolucao)
ato.mesResolucao = '{:0>2}'.format(
servidor[i].mesResolucao)
ato.anoResolucao = servidor[i].anoResolucao
ato.dataResolucao = ato.diaResolucao + '/' + ato.mesResolucao + '/' + ato.anoResolucao
ato.dia = '{:0>2}'.format(servidor[i].dia)
ato.mes = util.retornaMes(servidor[i].mes.replace(' ', ''))
ato.ano = servidor[i].ano
ato.dataEfeito = ato.dia + '/' + ato.mes + '/' + ato.ano
ato.matricula = '{: <12}'.format(
servidor[i].matricula.replace('.', ''))
#ato.cargo = '{: <48}'.format(servidor[i].cargo.upper()).replace('\n', ' ')
ato.cargo = '{: <48}'.format(
(servidor[i].cargo.upper()).replace('\n', ' ').replace(
' ', ' ').replace('- ', '').strip(" "))
ato.CPF = '{: <13}'.format(
servidor[i].CPF) #vER ESTA REGRA!!!!!
ato.tipocargo = servidor[i].tipocargo
ato.simbolo = '{: <6}'.format(servidor[i].simbolo.replace(
'\n', ''))
print(ato.CPF,
Tipo,
ato.numero,
ato.dataResolucao,
'DISPENSAR',
ato.matricula,
ato.nome,
ato.dataEfeito,
ato.cargo,
ato.simbolo,
ato.tipocargo,
file=arq1)
persistencia.insert(ato.matricula, ato.nome,
ato.dataResolucao, 'DISPESAR',
ato.dataEfeito, ato.cargo,
ato.tipocargo, ato.simbolo)
servidor = LayoutAtos.atos_exoneracoesTeste(
self, buffer_local, Detalhe)
ato = Ato()
util = Util()
for i in range(len(servidor)):
ato.numero = '{:0>4}'.format(servidor[i].numero)
ato.nome = '{: <50}'.format((servidor[i].nome).replace(
'\n', ' ').replace(' ', ' ').strip(" "))
ato.diaResolucao = '{:0>2}'.format(
servidor[i].diaResolucao)
ato.mesResolucao = '{:0>2}'.format(
servidor[i].mesResolucao)
ato.anoResolucao = servidor[i].anoResolucao
ato.dia = '{:0>2}'.format(servidor[i].dia)
ato.mes = util.retornaMes(servidor[i].mes)
ato.ano = servidor[i].ano
ato.dataEfeito = ato.dia + '/' + ato.mes + '/' + ato.ano
ato.dataResolucao = ato.diaResolucao + '/' + ato.mesResolucao + '/' + ato.anoResolucao
ato.matricula = '{: <12}'.format(
servidor[i].matricula.replace('.', ''))
#ato.cargo = '{: <48}'.format(servidor[i].cargo.upper()).replace('\n', ' ')
ato.cargo = '{: <48}'.format(
(servidor[i].cargo.upper()).replace('\n', ' ').replace(
' ', ' ').replace('- ', '').strip(" "))
ato.CPF = '{: <13}'.format(
servidor[i].CPF) #vER ESTA REGRA!!!!!
ato.tipocargo = servidor[i].tipocargo
ato.simbolo = '{: <6}'.format(servidor[i].simbolo.replace(
'\n', ''))
print(ato.CPF,
Tipo,
ato.numero,
ato.dataResolucao,
'EXONERAR ',
ato.matricula,
ato.nome,
ato.dataEfeito,
ato.cargo,
ato.simbolo,
ato.tipocargo,
file=arq1)
persistencia.insert(ato.matricula, ato.nome,
ato.dataResolucao, 'EXONERAR',
ato.dataEfeito, ato.cargo,
ato.tipocargo, ato.simbolo)
######################## RESOLUÇÃO SIMPLES ###########################
elif ((resolucao1.group('resolucao1') == 'RESOLUÇÃO')
or (resolucao1.group('resolucao1') == 'RESOLUÇAO')
or (resolucao1.group('resolucao1') == 'RESOLUCAO')
or (resolucao1.group('resolucao1') == 'DECRETO RIO')
or (resolucao1.group('resolucao1') == 'PORTARIA')):
servidor = LayoutAtos.atos_nomeacao(self, buffer_local,
Detalhe)
for i in range(len(servidor)):
ato = Ato()
ato.nome = '{: <50}'.format((servidor[i].nome).replace(
'\n', ' ').replace(' ', ' ').strip(" "))
ato.numero = '{:0>4}'.format(servidor[i].numero)
ato.diaResolucao = '{:0>2}'.format(
servidor[i].diaResolucao)
ato.mesResolucao = '{:0>2}'.format(
servidor[i].mesResolucao)
ato.anoResolucao = servidor[i].anoResolucao
ato.dataResolucao = ato.diaResolucao + '/' + ato.mesResolucao + '/' + ato.anoResolucao
ato.dia = '{:0>2}'.format(servidor[i].dia)
ato.mes = util.retornaMes(servidor[i].mes)
ato.ano = servidor[i].ano
ato.dataEfeito = ato.dia + '/' + ato.mes + '/' + ato.ano
ato.matricula = '{: <12}'.format(
servidor[i].matricula.replace('.', ''))
#ato.cargo = '{: <48}'.format(servidor[i].cargo.upper()).replace('\n', ' ')
ato.cargo = '{: <48}'.format(
(servidor[i].cargo.upper()).replace('\n', ' ').replace(
' ', ' ').replace('- ', '').strip(" "))
ato.CPF = '{: <13}'.format(
servidor[i].CPF) #vER ESTA REGRA!!!!!
ato.tipocargo = servidor[i].tipocargo
ato.simbolo = '{: <6}'.format(servidor[i].simbolo.replace(
'\n', ''))
print(ato.CPF,
Tipo,
ato.numero,
ato.dataResolucao,
'NOMEAR ',
ato.matricula,
ato.nome,
ato.dataEfeito,
ato.cargo,
ato.simbolo,
ato.tipocargo,
file=arq1)
persistencia.insert(ato.matricula, ato.nome,
ato.dataResolucao, 'NOMEAR',
ato.dataEfeito, ato.cargo,
ato.tipocargo, ato.simbolo)
servidor = LayoutAtos.atos_dispensar(self, buffer_local,
Detalhe)
for i in range(len(servidor)):
ato = Ato()
ato.nome = '{: <50}'.format((servidor[i].nome).replace(
'\n', ' ').replace(' ', ' ').strip(" "))
ato.numero = '{:0>4}'.format(servidor[i].numero)
ato.diaResolucao = '{:0>2}'.format(
servidor[i].diaResolucao)
ato.mesResolucao = '{:0>2}'.format(
servidor[i].mesResolucao)
ato.anoResolucao = servidor[i].anoResolucao
ato.dataResolucao = ato.diaResolucao + '/' + ato.mesResolucao + '/' + ato.anoResolucao
ato.dia = '{:0>2}'.format(servidor[i].dia)
ato.mes = util.retornaMes(servidor[i].mes)
ato.ano = servidor[i].ano
ato.dataEfeito = ato.dia + '/' + ato.mes + '/' + ato.ano
ato.matricula = '{: <12}'.format(
servidor[i].matricula.replace('.', ''))
#ato.cargo = '{: <48}'.format(servidor[i].cargo.upper()).replace('\n', ' ')
ato.cargo = '{: <48}'.format(
(servidor[i].cargo.upper()).replace('\n', ' ').replace(
' ', ' ').replace('- ', '').strip(" "))
ato.CPF = '{: <13}'.format(
servidor[i].CPF) #vER ESTA REGRA!!!!!
ato.tipocargo = servidor[i].tipocargo
ato.simbolo = '{: <6}'.format(servidor[i].simbolo.replace(
'\n', ''))
print(ato.CPF,
Tipo,
ato.numero,
ato.dataResolucao,
'DISPENSAR',
ato.matricula,
ato.nome,
ato.dataEfeito,
ato.cargo,
ato.simbolo,
ato.tipocargo,
file=arq1)
persistencia.insert(ato.matricula, ato.nome,
ato.dataResolucao, 'DISPENSAR',
ato.dataEfeito, ato.cargo,
ato.tipocargo, ato.simbolo)
servidor = LayoutAtos.atos_exonerar(self, buffer_local,
Detalhe)
for i in range(len(servidor)):
ato = Ato()
ato.nome = '{: <50}'.format((servidor[i].nome).replace(
'\n', ' ').replace(' ', ' ').strip(" "))
ato.numero = '{:0>4}'.format(servidor[i].numero)
ato.diaResolucao = '{:0>2}'.format(
servidor[i].diaResolucao)
ato.mesResolucao = '{:0>2}'.format(
servidor[i].mesResolucao)
ato.anoResolucao = servidor[i].anoResolucao
ato.dataResolucao = ato.diaResolucao + '/' + ato.mesResolucao + '/' + ato.anoResolucao
ato.dia = '{:0>2}'.format(servidor[i].dia)
ato.mes = util.retornaMes(servidor[i].mes)
ato.ano = servidor[i].ano
ato.dataEfeito = ato.dia + '/' + ato.mes + '/' + ato.ano
ato.matricula = '{: <12}'.format(
servidor[i].matricula.replace('.', ''))
#ato.cargo = '{: <48}'.format(servidor[i].cargo.upper()).replace('\n', ' ')
ato.cargo = '{: <48}'.format(
(servidor[i].cargo.upper()).replace('\n', ' ').replace(
' ', ' ').replace('- ', '').strip(" "))
ato.CPF = '{: <13}'.format(
servidor[i].CPF) #vER ESTA REGRA!!!!!
ato.tipocargo = servidor[i].tipocargo
ato.simbolo = '{: <6}'.format(servidor[i].simbolo.replace(
'\n', ''))
print(ato.CPF,
Tipo,
ato.numero,
ato.dataResolucao,
'EXONERAR ',
ato.matricula,
ato.nome,
ato.dataEfeito,
ato.cargo,
ato.simbolo,
ato.tipocargo,
file=arq1)
persistencia.insert(ato.matricula, ato.nome,
ato.dataResolucao, 'EXONERAR',
ato.dataEfeito, ato.cargo,
ato.tipocargo, ato.simbolo)
servidor = LayoutAtos.atos_designar(self, buffer_local,
Detalhe, arqres)
for i in range(len(servidor)):
ato = Ato()
ato.nome = '{: <50}'.format((servidor[i].nome).replace(
'\n', ' ').replace(' ', ' ').strip(" "))
#print(ato.nome)
ato.numero = '{:0>4}'.format(servidor[i].numero)
ato.diaResolucao = '{:0>2}'.format(
servidor[i].diaResolucao)
ato.mesResolucao = '{:0>2}'.format(
servidor[i].mesResolucao)
ato.anoResolucao = servidor[i].anoResolucao
ato.dataResolucao = ato.diaResolucao + '/' + ato.mesResolucao + '/' + ato.anoResolucao
ato.dia = '{:0>2}'.format(servidor[i].dia)
ato.mes = util.retornaMes(servidor[i].mes)
ato.ano = servidor[i].ano
ato.dataEfeito = ato.dia + '/' + ato.mes + '/' + ato.ano
ato.matricula = '{: <12}'.format(
servidor[i].matricula.replace('.', ''))
#ato.cargo = '{: <48}'.format(servidor[i].cargo.upper()).replace('\n', ' ')
ato.cargo = '{: <48}'.format(
(servidor[i].cargo.upper()).replace('\n', ' ').replace(
' ', ' ').replace('- ', '').strip(" "))
ato.CPF = '{: <13}'.format(
servidor[i].CPF) #vER ESTA REGRA!!!!!
ato.tipocargo = servidor[i].tipocargo
ato.simbolo = '{: <6}'.format(servidor[i].simbolo.replace(
'\n', ''))
print(ato.CPF,
Tipo,
ato.numero,
ato.dataResolucao,
'DESIGNAR ',
ato.matricula,
ato.nome,
ato.dataEfeito,
ato.cargo,
ato.simbolo,
ato.tipocargo,
file=arq1)
persistencia.insert(ato.matricula, ato.nome,
ato.dataResolucao, 'DESIGNAR',
ato.dataEfeito, ato.cargo,
ato.tipocargo, ato.simbolo)
def setUp(self):
self.tablero = TableroCelular(4, 5)
self.tablero.rellenar_matriz_al_azar(6)
self.tablero2 = TableroCelular(5,6)
self.tablero.rellenar_matriz_al_azar(15)
self.persistencia = Persistencia()
#!/usr/bin/env python
# -*- coding: utf8 -*-
from Persistencia import Persistencia
from Pessoa import Pessoa
persistencia = Persistencia()
persistencia.recuperaLista()
def lerPessoa():
codigo = int(input('Codigo : '))
nome = input('Nome : ')
status = bool(input('Status : '))
altura = float(input('Altura : '))
return Pessoa(codigo, nome, status, altura)
def incluir():
persistencia.gravaPessoa(lerPessoa())
def alterar():
codigoQuery = int(input('Digite o código da pessoa a ser alterada:'))
if (persistencia.existePessoa(codigoQuery)):
persistencia.atualizaPessoa(lerPessoa())
else:
print('Pessoa inexistente')
def excluir():
codigoQuery = int(input('Digite o código da pessoa a ser excluida:'))
if (persistencia.existePessoa(codigoQuery)):
persistencia.excluiPessoa(Pessoa(codigoQuery))
class Gerenciador(object):
def __init__(self):
self.jogoIniciado = False
self.partidaIniciada = False
self.salvouNoRanking = False
self.tamX =800
self.tamY = 600
self.persistencia = Persistencia()
self.ranking = self.persistencia.lerArquivo()
def iniciarJogo (self):
if (self.jogoIniciado == True):
raise ExcecaoJogo("Um jogo ja foi iniciado")
self.jogoIniciado = True
self.nave = None
self.listaTiros = []
self.listaNaves = []
# self.ranking = self.persistencia.lerArquivo()
self.salvouNoRanking = False
def moverNavesInimigas(self):
for naveInimiga in self.listaNaves:
naveInimiga.moverAleatorio()
def moverTiros (self):
for tiro in self.listaTiros:
tiro.mover()
if tiro.posY < 0: #neste caso o tamnho da nave
self.listaTiros.remove(tiro)
def iniciarPartida(self):
if (self.partidaIniciada == True):
raise ExcecaoJogo("Uma partida ja foi iniciada")
if (self.jogoIniciado == False):
raise ExcecaoJogo("Jogo não iniciado")
self.partidaIniciada = True
self.nave = Nave(self.tamX, self.tamY)
def jogoComecou(self):
return self.jogoIniciado
def getTamanhoTela(self):
return (self.tamX, self.tamY)
def getPosNave (self):
return self.nave.getPos()
def moverNave(self, deslocamentoX, deslocamentoY):
if (self.jogoIniciado == False):
raise ExcecaoJogo("Jogo não iniciado")
if (self.partidaIniciada == False):
raise ExcecaoJogo("Partida não iniciada")
self.nave.moverNave(deslocamentoX, deslocamentoY)
def atacarInimigo(self):
if (self.jogoIniciado == False):
raise ExcecaoJogo("Jogo não iniciado")
if (self.partidaIniciada == False):
raise ExcecaoJogo("Partida não iniciada")
posNave = self.getPosNave()
self.listaTiros.append(Tiro(posNave[0],posNave[1]))
def adicionarNomeNoRanking(self, Nome):
pontuacaoEnome = (Nome, self.getPontuacao())
self.adicionarNoRanking(pontuacaoEnome)
self.ranking.sort(self.funcaoOrdenacaoRanking)
self.ranking.reverse()
def funcaoOrdenacaoRanking(self,a,b):
if (a[1] == b[1]):
return (-1) * cmp(a[0], b[0])
return cmp(a[1], b[1])
def getRanking(self):
return self.ranking
def adicionarNoRanking(self, pontuacaoENome):
if (self.jogoIniciado == False):
raise ExcecaoJogo("Jogo não iniciado")
if (self.partidaIniciada == True):
raise ExcecaoJogo("Partida em andamento")
if(pontuacaoENome[1] == 0):
raise ExcecaoJogo("Você precisa ter pontuação maior que zero")
if (not(pontuacaoENome in self.ranking)):
self.ranking.append(pontuacaoENome)
self.ranking.sort()
self.ranking.reverse()
if (len(self.ranking )> 10):
self.ranking.remove(self.ranking[10])
#salvar em arquivo
self.persistencia.gravarArquivo( self.ranking )
def sairDaPartida(self):
if (self.jogoIniciado == False):
raise ExcecaoJogo("Jogo não iniciado")
if (self.partidaIniciada == False):
raise ExcecaoJogo("Partida não iniciada")
self.partidaIniciada = False
tamanhoRanking = len(self.ranking)
#retorna true se for para adicionar no ranking
if ((tamanhoRanking == 0)):
return True
elif (self.nave.pontuacao >= (self.ranking[tamanhoRanking-1])[1]):
return True
elif (tamanhoRanking < 10):
return True
return False
def sairDoJogo(self):
if (self.jogoIniciado == False):
raise ExcecaoJogo("Jogo não iniciado")
if (self.partidaIniciada == True):
raise ExcecaoJogo("Voce precisa terminar a partida antes de sair")
self.jogoIniciado = False
def getNivel(self):
if (self.jogoIniciado == False):
raise ExcecaoJogo("Jogo não iniciado")
if (self.partidaIniciada == False):
raise ExcecaoJogo("Partida não iniciada")
return self.nave.getNivel()
def ganharVida(self):
if (self.jogoIniciado == False):
raise ExcecaoJogo("Jogo não iniciado")
if (self.partidaIniciada == False):
raise ExcecaoJogo("Partida não iniciada")
self.nave.ganharVida()
nivel = self.nave.getNivel()
if (nivel >= 6):
tamanhoRanking = len(self.ranking)
#retorna true se for para adicionar no ranking
if (tamanhoRanking == 0):
self.partidaIniciada = False
return True
elif (self.nave.pontuacao >= (self.ranking[tamanhoRanking-1])[1]):
self.partidaIniciada = False
return True
elif (tamanhoRanking < 10):
self.partidaIniciada = False
return True
else:
return False
return False
def perderVida(self):
if (self.jogoIniciado == False):
raise ExcecaoJogo("Jogo não iniciado")
if (self.partidaIniciada == False):
raise ExcecaoJogo("Partida não iniciada")
vidasAcabaram = self.nave.perderVida()
if (vidasAcabaram == True):
return self.sairDaPartida()
return False
def partidaFoiIniciada(self):
return self.partidaIniciada
def criarNaveInimiga(self):
if (self.jogoIniciado == False):
raise ExcecaoJogo("Jogo não iniciado")
if (self.partidaIniciada == False):
raise ExcecaoJogo("Partida não iniciada")
escolhaPosX = random.choice
listaPosicoes = range(0, self.tamX)
naveInimiga = NaveInimigaComum(escolhaPosX(listaPosicoes), 50 , self.tamX, self.tamY)
self.listaNaves.append(naveInimiga)
def destruirNaveInimiga(self, nave):
if (self.jogoIniciado == False):
raise ExcecaoJogo("Jogo não iniciado")
if (self.partidaIniciada == False):
raise ExcecaoJogo("Partida não iniciada")
if (nave in self.listaNaves):
self.listaNaves.remove(nave)
self.nave.pontuar()
def getListaNaves(self):
return self.listaNaves
def getPontuacao(self):
if (self.jogoIniciado == False):
raise ExcecaoJogo("Jogo não iniciado")
return self.nave.getPontuacao()
def getListaTiros(self):
return self.listaTiros
def getVida(self):
return self.nave.getVida()