index int64 | repo_name string | branch_name string | path string | content string | import_graph string |
|---|---|---|---|---|---|
70,373 | Nitro/singularity-monitor | refs/heads/master | /sgmon/health.py | import json
from http.server import HTTPServer
from http.server import SimpleHTTPRequestHandler
from sgmon.task import TaskManager
class MonitorServer(SimpleHTTPRequestHandler):
def do_GET(self):
manager = TaskManager()
if "/tasks" in self.path:
self.send_response(200, "OK")
self.send_header("Content-type", "text/json")
self.end_headers()
self.wfile.write(bytes(json.dumps(manager.get_tasks()),
encoding="utf-8"))
if "/health" in self.path:
self.send_response(200, "OK")
self.send_header("Content-type", "text/json")
self.end_headers()
self.wfile.write(bytes(json.dumps(
{"data": {"monitor": {"result": "OK"},
"newrelic": {"result": "OK"}}}), encoding="utf-8"))
def serve_forever():
server = HTTPServer(('', 8888), MonitorServer)
server.serve_forever()
| {"/sgmon/event.py": ["/sgmon/http.py", "/sgmon/log.py", "/sgmon/task.py"], "/sgmon/http.py": ["/sgmon/log.py"], "/sgmon/monitor.py": ["/sgmon/event.py", "/sgmon/http.py", "/sgmon/log.py", "/sgmon/task.py", "/sgmon/utils.py", "/sgmon/nr.py"], "/sgmon/health.py": ["/sgmon/task.py"], "/sgmon/nr.py": ["/sgmon/log.py"]} |
70,374 | Nitro/singularity-monitor | refs/heads/master | /sgmon/nr.py | import os
import logging
import newrelic.agent as agent
from sgmon.log import get_logger
logger = get_logger(__name__)
def init_newrelic_agent():
try:
_ = os.environ["NEW_RELIC_LICENSE_KEY"]
except KeyError:
logger.info("Agent will not report data to New Relic APM")
else:
config_file = os.environ.get("NEW_RELIC_CONFIG_FILE")
env = os.environ.get("NEW_RELIC_ENVIRONMENT")
log_file = "stdout"
log_level = logging.DEBUG
agent.initialize(config_file, env, log_file, log_level)
logger.info("Agent start reporting data to New Relic APM")
| {"/sgmon/event.py": ["/sgmon/http.py", "/sgmon/log.py", "/sgmon/task.py"], "/sgmon/http.py": ["/sgmon/log.py"], "/sgmon/monitor.py": ["/sgmon/event.py", "/sgmon/http.py", "/sgmon/log.py", "/sgmon/task.py", "/sgmon/utils.py", "/sgmon/nr.py"], "/sgmon/health.py": ["/sgmon/task.py"], "/sgmon/nr.py": ["/sgmon/log.py"]} |
70,375 | Nitro/singularity-monitor | refs/heads/master | /sgmon/log.py | import logging
import logging.handlers
import sys
LOG_FMT = '%(asctime)s %(levelname)8s [%(name)12s] %(message)s'
def get_logger(name):
logging.basicConfig(format=LOG_FMT)
handler = logging.StreamHandler(stream=sys.stdout)
logger = logging.getLogger(name)
logger.setLevel(logging.INFO)
logger.addHandler(handler)
logger.removeHandler(logger.handlers.pop())
return logger
| {"/sgmon/event.py": ["/sgmon/http.py", "/sgmon/log.py", "/sgmon/task.py"], "/sgmon/http.py": ["/sgmon/log.py"], "/sgmon/monitor.py": ["/sgmon/event.py", "/sgmon/http.py", "/sgmon/log.py", "/sgmon/task.py", "/sgmon/utils.py", "/sgmon/nr.py"], "/sgmon/health.py": ["/sgmon/task.py"], "/sgmon/nr.py": ["/sgmon/log.py"]} |
70,379 | socom20/handwriting_editor | refs/heads/master | /hw_plotter.py | import pygame as pg
import pygame.locals
import thorpy
import numpy as np
import pygame.math as pm
import pygame.freetype
import sys, os
import json
import pickle
import hashlib as sh
import threading
import time
from matplotlib import pyplot as plt
from modules.screentext import ScreenText
from modules.thorpymenu import ThorpyMenu
from modules.line import Line
from modules.image import Image
import traceback
import argparse
from tkinter import Tk
from tkinter import messagebox
class Plotter:
def __init__(self, screen_size=(1440,810)):
self.screen_size = screen_size # tamaño de la pantalla
self.monitor_size = None
self.global_pos = pm.Vector2(0, -self.screen_size[1]) # coord canvas
self.global_zoom_factor = 1.0 # coord screen
self.global_zoomf_min = 0.2
self.global_zoomf_max = 10
self.screen_mouse_pos = pm.Vector2(0,0) # coord screen
self.screen_mouse_dx = 0
self.screen_mouse_dy = 0
self.canvas_mouse_pos = self.coord_screen2coord_canvas(self.screen_mouse_pos) # coord canvas
self.obj_list_v = [] # lista de objetos a dibujar
self.edit_obj_list_v = [] # lista de objetos a editar
self.screen_text_v = [] # lista de texto a mostrar en Modo Usuario
self.debug_text_v = [] # lista de texto a mostrar en Modo Debugging
self.edit_text_v = [] # lista de texto a mostrar en Modo Edición
self.debugging_Mode = False # Modo para encontrar errores: inicia en Falso
self.edit_Mode = False # Modo para editar objetos: Inicia en Falso
self.is_running = True # Inicia con el programa corriendo
self.fullScreen = False # Modo pantalla completa: Inicia desactivado
self.click_on_edit_obj = False
self.onSelectionChanged = False
self.onEditionChanged = True
self.onUndoChanged = False
self.drawing_junction = False
self.pos_is_dragging = False
self.using_aux_axes = False
self.last_click = None
self.canvas_d_cont_line = 2.5
self.do_start_cont_line = False
self.mouse_helper_on = False
self.unsave_changes = False
self.file_name = 'nuevo_dibujo.ptr'
self.image_path = ''
self.palette_color_d = { 'black' : {'color_1': ( 14, 17, 17),
'color_2': ( 35, 43, 43),
'color_3': ( 53, 56, 57),
'color_4': (101,115,126),
'color_5': (192,197,206),
'color_6': (243,207,122),
'color_7': (172, 63, 33),
'color_8': (26, 140, 255),
'color_9': (255, 102, 0),
'red': (255, 0, 0),
'green': (0, 179, 0),
'blue': (0, 0, 255),
'red_sel': (128, 0, 0),
'green_sel': (115, 230, 0),
'blue_sel': (0, 0, 255)}
}
self.color_palette_v = sorted(list(self.palette_color_d.keys()))
self.color_palette_idx = 0
self.color_palette = self.color_palette_v[self.color_palette_idx] # seleccionamos la paleta de colores a utilizar para la visualización del programa (opciones: black, white, neon)
self.set_color_palette(color_palette=self.color_palette)
self.global_bg_color = self.UM_bg_c # color de background
self.debug_txt = ScreenText(rel_pos=(0,0), abs_off=(50,50), text='Debug Text', parent=self)
self.debug_text_v.append( self.debug_txt )
self.edit_txt = ScreenText(rel_pos=(1,0), abs_off=(-200,25), text='Edit Mode', parent=self)
self.edit_text_v.append( self.edit_txt )
self.screen = self.init_display(display_size=self.screen_size, fullScreen=self.fullScreen)
self.myfont = pg.freetype.Font("./fonts/BebasNeue-Regular.ttf", 24) # fuente elegida para el texto
self.lowercases_font = pg.freetype.Font("./fonts/Helvetica.ttf", 10) # fuente elegida para el texto
self.slider = ThorpyMenu(rel_pos=(0,1), abs_off=(0,-30), rank=(0,1.0), name='TextProp', parent=self)
self.screen_text_v.append(self.slider)
self.undo_pointer = -1
self.undo_v = []
self.n_obj_drawn = 0
return None
def update_txt_pos(self, size=(0,0)):
"""Actualizo la posición del texto que se muestra en pantalla en funcion del tamaño de la ventana"""
self.edit_text_v[0].update_pos(size)
for txt in self.screen_text_v:
txt.update_pos(size)
return None
def set_color_palette(self, color_palette='black'):
print(color_palette)
self.UM_bg_c = self.palette_color_d[color_palette]['color_1'] # color de background en Modo Usuario
self.EM_bg_c = self.palette_color_d[color_palette]['color_3'] # color de background en Modo Edición
self.screen_txt_c = self.palette_color_d[color_palette]['color_8'] # color usado para el texto de la información mostrada por pantalla
self.EM_obj_line_selected_c = self.palette_color_d[color_palette]['color_9']
self.color_line_text = self.palette_color_d[color_palette]['red']
self.color_dot_e0 = self.palette_color_d[color_palette]['green']
self.color_dot_e1 = self.palette_color_d[color_palette]['blue']
self.color_line_e0 = self.palette_color_d[color_palette]['green']
self.color_line_e1 = self.palette_color_d[color_palette]['blue']
self.color_dot_e0_sel = self.palette_color_d[color_palette]['green_sel']
self.color_dot_e1_sel = self.palette_color_d[color_palette]['blue_sel']
self.color_line_e0_sel = self.palette_color_d[color_palette]['green_sel']
self.color_line_e1_sel = self.palette_color_d[color_palette]['blue_sel']
self.set_bg_color()
return None
def delete_obj(self):
"""se elimina el objeto seleccionado"""
if len(self.edit_obj_list_v) > 0:
self.edit_obj_list_v.clear()
self.onEditionChanged = True
return None
def clear(self):
"""Se eliminan todos los objetos existentes"""
if len(self.edit_obj_list_v)>0 or len(self.obj_list_v)>0:
self.edit_obj_list_v.clear()
self.obj_list_v.clear()
self.onEditionChanged = True
return None
def set_bg_color(self):
"""Establezco el color de fondo de pantalla"""
if self.edit_Mode:
self.global_bg_color = self.EM_bg_c
else:
self.global_bg_color = self.UM_bg_c
return None
def coord_screen2coord_canvas(self, screen_pos = (0,0)):
"""Transformo una posición de coordenadas SCREEN en una posicion de coordenadas CANVAS"""
screen_pos = pm.Vector2(screen_pos[0], -screen_pos[1])
canvas_pos = (screen_pos - self.global_pos)/self.global_zoom_factor
return canvas_pos
def coord_canvas2coord_screen(self, canvas_pos = (0,0)):
"""Transformo una posición de coordenadas CANVAS en una posicion de coordenadas SCREEN"""
canvas_pos = pm.Vector2(canvas_pos)
screen_pos = canvas_pos * self.global_zoom_factor + self.global_pos
screen_pos = pm.Vector2(int(round(screen_pos.x)), -int(round(screen_pos.y)))
return screen_pos
def init_display(self, display_size=(0,0), screen_name="Plotter", fullScreen = False):
""" Inicializa pygame y crea un onjeto screen.
display_size: tamaño de la ventana de pygame.
screen_name: Nombre que aparecerá en la ventana abierta
fullScreen: Modo pantalla completa. Inicia en Falso
return: screen"""
pg.init()
display_info = pg.display.Info()
window_size = (display_info.current_w, display_info.current_h)
if self.monitor_size is None:
self.monitor_size = window_size
self.clock = pg.time.Clock()
if fullScreen:
screen = pg.display.set_mode(self.monitor_size, pg.HWSURFACE | pg.FULLSCREEN)
self.update_txt_pos(size=self.monitor_size)
else:
screen = pg.display.set_mode(display_size, pygame.locals.HWSURFACE | pygame.locals.DOUBLEBUF | pygame.locals.RESIZABLE)
self.update_txt_pos(size=display_size)
pg.display.set_caption(screen_name)
return screen
def quit(self):
"""Se cierra Pygame"""
self.is_running = False
return None
def _onEditionChanged(self):
self.update_is_in_window()
self.undo_update()
self.onEditionChanged = False
self.unsave_changes = True
return None
def set_canvas_d_cont_line(self, value):
self.canvas_d_cont_line = value
def get_editor_state(self):
set_plotter = json.dumps({'type':'Plotter',
'set_args_d': {'global_zoom_factor': float(self.global_zoom_factor),
'global_pos': [float(x) for x in self.global_pos],
'canvas_d_cont_line': float(self.canvas_d_cont_line),
}
} )
state_v = [set_plotter]
for o in self.obj_list_v+self.edit_obj_list_v:
state_v.append( o.to_json() )
return state_v
def set_editor_state(self, state_v=[], del_current_state=True):
if self.drawing_junction:
# finalizamos el dibujo de la Junction
self.end_edit_junction()
if del_current_state:
# borramos todos los objetos
self.clear()
for s_str in state_v:
init_d = json.loads(s_str)
obj_class = eval(init_d['type'])
if obj_class == Plotter:
for attr_name in init_d['set_args_d'].keys():
meth = 'set_' + attr_name
value = init_d['set_args_d'][attr_name]
try:
self.__getattribute__(meth)(value)
except Exception as e:
print('WARNING, Plotter: Error al setear el metodo {} del objeto {}. Error: {}. Saltando setear'.format( meth, self, e), file=sys.stderr)
continue
else:
self.obj_list_v.append( obj_class(**init_d['init_args_d'], parent=self) )
self.onEditionChanged = True
return None
def rotate(self, d_angle=5, clockwise=True):
"""Rotación de los objetos seleccionados segun self.rotation_angle
d_angle: salto angular de rotación
clockwise = True: horario
clockwise = False: anti-horario """
to_rotate_v = [o for o in self.edit_obj_list_v + self.obj_list_v]
if len(to_rotate_v) == 0:
return None
if len(to_rotate_v) > 1:
pos_ref = to_rotate_v[0].get_pos()
else:
pos_ref = None
if clockwise:
d_angle = -d_angle
for o in to_rotate_v:
o.rotate(pos_ref=pos_ref, d_angle=d_angle)
self.onEditionChanged = True
return None
def undo_update(self):
if self.onUndoChanged:
self.onUndoChanged = False
return None
state_v = self.get_editor_state()
for s_str in state_v:
init_d = json.loads(s_str)
obj_class = eval(init_d['type'])
if obj_class == Plotter:
state_v.remove(s_str)
break
if len(self.undo_v) != 0 and len(self.undo_v)-1 != self.undo_pointer:
self.undo_v = self.undo_v[:self.undo_pointer+1]
self.undo_v.append(state_v)
self.undo_pointer = len(self.undo_v)-1
return None
def undo(self):
"""Deshace la ultima edición realizada sobre los objetos"""
if self.drawing_junction:
print('WARNING, undo, No es posible desahcer acciones mientras se edita una Line', file=sys.stderr)
return None
if self.undo_pointer > 0:
self.undo_pointer -= 1
self.set_editor_state(self.undo_v[self.undo_pointer])
self.onUndoChanged = True
return None
def redo(self):
"""Rehace la ultima edición realizada sobre los objetos"""
if self.drawing_junction:
print('WARNING, redo, No es posible resahcer acciones mientras se edita una Line', file=sys.stderr)
return None
if self.undo_pointer < len(self.undo_v)-1:
self.undo_pointer += 1
self.set_editor_state(self.undo_v[self.undo_pointer])
self.onUndoChanged = True
return None
def fullScreen_Mode(self):
"""Si "fullScreen is True" activa el modo pantalla completa"""
self.screen = self.init_display(fullScreen=self.fullScreen)
return None
def zoom_in(self):
"""Acerco la vista en la pantalla"""
if self.global_zoom_factor <= self.global_zoomf_max:
self.global_zoom_factor = self.global_zoom_factor*1.25
self.global_pos += pm.Vector2(self.global_pos.x-self.screen_mouse_pos[0], self.global_pos.y+self.screen_mouse_pos[1])*(1.25-1)
self.update_is_in_window()
return None
def zoom_out(self):
"""Alejo la vista en la pantalla"""
if self.global_zoom_factor >= self.global_zoomf_min:
self.global_zoom_factor = self.global_zoom_factor*0.8
self.global_pos += pm.Vector2(self.global_pos.x-self.screen_mouse_pos[0], self.global_pos.y+self.screen_mouse_pos[1])*(0.8-1)
self.update_is_in_window()
return None
def _onSelectionChanged(self):
self.onSelectionChanged = False
return None
def update_display(self):
""" Actualiza los objetos que se dibujan en Screen.
return: None"""
self.clock_tick = self.clock.tick(60)
if self.onSelectionChanged:
self._onSelectionChanged()
if self.onEditionChanged:
self._onEditionChanged()
self.screen.fill(self.global_bg_color)
i_d = 0
for obj in self.obj_list_v:
if obj.is_in_window():
i_d += 1
obj.draw(self.screen)
for obj in self.edit_obj_list_v:
if obj.is_in_window():
i_d += 1
obj.draw(self.screen)
self.n_obj_drawn = i_d
if not self.edit_Mode:
for txt in self.screen_text_v:
txt.draw(self.screen)
elif self.edit_Mode:
for e_txt in self.edit_text_v:
e_txt.draw(self.screen)
if self.debugging_Mode:
for d_txt in self.debug_text_v:
d_txt.draw(self.screen)
pg.display.flip()
return None
def switch_mode(self):
"""Cambio el modo (user/edit)"""
self.edit_Mode = not(self.edit_Mode)
self.set_bg_color()
if self.edit_Mode:
print('EDIT_MODE_ON')
else:
print('EDIT_MODE_OFF')
self.last_time_um = pg.time.get_ticks()
self.deselect_all()
self.using_aux_axes = False
if self.slider is not None:
self.slider.set_visible(not self.edit_Mode)
return None
def drag_view(self):
"""Desplazo la vista en la pantalla"""
self.global_pos += pm.Vector2(self.screen_mouse_dx, -self.screen_mouse_dy)
self.update_is_in_window()
return None
def del_points(self):
for o in self.edit_obj_list_v:
o.del_points()
self.onEditionChanged = True
return None
def drag_pos(self):
"""Desplazo la posición de los objetos seleccionados"""
self.pos_is_dragging = True
if self.click_on_edit_obj:
d_pos = pm.Vector2(self.screen_mouse_dx, -self.screen_mouse_dy) / self.global_zoom_factor
for o in self.edit_obj_list_v:
o.drag(d_pos)
return None
def edit_text(self):
print('Editando:')
## print( self.edit_obj_list_v, type(self.edit_obj_list_v[0]), type(self.edit_obj_list_v[0]) is Line)
if len(self.edit_obj_list_v) == 1 and type(self.edit_obj_list_v[0]) is Line:
self.edit_obj_list_v[0].edit_text()
self.onEditionChanged = True
return None
def change_e(self):
for o in self.edit_obj_list_v:
o.change_e()
self.onEditionChanged = True
return None
def cut_at_point(self):
for o in self.edit_obj_list_v:
new_o = o.cut_at_point()
if new_o is not None:
self.obj_list_v.append(new_o)
self.onEditionChanged = True
return None
def merge_lines(self):
if len(self.edit_obj_list_v) == 2 and type(self.edit_obj_list_v[0]) is Line and type(self.edit_obj_list_v[1] is Line):
self.edit_obj_list_v[0].merge_line(self.edit_obj_list_v[1])
self.edit_obj_list_v.remove(self.edit_obj_list_v[1])
else:
print(' Solo se pude juntar las lineas cuando con dos objetos Line seleccionados.', file=sys.stderr)
return None
def add_mid_point(self):
for o in self.edit_obj_list_v:
if o.add_mid_point() is not None:
self.onEditionChanged = True
return None
def set_line_prop(self, text_prop):
for o in self.obj_list_v + self.edit_obj_list_v:
if type(o) is Line:
o.set_value(text_prop)
self.onEditionChanged = True
return None
def select_all_points(self):
for o in self.edit_obj_list_v:
o.select_all_points()
return None
def default_start(self):
if len(sys.argv) != 1:
parser = argparse.ArgumentParser()
parser.add_argument("ImgFileName",
help="La dirección de la imagen a cargar.",
type=str)
args = parser.parse_args()
image_path = args.ImgFileName
else:
image_path = './samples/CartaA.png'
image_path = None
self.switch_mode()
self.new_image(image_path=image_path)
self.load()
self.switch_helper()
self.undo_update()
self.onEditionChanged = False
return None
def main_loop(self, do_default_start=False):
"""Loop principal"""
n_err_max = 2
n_err = 0
self.onEditionChanged = False
while self.is_running and n_err < n_err_max:
try:
self.event_handler()
if self.debugging_Mode:
pass
self.debug_txt.print('DEBUGGING MODE {}'.format('ON' if self.debugging_Mode else 'OFF'),
'EDIT MODE {}'.format('ON' if self.edit_Mode else 'OFF'),
'{} : {}'.format('Time', pg.time.get_ticks()),
'{} : {:0.2f}'.format('Fps', self.clock.get_fps()),
'{} : {:0.2f}'.format('Tick', self.clock_tick),
'{} : {:.2f}'.format('Zoom factor',self.global_zoom_factor),
'{} : {:d}'.format('obj count', len(self.edit_obj_list_v)+len(self.obj_list_v)),
'{} : {}'.format('Canvas Mouse Pos', self.canvas_mouse_pos),
'{} : {}'.format('Screen Mouse Pos', self.screen_mouse_pos),
'{} : {}'.format('Mouse Helper', 'ON' if self.mouse_helper_on else 'OFF'),
'{} : {}'.format('Delta Cont Line', self.canvas_d_cont_line),
'{} : {}'.format('Objs Drawn', self.n_obj_drawn)
)
self.canvas_mouse_pos = self.coord_screen2coord_canvas(self.screen_mouse_pos)
self.update_display()
if do_default_start:
self.default_start()
do_default_start = False
n_err = 0
except Exception as e:
n_err += 1
print('\n\n\n')
print(' -'*70, file=sys.stderr)
print(' ERROR: ', e, file=sys.stderr)
traceback.print_exc()
print(' Ecurrió un error en el editor. Se guardará un archivo de recuperación. *.ptr.rec', file=sys.stderr)
file_name = self.file_name + '.bak'
with open(file_name, 'w') as f:
f.write( '\n'.join(self.get_editor_state()) )
print(' Archivo "{}" salvado. Para recuperar el trabajo cambie la extensión *.ptr.rec a *.ptr (se recomienda no perder el último salvado *.ptr sin error)'.format(file_name))
print('Ahora se trata de recuperar el editor ...')
if n_err == n_err_max:
print(' Lamentablemente el editor no se pudo recuperar del error, Se procede a terminar el proceso.', file=sys.stderr)
else:
if self.unsave_changes:
Tk().wm_withdraw()
resp = messagebox.askyesno('Cerrando editor ...', 'Desea Salvar los último cambios?')
if resp:
self.save()
pg.quit()
pg.display.quit()
return None
def update_is_in_window(self):
## print('Update_is_in_window')
display_info = pg.display.Info()
window_size = pm.Vector2(display_info.current_w, display_info.current_h)
win_screen_v = [(0,0), (window_size.x, 0), (window_size.x, window_size.y), (0, window_size.y)]
win_canvas_v = [self.coord_screen2coord_canvas(v) for v in win_screen_v]
for o in self.obj_list_v + self.edit_obj_list_v:
o.update_is_in_window(win_canvas_v, win_screen_v)
return None
def add_delta_cont_line(self, canvas_delta_delta=+1):
self.canvas_d_cont_line += canvas_delta_delta
self.canvas_d_cont_line = min(max(0.5, self.canvas_d_cont_line), 10)
return None
def update_mouse_pos(self, pos):
"""Actualizo la posición del mouse en la pantalla"""
self.screen_mouse_dx = pos[0] - self.screen_mouse_pos[0]
self.screen_mouse_dy = pos[1] - self.screen_mouse_pos[1]
self.screen_mouse_pos = pos
return None
def collide(self, collision_pos=(0,0)):
"""Comparo la colision entre los objetos y el punto collision_pos"""
coll_v = self.edit_obj_list_v[::-1] + self.obj_list_v[::-1]
for o in coll_v:
if o.collide(collision_pos):
return o
return None
def select_by_click(self, click_pos=(0,0), add=False):
"""Selecciono el objeto si click_pos es un punto dentro del mismo
add = False: selecciono de a un objeto a la vez
add = True: acumulo los objetos seleccionados"""
to_select_obj_v=[]
for o in (self.obj_list_v + self.edit_obj_list_v):
if o.collide(click_pos):
to_select_obj_v.append( o )
break
self.select(to_select_obj_v, add, click_pos)
return None
def select(self, to_select_obj_v=[], add=False, screen_mouse_pos=None):
"""se seleccionan los objetos de la lista to_select_obj_v"""
if add:
to_select_obj_v += self.edit_obj_list_v
else:
self.deselect_all()
if len(to_select_obj_v) > 0:
for obj in to_select_obj_v:
if not obj.is_Selected():
self.obj_list_v.remove( obj )
self.edit_obj_list_v.append( obj )
self.onSelectionChanged = True
obj.select(screen_mouse_pos)
return None
def deselect(self, click_pos=(0,0)):
"""Deselecciono el objeto si click_pos es un punto dentro del mismo"""
for i_o, o in enumerate(self.edit_obj_list_v):
if o.collide(click_pos):
if o.deselect(click_pos) :
self.obj_list_v.append( self.edit_obj_list_v.pop(i_o) )
self.onSelectionChanged = True
break
return None
def deselect_all(self):
"""Deselecciono todos los objetos seleccionados a la vez"""
if len(self.edit_obj_list_v) > 0:
if self.drawing_junction:
# finalizamos el dibujo de la Junction
self.end_edit_junction()
while len(self.edit_obj_list_v) > 0:
o = self.edit_obj_list_v.pop(0)
self.obj_list_v.append( o )
assert o.deselect(), 'ERROR, el objeto {} no se desseleccinó.'
self.onSelectionChanged = True
return None
def new_image(self, screen_pos=(0,0), image_path='./CartaA.png'):
"""Genero un nuevo objeto Image"""
pos = self.coord_screen2coord_canvas(screen_pos=screen_pos)
new_obj = Image(pos=pos,
filename=image_path,
parent=self)
self.file_name = os.path.splitext( new_obj.get_image_filename() )[0] + '.ptr'
self.obj_list_v.append(new_obj)
self.onEditionChanged = True
return None
def new_junction(self):
"""Genero un nuevo objeto Line"""
new_obj = Line(is_drawing=True, parent=self)
print('creando Line', new_obj)
self.obj_list_v.append(new_obj)
self.onEditionChanged = True
self.select([new_obj])
return new_obj
def extend_junction(self, point):
if len(self.edit_obj_list_v) > 0:
j = self.edit_obj_list_v[0]
j.extend_line(point)
return None
def _start_cont_line(self):
if len(self.edit_obj_list_v) > 0:
j = self.edit_obj_list_v[0]
j.start_continuous_line()
return None
def start_cont_line(self):
self.do_start_cont_line = True
return None
def end_cont_line(self):
self.do_start_cont_line = False
if len(self.edit_obj_list_v) > 0:
j = self.edit_obj_list_v[0]
j.end_continuous_line()
return None
def update_mouse_pos_junction(self, point):
if len(self.edit_obj_list_v) > 0:
j = self.edit_obj_list_v[0]
j.update_mouse_pos(point)
return None
def end_edit_junction(self):
j = self.edit_obj_list_v[0]
j.finish_drawing()
if len(j.points_list) < 2:
self.edit_obj_list_v.pop(0)
print('No se ha creado ninguna Line')
else:
print('Dibujo finalizado', j)
self.drawing_junction = False
self.onEditionChanged = True
self.end_cont_line()
self.using_aux_axes = False
return None
def short_junction(self):
j = self.edit_obj_list_v[0]
j.short_line()
return None
def start_edit_junction(self):
if not self.drawing_junction:
if len(self.edit_obj_list_v) > 1 or (len(self.edit_obj_list_v) == 1 and type(self.edit_obj_list_v[0]) is not Line ):
self.deselect_all()
if len(self.edit_obj_list_v) == 1:
if type(self.edit_obj_list_v[0]) is Line:
j = self.edit_obj_list_v[0]
self.drawing_junction = True
j.start_drawing()
elif len(self.edit_obj_list_v) == 0:
self.drawing_junction = True
j = self.new_junction()
return None
def switch_helper(self):
if self.mouse_helper_on:
for o in self.obj_list_v + self.edit_obj_list_v:
if type(o) is Image:
o.deactivate_mouse_helper()
self.mouse_helper_on = False
else:
for o in self.obj_list_v + self.edit_obj_list_v:
if type(o) is Image:
o.activate_mouse_helper()
self.mouse_helper_on = True
return None
def get_helper_screen_pos(self):
for o in self.obj_list_v + self.edit_obj_list_v:
if type(o) is Image:
return o.get_helper_screen_pos()
print('WARNING, no se encontró una imagen.', file=sys.stderr)
return self.screen_mouse_pos
def get_global_pos(self):
return self.global_pos
def set_global_pos(self, global_pos):
self.global_pos = pm.Vector2(global_pos)
return None
def get_global_zoom_factor(self):
return self.global_zoom_factor
def set_global_zoom_factor(self, global_zoom_factor):
self.global_zoom_factor = global_zoom_factor
return None
def event_handler(self):
"""Lista de comandos para manejar los eventos desde teclado y mouse"""
keys_pressed_v = pg.key.get_pressed()
events_v = pg.event.get()
pressed_ctrl = (keys_pressed_v[pg.K_LCTRL] or keys_pressed_v[pg.K_RCTRL])
pressed_shift = (keys_pressed_v[pg.K_LSHIFT] or keys_pressed_v[pg.K_RSHIFT])
pressed_alt = (keys_pressed_v[pg.K_LALT] or keys_pressed_v[pg.K_RALT])
for event in events_v:
self.slider.react(event)
if event.type == pg.USEREVENT and event.id == 5:
## print('slider move!!!', self.slider.get_slider_value(), event)
self.set_line_prop( self.slider.get_slider_value() )
if event.type == pg.QUIT:
self.quit()
break
elif event.type == pg.VIDEORESIZE and not self.fullScreen:
screen_size = event.dict['size']
self.screen = self.init_display(display_size = screen_size)
# SUELTO UN BOTON DEL MOUSE
elif event.type == pg.MOUSEBUTTONUP:
if self.slider is not None:
self.slider.on_manipulation = False
self.click_on_edit_obj = False
if self.pos_is_dragging:
self.onEditionChanged = True
self.pos_is_dragging = False
if self.drawing_junction:
self.end_cont_line()
# PRESIONO UN BOTON DEL MOUSE
elif event.type == pg.MOUSEBUTTONDOWN:
if self.slider is not None:
self.slider.on_manipulation = True
if self.collide(event.pos) in self.edit_obj_list_v:
self.click_on_edit_obj = True
if self.edit_Mode:
if event.button == 1: # boton izquierdo del mouse
if self.drawing_junction:
self.extend_junction(event.pos)
self.start_cont_line()
# se selecciona el objeto clickeado
elif pressed_ctrl:
self.select_by_click(event.pos, add=True)
else:
self.select_by_click(event.pos, add=False)
elif event.button == 3: # boton derecho del mouse
# se acorta la junction en edición
if self.drawing_junction:
self.short_junction()
# se deselecciona el objeto clickeado
else:
self.deselect(event.pos)
if event.button == 4: # ruedita del mouse hacia arriba
# zoom in
self.zoom_in()
elif event.button == 5: # ruedita del mouse hacia abajo
# zoom out
self.zoom_out()
# MUEVO EL MOUSE
if event.type == pg.MOUSEMOTION:
self.update_mouse_pos(event.pos)
if self.drawing_junction:
self.update_mouse_pos_junction(event.pos)
if self.do_start_cont_line:
self._start_cont_line()
self.do_start_cont_line = False
mouseState = pg.mouse.get_pressed()
if mouseState[1]: # Ruedita apretada
# arrastro lo que se muestra por pantalla
self.drag_view()
elif mouseState[0] and self.edit_Mode and not self.drawing_junction: # Edit_Mode + boton izquierdo del mouse
# arrastro la posición del objeto seleccionado.
## if keys_pressed_v[pg.K_m] or keys_pressed_v[pg.K_c]:
self.drag_pos()
# PRESIONO UNA TECLA
elif event.type == pg.KEYDOWN:
# guardo en un archivo de texto
if event.key == pg.K_s and pressed_ctrl:
self.save()
# activo o desactivo el modo edit
if (event.key == pg.K_F1):
self.switch_mode()
# activo o desactivo el modo debugging
if (event.key == pg.K_F2):
self.debugging_Mode = not(self.debugging_Mode)
if self.debugging_Mode:
print('DEBUGGING_MODE_ON')
else:
print('DEBUGGING_MODE_OFF')
# FullScreen
if (event.key == pg.K_F11):
self.fullScreen = not(self.fullScreen)
self.fullScreen_Mode()
# cambio la paleta de colores
if (event.key == pg.K_F12):
self.color_palette_idx = (self.color_palette_idx + 1)%len(self.color_palette_v)
self.color_palette = self.color_palette_v[self.color_palette_idx]
self.set_color_palette(color_palette=self.color_palette)
# --------------------------------------- MODO EDICIÓN ----------------------------------------
if self.edit_Mode:
# rotación de los objetos seleccionados (anti-horario)
if (event.key == pg.K_r) and pressed_ctrl:
self.rotate(d_angle=30 if pressed_alt else 1, clockwise=not pressed_shift)
elif (event.key == pg.K_e):
self.change_e()
elif (event.key == pg.K_h):
self.switch_helper()
elif (event.key == pg.K_KP_PLUS):
self.add_delta_cont_line(0.5)
elif (event.key == pg.K_KP_MINUS):
self.add_delta_cont_line(-0.5)
elif (event.key == pg.K_c):
self.cut_at_point()
elif (event.key == pg.K_a):
self.add_mid_point()
elif (event.key == pg.K_s) and not pressed_ctrl:
self.select_all_points()
elif (event.key == pg.K_m):
self.merge_lines()
## elif (event.key == pg.K_i):
## print('New Image')
## self.new_image()
elif (event.key == pg.K_l) and not pressed_ctrl:
print('New Line')
self.start_edit_junction()
elif pressed_ctrl:
# dibujo objetos desde un arqchivo de texto
if event.key == pg.K_l:
self.load()
# deshacer/rehacer
if (event.key == pg.K_z):
if keys_pressed_v[pg.K_LSHIFT]:
self.redo()
else:
self.undo()
# elimino los objetos seleccionados
elif event.key == pg.K_DELETE:
self.delete_obj()
# elimino un punto de la linea
elif event.key == pg.K_d:
self.del_points()
# Edito el texto de la linea
elif event.key == pg.K_t:
self.edit_text()
# Deselecciono todos los objetos que estaban seleccionados
elif event.key == pg.K_ESCAPE:
self.deselect_all()
elif self.drawing_junction or self.pos_is_dragging:
if (event.key == pg.K_SPACE) or (event.key == pg.K_RETURN):
# finalizamos el dibujo de la Junction
self.deselect_all()
# --------------------------------------------- MODO USUARIO ---------------------------------------------
elif not self.edit_Mode:
pass
# ----------------------------------------------------------------------------------------------------
return None
def save(self):
print(' Salvando en archivo {0}'.format(self.file_name))
with open(self.file_name, 'w') as f:
f.write( '\n'.join(self.get_editor_state()) )
self.unsave_changes = False
return None
def load(self, del_current_state=True):
"""Cargamos un archivo de salvado."""
if not os.path.exists(self.file_name):
print(' - WARNING, No se encontró el archivo: "{}", no se podrá cargarlo.'.format(self.file_name), file=sys.stderr)
return None
print(' Cargando !!!!')
with open(self.file_name, 'r') as f:
ml_v = f.readlines()
state_v = []
for i_l, s_str in enumerate(ml_v):
try:
i_comment = s_str.find('#')
if i_comment != -1:
s_str = s_str[:i_comment].strip()
s_str = s_str.replace('\n', '')
if len(s_str) > 0:
json.loads(s_str)
state_v.append( s_str )
except Exception as e:
print(' - WARNING, linea número:{} no interpretada en el archivo de salvado: "{}".\n - El error: {}'.format(i_l, s_str, str(e)), file=sys.stderr)
continue
self.set_editor_state(state_v, del_current_state)
# Reseteamos el deshacer
self.undo_pointer = -1
self.undo_v = []
self.onEditionChanged = True
self.mouse_helper_on = False
return None
if __name__ =='__main__':
ptr = Plotter()
ptr.main_loop( do_default_start=True )
print('Programa Finalizado !!!')
| {"/hw_plotter.py": ["/modules/screentext.py", "/modules/thorpymenu.py", "/modules/line.py", "/modules/image.py"], "/modules/line.py": ["/modules/drawable.py"], "/modules/image.py": ["/modules/drawable.py"]} |
70,380 | socom20/handwriting_editor | refs/heads/master | /modules/drawable.py | import pygame as pg
import pygame.locals
import thorpy
import numpy as np
import pygame.math as pm
import pygame.freetype
import sys, os
import json
import pickle
import hashlib as sh
import threading
import time
import inspect
from matplotlib import pyplot as plt
class Drawable():
def __init__(self):
self.pos = pm.Vector2(100.0,100.0)
return None
def whoami(self):
return inspect.stack()[1][3]
def __str__(self):
return self.__repr__()
def edit_text(self):
return None
def is_color_able(self):
"""Retorna si el objeto es coloreable o no"""
return self.color_able
def draw(self, screen):
"""Dibujamos en pantalla el objeto dibujable"""
print("WARNING, Drawable, Método {} no implementado".format(self.whoami()), file=sys.stderr)
return None
def collide(self, screen_mouse_pos):
"""Verifica si existe o no colisión entre mouse y el objeto
Retorna Verdadero si hay colisión
Retorna Falso si no existe colisión"""
print("WARNING, Drawable, Método {} no implementado".format(self.whoami()), file=sys.stderr)
return None
def del_points(self):
return None
def select(self, screen_mouse_pos=None):
"""Se selecciona el objeto
Vuelve Verdadero al flag isSelected"""
self.isSelected = True
return self.isSelected
def change_e(self):
return None
def cut_at_point(self):
return None
def add_mid_point(self):
return None
def select_all_points(self):
return None
def deselect(self, screen_mouse_pos=None):
"""Se deselecciona el objeto
Vuelve Falso al flag isSelected"""
self.isSelected = False
return not self.isSelected
def is_Selected(self):
return self.isSelected
def aline(self, grid_size=10):
"""Se modifica la posición del objeto al punto mas cercano de una grilla cuadrada de ancho = grid_size"""
self.pos = pm.Vector2(grid_size*round(self.pos.x/grid_size),
grid_size*round(self.pos.y/grid_size))
return None
def drag(self, d_pos=pm.Vector2(0.0,0.0)):
""" Mueve self.pos en la dirección de d_pos.
d_pos: Vector2, unidades de canvas.
return: None"""
self.pos += d_pos
return None
def rotate(self, pos_ref=None, d_angle=15):
"""Rota el objeto un d_angle grados con respecto a pos_ref.
Si pos_ref is None, rota con respecto a si mismo"""
print("WARNING, Drawable, Método {} no implementado".format(self.whoami()), file=sys.stderr)
return None
def rescale(self, pos_ref=None, scale_factor=1.0):
"""Modifica las dimensiones del objeto segun una posición de referencia y un factor de escala"""
print("WARNING, Drawable, Método {} no implementado".format(self.whoami()), file=sys.stderr)
return None
def copy(self):
"""Genera una copia del objeto. La copia se posiciona a (150,150) respecto de la posición del objeto origen"""
print("WARNING, Drawable, Método {} no implementado".format(self.whoami()), file=sys.stderr)
return None
def to_json(self):
"""Se exporta a texto un diccionario con todos los argumentos para poder instanciarlo"""
print("WARNING, Drawable, Método {} no implementado".format(self.whoami()), file=sys.stderr)
return None
def set_color(self, color=[(100,125,121)]):
"""Se modifica el color del objeto"""
print("WARNING, Drawable, Método {} no implementado".format(self.whoami()), file=sys.stderr)
return None
def get_color(self):
"""Retorna el color actual del objeto"""
print("WARNING, Drawable, Método {} no implementado".format(self.whoami()), file=sys.stderr)
return None
def set_pos(self, pos):
"""Se modifica la posición del objeto"""
print("WARNING, Drawable, Método {} no implementado".format(self.whoami()), file=sys.stderr)
return None
def get_pos(self):
"""Retorna la posición actual del pipe"""
print("WARNING, Drawable, Método {} no implementado".format(self.whoami()), file=sys.stderr)
return self.pos
def set_angle(self, angle):
"""Se modifica el ángulo de inclinación del objeto"""
print("WARNING, Drawable, Método {} no implementado".format(self.whoami()), file=sys.stderr)
return None
def get_angle(self):
"""Retorna el angulo actual del objeto"""
print("WARNING, Drawable, Método {} no implementado".format(self.whoami()), file=sys.stderr)
return None
def set_description_name(self, description_name):
"""Modificamos el nombre descriptivo"""
print("WARNING, Drawable, Método {} no implementado".format(self.whoami()), file=sys.stderr)
return None
def get_description_name(self):
"""Retorna el nombre descriptivo"""
print("WARNING, Drawable, Método {} no implementado".format(self.whoami()), file=sys.stderr)
return None
def retrieve_corners(self):
"""Retorna los puntos de las esquinas del rectangulo que contiene al objeto"""
print("WARNING, Drawable, Método {} no implementado".format(self.whoami()), file=sys.stderr)
corner_list_v = [pm.Vector2(0.0,0.0) for i in range(4)]
return corner_list_v
def is_in_window(self):
return True
def update_is_in_window(self, win_canvas_v, win_screen_v):
return None
def collide_rect(self, rect_point_v, surface_point_list):
"""Verifica si existe colision o no entre rect_point_v y el objeto"""
obj_corners_v = self.retrieve_corners()
if self.__class__.__name__ is "Line":
# si el rectángulo esta dentro del objeto
if all(self.collide2(p) for p in surface_point_list):
return True
else:
if all(self.collide(p) for p in surface_point_list):
return True
# si la posicion del objeto está adentro del rectángulo
if len(obj_corners_v) > 0:
obj_pos = obj_corners_v[0]
x_min = min(rect_point_v[0].x, rect_point_v[2].x)
x_max = max(rect_point_v[0].x, rect_point_v[2].x)
y_min = min(rect_point_v[0].y, rect_point_v[2].y)
y_max = max(rect_point_v[0].y, rect_point_v[2].y)
if (x_min <= obj_pos.x < x_max) and (y_min <= obj_pos.y < y_max):
return True
# si alguno de los segmentos del objeto intersecta a algun lado del rectángulo
idx_start = -1 if self.__class__.__name__ is not "Junction" else 0
for i_p in range(-1, len(rect_point_v)-1):
p_0 = rect_point_v[i_p]
p_1 = rect_point_v[i_p+1]
p0p1 = p_1 - p_0
for i_r in range(idx_start, len(obj_corners_v)-1):
r_0 = obj_corners_v[i_r]
r_1 = obj_corners_v[i_r+1]
r0r1 = r_1 - r_0
p0r0 = r_0 - p_0
det_a = -p0p1.x*r0r1.y + r0r1.x*p0p1.y
if det_a == 0:
continue
s = (-r0r1.y*p0r0.x + r0r1.x*p0r0.y)/det_a
t = (-p0p1.y*p0r0.x + p0p1.x*p0r0.y)/det_a
if (0 <= s <= 1) and (0 <= t <= 1):
return True
return False
| {"/hw_plotter.py": ["/modules/screentext.py", "/modules/thorpymenu.py", "/modules/line.py", "/modules/image.py"], "/modules/line.py": ["/modules/drawable.py"], "/modules/image.py": ["/modules/drawable.py"]} |
70,381 | socom20/handwriting_editor | refs/heads/master | /modules/line.py | import pygame as pg
import numpy as np
import pygame.math as pm
import sys, os
import json
from modules.drawable import Drawable
class Line(Drawable):
def __init__(self,
text='Empty',
pos=(100.0, 100.0),
txt_size=10,
width=2,
is_drawing=False,
pos_points_list=[],
e_points_list=[],
parent=None):
self.text = text
self.pos = pm.Vector2(*pos)
self.txt_size = txt_size
self.is_drawing = is_drawing
self.pos_points_list = [pm.Vector2(*v) for v in pos_points_list]
self.e_points_list = e_points_list[:]
self.sel_point_list = [False for i in e_points_list]
self.parent = parent
self.width = 2
self.points_list = []
self.values_v = []
self.screen_mouse_point_v = []
self.color_able = False
self.isSelected = False
self.value = 1.0
self.draw_cont_line = False
self.is_in_win = True
assert len(pos_points_list) == len(e_points_list), ' Deben ser iguales: len(pos_points_list) == len(e_points_list)'
self.update_box()
return None
def __repr__(self):
name = 'Line {}'.format(self.text)
return name
def update_mouse_pos(self, screen_point):
if self.is_drawing:
if len(self.screen_mouse_point_v) > 0:
self.screen_mouse_point_v[-1] = screen_point
else:
self.screen_mouse_point_v.append(screen_point)
else:
print('WARNING, Junction, no deberías llamar a este método', file=sys.stderr)
return None
def update(self):
"""Actualizamos la posición de los puntos para contruir las lineas"""
# Modificamos la posición de los vectores de la polilinea
self.points_list = [v + self.pos for v in self.pos_points_list]
return None
def start_drawing(self):
if not self.is_drawing:
self.is_drawing = True
return None
def finish_drawing(self):
if self.is_drawing:
self.is_drawing = False
self.screen_mouse_point_v.clear()
self.update_box()
return None
def start_continuous_line(self):
self.draw_cont_line = True
return None
def end_continuous_line(self):
self.draw_cont_line = False
self.update_box()
return None
def extend_line(self, screen_point, solid=True):
if self.is_drawing:
canvas_point = self.parent.coord_screen2coord_canvas(screen_point)
if len(self.pos_points_list) == 0:
self.pos = canvas_point
diff = canvas_point - self.pos
self.pos_points_list.append(diff)
if solid:
self.e_points_list.append(0)
else:
self.e_points_list.append(1)
if len(self.sel_point_list) > 0:
self.sel_point_list[-1] = False
self.sel_point_list.append(True)
else:
print('WARNING, Junction, no se puede extender la junction si is_drawing == False', file=sys.stderr)
self.update_box()
return None
def short_line(self):
if self.is_drawing:
if len(self.pos_points_list) > 1:
p = self.pos_points_list.pop(-1)
self.e_points_list.pop(-1)
self.sel_point_list.pop(-1)
if len(self.sel_point_list) > 0:
self.sel_point_list[-1] = True
else:
print('WARNING, Junction, no se puede acortar la junction si is_drawing == False', file=sys.stderr)
self.update_box()
return None
def is_in_window(self):
return self.is_in_win or self.is_drawing
def update_is_in_window(self, win_canvas_v, win_screen_v):
## print('update_is_in_window')
self.is_in_win = self.collide_rect(win_canvas_v, win_screen_v)
return None
def draw(self, screen):
"""Dibujamos en pantalla la linea"""
## self.update()
self.draw_line()
## if len(self.points_list) > 1:
## pass
#dibujamos la descripción del esquema
self.draw_name()
return None
def draw_screen_lines(self):
to_draw = []
if len(self.points_list) > 0:
to_draw.append( self.parent.coord_canvas2coord_screen(self.points_list[-1]) )
if self.parent.mouse_helper_on:
to_draw.append( self.parent.get_helper_screen_pos() )
else:
to_draw += self.screen_mouse_point_v
if len( to_draw ) > 1:
pg.draw.lines(self.parent.screen, self.parent.EM_obj_line_selected_c, False, to_draw, self.width)
if self.draw_cont_line:
d_length = np.sqrt( np.square(to_draw[1][0] - to_draw[0][0])+np.square(to_draw[1][1] - to_draw[0][1]) ) / self.parent.global_zoom_factor
## print(d_length)
if d_length > self.parent.canvas_d_cont_line:
self.extend_line(to_draw[1], solid=True)
return None
def draw_line(self):
"""dibujamos la linea de la linea"""
points_list_screen = [self.parent.coord_canvas2coord_screen(v) for v in self.points_list]
if self.parent.edit_Mode:
n_dots = len(points_list_screen)
else:
n_dots = min(len(points_list_screen), max(min(1, len(points_list_screen)), int(self.value * len(points_list_screen))))
if self.parent.global_zoom_factor < 2.0:
zoom_w = 1
else:
zoom_w = 0
for i in range(1, n_dots):
e = self.e_points_list[i]
sel = self.sel_point_list[i]
pos0 = tuple(int(p) for p in points_list_screen[i-1])
pos1 = tuple(int(p) for p in points_list_screen[i])
if sel:
line_width = self.width + 3 + zoom_w
if e == 0:
line_color = self.parent.color_line_e0_sel
else:
line_color = self.parent.color_line_e1_sel
else:
line_width = self.width + zoom_w
if e == 0:
line_color = self.parent.color_line_e0
else:
line_color = self.parent.color_line_e1
pg.draw.line(self.parent.screen, line_color, pos0, pos1, line_width)
if self.parent.global_zoom_factor > 2.0 or n_dots == 1:
for i in range(n_dots):
e = self.e_points_list[i]
sel = self.sel_point_list[i]
pos = tuple(int(p) for p in points_list_screen[i])
if sel:
circle_r = self.width + 4
if e == 0:
dot_color = self.parent.color_dot_e0_sel
else:
dot_color = self.parent.color_dot_e1_sel
else:
circle_r = self.width + 2
if e == 0:
dot_color = self.parent.color_dot_e0
else:
dot_color = self.parent.color_dot_e1
pg.draw.circle(self.parent.screen, dot_color, pos, circle_r, circle_r)
if self.is_drawing:
self.draw_screen_lines()
return None
def draw_name(self):
"""dibujamos el nombre de la linea"""
(x_min, x_max), (y_min, y_max) = self.return_box()
name_angle = 0
name_color = self.parent.color_line_text
name_str = '{}'.format(self.text)
offset_v = pm.Vector2()
offset_v.from_polar( (6, 90) )
name_pos = pm.Vector2(0.5*(x_min + x_max), y_max) + offset_v
name_size = max(0.8*self.txt_size*self.parent.global_zoom_factor, 0.2 * (y_max-y_min) * self.parent.global_zoom_factor)
name_surface, name_rect = self.parent.lowercases_font.render(name_str, name_color, size=name_size)
name_rect.center = self.parent.coord_canvas2coord_screen( name_pos )
self.parent.screen.blit(name_surface, name_rect)
return None
def _collide(self, screen_mouse_pos):
"""Verifica si existe o no colisión entre screen_mouse_pos y el objeto.
Retorna Verdadero si hay colisión
Retorna Falso si no existe colisión"""
canvas_mouse_pos = self.parent.coord_screen2coord_canvas(screen_mouse_pos)
dmin = 5/self.parent.global_zoom_factor
p_list = self.points_list
for i_p in range(len(p_list)):
r = (canvas_mouse_pos - p_list[i_p]).length()
if r < dmin:
return ['dot', i_p]
for i_p in range(len(p_list)-1):
dA = (canvas_mouse_pos - p_list[i_p]).length()
dB = (canvas_mouse_pos - p_list[i_p+1]).length()
dS = (p_list[i_p] - p_list[i_p+1]).length()
touching = dA + dB < dmin + dS
if touching:
return ['line', i_p+1]
return None
def collide2(self, screen_mouse_pos):
"""Verifica si existe o no colisión entre screen_mouse_pos y el objeto.
Retorna Verdadero si hay colisión
Retorna Falso si no existe colisión"""
canvas_mouse_pos = self.parent.coord_screen2coord_canvas(screen_mouse_pos)
points_list = self.retrieve_corners()
p_list = points_list + points_list[:1]
for i_p in range(len(p_list)-1):
dM = canvas_mouse_pos - p_list[i_p]
dp = p_list[i_p+1] - p_list[i_p]
outside = dM.x * dp.y < dM.y * dp.x
if outside:
return False
return True
def collide(self, screen_mouse_pos):
if self._collide(screen_mouse_pos) is None:
return False
else:
return True
def rotate(self, pos_ref=None, d_angle=15):
""" Rota el objeto respecto a pos un ángulo d_angle.
pos_ref: Vector2, centro de rotación, si es None, rota respecto a self.pos
d_angle: float, ángulo en grados
return: None"""
if self.is_drawing:
print('WARNING, junction: No se puede rotar mientras se esta editando la linea.', file=sys.stderr)
return None
angle = d_angle
if pos_ref is not None:
diff = self.pos - pos_ref
diff.rotate_ip(d_angle)
self.pos = pos_ref + diff
while angle >= 360:
angle -= 360
while angle < 0:
angle += 360
# Modificamos el ángulo de los vectores de la polilinea
for v in self.pos_points_list:
v.rotate_ip(angle)
self.update_box()
return None
def to_json(self):
"""Se exporta a texto un diccionario con todas los argumentos para poder instanciarlo"""
to_save = {'type':'Line',
'init_args_d': {'text': self.text,
'pos': [float(x) for x in self.pos],
'txt_size': float(self.txt_size),
'is_drawing': False,
'width': self.width,
'pos_points_list': [[float(x) for x in c] for c in self.pos_points_list],
'e_points_list': [float(x) for x in self.e_points_list]}}
return json.dumps(to_save)
def select(self, screen_mouse_pos=None):
"""Se selecciona el objeto
Vuelve Verdadero al flag isSelected"""
sel_all = False
if screen_mouse_pos is None:
sel_all = True
else:
col = self._collide(screen_mouse_pos)
if col is not None:
if col[0] == 'line':
## sel_all = True
self.sel_point_list[col[1]] = True
else:
self.sel_point_list[col[1]] = True
if sel_all:
for i in range(len(self.sel_point_list)):
self.sel_point_list[i] = True
if any(self.sel_point_list):
self.isSelected = True
else:
self.isSelected = False
return self.isSelected
def deselect(self, screen_mouse_pos=None):
"""Se deselecciona el objeto
Vuelve Falso al flag isSelected"""
if screen_mouse_pos is None:
for i in range(len(self.sel_point_list)):
self.sel_point_list[i] = False
if any(self.sel_point_list):
self.isSelected = True
else:
self.isSelected = False
return not self.isSelected
def drag(self, d_pos=pm.Vector2(0.0,0.0)):
""" Mueve self.pos en la dirección de d_pos.
d_pos: Vector2, unidades de canvas.
return: None"""
for i in range(len(self.sel_point_list)):
if self.sel_point_list[i]:
self.pos_points_list[i] += d_pos
if len(self.pos_points_list) > 0 and self.pos_points_list[0].x != 0 and self.pos_points_list[0].y != 0:
self.pos += d_pos
for i_p in range(len(self.pos_points_list)):
self.pos_points_list[i_p] -= d_pos
self.update_box()
return None
def change_e(self):
for i_p in range(len(self.sel_point_list)):
if self.sel_point_list[i_p]:
self.e_points_list[i_p] = not self.e_points_list[i_p]
self.update_box()
return None
def del_points(self):
for i_p in range(len(self.sel_point_list)-1, -1, -1):
if self.sel_point_list[i_p]:
self.pos_points_list.pop(i_p)
self.e_points_list.pop(i_p)
self.sel_point_list.pop(i_p)
if len(self.pos_points_list) > 0 and self.pos_points_list[0].x != 0 and self.pos_points_list[0].y != 0:
d_pos = self.pos_points_list[0]
self.pos += d_pos
for i_p in range(len(self.pos_points_list)):
self.pos_points_list[i_p] -= d_pos
self.update_box()
return None
def cut_at_point(self):
if sum(1 if i else 0 for i in self.sel_point_list) != 1:
print(' - WARNING, cut_at_point: Solo se puede cortar si hay un solo punto seleccionado.', file=sys.stderr)
return None
if len(self.sel_point_list) > 0 and (self.sel_point_list[0] or self.sel_point_list[-1]):
print(' - WARNING, cut_at_point: No se puede cortar si se seleccionan los puntos de los extremos.', file=sys.stderr)
return None
for i_p in range(len(self.sel_point_list)):
if self.sel_point_list[i_p]:
pos_new = self.pos_points_list[i_p] + self.pos
pos_points_list_new = [self.pos_points_list[i] - self.pos_points_list[i_p] for i in range(i_p, len(self.pos_points_list))]
e_points_list_new = [self.e_points_list[i] for i in range(i_p, len(self.e_points_list))]
new_line = Line(text=self.text,
pos=pos_new,
txt_size=self.txt_size,
width=self.width,
is_drawing=False,
pos_points_list=pos_points_list_new,
e_points_list=e_points_list_new,
parent=self.parent)
self.pos_points_list = self.pos_points_list[:i_p]
self.e_points_list = self.e_points_list[:i_p]
self.sel_point_list = self.sel_point_list[:i_p]
self.update_box()
return new_line
self.update_box()
return None
def merge_line(self, line):
d_pos = line.pos - self.pos
pos_points_list_new = [p + d_pos for p in line.pos_points_list]
self.pos_points_list += pos_points_list_new
line.e_points_list[0] = 1
self.e_points_list += line.e_points_list
self.sel_point_list += line.sel_point_list
self.text += ' ' + line.text
self.update_box()
return None
def add_mid_point(self):
if len(self.sel_point_list) > 0 and self.sel_point_list[0]:
self.sel_point_list[0] = False
to_ret = None
for i_p in range(len(self.sel_point_list)-1,-1,-1):
if self.sel_point_list[i_p]:
pos_new = 0.5 * (self.pos_points_list[i_p] + self.pos_points_list[i_p-1])
self.pos_points_list = self.pos_points_list[:i_p] + [pos_new] + self.pos_points_list[i_p:]
self.e_points_list = self.e_points_list[:i_p] + [0] + self.e_points_list[i_p:]
self.sel_point_list = self.sel_point_list[:i_p] + [True] + self.sel_point_list[i_p:]
to_ret = True
self.update_box()
return to_ret
def select_all_points(self):
for i_p in range(len(self.sel_point_list)):
self.sel_point_list[i_p] = True
return None
def get_width(self):
return self.width
def edit_text(self):
print('\n\n')
print(' - Editando Texto!!!')
print(' Texto anterior: {}'.format(self.text))
text = input('Entre el texto de la linea (Presione ENTER al finalizar):\n >>> ')
self.set_text(text)
print('OK!"')
return None
def set_text(self, text):
"""Modificamos el nombre descriptivo"""
self.text = str(text)
return None
def get_text(self):
"""Retorna el nombre descriptivo"""
return self.text
def set_pos(self, pos):
"""Se modifica la posición de la linea"""
self.pos = pm.Vector2(*pos)
self.update_box()
return None
def get_pos(self):
"""Retorna la posición actual de la linea"""
return self.pos
def get_angle(self):
"""Retorna el angulo actual de la linea"""
return self.angle
def update_box(self):
## print('update_box')
self.update()
x_coords = [p.x for p in self.points_list]
y_coords = [p.y for p in self.points_list]
self.box_coords = (min(x_coords,default=0), max(x_coords,default=0)), (min(y_coords,default=0), max(y_coords,default=0))
return None
def return_box(self):
return self.box_coords
def retrieve_corners(self):
"""Retorna la lista de puntos que rodean a la linea."""
(x_min, x_max), (y_min,y_max) = self.return_box()
points_list_v = [pm.Vector2(x_min, y_min),
pm.Vector2(x_min, y_max),
pm.Vector2(x_max, y_max),
pm.Vector2(x_max, y_min)]
return points_list_v
def set_value(self, value=1.0):
self.value = max(0.0, min(1.0, float(value)))
return None
| {"/hw_plotter.py": ["/modules/screentext.py", "/modules/thorpymenu.py", "/modules/line.py", "/modules/image.py"], "/modules/line.py": ["/modules/drawable.py"], "/modules/image.py": ["/modules/drawable.py"]} |
70,382 | socom20/handwriting_editor | refs/heads/master | /modules/screentext.py | import pygame as pg
import numpy as np
import pygame.math as pm
import sys, os
class ScreenText:
"""Esta clase controla el texto que será mostrado por pantalla"""
def __init__(self,
rel_pos=(0,0),
abs_off=(100,-50),
scale=1.0,
color=(243,207,122),
text='colocar texto aqui',
f_updater=(lambda self: None),
parent=None):
self.rel_pos = pm.Vector2(rel_pos)
self.abs_off = pm.Vector2(abs_off)
self.scale = scale
self.f_updater = f_updater
self.text = text
self.parent = parent
self.color = color
self.update_pos( self.parent.screen_size )
return None
def update(self):
self.f_updater(self)
return None
def print(self, *args_v, sep='\n'):
self.text = sep.join([a if type(a) is str else repr(a) for a in args_v])
return None
def draw(self, screen):
self.update()
for i, text in enumerate(self.text.split('\n')):
self.color = self.parent.screen_txt_c
text_surface, rect = self.parent.myfont.render(text, self.color)
self.parent.screen.blit(text_surface, self.pos+pm.Vector2(0, 20*i))
return None
def update_pos(self, screen_size):
self.pos = pm.Vector2(screen_size[0] * self.rel_pos[0] + self.abs_off[0],
screen_size[1] * self.rel_pos[1] + self.abs_off[1])
return None
| {"/hw_plotter.py": ["/modules/screentext.py", "/modules/thorpymenu.py", "/modules/line.py", "/modules/image.py"], "/modules/line.py": ["/modules/drawable.py"], "/modules/image.py": ["/modules/drawable.py"]} |
70,383 | socom20/handwriting_editor | refs/heads/master | /modules/image.py | import pygame as pg
import numpy as np
import pygame.math as pm
import sys, os
import json
import cv2
import skimage.morphology
import skimage.filters
from modules.drawable import Drawable
class Image(Drawable):
def __init__(self,
pos=(0.0, 0.0),
angle=0.0,
filename='./CartaA.png',
scale=1.0,
parent=None):
self.pos = pm.Vector2(*pos)
self.angle = angle
self.filename = filename
self.scale = scale
self.parent = parent
self.run_helper = False
self.blit_helper = False
self.helper_p_min_v = pm.Vector2(0,0)
self.helper_win_size = (80,80)
self._calc_helper_dist_matrixes()
self.last_angle = None
self.last_zoom = None
self.last_mode = None
if self.filename is not None and not os.path.exists(self.filename) and os.path.exists(self.parent.image_path):
self.filename = self.parent.image_path
while self.filename is None or self._load_image() == False:
self._ask_image_path()
if self.filename == '':
print(' - WARNING: Se canceló la operación de apertura de imagen.', file=sys.stderr)
self.parent.quit()
break
return None
def _calc_helper_dist_matrixes(self):
m_shape = self.helper_win_size[::-1]
assert m_shape[0] % 2 == 0 and m_shape[1] % 2 == 0, ' - ERROR, _calc_helper_dist_matrixes: helper_win_size must be even.'
self.helper_idx_m = np.concatenate([ np.repeat(np.arange(m_shape[0])[:,np.newaxis], m_shape[1], axis=-1)[...,np.newaxis], np.repeat(np.arange(m_shape[1])[np.newaxis,:], m_shape[0], axis=0)[...,np.newaxis]], axis=-1)
self.helper_d_m = np.sqrt(np.square(self.helper_idx_m[...,0] - (m_shape[0]-1)/2) +np.square(self.helper_idx_m[...,1] - (m_shape[1]-1)/2))
return None
def _load_image(self):
try:
self.img_array = cv2.imread(self.filename)[..., ::-1]
## print('Image shape:', self.img_array.shape)
self.original_size_v = self.img_array.shape[1::-1]
self.parent.image_path = self.filename
return True
except:
print(' - WARNING, Image, no se pudo abrir la imagen:', self.filename, file=sys.stderr)
return False
def get_image_filename(self):
return self.filename
def _ask_image_path(self, use_tk=True):
if use_tk:
from tkinter import Tk
from tkinter import filedialog
Tk().wm_withdraw()
self.filename = filedialog.askopenfilename(initialdir = "./",title = "Abriendo imagen a editar",filetypes = (("Image files", "*.jpg *.jpeg *.png *.bmp *.gif"), ("jpeg files","*.jpg"),("png files","*.png"),("bmp files","*.bmp"),("gif files","*.gif"),("all files","*.*")))
else:
self.filename = input(' - Entre la dirección de la imagen a utilizar: ')
return None
def __repr__(self):
name = 'IMAGE {}'.format(self.filename)
return name
def rotate_bound(self, image, angle=0.0, zoom=1.0, borderValue=(0,0,0)):
# grab the dimensions of the image and then determine the
# center
(h, w) = image.shape[:2]
(cX, cY) = (w // 2, h // 2)
# grab the rotation matrix (applying the negative of the
# angle to rotate clockwise), then grab the sine and cosine
# (i.e., the rotation components of the matrix)
M = cv2.getRotationMatrix2D((cX, cY), -angle, zoom)
cos = np.abs(M[0, 0])
sin = np.abs(M[0, 1])
# compute the new bounding dimensions of the image
nW = int((h * sin) + (w * cos))
nH = int((h * cos) + (w * sin))
# adjust the rotation matrix to take into account translation
M[0, 2] += (nW / 2) - cX
M[1, 2] += (nH / 2) - cY
# perform the actual rotation and return the image
return cv2.warpAffine(image, M, (nW, nH), borderValue=borderValue)
def proc_array_helper(self, array_helper):
array_proc = array_helper.mean(axis=-1).astype(np.uint8)
img_th = skimage.filters.threshold_yen(array_proc, nbins=256)
array_proc = (array_proc < img_th ).astype(np.uint8)
array_proc = skimage.morphology.erosion(array_proc, skimage.morphology.square(4))
## array_proc = skimage.morphology.medial_axis(array_proc,
## mask=None,
## return_distance=False)
array_proc_bool = np.array(array_proc, dtype=np.bool)
array_proc = np.repeat(255*array_proc[...,np.newaxis], 3, axis=-1).astype(np.uint8)
return array_proc, array_proc_bool
def activate_mouse_helper(self, do_blit=True):
self.run_helper = True
self.blit_helper = do_blit
return None
def deactivate_mouse_helper(self):
self.run_helper = False
self.blit_helper = False
self.helper_p_min_v = pm.Vector2(0,0)
return None
def draw_win_helper(self, array_cuted, blit_pos):
H2_win, W2_win = self.helper_win_size[0]//2, self.helper_win_size[1]//2
W_m, H_m = self.parent.screen_mouse_pos
H_m_a, W_m_a = int(H_m - blit_pos[1]), int(W_m - blit_pos[0])
W_a, H_a = array_cuted.shape[:2]
if H2_win <= H_m_a <= H_a-H2_win and W2_win <= W_m_a <= W_a-W2_win:
W_s, H_s = self.parent.screen.get_size()
## # Blit button right
## blit_pos_helper = pm.Vector2(W_s-self.helper_win_size[1], H_s-self.helper_win_size[0])
# Mouse Pos
blit_pos_helper = pm.Vector2(W_m+W2_win, H_m+H2_win)
## blit_pos_helper = pm.Vector2(W_m-W2_win, H_m-H2_win)
t_h = H_m_a - H2_win
b_h = H_m_a + H2_win
l_h = W_m_a - W2_win
r_h = W_m_a + W2_win
array_helper = array_cuted[l_h:r_h, t_h:b_h]
array_proc, array_proc_bool = self.proc_array_helper(array_helper)
sequ_v = self.helper_d_m[array_proc_bool]
if sequ_v.shape[0] > 0:
i_min = np.argmin( sequ_v )
p_min_v = self.helper_idx_m[array_proc_bool][i_min]
## print('if:', p_min_v)
else:
p_min_v = np.array( [W2_win, H2_win] )
## print('else:', p_min_v)
self.helper_p_min_v = ( int(p_min_v[0] - W2_win), int(p_min_v[1] - H2_win) )
if self.blit_helper:
# Pintamos un poco
array_proc[p_min_v[0]-2:p_min_v[0]+3, p_min_v[1]-2:p_min_v[1]+3] = np.array( (255,0,0) )
img_helper = pg.surfarray.make_surface(array_proc)
self.parent.screen.blit(img_helper, blit_pos_helper)
pg.draw.circle(self.parent.screen, (255,0,0), self.get_helper_screen_pos(), 3, 3)
return None
def get_helper_screen_pos(self):
return (int(self.parent.screen_mouse_pos[0] + self.helper_p_min_v[0]),
int(self.parent.screen_mouse_pos[1] + self.helper_p_min_v[1]))
def get_pos(self):
"""Retorna la posición actual del pipe"""
return self.pos
def draw_image(self):
""" Plotea la imagene en el objeto screen."""
## self.angle += 1.0
## self.pos += pm.Vector2(1.0,0.0)
zoom = self.scale*self.parent.global_zoom_factor
## new_size_v = tuple(int(zoom * s) for s in self.original_size_v)
if self.last_zoom != zoom or self.angle != self.last_angle or self.parent.edit_Mode != self.last_mode:
if self.parent.edit_Mode:
borderValue = self.parent.EM_bg_c
else:
borderValue = self.parent.UM_bg_c
# Image Rotation + scale
## image_center = (0.0,0.0)
## rot_mat = cv2.getRotationMatrix2D(image_center, self.angle, zoom)
## self.img_to_plot = cv2.warpAffine(self.img_array, rot_mat, new_size_v, flags=cv2.INTER_CUBIC)
self.array_to_plot = self.rotate_bound(self.img_array, angle=self.angle, zoom=zoom, borderValue=borderValue)
self.array_to_plot = np.transpose(self.array_to_plot, [1,0,2])
self.d_screen_pos = pm.Vector2( self.array_to_plot.shape[0]//2, self.array_to_plot.shape[1]//2)
self.last_zoom = zoom
self.last_angle = self.angle
self.last_mode = self.parent.edit_Mode
blit_pos = self.parent.coord_canvas2coord_screen(self.pos) - self.d_screen_pos
W, H, C = self.array_to_plot.shape
t = int(blit_pos[1])
## b = t + H
l = int(blit_pos[0])
## r = l + W
W_s, H_s = self.parent.screen.get_size()
t_s = -t
b_s = t_s + H_s
l_s = -l
r_s = l_s + W_s
t_i = min(max(0, t_s), H)
b_i = max(min(H, b_s), 0)
l_i = min(max(0, l_s), W)
r_i = max(min(W, r_s), 0)
## print('S:',t_s, b_s, l_s, r_s)
## print('I:',t_i, b_i, l_i, r_i, 'SS:', (W_s, H_s))
if l_i != r_i and t_i != b_i:
array_cuted = self.array_to_plot[l_i:r_i, t_i:b_i]
img_cuted = pg.surfarray.make_surface(array_cuted)
blit_pos += pm.Vector2(l_i, t_i)
self.parent.screen.blit(img_cuted, blit_pos)
if self.run_helper:
self.draw_win_helper(array_cuted, blit_pos)
## self.img_to_plot = pg.surfarray.make_surface(self.array_to_plot)
## self.parent.screen.blit(self.img_to_plot, blit_pos)
return None
def collide(self, screen_mouse_pos):
return False
def draw(self, screen):
"""Dibujamos en pantalla la imagen"""
self.draw_image()
return None
def rotate(self, pos_ref=None, d_angle=15):
""" Rota el objeto respecto a pos un ángulo d_angle.
pos_ref: Vector2, centro de rotación, si es None, rota respecto a self.pos
d_angle: float, ángulo en grados
return: None"""
self.angle -= d_angle
if pos_ref is not None:
diff = self.pos - pos_ref
diff.rotate_ip(d_angle)
self.pos = pos_ref + diff
while self.angle >= 360:
self.angle -= 360
while self.angle < 0:
self.angle += 360
return None
def to_json(self):
"""Se exporta a texto un diccionario con todas los argumentos para poder instanciarlo"""
to_save = {'type':'Image',
'init_args_d': {'pos': [float(x) for x in self.pos],
'angle': float(self.angle),
'filename': str(self.filename),
'scale': float(self.scale),
} }
return json.dumps(to_save)
if __name__ == '__main__':
img = Image()
| {"/hw_plotter.py": ["/modules/screentext.py", "/modules/thorpymenu.py", "/modules/line.py", "/modules/image.py"], "/modules/line.py": ["/modules/drawable.py"], "/modules/image.py": ["/modules/drawable.py"]} |
70,384 | socom20/handwriting_editor | refs/heads/master | /modules/thorpymenu.py | import pygame as pg
import numpy as np
import pygame.math as pm
import sys, os
import thorpy
class ThorpyMenu:
def __init__(self, rel_pos=(1, 0), abs_off=(0, 0), rank=(0,2000), name='SimTime', parent=None):
self.rel_pos = pm.Vector2(rel_pos)
self.rel_pos_visible = self.rel_pos
self.rel_pos_invisible = pm.Vector2(1,1)
self.abs_off = pm.Vector2(abs_off)
self.parent = parent
self.rank = rank
self.name = name
self.slider = None
self.visible = True
self.on_manipulation = False
self.update_pos( pm.Vector2(self.parent.screen_size) )
return None
def react(self, event):
self.menu.react(event)
return None
def create_menu(self, screen_size):
## print(screen_size, screen_size[0] - 2*self.abs_off[0])
# Colocamos el Slider
self.slider = thorpy.SliderX.make(screen_size[0] - 2*self.abs_off[0] - 130, self.rank, self.name)
## self.button = thorpy.make_button("Quit", func=thorpy.functions.quit_func)
self.box = thorpy.Box.make(elements=[self.slider])
self.menu = thorpy.Menu(self.box)
for element in self.menu.get_population():
element.surface = self.parent.screen
self.set_slider_value(100.0)
return None
def set_slider_rank(self, rank=(0.0, 2000.0)):
self.rank = rank
self.update_pos( pm.Vector2(self.parent.screen.get_size()) )
return None
def get_slider_value(self, value=0.0):
if self.slider is not None:
v = self.slider.get_value()
else:
v = 0.0
return v
def set_slider_value(self, value=0.0):
self.slider.set_value(value)
return None
def update_pos(self, screen_size):
v = self.get_slider_value()
self.create_menu(screen_size)
self.set_slider_value(v)
self.pos = pm.Vector2(screen_size[0] * self.rel_pos[0] + self.abs_off[0],
screen_size[1] * self.rel_pos[1] + self.abs_off[1])
self.box.set_topleft( self.pos )
return None
def set_visible(self, is_visible=True):
self.visible = is_visible
if self.visible:
self.rel_pos = self.rel_pos_visible
else:
self.rel_pos = self.rel_pos_invisible
self.update_pos(self.parent.screen.get_size())
return None
def get_visible(self, is_visible=True):
return self.visible
def draw(self, screen):
if self.visible:
self.box.blit()
self.box.update()
return None
| {"/hw_plotter.py": ["/modules/screentext.py", "/modules/thorpymenu.py", "/modules/line.py", "/modules/image.py"], "/modules/line.py": ["/modules/drawable.py"], "/modules/image.py": ["/modules/drawable.py"]} |
70,396 | leonidaas/motivatorbot | refs/heads/master | /quotes_crawler.py | import requests
from bs4 import BeautifulSoup as BS
import random
import json
class Crawler:
def __init__(self):
print("Crawler wurde angestoßen")
self.url = 'https://www.brainyquote.com/topics/motivational'
self.quotes = list()
self.source = requests.get(self.url)
plain_text = self.source.text
self.cid = 0
self.counter = 1
obj = BS(plain_text, "html5lib")
for a in obj.find_all('a', {'title': 'view quote'}):
#print (a.text)
self.quotes.append(
a.text
)
def getRandomQuote(self):
quote = self.quotes[random.randint(0, len(self.quotes))]
while len(quote) == 0:
quote = self.quotes[random.randint(0, len(self.quotes))]
return quote
def fetchQuotes(self):
print("fetching quotes..")
self.quotes.clear()
self.source = requests.get(self.url)
plain_text = self.source.text
obj = BS(plain_text, "html5lib")
for a in obj.find_all('a', {'title': 'view quote'}):
self.quotes.append(
a.text
)
self.counter = 1
def fetchMoreQuotes(self):
print("scrolling down the page")
self.api = "https://www.brainyquote.com/api/inf"
self.data = {}
self.data['typ'] = "topic"
self.data['langc'] = "en"
self.data['v'] = "8.5.4:3062111"
self.data['ab'] = "b"
self.data['pg'] = self.counter
self.data['id'] = "t:132622"
self.data['vid'] = "7b363d749b4c7c684ace871c8a75f8e6"
self.data['fdd'] = "d"
self.data['m'] = 0
self.source = requests.request(method="get", url=self.api, json=self.data)
print(self.source)
self.counter += 1
obj2 = BS(self.source.content, "html5lib")
stringToSlice = str(obj2)
finishedString = stringToSlice[50:len(obj2.text) - 16]
soup = BS(finishedString, "html5lib")
for a in soup.find_all('a', {'class', '\\"b-qt'}):
self.quotes.append(
a.text
)
def printAllQuotes(self):
for q in self.quotes:
print(q)
| {"/HappyBot.py": ["/quotes_crawler.py"]} |
70,397 | leonidaas/motivatorbot | refs/heads/master | /HappyBot.py | from telegram.ext import Updater, CommandHandler, MessageHandler, Filters, InlineQueryHandler
from telegram import InlineQueryResultArticle, InputTextMessageContent
from quotes_crawler import Crawler
import logging
logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO)
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
crawler = Crawler()
cid = int(454323424)
print("HappyBot wurde instanziiert")
updater = Updater(token='785333374:AAGiHCETBBEwIBJUY_qaYGrnIAbttBqqQn8')
job = updater.job_queue
dispatcher = updater.dispatcher
#answer section
def start(bot, update):
crawler.cid = update.message.chat_id
job.run_repeating(callback_quote, interval=1800, first=0)
bot.send_message(chat_id=update.message.chat_id, text="Hi, ich bin Leons persönlicher Bot. Ich helfe ihm dabei fokusiert und motiviert zu bleiben")
def unknown(bot, update):
bot.send_message(chat_id=update.message.chat_id, text="Den Command habe ich nicht im Repertoire, hörma!")
def caps(bot, update, args):
text_caps = ' '.join(args).upper()
bot.send_message(chat_id=update.message.chat_id, text=text_caps)
def quote(bot, update):
bot.send_message(chat_id=update.message.chat_id, text=crawler.getRandomQuote())
def fetch(bot, update):
crawler.fetchQuotes()
print(len(crawler.quotes))
bot.send_message(chat_id=update.message.chat_id, text="Ich besorch mal eben neue Quotes!")
def fetchMore(bot, update):
crawler.fetchMoreQuotes()
print(len(crawler.quotes))
bot.send_message(chat_id=update.message.chat_id, text="Ich scroll mal bissale nunder!")
def callback_quote(bot, job):
print("message sent")
quote = crawler.getRandomQuote()
crawler.fetchMoreQuotes()
bot.send_message(chat_id=crawler.cid, text=quote)
def showQuotes(bot, update):
for q in crawler.quotes:
print(q)
dispatcher.add_handler(CommandHandler("start", start))
dispatcher.add_handler(CommandHandler("caps", caps, pass_args=True))
dispatcher.add_handler(CommandHandler("quote", quote))
dispatcher.add_handler(CommandHandler("fetch", fetch))
dispatcher.add_handler(CommandHandler("fetchMore", fetchMore))
dispatcher.add_handler(CommandHandler("showQuotes", showQuotes))
# this must be the last argument so it goes through all commands
dispatcher.add_handler(MessageHandler(Filters.command, unknown))
updater.start_polling()
updater.idle()
| {"/HappyBot.py": ["/quotes_crawler.py"]} |
70,402 | nthuepl/On-Pen-handwritten-Word-Recognition-Using-Long-Short-Term-Memory-Model | refs/heads/master | /QTGraph.py | from pyqtgraph.Qt import QtGui, QtCore
import pyqtgraph as pg
from scipy.signal import butter, lfilter, freqz, argrelextrema
import numpy as np
import threading
import time
import sys
streams = list()
# numpy parameters
order = 2
fs = 100.0
cutoff = 1.8
def butter_lowpass(cutoff, fs, order=5):
nyq = 0.5 * fs
normal_cutoff = cutoff / nyq
b, a = butter(order, normal_cutoff, btype='low', analog=False)
return b, a
def butter_lowpass_filter(data, cutoff, fs, order=5):
b, a = butter_lowpass(cutoff, fs, order=order)
y = lfilter(b, a, data)
return y
class myQWidget(QtGui.QWidget):
def __init__(self):
super(myQWidget, self).__init__()
def keyPressEvent(self, e):
if e.key() == QtCore.Qt.Key_Enter or e.key() == QtCore.Qt.Key_Space:
self.event.set()
def setKeyPressTarget(self, thread, evt):
self.kpThread = thread
self.event = evt
self.kpThread.start()
class QTGraph():
def __init__(self, sources, sourcesName, sourcesNum=1, title='curve graph',\
width=600, height=600, x_range=500, y_range=1, y_central=0.5, lock=None, lowpass=False):
# set data sources
self.title = title
self.sources = sources
self.sourcesName = sourcesName
self.sourcesNum = sourcesNum
self.lock = lock
# graph configure
self.width = width
self.height = height
self.x_range = x_range
self.y_range = y_range
self.y_central = y_central
self.x_coordinate = [i for i in range(self.x_range)]
self.app = QtGui.QApplication(sys.argv)
self.mainWindow = QtGui.QMainWindow()
self.mainWindow.setWindowTitle(self.title)
self.mainWindow.resize(self.width, self.height)
self.mainWidget = myQWidget()
self.mainWindow.setCentralWidget(self.mainWidget)
self.layout = QtGui.QVBoxLayout()
self.mainWidget.setLayout(self.layout)
# curve in plot widgets configure
self.showLowPass = lowpass
self.curves = []
for i in range(self.sourcesNum):
plotWidget = pg.PlotWidget(name=self.sourcesName[i])
plotWidget.setXRange(0, self.x_range)
plotWidget.setYRange(self.y_central-float(self.y_range)/2, self.y_central+float(self.y_range)/2)
self.layout.addWidget(plotWidget)
curve = plotWidget.plot()
self.curves.append(curve)
def update(self):
if self.lock != None:
self.lock.acquire()
for src, curve in zip(self.sources, self.curves):
if len(src) < self.x_range:
fill = [np.NAN for i in range(self.x_range-len(src))]
if self.showLowPass == False:
curve.setData(y=fill+src, x=self.x_coordinate)
else:
disp = butter_lowpass_filter(src, cutoff, fs, order)
curve.setData(y=fill+disp.tolist(), x=self.x_coordinate)
else:
if self.showLowPass == False:
curve.setData(y=src, x=self.x_coordinate)
else:
disp = butter_lowpass_filter(src, cutoff, fs, order)
curve.setData(y=disp.tolist(), x=self.x_coordinate)
if self.lock != None:
self.lock.release()
# self.app.processEvents()
def show(self, animate=False):
self.mainWindow.show()
if animate:
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.update)
self.timer.start(50)
self.app.instance().exec_()
else:
self.update()
self.app.instance().exec_()
def close(self):
self.app.closeAllWindows()
self.app.quit()
def setTask(self, thread, evt):
self.mainWidget.setKeyPressTarget(thread, evt)
if __name__ == '__main__':
# files = ['ax.txt', 'ay.txt', 'az.txt']
# fps = [open(file, 'r') for file in files]
# for file, fp in zip(files,fps):
# print(file)
# stream = list()
# for line in fp.readlines():
# stream += [float(x) for x in line.split(' ')]
# fp.close()
# streams.append(stream)
import argparse
import json
import math
parser = argparse.ArgumentParser(description='process input parameters')
parser.add_argument('fn', help='input the filename you want to show', type=str)
args = parser.parse_args()
filename = args.fn
fp = open(filename, 'r')
word = filename.split('.')[0].split('/')[-1]
jsdata = json.loads(fp.read())
fp.close()
valid_curve_length = min( [ len(c) for c in [ jsdata["gx"], jsdata["gy"], jsdata["gz"] ] ] )
resultant_gyro = [ math.sqrt( jsdata["gx"][i]**2 + jsdata["gy"][i]**2 + jsdata["gz"][i]**2 ) for i in range( valid_curve_length ) ]
streams.append(resultant_gyro)
qtGraph = QTGraph(streams, [filename], 1, x_range=max([len(l) for l in streams]))
qtGraph.show(animate=False)
qtGraph.close()
| {"/spell.py": ["/Levenshtein.py"], "/Corrector.py": ["/spell.py", "/Levenshtein.py"], "/LSTMsocket.py": ["/preprocess.py", "/Corrector.py", "/Levenshtein.py"]} |
70,403 | nthuepl/On-Pen-handwritten-Word-Recognition-Using-Long-Short-Term-Memory-Model | refs/heads/master | /spell.py | import re
import math
from Levenshtein import levenshtein
from collections import Counter
def words(text): return re.findall(r'\w+', text.lower())
WORDS = Counter(words(open('20k.txt').read()))
default_MSR = {'i':0.2, 'n':0.1, 'other':0.01}
default_dw = 0.133
def P(word, N=sum(WORDS.values())):
"Probability of `word`."
return WORDS[word] / N
def MSP(src, word, MSR=default_MSR, distance_weight=default_dw):
p = 1
p *= math.pow(distance_weight, levenshtein(src, word, len_weight=1))
for ch in set(word)-(set(word) & set(src)):
if ch in MSR.keys():
p *= MSR[ch]
else:
p *= MSR['other']
return p
def correction(word, MSR=default_MSR, distance_weight=default_dw):
"Most probable spelling correction for word."
# return max(candidates(word), key=P)
p_contribution = {}
# p_contribution = [MSP(word, candidate) for candidate in candidates(word)]
for candidate in candidates(word):
p_contribution[candidate] = MSP(word, candidate, MSR=MSR, distance_weight=distance_weight)
for candidate, p in p_contribution.items():
if p is max(p_contribution.values()):
return candidate
def candidates(word):
"Generate possible spelling corrections for word."
return (known([word]) | known(edits1(word)) | known(edits2(word)))
def known(words):
"The subset of `words` that appear in the dictionary of WORDS."
return set(w for w in words if w in WORDS)
def edits1(word):
"All edits that are one edit away from `word`."
letters = 'abcdefghijklmnopqrstuvwxyz'
similars = {'m':'n', 'j':'i'}
splits = [(word[:i], word[i:]) for i in range(len(word) + 1)]
deletes = [L + R[1:] for L, R in splits if R]
# transposes = [L + R[1] + R[0] + R[2:] for L, R in splits if len(R)>1]
replaces = [L + similars[R[0]] + R[1:] for L, R in splits if R and R[0] in similars.keys()]
inserts = [L + c + R for L, R in splits for c in letters]
return set(deletes + replaces + inserts)
def edits2(word):
"All edits that are two edits away from `word`."
# return (e2 for e1 in edits1(word) for e2 in edits1(e1))
tmp = set()
for e1 in edits1(word):
for e2 in edits1(e1):
tmp.add(e2)
return tmp
if __name__ == '__main__':
print(candidates("aooayttes")) | {"/spell.py": ["/Levenshtein.py"], "/Corrector.py": ["/spell.py", "/Levenshtein.py"], "/LSTMsocket.py": ["/preprocess.py", "/Corrector.py", "/Levenshtein.py"]} |
70,404 | nthuepl/On-Pen-handwritten-Word-Recognition-Using-Long-Short-Term-Memory-Model | refs/heads/master | /Levenshtein.py | import numpy as np
default_del_map = np.array([float(1) for i in range(26)])
default_sub_map = np.array([[float(1) for i in range(26)] for j in range(26)])
default_ins_map = np.array([float(1) for i in range(26)])
def index(ch):
return ord(ch)-ord('a')
def levenshtein(seq1, seq2, insert_costs=default_ins_map, delete_costs=default_del_map, substitute_costs=default_sub_map, len_weight=0):
del_map = delete_costs
sub_map = substitute_costs
ins_map = insert_costs
size_x = len(seq1) + 1
size_y = len(seq2) + 1
matrix = [[0 for i in range(size_y)] for j in range(size_x)]
for x in range(size_x):
matrix[x][0] = x
for y in range(size_y):
matrix[0][y] = y
for x in range(1, size_x):
for y in range(1, size_y):
if seq1[x-1] == seq2[y-1]:
matrix[x][y] = min(
matrix[x-1][y] + del_map[index(seq1[x-1])] ,
matrix[x-1][y-1],
matrix[x][y-1] + ins_map[index(seq2[y-1])]
) + abs(x-y)*len_weight
else:
matrix[x][y] = min(
matrix[x-1][y] + del_map[index(seq1[x-1])],
matrix[x-1][y-1] + sub_map[index(seq1[x-1]), index(seq2[y-1])],
matrix[x][y-1] + ins_map[index(seq2[y-1])]
) + abs(x-y)*len_weight
return (matrix[-1][-1])
def easy_levenshtein(seq1, seq2):
size_x = len(seq1) + 1
size_y = len(seq2) + 1
matrix = [[0 for i in range(size_y)] for j in range(size_x)]
for x in range(size_x):
matrix[x][0] = x
for y in range(size_y):
matrix[0][y] = y
for x in range(1, size_x):
for y in range(1, size_y):
if seq1[x-1] == seq2[y-1]:
matrix[x][y] = min(
matrix[x-1][y] + 1 ,
matrix[x-1][y-1],
matrix[x][y-1] + 1
)
else:
matrix[x][y] = min(
matrix[x-1][y] + 1,
matrix[x-1][y-1] + 1,
matrix[x][y-1] + 1
)
return (matrix[-1][-1])
if __name__ == '__main__':
# au_w, bp_w, ce_w, fl_w, hn_w, rv_w = (0.15989722192473754, 0.26844730018846663, \
# 0.6323528324149036, 0.6527867146396427, 0.9156480941719015, 0.00916320719209418)
# sub_map = np.array([[float(1) for i in range(26)] for j in range(26)])
# sub_map[index('a'), index('u')] = au_w
# sub_map[index('p'), index('b')] = bp_w
# sub_map[index('e'), index('c')] = ce_w
# sub_map[index('l'), index('f')] = fl_w
# sub_map[index('r'), index('v')] = rv_w
# sub_map[index('n'), index('h')] = hn_w
example = 'qaicker'
word_list = []
tmp = []
distance_distribution = []
fp = open('20k.txt', 'r')
for line in fp.readlines():
word = line[:-1]
tmp.append(word)
# word_list.append(word)
fp.close()
min_d = 17
min_p = 0
page_index = [0]
for i in range(1, 18):
page_index.append(len(word_list))
for j, word in enumerate(tmp):
if len(word) == i:
word_list.append(word)
for i, word in enumerate(word_list):
d = easy_levenshtein(example, word)
distance_distribution.append(d)
# distance_distribution.append(len(word))
if d < min_d:
min_d = d
min_p = i
import matplotlib.pyplot as plt
plt.plot(distance_distribution, label='Levenshtein distance')
plt.plot([min_p], [min_d], marker='*', markersize=5, color="red", label='target')
print("average compare element: %s" % ( str( sum( [ float(page_index[i+2]-page_index[i]) for i in range(1, 16)] ) / 15 ) ) )
plt.plot([page_index[len(example)], page_index[len(example)]],[0, 16], color='green', label='search area')
plt.plot([page_index[len(example)+2], page_index[len(example)+2]],[0, 16], color='green')
plt.yticks(np.array([i for i in range(18)]))
plt.legend(loc='upper left')
plt.savefig("search_in_20k_with_sort.pdf", bbox_inches='tight')
plt.show()
| {"/spell.py": ["/Levenshtein.py"], "/Corrector.py": ["/spell.py", "/Levenshtein.py"], "/LSTMsocket.py": ["/preprocess.py", "/Corrector.py", "/Levenshtein.py"]} |
70,405 | nthuepl/On-Pen-handwritten-Word-Recognition-Using-Long-Short-Term-Memory-Model | refs/heads/master | /Corrector.py | from spell import correction
from Levenshtein import levenshtein, index
import numpy as np
class Lexicon():
def __init__(self):
vocab_list = []
# load from file
fp = open('20k.txt', 'r')
for line in fp.readlines():
word = line[:-1]
vocab_list.append(word)
fp.close()
self.word_list = []
self.page_table = [0 for i in range(20)]
self.cnt = -1
for length in range(1, 18):
self.page_table[length] = len(self.word_list)
word_n = []
for i in range(len(vocab_list)):
if len(vocab_list[i]) == length:
word_n.append(vocab_list[i])
word_n = sorted(word_n, key=str.upper)
self.word_list += word_n
au_w, bp_w, ce_w, fl_w, hn_w, rv_w = (0.136, 0.695, 0.628, \
0.501, 0.917, 0.139)
sub_w, del_w, ins_w = (1.389, 1.925, 1.954)
self.del_map = np.array([del_w for i in range(26)])
self.ins_map = np.array([ins_w for i in range(26)])
self.sub_map = np.array([[sub_w for i in range(26)] for j in range(26)])
self.sub_map[index('a'), index('u')] = au_w
self.sub_map[index('p'), index('b')] = bp_w
self.sub_map[index('e'), index('c')] = ce_w
self.sub_map[index('l'), index('f')] = fl_w
self.sub_map[index('r'), index('v')] = rv_w
self.sub_map[index('n'), index('h')] = hn_w
def __iter__(self):
return self
def __next__(self):
if self.cnt >= len(self.word_list):
raise StopIteration
else:
self.cnt += 1
return str(self.word_list[cnt])
def __str__(self):
return "Lexicon:\n\t"+str(len(self.word_list))+" words\n\t"+"page table: "+str(self.page_table)
def page(self, i):
return str(self.word_list[i])
def index(self, i):
return int(self.page_table[i])
def tolist(self):
return list(self.word_list)
def leven_fit(self, word, area=None):
answer = ''
MIN = 20
head, tail = 0, len(self.word_list)-1
if area != None:
head, tail = area
# for w in lexicon:
for w in self.word_list[head:tail]:
d = levenshtein(word, w, insert_costs=self.ins_map, delete_costs=self.del_map, substitute_costs=self.sub_map)
if d < MIN:
MIN = d
answer = w
if d == 0:
break
return answer
class Corrector():
def __init__(self, lexicon=None):
self.lex = lexicon
if lexicon == None:
self.lex = Lexicon()
print(self.lex)
self.MSR = {'r': 0.09, 'other': 0.514, 'n': 0.196, 'e': 0.139, 'l': 0.208, 'p': 0.227, 'a': 0.142}
self.dw = 0.459
def correction(self, word):
tmp = str(word)
word = correction(word, MSR=self.MSR, distance_weight=self.dw)
if word == None:
word = self.lex.leven_fit(tmp, area=(self.lex.index(len(tmp)), self.lex.index(len(tmp)+2)))
return word
if __name__ == '__main__':
corrector = Corrector()
print(corrector.lex)
| {"/spell.py": ["/Levenshtein.py"], "/Corrector.py": ["/spell.py", "/Levenshtein.py"], "/LSTMsocket.py": ["/preprocess.py", "/Corrector.py", "/Levenshtein.py"]} |
70,406 | nthuepl/On-Pen-handwritten-Word-Recognition-Using-Long-Short-Term-Memory-Model | refs/heads/master | /test.py | import pymongo
import os
import pickle
import json
# cnt = [0 for i in range(26)]
# for fn in os.listdir(os.getcwd()+'/train/'):
# if ".json" in fn:
# word = fn.split('.')[0]
# for char in word:
# cnt[ord(char)-ord('a')] += 1
# for i in range(26):
# print(chr(i+ord('a')), cnt[i])
# for fn in os.listdir(os.getcwd()+'/train/'):
# if ".json" in fn:
# os.system("python preprocess.py train/"+fn)
# # os.system("mv "+fn+" "+"train/"+fn)
# for fn in os.listdir(os.getcwd()):
# if ".json" in fn:
# os.system("python preclass.py %s" %(fn))
# os.system("mv %s train/%s" % (fn, fn))
# try:
# client = pymongo.MongoClient("localhost", 27017)
# except Exception as e:
# raise
# namespace = [chr(ord('a')+i) for i in range(26)]
# db = client.train_set
# count = 0
# for label in namespace:
# collection = db[label]
# print(label, collection.count())
# count += collection.count()
# print("total "+str(count)+" tuple of data")
# import matplotlib.pyplot as plt
# import numpy as np
# # namespace = ['ax', 'ay', 'az', 'gx', 'gy', 'gz']
# namespace = ['gy']
# colorspace = ['b', 'g', 'r', 'c', 'm', 'y']
# db = client.train
# collection = db['g']
# cursor = collection.find({})
# for data in cursor:
# for i, domain in enumerate(namespace):
# plt.plot(data[domain], colorspace[i])
# plt.show()
# try:
# client = pymongo.MongoClient("localhost", 27017)
# except Exception as e:
# raise
# pickleObject = {}
# namespace = [chr(ord('a')+i) for i in range(26)]
# db = client.train_set
# for label in namespace:
# pickleObject[label] = []
# for label in namespace:
# collection = db[label]
# cursor = collection.find({})
# for data in cursor:
# pickleObject[label].append(data)
# pickle.dump(pickleObject, open('train_set.dat', 'wb'))
# train_set = pickle.load(open('train_set.dat', 'r'))
# cnt = 0
# for key, values in train_set.items():
# if len(values) > 0:
# cnt += 1
# print(cnt)
# import matplotlib.pyplot as plt
# import numpy as np
# fp = open('experiment/record11', 'r')
# curve = []
# for line in fp.readlines():
# try:
# curve.append(float(line[:-1]))
# except Exception as e:
# pass
# plt.plot(curve)
# plt.show()
# fp.close()
# cnt = 0
# path = os.getcwd()+'/test_set/raw/'
# for fn in os.listdir(path):
# if ".json" in fn:
# cnt += 1
# os.system("python preprocess.py test_set/raw/%s" % (fn))
# # print("(%d/%d)" % (cnt, len(os.listdir(path))))
# try:
# client = pymongo.MongoClient("localhost", 27017)
# except Exception as e:
# raise
# # classspace = ['au', 'bp', 'c', 'd', 'e', 'f', 'g', 'hmn', 'it', 'j', 'k', 'l', 'o', 'q', 'r', 's', 'v', 'w', 'x', 'y', 'z']
# classspace = [chr(ord('a')+i) for i in range(26)]
# db = client.test_set
# count = 0
# for label in classspace:
# collection = db[label]
# print(label, collection.count())
# count += collection.count()
# print("total "+str(count)+" tuple of data")
# obj = {}
# for label in classspace:
# obj[label] = []
# for label in classspace:
# collection = db[label]
# cursor = collection.find({})
# for data in cursor:
# input_data = {}
# for key in data.keys():
# if "id" not in key:
# input_data[key] = data[key]
# obj[label].append(input_data)
# output_filename = 'test_set.dat'
# pickle.dump(obj, open(output_filename, 'wb'))
# print("data is record in %s" % output_filename)
# def levenshtein(seq1, seq2):
# size_x = len(seq1) + 1
# size_y = len(seq2) + 1
# matrix = [[0 for i in range(size_y)] for j in range(size_x)]
# for x in range(size_x):
# matrix[x][0] = x
# for y in range(size_y):
# matrix[0][y] = y
# for x in range(1, size_x):
# for y in range(1, size_y):
# if seq1[x-1] == seq2[y-1]:
# matrix[x][y] = min(
# matrix[x-1][y] + 1,
# matrix[x-1][y-1],
# matrix[x][y-1] + 1
# )
# else:
# matrix[x][y] = min(
# matrix[x-1][y] + 1,
# matrix[x-1][y-1] + 1,
# matrix[x][y-1] + 1
# )
# for x in range(1, size_x):
# for y in range(1, size_y):
# if x != y:
# matrix[x][y] += abs(x-y)
# return (matrix[-1][-1])
# str1 = 'abcf'
# str2 = 'aedf'
# print(levenshtein(str1, str2))
# import random
# au_w, bp_w, ce_w, fl_w, hn_w, rv_w = (random.random(), random.random(), random.random(), random.random(), random.random(), random.random())
# sub_w, del_w, ins_w = (1+random.random(), 1+random.random(), 1+random.random())
# jsonObj = {}
# jsonObj["sub"] = sub_w
# jsonObj["del"] = del_w
# jsonObj["ins"] = ins_w
# jsonObj["au"] = au_w
# jsonObj["bp"] = bp_w
# jsonObj["ce"] = ce_w
# jsonObj["fl"] = fl_w
# jsonObj["hn"] = hn_w
# jsonObj["rv"] = rv_w
# filename = 'param.json'
# json_str = json.dumps(jsonObj)
# output = open(filename, 'w')
# output.write(json_str)
# output.close()
# from QTGraph import QTGraph
# acceleration = [1 for i in range(500)]
# gyroscope = [1 for i in range(500)]
# graph = QTGraph([acceleration, gyroscope], ['acc', 'gyro'], sourcesNum=2, x_range=500)
# graph.show() | {"/spell.py": ["/Levenshtein.py"], "/Corrector.py": ["/spell.py", "/Levenshtein.py"], "/LSTMsocket.py": ["/preprocess.py", "/Corrector.py", "/Levenshtein.py"]} |
70,407 | nthuepl/On-Pen-handwritten-Word-Recognition-Using-Long-Short-Term-Memory-Model | refs/heads/master | /preprocess.py | import numpy as np
from scipy.signal import butter, lfilter, freqz, argrelextrema
import math
import json
import argparse
import pickle
import pymongo
# numpy parameters
order = 4
fs = 100.0
cutoff = 2.2
def butter_lowpass(cutoff, fs, order=5):
nyq = 0.5 * fs
normal_cutoff = cutoff / nyq
b, a = butter(order, normal_cutoff, btype='low', analog=False)
return b, a
def butter_lowpass_filter(data, cutoff, fs, order=5):
b, a = butter_lowpass(cutoff, fs, order=order)
y = lfilter(b, a, data)
return y
def normalize(src, nor_len=200):
# length normalization
dest = [0 for i in range(nor_len)]
org_len = len(src)
for i in range(nor_len):
expected_index = float(i)*org_len/nor_len
real_index = i*org_len/nor_len
dist = expected_index-real_index
if real_index < len(src)-1:
dest[i] = src[int(real_index)+1]*(dist) + src[int(real_index)]*(1-dist)
else:
dest[i] = src[int(real_index)]
# value normalization
MAX = max(dest)
MIN = min(dest)
for i, v in enumerate(dest):
dest[i] = (v-MIN)/(MAX-MIN)
return dest
def toClass(char):
# classspace = [chr(ord('a')+i) for i in range(26)]
# classspace = ['au', 'bp', 'c', 'd', 'e', 'f', 'g', 'hmn', 'it', 'j', 'k', 'l', 'o', 'q', 'r', 's', 'v', 'w', 'x', 'y', 'z']
classspace = [chr(ord('a')+i) for i in range(26)]
# classspace = ['a', 'u']
for Class in classspace:
if char in Class:
return Class
return 'None'
def preprocess(filename, return_segmentation=False):
fp = open(filename, "r")
jsdata = json.loads(fp.read())
fp.close()
result = []
# step 1 : segmentation # # # # # # #
# # segment data according to total sum of gyroscope curve # # # # # #
valid_curve_length = min( [ len(c) for c in [ jsdata["gx"], jsdata["gy"], jsdata["gz"] ] ] )
# # # # low-pass filter gyroscope curve # #
gyroForceCurve = [ math.sqrt( jsdata["gx"][i]**2 + jsdata["gy"][i]**2 + jsdata["gz"][i]**2 ) for i in range( valid_curve_length ) ]
low_pass_gyroForceCurve = butter_lowpass_filter( gyroForceCurve, cutoff, fs, order )
gf = list(gyroForceCurve)
tmp_gf = list(gyroForceCurve)
lpgf = butter_lowpass_filter( tmp_gf, cutoff, fs, 1 )
# # # # find local minimum in the curve, as candidates of segmentation point # # # #
local_minimums, = argrelextrema( np.array( low_pass_gyroForceCurve ), np.less )
local_minimums = local_minimums.tolist()
if low_pass_gyroForceCurve[0] < low_pass_gyroForceCurve[1]:
local_minimums.insert(0, 0)
if low_pass_gyroForceCurve[-1] < low_pass_gyroForceCurve[-2]:
local_minimums.append(len(low_pass_gyroForceCurve)-1)
# # # # judge segmentation candidates' point, segmentation finish # # # #
segmentation = []
threshold = ( max( low_pass_gyroForceCurve ) + min( low_pass_gyroForceCurve ) ) / 2
entropy = max( low_pass_gyroForceCurve ) - min( low_pass_gyroForceCurve )
threshold_coef = float(1)/3.5
# print(local_minimums)
window = []
windows = []
head = 0
tail = 0
for i, point in enumerate(local_minimums[:-1]):
nextpoint = local_minimums[i+1]
if not window:
window = low_pass_gyroForceCurve[ point:nextpoint ].tolist()
head = point
tail = nextpoint
MAX = max(window)
MIN = min(window)
rise = MAX - window[0]
fall = MAX - window[-1]
height = MAX - MIN
# print("fall = %s, rise = %s, height = %s" % (fall, rise, height))
if height < entropy*threshold_coef:
# print("window (%s,%s) is deprecated." % (head, tail))
window = []
continue
if rise < entropy*threshold_coef or fall < entropy*threshold_coef:
# print("point %s is deprecated." % (str(nextpoint)))
if point in segmentation:
del segmentation[-1]
segmentation.append(nextpoint)
if i+2 < len(local_minimums):
window = window+low_pass_gyroForceCurve[ nextpoint:local_minimums[i+2] ].tolist()
continue
if not segmentation:
# print("%s is added." % head)
segmentation.append(head)
# print("%s is added." % tail)
segmentation.append(tail)
windows.append((head, tail))
window = []
# # split each segment data from raw curves # # # # # #
# # # # rawdata is stored after going through a order=1 low-pass filter # # # #
namespace = ['ax', 'ay', 'az', 'gx', 'gy', 'gz']
# # # # rawdata is stored after going through a order=1 low-pass filter # # # #
data = {}
for key in namespace:
data[key] = butter_lowpass_filter( jsdata[key], cutoff, fs, 1 )
cnt = 0
# print(pred_size, word)
for i, chosen in enumerate(windows):
chosen_head, chosen_tail = chosen
d = {}
d[ 'rgs' ] = normalize(gf[ chosen_head:chosen_tail ], nor_len=100)
d[ 'gs' ] = normalize(lpgf[ chosen_head:chosen_tail ], nor_len=100)
for key in namespace:
d[ key ] = normalize(data[ key ][ chosen_head:chosen_tail ], nor_len=100)
d[ 'r'+key ] = normalize(jsdata[ key ][ chosen_head:chosen_tail ], nor_len=100)
result.append(d)
cnt += 1
# print('collect %s characters.' % cnt)
if not return_segmentation:
return result
else:
return (result, windows)
if __name__ == "__main__":
# parse parameters
parser = argparse.ArgumentParser(description='process input parameters')
parser.add_argument('fn', help='input the filename you want to show', type=str)
args = parser.parse_args()
filename = args.fn
word = filename.split('.')[0].split('/')[-1]
fp = open(filename, "r")
jsdata = json.loads(fp.read())
fp.close()
# step 1 : segmentation # # # # # # #
# # segment data according to total sum of gyroscope curve # # # # # #
valid_curve_length = min( [ len(c) for c in [ jsdata["gx"], jsdata["gy"], jsdata["gz"] ] ] )
# # # # low-pass filter gyroscope curve # #
gyroForceCurve = [ math.sqrt( jsdata["gx"][i]**2 + jsdata["gy"][i]**2 + jsdata["gz"][i]**2 ) for i in range( valid_curve_length ) ]
low_pass_gyroForceCurve = butter_lowpass_filter( gyroForceCurve, cutoff, fs, order )
gf = list(gyroForceCurve)
tmp_gf = list(gyroForceCurve)
lpgf = butter_lowpass_filter( tmp_gf, cutoff, fs, 1 )
# # # # find local minimum in the curve, as candidates of segmentation point # # # #
local_minimums, = argrelextrema( np.array( low_pass_gyroForceCurve ), np.less )
local_minimums = local_minimums.tolist()
if low_pass_gyroForceCurve[0] < low_pass_gyroForceCurve[1]:
local_minimums.insert(0, 0)
if low_pass_gyroForceCurve[-1] < low_pass_gyroForceCurve[-2]:
local_minimums.append(len(low_pass_gyroForceCurve)-1)
# # # # judge segmentation candidates' point, segmentation finish # # # #
segmentation = []
threshold = ( max( low_pass_gyroForceCurve ) + min( low_pass_gyroForceCurve ) ) / 2
entropy = max( low_pass_gyroForceCurve ) - min( low_pass_gyroForceCurve )
threshold_coef = float(1)/3.5
# print(local_minimums)
window = []
windows = []
head = 0
tail = 0
for i, point in enumerate(local_minimums[:-1]):
nextpoint = local_minimums[i+1]
if not window:
window = low_pass_gyroForceCurve[ point:nextpoint ].tolist()
head = point
tail = nextpoint
MAX = max(window)
MIN = min(window)
rise = MAX - window[0]
fall = MAX - window[-1]
height = MAX - MIN
# print("fall = %s, rise = %s, height = %s" % (fall, rise, height))
if height < entropy*threshold_coef:
# print("window (%s,%s) is deprecated." % (head, tail))
window = []
continue
if rise < entropy*threshold_coef or fall < entropy*threshold_coef:
# print("point %s is deprecated." % (str(nextpoint)))
if point in segmentation:
del segmentation[-1]
segmentation.append(nextpoint)
if i+2 < len(local_minimums):
window = window+low_pass_gyroForceCurve[ nextpoint:local_minimums[i+2] ].tolist()
continue
if not segmentation:
# print("%s is added." % head)
segmentation.append(head)
# print("%s is added." % tail)
segmentation.append(tail)
windows.append((head, tail))
window = []
# print(segmentation)
# # split each segment data from raw curves # # # # # #
# # # # dataset structure # # # #
# # # # | 'a' : [{'ax':[], 'ay': [], ...}, {}, {}, ...] | # # # #
# # # # | 'b' : [{}, {}, {}, ...] | # # # #
# # # # | 'c' : [{}, {}, {}, ...] | # # # #
# # # # | : | # # # #
# # # # | : | # # # #
# # # # | 'y' : [{}, {}, {}, ...] | # # # #
# # # # | 'z' : [{}, {}, {}, ...] | # # # #
try:
client = pymongo.MongoClient("localhost", 27017)
except Exception as e:
raise
db = client.test_set
namespace = ['ax', 'ay', 'az', 'gx', 'gy', 'gz']
# # # # rawdata is stored after going through a order=1 low-pass filter # # # #
data = {}
for key in namespace:
data[key] = butter_lowpass_filter( jsdata[key], cutoff, fs, 1 )
cnt = 0
pred_size = (segmentation[-1]-segmentation[0])/len(word)
# print(pred_size, word)
for i, ch in enumerate(word):
pred_head = segmentation[0]+pred_size*i
pred_tail = segmentation[0]+pred_size*(i+1)
chosen = None
min_diff = (segmentation[-1]-segmentation[0])
for head, tail in windows:
diff = abs(head-pred_head)+abs(tail-pred_tail)
if diff < min_diff:
chosen = (head, tail)
min_diff = diff
# print(chosen)
chosen_head, chosen_tail = chosen
d = {}
d[ 'rgs' ] = normalize(gf[ chosen_head:chosen_tail ], nor_len=100)
d[ 'gs' ] = normalize(lpgf[ chosen_head:chosen_tail ], nor_len=100)
for key in namespace:
d[ key ] = normalize(data[ key ][ chosen_head:chosen_tail ], nor_len=100)
d[ 'r'+key ] = normalize(jsdata[ key ][ chosen_head:chosen_tail ], nor_len=100)
db[toClass(ch)].insert_one(d)
cnt += 1 | {"/spell.py": ["/Levenshtein.py"], "/Corrector.py": ["/spell.py", "/Levenshtein.py"], "/LSTMsocket.py": ["/preprocess.py", "/Corrector.py", "/Levenshtein.py"]} |
70,408 | nthuepl/On-Pen-handwritten-Word-Recognition-Using-Long-Short-Term-Memory-Model | refs/heads/master | /training/database/train/test.py | import pickle
import json
import os
axis = ['ax', 'ay', 'az', 'gx', 'gy', 'gz']
for fn in os.listdir(os.getcwd()):
if ".json" in fn:
jsdata = json.loads(open(fn).read())
print(jsdata)
break
| {"/spell.py": ["/Levenshtein.py"], "/Corrector.py": ["/spell.py", "/Levenshtein.py"], "/LSTMsocket.py": ["/preprocess.py", "/Corrector.py", "/Levenshtein.py"]} |
70,409 | nthuepl/On-Pen-handwritten-Word-Recognition-Using-Long-Short-Term-Memory-Model | refs/heads/master | /training/LSTM.py | #!/usr/bin/python
# -*- coding: UTF-8 -*-
#fuser 6007/tcp -k
import numpy as np
import os
import tensorflow as tf
import math
import pickle
import random
from tensorflow.contrib import rnn
###### Do not modify here ######
# to make this notebook's output stable across runs
def reset_graph(seed=42):
tf.reset_default_graph()
tf.set_random_seed(seed)
np.random.seed(seed)
labelspace = [chr(i+ord('a')) for i in range(26)]
def labelEncode(char):
r = [0 for c in labelspace]
r[labelspace.index(char)] = 1
return r
def labelDecoder(arr):
return arr.index(max(arr))
def list2String(arr):
r = "[ "
for i in range(len(arr)):
r += str(arr[i])
if i < len(arr)-1:
r += ", "
return r
reset_graph()
train_set = pickle.load(open("train_set.dat", "rb"))
test_set = pickle.load(open("validate_set.dat", "rb"))
print("all labels: ", end="")
print(train_set.keys())
# training on data but only on alpha a to z
axiss = ['ay', 'az', 'ray', 'raz', 'gx', 'rgx', 'gy', 'rgy', 'gz', 'rgz', 'gs', 'rgs']
X_train1 = []
y_train1 = []
X_valid1 = []
y_valid1 = []
X_test1 = []
y_test1 = []
# shuffle trainninf set
items = []
for label, values in train_set.items():
for v in values:
items.append((label, v))
test_items = []
for label, values in test_set.items():
for v in values:
test_items.append((label, v))
shuffled = sorted(items, key=lambda k: random.random())
for label, data in shuffled:
# rebuild data structure
img = []
width = len(data['ax'])
for i in range(width):
img += [data[axis][i] for axis in axiss]
X_train1.append(img)
y_train1.append(labelEncode(label))
for label, data in test_items:
img = []
width = len(data['ax'])
for i in range(width):
img += [data[axis][i] for axis in axiss]
X_test1.append(img)
y_test1.append(labelEncode(label))
print('dataset loading has finished')
###### Do not modify here ######
learning_rate = 0.001 # learning rate
epochs = 2500 # epochs
batch_size = 512 # batch size
num_inputs = len(axiss) # MNIST data input (img shape: len(axiss)*100)
num_steps = len(data[axiss[0]]) # time steps
num_neurons = 64 # neurons in hidden layer
num_classes = len(labelspace)
X_train1 = np.asarray(X_train1)
X_train1 = X_train1.reshape([-1, num_steps, num_inputs])
X_test1 = np.asarray(X_test1)
X_test1 = X_test1.reshape([-1, num_steps, num_inputs])
x = tf.placeholder(tf.float32, [None, num_steps, num_inputs], name = 'x')
y = tf.placeholder(tf.float32, [None, num_classes], name = 'labels')
with tf.name_scope("init_weights"):
weights = {
# shape (N, 64)
'in': tf.Variable(tf.random_normal([num_inputs, num_neurons]), name = "weights_in"),
# shape (64, 26)
'out': tf.Variable(tf.random_normal([num_neurons, num_classes]), name = "weight_out")
}
with tf.name_scope("init_biases"):
biases = {
# shape (128, )
'in': tf.Variable(tf.constant(0.1, shape=[num_neurons, ]), name = "biases_in"),
# shape (5, )
'out': tf.Variable(tf.constant(0.1, shape=[num_classes, ]), name = "biases_out")
}
def RNN(X, weights, biases, name = "RNN"):
with tf.name_scope("input_layer"):
X = tf.reshape(X, [-1, num_inputs])
X_in = tf.matmul(X, weights['in']) + biases['in']
#LSTM accept input shape is [batch_size, time_step, num_neurons]
X_in = tf.reshape(X_in, [-1, num_steps, num_neurons])
with tf.name_scope("RNN_CELL"):
cell = tf.contrib.rnn.BasicLSTMCell(num_units=num_neurons, forget_bias=1.0, state_is_tuple=True)
#states[0]= c(t), states[1]=h(t)
outputs, states = tf.nn.dynamic_rnn(cell, X_in, dtype=tf.float32)
with tf.name_scope('output_layer'):
#results = h(t)*V
results = tf.matmul(states[1], weights['out']) + biases['out']
return results
output = RNN(x, weights, biases)
# weights = {
# # Hidden layer weights => 2*n_hidden because of forward + backward cells
# 'out': tf.Variable(tf.random_normal([2*num_neurons, num_classes]))
# }
# biases = {
# 'out': tf.Variable(tf.random_normal([num_classes]))
# }
# def BiRNN(X, weights, biases):
# # Prepare data shape to match `rnn` function requirements
# # Current data input shape: (batch_size, timesteps, n_input)
# # Required shape: 'timesteps' tensors list of shape (batch_size, num_input)
# # Unstack to get a list of 'timesteps' tensors of shape (batch_size, num_input)
# X = tf.unstack(X, num_steps, 1)
# # Define lstm cells with tensorflow
# # Forward direction cell
# lstm_fw_cell = rnn.BasicLSTMCell(num_neurons, forget_bias=1.0)
# # Backward direction cell
# lstm_bw_cell = rnn.BasicLSTMCell(num_neurons, forget_bias=1.0)
# # Get lstm cell output
# try:
# outputs, _, _ = rnn.static_bidirectional_rnn(lstm_fw_cell, lstm_bw_cell, X,
# dtype=tf.float32)
# except Exception: # Old TensorFlow version only returns outputs not states
# outputs = rnn.static_bidirectional_rnn(lstm_fw_cell, lstm_bw_cell, X,
# dtype=tf.float32)
# # Linear activation, using rnn inner loop last output
# print(outputs[-1])
# return tf.matmul(outputs[-1], weights['out']) + biases['out']
# output = BiRNN(x, weights, biases)
with tf.name_scope("softmax_layer"):
pred = tf.nn.softmax(output,name="prediction")
with tf.name_scope("loss"):
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred , labels=y), name = "loss")
with tf.name_scope("train"):
train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss, name = "train_step")
with tf.name_scope("accuracy"):
correct_pred = tf.equal(tf.argmax(pred, 1, name = "prediction_matrix"), tf.argmax(y, 1, name = "label_matrix"), name = "correct_pred")
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32), name = "accuracy")
init = tf.global_variables_initializer()
import time
arr = []
st = time.time()
saver = tf.train.Saver()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
max_accuracy = 0.0
with tf.Session(config=config) as sess:
writer = tf.summary.FileWriter("logs/", sess.graph)
sess.run(init)
for epoch in range(epochs):
i = 0
j = batch_size
for k in range(int(math.ceil(len(X_train1)/batch_size))):
epoch_x, epoch_y= X_train1[i:j], y_train1[i:j]
sess.run(train_step, feed_dict = {x:epoch_x, y:epoch_y})
i = i + batch_size
j = j + batch_size
result = sess.run(accuracy, feed_dict={x:X_test1, y:y_test1})
if result > max_accuracy:
max_accuracy = result
save_path = saver.save(sess, "./RNNLevel1")
arr.append(result)
print("Epoch:%d, Accuracy:%lf" %((epoch+1), result))
end = time.time()
print('training finish.\ncost time:',int(end-st))
print(sess.run(weights['out']))
result_matrix = [[0 for i in range(len(labelspace))] for j in range(len(labelspace))]
results = sess.run(pred, feed_dict={x:X_test1})
for i, result in enumerate(results):
# print(result)
pred_label = labelDecoder(result.tolist())
real_label = labelDecoder(y_test1[i])
result_matrix[real_label][pred_label] += 1
# print('pred: %d(%s), real: %d(%s)' % (pred_label, labelspace[pred_label], real_label, labelspace[real_label]))
# print("==============================================================================")
for i, raw in enumerate(result_matrix):
print(labelspace[i]+'\t', end="")
print(raw)
pickle.dump(result_matrix, open('result.mtx', 'wb'))
print(labelspace)
fp = open('record', 'w')
fp.write("labelspace = "+list2String(labelspace)+'], num_neurons = '+str(num_neurons)+'\n')
for num in arr:
fp.write(str(num)+'\n')
fp.close() | {"/spell.py": ["/Levenshtein.py"], "/Corrector.py": ["/spell.py", "/Levenshtein.py"], "/LSTMsocket.py": ["/preprocess.py", "/Corrector.py", "/Levenshtein.py"]} |
70,410 | nthuepl/On-Pen-handwritten-Word-Recognition-Using-Long-Short-Term-Memory-Model | refs/heads/master | /LSTMsocket.py | from __future__ import division, print_function, absolute_import
from tensorflow.python.framework.graph_util import convert_variables_to_constants
from tensorflow.python.platform import gfile
import numpy as np
import os
import tensorflow as tf
import pickle
import argparse
from preprocess import preprocess
from Corrector import Lexicon, Corrector
from Levenshtein import levenshtein, index, easy_levenshtein
import progressbar
import random
import time
import socket
# labelspace = ['au', 'bp', 'c', 'd', 'e', 'f', 'g', 'hmn', 'it', 'j', 'k', 'l', 'o', 'q', 'r', 's', 'v', 'w', 'x', 'y', 'z']
labelspace = [chr(ord('a')+i) for i in range(26)]
axiss = ['ax', 'ay', 'rax', 'ray', 'gx', 'gy', 'gz', 'rgx', 'rgy', 'rgz', 'gs', 'rgs']
# additional function # # # # # # # # #
def labelEncoder(char):
r = [0 for c in labelspace]
r[labelspace.index(char)] = 1
return r
def labelDecoder(arr):
return arr.index(max(arr))
def loadFile(filename):
X_test = []
word_data = preprocess(filename)
for data in word_data:
img = []
width = len(data['ax'])
for i in range(width):
img.append([data[axis][i] for axis in axiss])
X_test.append(img)
num_steps = 100
num_inputs = len(axiss)
X_test = np.asarray(X_test)
X_test = X_test.reshape([-1, num_steps, num_inputs])
return X_test
class LSTMsocket():
"""docstring for LSTMsocket"""
def __init__(self):
frozen_graph="./all_alpha.pb"
with tf.gfile.GFile(frozen_graph, "rb") as f:
restored_graph_def = tf.GraphDef()
restored_graph_def.ParseFromString(f.read())
# construct a graph object that hold test.pb.
with tf.Graph().as_default() as graph:
tf.import_graph_def(
restored_graph_def,
input_map=None,
return_elements=None,
name="")
x=graph.get_tensor_by_name("x:0")
#y=graph.get_tensor_by_name("labels:0")
pred =graph.get_tensor_by_name("softmax_layer/prediction:0")
weight = graph.get_tensor_by_name("init_weights/weights_in:0")
lex = Lexicon()
crtr = Corrector(lexicon=lex)
# for fn in os.listdir(os.getcwd()+'/../penwriting/validate/'):
# if ".json" in fn:
# try:
# data = loadFile('../penwriting/validate/'+fn)
# dataset.append(data)
# groundtruth.append(fn.split('.')[0])
# except Exception as e:
# continue
# socket setup
HOST = '127.0.0.1'
PORT = 8001
self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.s.bind((HOST, PORT))
self.s.listen(5)
print('LSTM classifier start at: %s:%s' %(HOST, PORT))
print('wait for input...')
# socket setup
with tf.Session(graph=graph) as sess:
while True:
conn, addr = self.s.accept()
print('Connected by', addr)
data = conn.recv(1024)
print(type(data))
print(data.decode('utf-8'))
filename = data.decode('utf-8')
X_test = loadFile(filename)
results = sess.run(pred, feed_dict={x:X_test})
word = ''
for i, result in enumerate(results):
pred_label = labelDecoder(result.tolist())
label = labelspace[pred_label]
word += label
word = crtr.correction(word)
conn.send(word.encode('utf-8'))
def __exit__(self, exc_type, exc_value, traceback):
self.s.close()
if __name__ == '__main__':
socket = LSTMsocket() | {"/spell.py": ["/Levenshtein.py"], "/Corrector.py": ["/spell.py", "/Levenshtein.py"], "/LSTMsocket.py": ["/preprocess.py", "/Corrector.py", "/Levenshtein.py"]} |
70,411 | nthuepl/On-Pen-handwritten-Word-Recognition-Using-Long-Short-Term-Memory-Model | refs/heads/master | /train.py | # from bluepy.btle import Scanner, DefaultDelegate
from bluepy.btle import *
# import numpy as np
import numpy as np
from scipy.signal import butter, lfilter, freqz
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from matplotlib import style
import threading
import Queue
from time import sleep
from QTGraph import QTGraph
import random
import json
import time
import math
import os
# Flag for stopping the program
RUNNING = True
# Devices' name
# The size of window
windowSize = 2000
x_lim = 0
# Global variables
acc_dividor = 4096
gyro_dividor = 65.5
accBias = [0,0,0]
gyroBias = [0,0,0]
DEG2RAD = 0.01745329251
alpha = 0.8
# numpy parameters
order = 1
fs = 30.0
cutoff = 2.0
targetDeviceName = "WinstonScale"
deviceTargets = []
updateLock = threading.Lock()
dataStreamList = [[0] for i in range(6)]
gravity = [float(0) for i in range(4)]
isRemoveNoise = [False, False, False, False, False, False]
acceleration = []
gyroscope = []
# plt.ion()
style.use('fivethirtyeight')
fig = plt.figure()
ax1 = plt.subplot2grid((3,3),(0,0),colspan=3)
ax2 = plt.subplot2grid((3,3),(1,0),colspan=3)
ax3 = plt.subplot2grid((3,3),(2,0),colspan=3)
def eliminate_gravity(value, axis):
a_policy = ['ax', 'ay', 'az']
g_policy = ['gx', 'gy', 'gz']
if axis in a_policy:
index = a_policy.index(axis)
gravity[index] = alpha*gravity[index]+(1-alpha)*value
return value-gravity[index]
elif axis in g_policy:
return value
else:
return None
def butter_lowpass(cutoff, fs, order=5):
nyq = 0.5 * fs
normal_cutoff = cutoff / nyq
b, a = butter(order, normal_cutoff, btype='low', analog=False)
return b, a
def butter_lowpass_filter(data, cutoff, fs, order=5):
b, a = butter_lowpass(cutoff, fs, order=order)
y = lfilter(b, a, data)
return y
def hexString2Int(string):
num = 0
buf_ = string.lower()
for i in range(0, len(buf_), 1):
ch = buf_[i]
num = num*16+int(ch, 16)
if num >= 32768:
num = num-65536
return num
def hexString2float(string):
singed = ''
degree = ''
tail = ''
stream = ''
for ch in string:
stream = stream+format(int(ch, 16), 'b').zfill(4)
signed = stream[0]
degree = stream[1:9]
tail = stream[9:]
power = 0
for i in range(0, len(degree), 1):
if degree[7-i] == '1':
power = power+pow(2, i)
power = power-127
base = 1.0
for i in range(0, len(tail), 1):
if (tail[i] == '1'):
base = base+pow( 2, (-1)*(i+1) )
if signed == '1':
return (-1)*base*pow(2, power)
elif signed == '0':
return base*pow(2, power)
class handleNotificationDelegate(DefaultDelegate):
def __init__(self, scanEntry, lock=None):
DefaultDelegate.__init__(self)
self.scanEntry = scanEntry
self.lock = lock
def handleNotification(self, cHandle, data):
reading = str(binascii.hexlify(data))
global counter
global windowSize
global dataStreamQueue
axis = ['ax', 'ay', 'az', 'gx', 'gy', 'gz']
rawdata = [reading[4*i:4*i+4] for i in range(6)]
rawvalue = [hexString2Int(data) for data in rawdata]
rawvalue.append(int(reading[24:28], 16))
rawvalue[0] = float(rawvalue[0]) / acc_dividor - accBias[0]
rawvalue[1] = -( float(rawvalue[1]) / acc_dividor) + accBias[1]
rawvalue[2] = -( float(rawvalue[2]) / acc_dividor ) + accBias[2]
rawvalue[3] = ( float(rawvalue[3]) / gyro_dividor - gyroBias[0]) * DEG2RAD
rawvalue[4] = -( float(rawvalue[4]) / gyro_dividor - gyroBias[1]) * DEG2RAD
rawvalue[5] = -( float(rawvalue[5]) / gyro_dividor - gyroBias[2]) * DEG2RAD
# for v in rawvalue: print(v)
# print(" ")
if self.lock != None:
self.lock.acquire()
# critical section
for i in range(6):
dataStreamList[i].append(eliminate_gravity(rawvalue[i], axis[i]))
# dataStreamList[i].append(rawvalue[i])
if len(dataStreamList[i]) > windowSize:
del dataStreamList[i][0]
if len(dataStreamList[i]) == 20 and isRemoveNoise[i] == False:
dataStreamList[i] = []
isRemoveNoise[i] = True
if dataStreamList[0]:
acceleration.append(math.sqrt(dataStreamList[0][-1]**2 + dataStreamList[1][-1]**2 + dataStreamList[2][-1]**2))
gyroscope.append(math.sqrt(dataStreamList[3][-1]**2 + dataStreamList[4][-1]**2 + dataStreamList[5][-1]**2))
if len(acceleration) > windowSize:
del acceleration[0]
del gyroscope[0]
# critical section
if self.lock != None:
self.lock.release()
class handleDiscoveryDelegate(DefaultDelegate):
def __init__(self):
DefaultDelegate.__init__(self)
def handleDiscovery(self, scanEntry, isNewDev, isNewData):
if isNewDev:
print "Discovered device", scanEntry.addr
elif isNewData:
print "Received new data from", scanEntry.addr
def scanFunction():
# setting the dongle number from yourself
scanner = Scanner(1).withDelegate(handleDiscoveryDelegate())
scanResults = scanner.scan(3)
global deviceTargets
for scanEntry in scanResults:
"""
print "Device %s (%s), RSSI=%d dB" % (scanEntry.addr, scanEntry.addrType, scanEntry.rssi)
for (adtype, desc, value) in scanEntry.getScanData():
print " %s = %s" % (desc, value)
"""
for (adtype, desc, value) in scanEntry.getScanData():
if value == targetDeviceName:
deviceTargets.append(scanEntry)
print scanEntry.addr
continue
if (len(deviceTargets) > 1):
print "< %s devices were found >" % len(deviceTargets)
elif (len(deviceTargets) == 1):
print "< %s device was found >" % len(deviceTargets)
else:
print "< No target device was found >"
class PeripheralThread(threading.Thread):
def __init__(self, device):
threading.Thread.__init__(self)
self.device = device
def run(self):
# print "PeripheralThread : Run()"
try:
global updateLock
connection = Peripheral(self.device)
connection.setDelegate(handleNotificationDelegate(self.device, lock=updateLock))
connection.getServices()
Service = connection.getServiceByUUID("0000fff0-0000-1000-8000-00805f9b34fb")
accBiasChar = Service.getCharacteristics()[0]
gyroBiasChar = Service.getCharacteristics()[1]
accBiasString = str(binascii.hexlify(accBiasChar.read()))
gyroBiasString = str(binascii.hexlify(gyroBiasChar.read()))
accBias = [accBiasString[4*i:4*i+4] for i in range(3)]
gyroBias = [gyroBiasString[4*i:4*i+4] for i in range(3)]
# accBias = [ float.fromhex(accBias[i]) for i in range(3) ]
# gyroBias = [ float.fromhex(gyroBias[i]) for i in range(3) ]
accBias = [ hexString2float(accBias[i]) for i in range(3) ]
gyroBias = [ hexString2float(gyroBias[i]) for i in range(3) ]
# print(accBias)
# print(gyroBias)
Characteristic_4 = Service.getCharacteristics()[3]
connection.writeCharacteristic(Characteristic_4.handle + 2, struct.pack('<h', 0x0001), True)
waitCycle = 0
while RUNNING:
if connection.waitForNotifications(0.5):
continue
print "Waiting..."
waitCycle += 1
if (waitCycle >= 3):
raise ValueError('Timeout')
except Exception as e:
print "PeripheralThread Exception"
if 'connection' in locals():
connection.disconnect()
del connection
print(e)
self.run()
def main():
global deviceTargets
global RUNNING
global updateLock
newScanThread = threading.Thread(target = scanFunction, name = "scanFunction")
newScanThread.setDaemon(True)
newScanThread.start()
newScanThread.join() # Wait until it's done
if (len(deviceTargets) != 0):
# PeripheralThreads = []
#for deviceTarget in deviceTargets:
for idx, deviceTarget in enumerate(deviceTargets):
print deviceTarget.addr
try:
print idx #############0 1 2 3
print deviceTarget
newPeripheralThread = PeripheralThread(deviceTarget)
newPeripheralThread.setDaemon(True)
newPeripheralThread.start()
# PeripheralThreads.append(newPeripheralThread)
except (KeyboardInterrupt, SystemExit):
print "!!!!!!!!!!!!!!!"
cleanup_stop_thread()
sys.exit()
while isRemoveNoise[0] == False:
pass
dataName = ['ax', 'ay', 'az', 'gx', 'gy', 'gz']
# graph = QTGraph(dataStreamList, dataName, sourcesNum=6, x_range=windowSize, lock=updateLock, lowpass=True)
graph = QTGraph([acceleration, gyroscope], ['acc', 'gyro'], sourcesNum=2, x_range=windowSize, lock=updateLock, lowpass=True)
def cut(g, evt):
global dataStreamList, RUNNING
# generate English word
wordset = set()
fp = open('20k.txt', 'r')
for line in fp.readlines():
if 'q' in line or 'b' in line or 'z' in line or 'x' in line:
wordset.add(line[:-1])
# wordset.add(line[:-1])
fp.close()
sampleNum = 5
menu = random.sample(wordset, sampleNum)
print('Training set collection program start. There are %d words to write...' % sampleNum)
for i, word in enumerate(menu):
while True:
updateLock.acquire()
for s in dataStreamList:
del s[:-1]
updateLock.release()
print('[sample %s] Please write %s' % (i+1, word))
evt.wait()
break
if RUNNING == False:
print('sampling thread termitating.')
break
data = {
dataName[0] : list(dataStreamList[0]),
dataName[1] : list(dataStreamList[1]),
dataName[2] : list(dataStreamList[2]),
dataName[3] : list(dataStreamList[3]),
dataName[4] : list(dataStreamList[4]),
dataName[5] : list(dataStreamList[5])
}
print("now recording...")
time.sleep(3)
# Write raw data to a plain text file
filename = word+'.json'
json_str = json.dumps(data)
output = open(filename, 'w')
output.write(json_str)
output.close()
evt.clear()
if RUNNING:
g.close()
RUNNING = False
print('##########training is done.##########')
evt = threading.Event()
cutting = threading.Thread(target=cut, args=(graph, evt,))
graph.setTask(cutting, evt)
graph.show(animate=True)
if RUNNING:
evt.set()
graph.close()
RUNNING = False
cutting.join()
print "< Program Terminated >"
else:
pass
if __name__ == '__main__':
main()
| {"/spell.py": ["/Levenshtein.py"], "/Corrector.py": ["/spell.py", "/Levenshtein.py"], "/LSTMsocket.py": ["/preprocess.py", "/Corrector.py", "/Levenshtein.py"]} |
70,412 | jmootrey/bjsim | refs/heads/master | /bjsim/__init__.py | #from bjsim import bjsim
| {"/main.py": ["/bjsim/__init__.py"], "/bjsim/bjsim.py": ["/bjsim/__init__.py"]} |
70,413 | jmootrey/bjsim | refs/heads/master | /main.py | #!/usr/bin/env python3
from bjsim import bjsim
import argparse
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Bonjoivi Amp Simulator')
parser.add_argument('-t', '--tx', help='Transmit Dev (/dev/ttyUSBx)',
default='stdout')
parser.add_argument('-r', '--rx', help='Receive Dev (/dev/ttyUSBx)',
default='stdout')
args = parser.parse_args()
App = bjsim.BongjoviSimulator(args)
App.run()
| {"/main.py": ["/bjsim/__init__.py"], "/bjsim/bjsim.py": ["/bjsim/__init__.py"]} |
70,414 | jmootrey/bjsim | refs/heads/master | /bjsim/utest.py | '''
unittesy.py
Handles serial communication and Testing
Bonjoiv Amp
'''
import serial
import time
from random import random
class Utest:
def __init__(self, tx, rx):
self.tx = tx
self.rx = rx
self.logfile = 'caplog.log'
# self.pdic = {23:1, 0:1, 8:None, 1:2, 10:None,
# 28:None,29:None,3:None, 2:2}
self.pdic = {23:1, 0:1, 8:1, 1:2, 10:1,
28:1,29:1,3:1, 2:2}
def log_facility(self, message):
with open(self.logfile, mode='w') as self.f:
self.f.write(message)
def RunTest(self, id):
self.results = 'Ok'
# Late Reply Operating
if id == 1:
self.results = ' Ok'
self.timeout = time.time() + 60 * 5
if not self.handshake():
self.results = ' Failed Handshake'
else:
while time.time() < self.timeout:
if random() > .1:
time.sleep(.4)
self.p = self.get_packet(f=False, attempts=1)
if self.p:
self.r = self.response_handler(self.p, e=None)
return self.results
# Normal Reply
elif id == 0:
self.results = ' Ok'
self.timeout = time.time() + 60 * 5
if not self.handshake():
self.results = ' Failed Handshake'
else:
while time.time() < self.timeout:
self.p = self.get_packet(f=False, attempts=1)
self.log_facility('Rx: ' + str(self.p))
if self.p:
self.r = self.response_handler(self.p, e=None)
self.results = ' Ok'
return self.results
elif id == 2:
return ' Ok'
def MakeLink(self, m='o'):
if m == 'o':
try:
# transmit bus
self.tx = serial.Serial(port=self.tx, baudrate=115200, timeout=.4)
# rec bus
self.rx = serial.Serial(port=self.rx, baudrate=115200, timeout=.4)
return True
except ValueError:
return NameError('Illegal Comm Parameter')
else:
if self.tx:
self.tx.close()
if self.rx:
self.rx.close()
def crc_check(self, d, m='check'):
# checksum ~(b1 + b2 + b3)+1 & 127
self.crc = (~sum(d[0:3])) + 1 & 127
if m == 'check':
if self.crc != d[3]:
return False
else:
return True
else:
return self.crc
def flushbuffer(self):
self.rx.flushInput()
def get_packet(self, attempts=2, f=True):
self.rec = []
self.crc_error = 0
self.c = 0
if f: self.rx.flushInput()
while True:
self.rec = self.rx.read(4)
self.c += 1
if self.rec:
if self.rec[0] == 2:
if self.crc_check(self.rec):
return self.rec
else:
self.crc_error += 1
if self.c >= attempts:
if self.crc_error == 0:
return False
else:
return self.crc_error
# Initiate communication with CWR450, return packet following init.
def handshake(self):
self.im_awake = bytes([0x04, 0xBA, 0x00, 0x42])
self.flushbuffer()
self.tout=10
while True:
self.tx.write(self.im_awake)
self.r = self.get_packet(attempts=1, f=False)
if self.r:
self.r = self.response_handler(d=self.r, e='0xba', r=False)
if self.r:
break
else:
self.tout -= 1
if self.tout == 0:
self.r = False
return self.r
def packet_assembly(self, d=None):
self.rtn = bytearray([0x04, d[1], d[2]])
self.rtn.append(self.crc_check(self.rtn, 'gen'))
return self.rtn
# Gen response handler. d=data_packet e=expected packet type
# r = supply sane response to bus
def response_handler(self, d=None, e=None, r=True):
d=bytearray(d)
if d[2] != 255 and d[1] in self.pdic:
self.pdic[d[1]]=d[2]
if r and e == hex(d[1]):
self.tx.write(self.packet_assembly(d))
return True
elif not r and int(e, 16) == d[1]:
return True
elif not e and r:
if d[2] == 255:
d[2] = self.pdic[d[1]]
self.rtn = self.packet_assembly(d)
self.log_facility('Tx: ' + str(self.rec))
self.tx.write(self.rtn)
return self.rtn
else:
return False | {"/main.py": ["/bjsim/__init__.py"], "/bjsim/bjsim.py": ["/bjsim/__init__.py"]} |
70,415 | jmootrey/bjsim | refs/heads/master | /bjsim/bjsim.py | import npyscreen
from bjsim import utest
class TestSuite:
tx = None
rx = None
def __init__(self, args):
self.t = ["Normal Operating / Response", "Late Reply", "Mid-Op Reset"]
self.toRuni = []
self.toRunt = []
def listTest(self):
tests = self.t
return tests
def makeList(self, sti):
self.toRuni = sorted(sti)
for i in self.toRuni:
self.toRunt.append(self.t[i])
def getList(self, rtype):
if rtype == 'i':
return self.toRuni
elif rtype == 't':
for i in self.toRuni:
self.toRunt.append(self.t[i])
return self.toRunt
class StatusForm(npyscreen.ActionFormV2):
def create(self):
# TitleSlider name refuses to update...
self.max_width = 200
self.sb = self.add(npyscreen.TitleFixedText, name='Progress:',
value='0 / 0')
self.rs = self.add(npyscreen.TitlePager, rely=5, name="History",
hidden=True, max_height=15)
self.ui = self.add(npyscreen.FixedText, value="Press OK To Begin -->",
rely=-3)
def on_cancel(self):
self.parentApp.switchForm('MAIN')
def on_ok(self):
self.complete = 0
self.rt = []
self.ti = self.parentApp.ts.getList('i')
self.tt = self.parentApp.ts.getList('t')
self.outof = len(self.ti)
self.sb.value= '0 / ' + str(self.outof)
self.rs.hidden = False
self.ui.value = "Running"
self.display()
self.r = utest.Utest(self.parentApp.ts.tx, self.parentApp.ts.rx)
self.r.MakeLink()
for self.test in self.ti:
# Class/function to handle test
self.complete += 1
self.sb.value = str(self.complete) + ' / ' + str(self.outof)
self.display()
self.result = self.r.RunTest(self.test)
self.rtn = self.tt.pop(0)
if not self.result:
self.result = ' Test Implementation Error'
self.rtn = self.rtn + ':' + self.result
self.rt.append(self.rtn)
self.rs.values = self.rt
self.display()
self.ui.value = 'Complete'
self.r.MakeLink(m='c')
self.display()
self.r.MakeLink(m='close')
class TestSelectionForm(npyscreen.ActionFormWithMenus):
def create(self):
self.menu = self.new_menu(name='Settings', shortcut="^S")
self.menu.addItemsFromList([("Configure Serial Ports", self.cs)])
self.values = self.parentApp.ts.listTest()
self.selectedTest = self.add(npyscreen.TitleMultiSelect, name="Tests",
values=self.values)
def cs(self):
self.parentApp.switchForm("SERIAL")
def on_ok(self):
if self.parentApp.ts.tx == 'stdout' or self.parentApp.ts.rx == 'empty':
self.parentApp.switchForm('WARNING')
else:
self.parentApp.ts.makeList(self.selectedTest.value)
self.parentApp.switchForm("STATUS")
def on_cancel(self):
self.parentApp.switchForm(None)
class DeviceWarning(npyscreen.ActionPopup):
def create(self):
self.warning = self.add(npyscreen.Textfield, editable=False,
value='Please Configure Serial Device')
def on_ok(self):
self.parentApp.switchFormPrevious()
def on_cancel(self):
self.parentApp.switchFormPrevious()
class SerialConfig(npyscreen.ActionPopup):
def create(self):
self.rxp = self.add(npyscreen.TitleFilename, name='Receive:', value='/dev/ttyUSB')
self.txp = self.add(npyscreen.TitleFilename, name='Transmit:', value='/dev/ttyUSB')
self.rx_exist = self.rxp.value
self.tx_exist = self.txp.value
def on_cancel(self):
self.parentApp.switchForm('MAIN')
def on_ok(self):
if self.txp.value != self.tx_exist:
self.parentApp.ts.tx = self.txp.value
self.tx_exist = self.txp.value
if self.rxp.value != self.rx_exist:
self.parentApp.ts.rx = self.rxp.value
self.rx_exist = self.rxp.value
self.parentApp.switchFormPrevious()
class BongjoviSimulator(npyscreen.NPSAppManaged):
def __init__(self, args):
self.args = args
TestSuite.tx = self.args.tx
TestSuite.rx = self.args.rx
super().__init__()
def onStart(self):
self.ts = TestSuite(self.args)
self.addForm('MAIN', TestSelectionForm, name="Bongjovi Simulator")
self.addForm('STATUS', StatusForm, name='Testing Progress')
self.addForm('SERIAL', SerialConfig, name='Serial Configuration')
self.addForm('WARNING', DeviceWarning, name='Serial Device Warning')
| {"/main.py": ["/bjsim/__init__.py"], "/bjsim/bjsim.py": ["/bjsim/__init__.py"]} |
70,416 | mekcherie/SUPERHERO.CS1.1 | refs/heads/main | /my_dogs.py | # my_dogs.py
import dog
# instantiation call that creates a Dog object:
my_dog = dog.Dog("Rex", "SuperDog")
print(my_dog.name)
print(my_dog.breed)
my_dog.bark()
print("\n")
my_other_dog = dog.Dog("Nany", "SuperSmartDog")
print(my_other_dog.name)
print(my_other_dog.breed)
my_dog.roll_over()
print("\n")
my_third_dog = dog.Dog("Lacy", "SuperFastDog")
print(my_third_dog.name)
print(my_third_dog.breed)
my_dog.sit_down() | {"/arena.py": ["/armor.py"]} |
70,417 | mekcherie/SUPERHERO.CS1.1 | refs/heads/main | /animal.py |
class Animal:
def __init__(self, name):
self.name = name
def eat(self):
print('{} is eating'.format(self.name))
def drink(self):
print('{} is drinking'.format(self.name))
class Frog(Animal):
def jump(self):
print('{} is jumping'.format(self.name))
# "EXAMPLE"
# class Animal:
# def __init__(self, name, sleep_time):
# self.name = name
# self.sleep_time = sleep_time
# def sleep(self):
# print(
# "{} sleeps for {} hours {}".format(
# self.name,
# self.sleep_time)
# dog = Animal("Sophie", 12)
# dog.sleep()
# class Animal:
# def __init__(self, name, sleep_duration):
# self.name = name
# self.sleep_duration = sleep_duration
# def sleep(self):
# print(
# "{} sleeps for {} hours".format(
# self.name,
# self.sleep_duration))
# # Note that the class Dog takes in Animal as a parameter!
# class Dog(Animal):
# def bark(self):
# print("Woof! Woof!") | {"/arena.py": ["/armor.py"]} |
70,418 | mekcherie/SUPERHERO.CS1.1 | refs/heads/main | /arena.py | from ability import Ability
from weapon import Weapon
from armor import Armor
from hero import Hero
from team import Team
class Arena:
def __init__(self):
'''Instantiate properties
team_one: None
team_two: None
'''
self.team_one: None
self.team_two: None
def create_ability(self):
'''Prompt for Ability information.
return Ability with values from user Input
'''
name = input("What is the ability name? ")
max_damage = input(
"What is the max damage of the ability? ")
return Ability(name, max_damage)
def create_weapon(self):
'''Prompt user for Weapon information
return Weapon with values from user input.
'''
name = input("What is the weapon's name? ")
max_damage = input(
"What is the max damage of the weapon? ")
return Weapon(name, max_damage)
def create_armor(self):
'''Prompt user for Armor information
return Armor with values from user input.
'''
name = input("What is the armor's name? ")
max_defense = input(
"What is the max defense of the armor? ")
return Armor(name, max_defense)
def create_hero(self):
'''Prompt user for Hero information
return Hero with values from user input.
'''
hero_name = input("Hero's name: ")
hero = Hero(hero_name)
add_item = None
while add_item != "4":
add_item = input("[1] Add ability\n[2] Add weapon\n[3] Add armor\n[4] Done adding items\n\nYour choice: ")
if add_item == "1":
ability = self.create_ability()
hero.add_ability(ability)
elif add_item == "2":
weapon = self.create_weapon()
hero.add_weapon(weapon)
elif add_item == "3":
armor = self.create_armor()
hero.add_armor(armor)
return hero
def build_team_one(self):
'''Prompt the user to build team_one '''
team_name = input("What is the name of the first team? ")
self.team_one = Team(team_name)
numOfTeamMembers = int(input("How many members would you like on Team One?\n"))
for i in range(numOfTeamMembers):
hero = self.create_hero()
self.team_one.add_hero(hero)
def build_team_two(self):
'''Prompt the user to build team_two'''
team_name = input("What is the name of the second team? ")
self.team_two = Team(team_name)
numOfTeamMembers = int(input("How many members would you like on Team Two?\n"))
for i in range(numOfTeamMembers):
hero = self.create_hero()
self.team_two.add_hero(hero)
def team_battle(self):
'''Battle team_one and team_two together.'''
self.team_one.attack(self.team_two)
def show_stats(self):
'''Shows the stats of both teams.'''
print("\n")
print(self.team_one.name + " statistics: ")
self.team_one.stats()
print("\n")
print(self.team_two.name + " statistics: ")
self.team_two.stats()
print("\n")
team_kills = 0
team_deaths = 0
for hero in self.team_one.heroes:
team_kills += hero.kills
team_deaths += hero.deaths
if team_deaths == 0:
team_deaths = 1
print(self.team_one.name + " average K/D was: " + str(team_kills/team_deaths))
# Display the average K/D for Team Two
team_kills2 = 0
team_deaths2 = 0
for hero in self.team_two.heroes:
team_kills2 += hero.kills
team_deaths2 += hero.deaths
if team_deaths2 == 0:
team_deaths2 = 1
print(self.team_two.name + " average K/D was: " + str(team_kills2/team_deaths2))
# List the heroes from Team One that survived
for hero in self.team_one.heroes:
if hero.deaths == 0:
print("survived from " + self.team_one.name + ": " + hero.name)
#List the heroes from Team Two that survived
for hero in self.team_two.heroes:
if hero.deaths == 0:
print("survived from " + self.team_two.name + ": " + hero.name)
if __name__ == "__main__":
game_is_running = True
arena = Arena()
arena.build_team_one()
arena.build_team_two()
while game_is_running:
arena.team_battle()
arena.show_stats()
play_again = input("Play Again? Y or N: ")
if play_again.lower() == "n":
print("Thank you for playing!")
game_is_running = False
else:
arena.team_one.revive_heroes()
arena.team_two.revive_heroes() | {"/arena.py": ["/armor.py"]} |
70,419 | mekcherie/SUPERHERO.CS1.1 | refs/heads/main | /armor.py |
import random
class Armor:
def __init__(self, name, max_block):
'''
Initialize the values passed into this method as instance variables.
'''
self.name = name
self.max_block = max_block
def block(self):
random_block_value = random.randint(0, int(self.max_block))
return random_block_value
| {"/arena.py": ["/armor.py"]} |
70,420 | WANTEDv2/architecture.py | refs/heads/main | /application_services/implements/get_all_dvd.py | from application_services.get_all_dvd import GetAllDvd
from application_services.implements.dvd_mapper import DvdMapper
from domain_services.i_dvd_repository import IDvdRepository
class GetAllDvd(GetAllDvd):
def __init__(self, repository: IDvdRepository):
self.repository = repository
def exec(self) -> list:
cddvd = self.repository.all()
return list(map(lambda b: DvdMapper.domain_to_dto(b), cddvd))
| {"/application_services/implements/get_all_dvd.py": ["/application_services/get_all_dvd.py", "/application_services/implements/dvd_mapper.py", "/domain_services/i_dvd_repository.py"], "/application_services/implements/dvd_mapper.py": ["/domain/Cddvd.py"], "/infrastructure/data_access/dvd_repository.py": ["/domain/Cddvd.py", "/domain_services/i_dvd_repository.py"], "/domain_services/i_dvd_repository.py": ["/domain/Cddvd.py"], "/application_services/implements/create_dvd.py": ["/application_services/CreateDvd.py", "/application_services/UpdateDvd.py", "/application_services/implements/dvd_mapper.py", "/domain_services/i_dvd_repository.py"], "/ui/main.py": ["/application_services/implements/create_dvd.py", "/application_services/implements/get_all_dvd.py", "/application_services/implements/remove_dvd.py", "/infrastructure/data_access/dvd_repository.py", "/ui/presenter/dvd_presenter.py", "/ui/views/q_dvd_main.py", "/ui/views/q_dvd_edit.py"], "/application_services/implements/remove_dvd.py": ["/application_services/Remove_dvd.py", "/domain_services/i_dvd_repository.py"], "/ui/presenter/dvd_presenter.py": ["/application_services/CreateDvd.py", "/application_services/get_all_dvd.py", "/application_services/Remove_dvd.py", "/application_services/UpdateDvd.py", "/ui/views/q_dvd_edit.py", "/ui/views/q_dvd_main.py"]} |
70,421 | WANTEDv2/architecture.py | refs/heads/main | /application_services/implements/dvd_mapper.py | from domain.Cddvd import Cddvd
class DvdMapper:
@staticmethod
def dto_to_domain(dto: dict) -> Cddvd:
return Cddvd(id=None if "id" not in dto else dto['id'], name=dto['name'])
@staticmethod
def domain_to_dto(book: Cddvd) -> dict:
return {"id": book.id, "name": book.name}
| {"/application_services/implements/get_all_dvd.py": ["/application_services/get_all_dvd.py", "/application_services/implements/dvd_mapper.py", "/domain_services/i_dvd_repository.py"], "/application_services/implements/dvd_mapper.py": ["/domain/Cddvd.py"], "/infrastructure/data_access/dvd_repository.py": ["/domain/Cddvd.py", "/domain_services/i_dvd_repository.py"], "/domain_services/i_dvd_repository.py": ["/domain/Cddvd.py"], "/application_services/implements/create_dvd.py": ["/application_services/CreateDvd.py", "/application_services/UpdateDvd.py", "/application_services/implements/dvd_mapper.py", "/domain_services/i_dvd_repository.py"], "/ui/main.py": ["/application_services/implements/create_dvd.py", "/application_services/implements/get_all_dvd.py", "/application_services/implements/remove_dvd.py", "/infrastructure/data_access/dvd_repository.py", "/ui/presenter/dvd_presenter.py", "/ui/views/q_dvd_main.py", "/ui/views/q_dvd_edit.py"], "/application_services/implements/remove_dvd.py": ["/application_services/Remove_dvd.py", "/domain_services/i_dvd_repository.py"], "/ui/presenter/dvd_presenter.py": ["/application_services/CreateDvd.py", "/application_services/get_all_dvd.py", "/application_services/Remove_dvd.py", "/application_services/UpdateDvd.py", "/ui/views/q_dvd_edit.py", "/ui/views/q_dvd_main.py"]} |
70,422 | WANTEDv2/architecture.py | refs/heads/main | /application_services/CreateDvd.py | from abc import ABC, abstractmethod
class CreateDvd(ABC): # Будет работать с репозиторием через интерфейс
@abstractmethod
def exec(self, cddvd_dto: dict) -> dict: # Этот метод принимает dvd ДТО и возвращает dvd ДТО
pass
| {"/application_services/implements/get_all_dvd.py": ["/application_services/get_all_dvd.py", "/application_services/implements/dvd_mapper.py", "/domain_services/i_dvd_repository.py"], "/application_services/implements/dvd_mapper.py": ["/domain/Cddvd.py"], "/infrastructure/data_access/dvd_repository.py": ["/domain/Cddvd.py", "/domain_services/i_dvd_repository.py"], "/domain_services/i_dvd_repository.py": ["/domain/Cddvd.py"], "/application_services/implements/create_dvd.py": ["/application_services/CreateDvd.py", "/application_services/UpdateDvd.py", "/application_services/implements/dvd_mapper.py", "/domain_services/i_dvd_repository.py"], "/ui/main.py": ["/application_services/implements/create_dvd.py", "/application_services/implements/get_all_dvd.py", "/application_services/implements/remove_dvd.py", "/infrastructure/data_access/dvd_repository.py", "/ui/presenter/dvd_presenter.py", "/ui/views/q_dvd_main.py", "/ui/views/q_dvd_edit.py"], "/application_services/implements/remove_dvd.py": ["/application_services/Remove_dvd.py", "/domain_services/i_dvd_repository.py"], "/ui/presenter/dvd_presenter.py": ["/application_services/CreateDvd.py", "/application_services/get_all_dvd.py", "/application_services/Remove_dvd.py", "/application_services/UpdateDvd.py", "/ui/views/q_dvd_edit.py", "/ui/views/q_dvd_main.py"]} |
70,423 | WANTEDv2/architecture.py | refs/heads/main | /domain/Cddvd.py | class Cddvd:
def __init__(self, name: str, id: int = None):
self._name = name
self._id = id
@property
def name(self) -> str:
return self._name
@name.setter
def name(self, value: str) -> None:
self._name = value
@property
def id(self) -> int:
return self._id
@id.setter
def id(self, value: id) -> None:
self._id = value
| {"/application_services/implements/get_all_dvd.py": ["/application_services/get_all_dvd.py", "/application_services/implements/dvd_mapper.py", "/domain_services/i_dvd_repository.py"], "/application_services/implements/dvd_mapper.py": ["/domain/Cddvd.py"], "/infrastructure/data_access/dvd_repository.py": ["/domain/Cddvd.py", "/domain_services/i_dvd_repository.py"], "/domain_services/i_dvd_repository.py": ["/domain/Cddvd.py"], "/application_services/implements/create_dvd.py": ["/application_services/CreateDvd.py", "/application_services/UpdateDvd.py", "/application_services/implements/dvd_mapper.py", "/domain_services/i_dvd_repository.py"], "/ui/main.py": ["/application_services/implements/create_dvd.py", "/application_services/implements/get_all_dvd.py", "/application_services/implements/remove_dvd.py", "/infrastructure/data_access/dvd_repository.py", "/ui/presenter/dvd_presenter.py", "/ui/views/q_dvd_main.py", "/ui/views/q_dvd_edit.py"], "/application_services/implements/remove_dvd.py": ["/application_services/Remove_dvd.py", "/domain_services/i_dvd_repository.py"], "/ui/presenter/dvd_presenter.py": ["/application_services/CreateDvd.py", "/application_services/get_all_dvd.py", "/application_services/Remove_dvd.py", "/application_services/UpdateDvd.py", "/ui/views/q_dvd_edit.py", "/ui/views/q_dvd_main.py"]} |
70,424 | WANTEDv2/architecture.py | refs/heads/main | /infrastructure/data_access/dvd_repository.py | from domain.Cddvd import Cddvd
from domain_services.i_dvd_repository import IDvdRepository
class DvdRepository(IDvdRepository):
def __init__(self): # Сохранение в оперативной памяти
self._db = {1: Cddvd(name="Фильм1", id=1),
2: Cddvd(name="Фильм2", id=2)}
self._counter = len(self._db) + 1
def create_or_update(self, cddvd: Cddvd) -> Cddvd:
if not cddvd.id:
cddvd.id = self._counter
self._counter += 1
self._db[cddvd.id] = cddvd
return cddvd
def remove(self, id: int) -> None:
if id in self._db:
del self._db[id]
def all(self) -> list:
return list(self._db.values()) | {"/application_services/implements/get_all_dvd.py": ["/application_services/get_all_dvd.py", "/application_services/implements/dvd_mapper.py", "/domain_services/i_dvd_repository.py"], "/application_services/implements/dvd_mapper.py": ["/domain/Cddvd.py"], "/infrastructure/data_access/dvd_repository.py": ["/domain/Cddvd.py", "/domain_services/i_dvd_repository.py"], "/domain_services/i_dvd_repository.py": ["/domain/Cddvd.py"], "/application_services/implements/create_dvd.py": ["/application_services/CreateDvd.py", "/application_services/UpdateDvd.py", "/application_services/implements/dvd_mapper.py", "/domain_services/i_dvd_repository.py"], "/ui/main.py": ["/application_services/implements/create_dvd.py", "/application_services/implements/get_all_dvd.py", "/application_services/implements/remove_dvd.py", "/infrastructure/data_access/dvd_repository.py", "/ui/presenter/dvd_presenter.py", "/ui/views/q_dvd_main.py", "/ui/views/q_dvd_edit.py"], "/application_services/implements/remove_dvd.py": ["/application_services/Remove_dvd.py", "/domain_services/i_dvd_repository.py"], "/ui/presenter/dvd_presenter.py": ["/application_services/CreateDvd.py", "/application_services/get_all_dvd.py", "/application_services/Remove_dvd.py", "/application_services/UpdateDvd.py", "/ui/views/q_dvd_edit.py", "/ui/views/q_dvd_main.py"]} |
70,425 | WANTEDv2/architecture.py | refs/heads/main | /ui/views/q_dvd_main.py | from PyQt5 import uic
from PyQt5.QtWidgets import QMainWindow
class QDvdMain(QMainWindow):
def __init__(self):
super().__init__()
uic.loadUi("views/dvd_main.ui", self)
def connect_add(self, slot):
self.add_btn.clicked.connect(slot)
def connect_del(self, slot):
self.del_btn.clicked.connect(slot)
def connect_edit(self, slot):
self.edit_btn.clicked.connect(slot)
def set_dvd(self, dvds):
self.dvd_list.clear()
for i in dvds:
self.dvd_list.addItem(i['name'])
def get_current_dvd_index(self):
return self.dvd_list.currentRow() | {"/application_services/implements/get_all_dvd.py": ["/application_services/get_all_dvd.py", "/application_services/implements/dvd_mapper.py", "/domain_services/i_dvd_repository.py"], "/application_services/implements/dvd_mapper.py": ["/domain/Cddvd.py"], "/infrastructure/data_access/dvd_repository.py": ["/domain/Cddvd.py", "/domain_services/i_dvd_repository.py"], "/domain_services/i_dvd_repository.py": ["/domain/Cddvd.py"], "/application_services/implements/create_dvd.py": ["/application_services/CreateDvd.py", "/application_services/UpdateDvd.py", "/application_services/implements/dvd_mapper.py", "/domain_services/i_dvd_repository.py"], "/ui/main.py": ["/application_services/implements/create_dvd.py", "/application_services/implements/get_all_dvd.py", "/application_services/implements/remove_dvd.py", "/infrastructure/data_access/dvd_repository.py", "/ui/presenter/dvd_presenter.py", "/ui/views/q_dvd_main.py", "/ui/views/q_dvd_edit.py"], "/application_services/implements/remove_dvd.py": ["/application_services/Remove_dvd.py", "/domain_services/i_dvd_repository.py"], "/ui/presenter/dvd_presenter.py": ["/application_services/CreateDvd.py", "/application_services/get_all_dvd.py", "/application_services/Remove_dvd.py", "/application_services/UpdateDvd.py", "/ui/views/q_dvd_edit.py", "/ui/views/q_dvd_main.py"]} |
70,426 | WANTEDv2/architecture.py | refs/heads/main | /domain_services/i_dvd_repository.py | from abc import ABC, abstractmethod
from domain.Cddvd import Cddvd
class IDvdRepository(ABC):
@abstractmethod
def create_or_update(self, cddvd: Cddvd) -> Cddvd: # Возвращает диск
pass
@abstractmethod
def remove(self, id: int) -> None:
pass
@abstractmethod
def all(self) -> list: # Возвращает список
pass
| {"/application_services/implements/get_all_dvd.py": ["/application_services/get_all_dvd.py", "/application_services/implements/dvd_mapper.py", "/domain_services/i_dvd_repository.py"], "/application_services/implements/dvd_mapper.py": ["/domain/Cddvd.py"], "/infrastructure/data_access/dvd_repository.py": ["/domain/Cddvd.py", "/domain_services/i_dvd_repository.py"], "/domain_services/i_dvd_repository.py": ["/domain/Cddvd.py"], "/application_services/implements/create_dvd.py": ["/application_services/CreateDvd.py", "/application_services/UpdateDvd.py", "/application_services/implements/dvd_mapper.py", "/domain_services/i_dvd_repository.py"], "/ui/main.py": ["/application_services/implements/create_dvd.py", "/application_services/implements/get_all_dvd.py", "/application_services/implements/remove_dvd.py", "/infrastructure/data_access/dvd_repository.py", "/ui/presenter/dvd_presenter.py", "/ui/views/q_dvd_main.py", "/ui/views/q_dvd_edit.py"], "/application_services/implements/remove_dvd.py": ["/application_services/Remove_dvd.py", "/domain_services/i_dvd_repository.py"], "/ui/presenter/dvd_presenter.py": ["/application_services/CreateDvd.py", "/application_services/get_all_dvd.py", "/application_services/Remove_dvd.py", "/application_services/UpdateDvd.py", "/ui/views/q_dvd_edit.py", "/ui/views/q_dvd_main.py"]} |
70,427 | WANTEDv2/architecture.py | refs/heads/main | /application_services/implements/create_dvd.py | from application_services.CreateDvd import CreateDvd
from application_services.UpdateDvd import UpdateDvd
from application_services.implements.dvd_mapper import DvdMapper
from domain_services.i_dvd_repository import IDvdRepository
class CreateOrUpdateDvd (CreateDvd, UpdateDvd): # Класс унаследовал итерфэйсы application_services
def __init__(self, repository: IDvdRepository):
self.repository = repository
def exec(self, dvd_dto: dict) -> dict: # Создание dvd
cddvd = DvdMapper.dto_to_domain(dvd_dto)
new_dvd = self.repository.create_or_update(cddvd)
return DvdMapper.domain_to_dto(new_dvd) | {"/application_services/implements/get_all_dvd.py": ["/application_services/get_all_dvd.py", "/application_services/implements/dvd_mapper.py", "/domain_services/i_dvd_repository.py"], "/application_services/implements/dvd_mapper.py": ["/domain/Cddvd.py"], "/infrastructure/data_access/dvd_repository.py": ["/domain/Cddvd.py", "/domain_services/i_dvd_repository.py"], "/domain_services/i_dvd_repository.py": ["/domain/Cddvd.py"], "/application_services/implements/create_dvd.py": ["/application_services/CreateDvd.py", "/application_services/UpdateDvd.py", "/application_services/implements/dvd_mapper.py", "/domain_services/i_dvd_repository.py"], "/ui/main.py": ["/application_services/implements/create_dvd.py", "/application_services/implements/get_all_dvd.py", "/application_services/implements/remove_dvd.py", "/infrastructure/data_access/dvd_repository.py", "/ui/presenter/dvd_presenter.py", "/ui/views/q_dvd_main.py", "/ui/views/q_dvd_edit.py"], "/application_services/implements/remove_dvd.py": ["/application_services/Remove_dvd.py", "/domain_services/i_dvd_repository.py"], "/ui/presenter/dvd_presenter.py": ["/application_services/CreateDvd.py", "/application_services/get_all_dvd.py", "/application_services/Remove_dvd.py", "/application_services/UpdateDvd.py", "/ui/views/q_dvd_edit.py", "/ui/views/q_dvd_main.py"]} |
70,428 | WANTEDv2/architecture.py | refs/heads/main | /ui/main.py | import sys
from PyQt5.QtWidgets import QApplication
from application_services.implements.create_dvd import CreateOrUpdateDvd
from application_services.implements.get_all_dvd import GetAllDvd
from application_services.implements.remove_dvd import RemoveDvd
from infrastructure.data_access.dvd_repository import DvdRepository
from ui.presenter.dvd_presenter import DvdPresenter
from ui.views.q_dvd_main import QDvdMain
from ui.views.q_dvd_edit import QDvdEdit
app = QApplication(sys.argv)
main_win = QDvdMain()
dialog=QDvdEdit
repository = DvdRepository()
c = CreateOrUpdateDvd(repository)
presenter = DvdPresenter(main_win, c, c, GetAllDvd(repository), RemoveDvd(repository))
main_win.show()
dialog = QDvdEdit
app.exec() | {"/application_services/implements/get_all_dvd.py": ["/application_services/get_all_dvd.py", "/application_services/implements/dvd_mapper.py", "/domain_services/i_dvd_repository.py"], "/application_services/implements/dvd_mapper.py": ["/domain/Cddvd.py"], "/infrastructure/data_access/dvd_repository.py": ["/domain/Cddvd.py", "/domain_services/i_dvd_repository.py"], "/domain_services/i_dvd_repository.py": ["/domain/Cddvd.py"], "/application_services/implements/create_dvd.py": ["/application_services/CreateDvd.py", "/application_services/UpdateDvd.py", "/application_services/implements/dvd_mapper.py", "/domain_services/i_dvd_repository.py"], "/ui/main.py": ["/application_services/implements/create_dvd.py", "/application_services/implements/get_all_dvd.py", "/application_services/implements/remove_dvd.py", "/infrastructure/data_access/dvd_repository.py", "/ui/presenter/dvd_presenter.py", "/ui/views/q_dvd_main.py", "/ui/views/q_dvd_edit.py"], "/application_services/implements/remove_dvd.py": ["/application_services/Remove_dvd.py", "/domain_services/i_dvd_repository.py"], "/ui/presenter/dvd_presenter.py": ["/application_services/CreateDvd.py", "/application_services/get_all_dvd.py", "/application_services/Remove_dvd.py", "/application_services/UpdateDvd.py", "/ui/views/q_dvd_edit.py", "/ui/views/q_dvd_main.py"]} |
70,429 | WANTEDv2/architecture.py | refs/heads/main | /application_services/UpdateDvd.py | from abc import ABC, abstractmethod
class UpdateDvd(ABC):
@abstractmethod
def exec(self, cddvd_dto: dict) -> dict:
pass
| {"/application_services/implements/get_all_dvd.py": ["/application_services/get_all_dvd.py", "/application_services/implements/dvd_mapper.py", "/domain_services/i_dvd_repository.py"], "/application_services/implements/dvd_mapper.py": ["/domain/Cddvd.py"], "/infrastructure/data_access/dvd_repository.py": ["/domain/Cddvd.py", "/domain_services/i_dvd_repository.py"], "/domain_services/i_dvd_repository.py": ["/domain/Cddvd.py"], "/application_services/implements/create_dvd.py": ["/application_services/CreateDvd.py", "/application_services/UpdateDvd.py", "/application_services/implements/dvd_mapper.py", "/domain_services/i_dvd_repository.py"], "/ui/main.py": ["/application_services/implements/create_dvd.py", "/application_services/implements/get_all_dvd.py", "/application_services/implements/remove_dvd.py", "/infrastructure/data_access/dvd_repository.py", "/ui/presenter/dvd_presenter.py", "/ui/views/q_dvd_main.py", "/ui/views/q_dvd_edit.py"], "/application_services/implements/remove_dvd.py": ["/application_services/Remove_dvd.py", "/domain_services/i_dvd_repository.py"], "/ui/presenter/dvd_presenter.py": ["/application_services/CreateDvd.py", "/application_services/get_all_dvd.py", "/application_services/Remove_dvd.py", "/application_services/UpdateDvd.py", "/ui/views/q_dvd_edit.py", "/ui/views/q_dvd_main.py"]} |
70,430 | WANTEDv2/architecture.py | refs/heads/main | /ui/views/q_dvd_edit.py | import sys
from PyQt5 import uic
from PyQt5.QtWidgets import QDialog, QApplication
class QDvdEdit(QDialog):
def __init__(self, parent, name=''):
super().__init__(parent)
uic.loadUi("views/dvd_edit.ui", self)
self.name_edit.setText(name)
def get_current_name(self):
return self.name_edit.text()
if __name__ == '__main__':
app=QApplication(sys.argv)
dialog = QDialog(None)
app.exec() | {"/application_services/implements/get_all_dvd.py": ["/application_services/get_all_dvd.py", "/application_services/implements/dvd_mapper.py", "/domain_services/i_dvd_repository.py"], "/application_services/implements/dvd_mapper.py": ["/domain/Cddvd.py"], "/infrastructure/data_access/dvd_repository.py": ["/domain/Cddvd.py", "/domain_services/i_dvd_repository.py"], "/domain_services/i_dvd_repository.py": ["/domain/Cddvd.py"], "/application_services/implements/create_dvd.py": ["/application_services/CreateDvd.py", "/application_services/UpdateDvd.py", "/application_services/implements/dvd_mapper.py", "/domain_services/i_dvd_repository.py"], "/ui/main.py": ["/application_services/implements/create_dvd.py", "/application_services/implements/get_all_dvd.py", "/application_services/implements/remove_dvd.py", "/infrastructure/data_access/dvd_repository.py", "/ui/presenter/dvd_presenter.py", "/ui/views/q_dvd_main.py", "/ui/views/q_dvd_edit.py"], "/application_services/implements/remove_dvd.py": ["/application_services/Remove_dvd.py", "/domain_services/i_dvd_repository.py"], "/ui/presenter/dvd_presenter.py": ["/application_services/CreateDvd.py", "/application_services/get_all_dvd.py", "/application_services/Remove_dvd.py", "/application_services/UpdateDvd.py", "/ui/views/q_dvd_edit.py", "/ui/views/q_dvd_main.py"]} |
70,431 | WANTEDv2/architecture.py | refs/heads/main | /application_services/implements/remove_dvd.py | from application_services.Remove_dvd import RemoveDvd
from domain_services.i_dvd_repository import IDvdRepository
class RemoveDvd(RemoveDvd):
def __init__(self, repository: IDvdRepository):
self.repository = repository
def exec(self, id: int) -> None:
self.repository.remove(id) | {"/application_services/implements/get_all_dvd.py": ["/application_services/get_all_dvd.py", "/application_services/implements/dvd_mapper.py", "/domain_services/i_dvd_repository.py"], "/application_services/implements/dvd_mapper.py": ["/domain/Cddvd.py"], "/infrastructure/data_access/dvd_repository.py": ["/domain/Cddvd.py", "/domain_services/i_dvd_repository.py"], "/domain_services/i_dvd_repository.py": ["/domain/Cddvd.py"], "/application_services/implements/create_dvd.py": ["/application_services/CreateDvd.py", "/application_services/UpdateDvd.py", "/application_services/implements/dvd_mapper.py", "/domain_services/i_dvd_repository.py"], "/ui/main.py": ["/application_services/implements/create_dvd.py", "/application_services/implements/get_all_dvd.py", "/application_services/implements/remove_dvd.py", "/infrastructure/data_access/dvd_repository.py", "/ui/presenter/dvd_presenter.py", "/ui/views/q_dvd_main.py", "/ui/views/q_dvd_edit.py"], "/application_services/implements/remove_dvd.py": ["/application_services/Remove_dvd.py", "/domain_services/i_dvd_repository.py"], "/ui/presenter/dvd_presenter.py": ["/application_services/CreateDvd.py", "/application_services/get_all_dvd.py", "/application_services/Remove_dvd.py", "/application_services/UpdateDvd.py", "/ui/views/q_dvd_edit.py", "/ui/views/q_dvd_main.py"]} |
70,432 | WANTEDv2/architecture.py | refs/heads/main | /application_services/Remove_dvd.py | from abc import ABC, abstractmethod
class RemoveDvd(ABC):
@abstractmethod
def exec(self, id: int) -> dict:
pass
| {"/application_services/implements/get_all_dvd.py": ["/application_services/get_all_dvd.py", "/application_services/implements/dvd_mapper.py", "/domain_services/i_dvd_repository.py"], "/application_services/implements/dvd_mapper.py": ["/domain/Cddvd.py"], "/infrastructure/data_access/dvd_repository.py": ["/domain/Cddvd.py", "/domain_services/i_dvd_repository.py"], "/domain_services/i_dvd_repository.py": ["/domain/Cddvd.py"], "/application_services/implements/create_dvd.py": ["/application_services/CreateDvd.py", "/application_services/UpdateDvd.py", "/application_services/implements/dvd_mapper.py", "/domain_services/i_dvd_repository.py"], "/ui/main.py": ["/application_services/implements/create_dvd.py", "/application_services/implements/get_all_dvd.py", "/application_services/implements/remove_dvd.py", "/infrastructure/data_access/dvd_repository.py", "/ui/presenter/dvd_presenter.py", "/ui/views/q_dvd_main.py", "/ui/views/q_dvd_edit.py"], "/application_services/implements/remove_dvd.py": ["/application_services/Remove_dvd.py", "/domain_services/i_dvd_repository.py"], "/ui/presenter/dvd_presenter.py": ["/application_services/CreateDvd.py", "/application_services/get_all_dvd.py", "/application_services/Remove_dvd.py", "/application_services/UpdateDvd.py", "/ui/views/q_dvd_edit.py", "/ui/views/q_dvd_main.py"]} |
70,433 | WANTEDv2/architecture.py | refs/heads/main | /application_services/get_all_dvd.py | from abc import ABC, abstractmethod
class GetAllDvd(ABC):
@abstractmethod
def exec(self) -> list:
pass
| {"/application_services/implements/get_all_dvd.py": ["/application_services/get_all_dvd.py", "/application_services/implements/dvd_mapper.py", "/domain_services/i_dvd_repository.py"], "/application_services/implements/dvd_mapper.py": ["/domain/Cddvd.py"], "/infrastructure/data_access/dvd_repository.py": ["/domain/Cddvd.py", "/domain_services/i_dvd_repository.py"], "/domain_services/i_dvd_repository.py": ["/domain/Cddvd.py"], "/application_services/implements/create_dvd.py": ["/application_services/CreateDvd.py", "/application_services/UpdateDvd.py", "/application_services/implements/dvd_mapper.py", "/domain_services/i_dvd_repository.py"], "/ui/main.py": ["/application_services/implements/create_dvd.py", "/application_services/implements/get_all_dvd.py", "/application_services/implements/remove_dvd.py", "/infrastructure/data_access/dvd_repository.py", "/ui/presenter/dvd_presenter.py", "/ui/views/q_dvd_main.py", "/ui/views/q_dvd_edit.py"], "/application_services/implements/remove_dvd.py": ["/application_services/Remove_dvd.py", "/domain_services/i_dvd_repository.py"], "/ui/presenter/dvd_presenter.py": ["/application_services/CreateDvd.py", "/application_services/get_all_dvd.py", "/application_services/Remove_dvd.py", "/application_services/UpdateDvd.py", "/ui/views/q_dvd_edit.py", "/ui/views/q_dvd_main.py"]} |
70,434 | WANTEDv2/architecture.py | refs/heads/main | /ui/presenter/dvd_presenter.py | from application_services.CreateDvd import CreateDvd
from application_services.get_all_dvd import GetAllDvd
from application_services.Remove_dvd import RemoveDvd
from application_services.UpdateDvd import UpdateDvd
from ui.views.q_dvd_edit import QDvdEdit
from ui.views.q_dvd_main import QDvdMain
class DvdPresenter:
def __init__(self, view: QDvdMain,
create_dvd: CreateDvd,
update_dvd : UpdateDvd,
get_all_dvd: GetAllDvd,
remove_dvd: RemoveDvd,):
self.view = view
self.create_dvd = create_dvd
self.update_dvd = update_dvd
self.get_all_dvd = get_all_dvd
self.remove_dvd = remove_dvd
self.setup()
def setup(self):
self.view.connect_add(self.add)
self.view.connect_del(self.remove)
self.view.connect_edit(self.edit)
self.get_all()
def open_dialog(self, cddvd: dict):
dialog = QDvdEdit(self.view, cddvd['name'])
if dialog.exec():
current_name = dialog.get_current_name()
if not cddvd['id']:
self.create_dvd.exec({"name": current_name})
else:
cddvd['name'] = current_name
self.update_dvd.exec(cddvd)
self.get_all()
def add(self):
self.open_dialog({'id': None, "name": ""})
def edit(self):
index = self.view.get_current_dvd_index()
self.open_dialog(self.dvds[index])
def remove(self):
index = self.view.get_current_dvd_index()
self.remove_dvd.exec(index)
self.get_all()
def get_all(self):
self.dvds = self.get_all_dvd.exec() # Получение всех dvd
self.view.set_dvd(self.dvds)
| {"/application_services/implements/get_all_dvd.py": ["/application_services/get_all_dvd.py", "/application_services/implements/dvd_mapper.py", "/domain_services/i_dvd_repository.py"], "/application_services/implements/dvd_mapper.py": ["/domain/Cddvd.py"], "/infrastructure/data_access/dvd_repository.py": ["/domain/Cddvd.py", "/domain_services/i_dvd_repository.py"], "/domain_services/i_dvd_repository.py": ["/domain/Cddvd.py"], "/application_services/implements/create_dvd.py": ["/application_services/CreateDvd.py", "/application_services/UpdateDvd.py", "/application_services/implements/dvd_mapper.py", "/domain_services/i_dvd_repository.py"], "/ui/main.py": ["/application_services/implements/create_dvd.py", "/application_services/implements/get_all_dvd.py", "/application_services/implements/remove_dvd.py", "/infrastructure/data_access/dvd_repository.py", "/ui/presenter/dvd_presenter.py", "/ui/views/q_dvd_main.py", "/ui/views/q_dvd_edit.py"], "/application_services/implements/remove_dvd.py": ["/application_services/Remove_dvd.py", "/domain_services/i_dvd_repository.py"], "/ui/presenter/dvd_presenter.py": ["/application_services/CreateDvd.py", "/application_services/get_all_dvd.py", "/application_services/Remove_dvd.py", "/application_services/UpdateDvd.py", "/ui/views/q_dvd_edit.py", "/ui/views/q_dvd_main.py"]} |
70,438 | krunaltule09/statusChecker | refs/heads/master | /scanner/views.py | from django.shortcuts import render
from urllib.request import urlopen
import urllib3
import requests as req
import tldextract
def getStatus(link):
http = urllib3.PoolManager()
r = http.request('GET', link)
status=r.status
return status
def getDomain(link):
list = tldextract.extract(link)
domain_name = list.domain + '.' + list.suffix
print(domain_name)
return domain_name
def getinfo(link):
response=[]
html = urlopen(link)
data=html.info()
return dict(data)
def get301withUrl(url):
resp = req.get(url)
print(resp.history)
print(resp.url)
return resp.history,resp.url
def HomePageView(request):
if(request.method=="POST"):
info=[]
mainUrl=""
urls=[]
isRedirection=False
Url=request.POST.get('url')
Url=getDomain(Url)
url1="https://"+Url
url2="http://"+Url
url3="https://www."+Url
url4="http://www."+Url
urls.append(url1)
urls.append(url2)
urls.append(url3)
urls.append(url4)
print(urls)
header_info=getinfo(url4)
status=[]
status.append(getStatus(url4))
context={}
redirect,redirectionURL=get301withUrl(url2)
if(len(redirect)>0):
context['numberOfredirect']=len(redirect)
isRedirection=True
context['redirectionURL']=redirectionURL
if(isRedirection):
for i in range (context['numberOfredirect']):
status.append(301)
mainUrl="http://"+Url
context['header_info']=header_info
context['status_code']=status
context['mainUrl']=mainUrl
context['isRedirect']=isRedirection
# print(context)
return render(request,'index.html',context)
return render(request,"index.html",{}) | {"/scanner/urls.py": ["/scanner/views.py"]} |
70,439 | krunaltule09/statusChecker | refs/heads/master | /scanner/urls.py | from django.urls import path
from .views import HomePageView
urlpatterns = [
path('index',HomePageView,name="home"),
] | {"/scanner/urls.py": ["/scanner/views.py"]} |
70,442 | xdhome/my | refs/heads/master | /WYKL/views.py | import hashlib
import uuid
from audioop import reverse
from django.http import HttpResponse, JsonResponse
from django.shortcuts import render, redirect
# Create your views here.
from WYKL.models import *
# 首页
def index(request):
# 获取轮播图数据
wheels = Wheel.objects.all()
# print(len(wheels))
# for wheel in wheels:
# print(type(wheel.imgpath), wheel.imgpath)
# 导航栏数据
navs = Nav.objects.all()
# print(111111)
# if request.method == "GET":
# print(2222222)
# return render(request, "index.html")
# elif request.method == "POST":
# print(333333)
goods = Goods.objects.all()
# 获取 cookie
account = request.COOKIES.get("account")
data = {
'account': account,
'wheels': wheels,
'navs': navs,
'goods': goods
}
return render(request, "index.html", context=data)
# 详情
def detail(request):
return render(request, "detail.html")
# 购物车
def cart(request):
# 获取 cookie
account = request.COOKIES.get("account")
# 获取用户
user = User.objects.get(account=account)
userid = user.id
# 获取当前用户的购物车数据
carts = Cart.objects.filter(user_id=userid)
# 总价
carts_selects = Cart.objects.filter(user_id=userid).filter(isselect=1)
print("商品数量" ,len(carts_selects))
# total_value = 0
# for carts_select in carts_selects:
# total_value += carts_select.
data = {
"account": account,
"carts": carts,
}
return render(request, "cart.html",data)
# 加密
def encryption(password):
m = hashlib.md5()
m.update(password.encode())
return m.hexdigest()
# 注册
def register(request):
reg_data = {
"register_error": ""
}
if request.method == "GET": # 获取注册页面
# return HttpResponse("11111")
return render(request, "register.html")
elif request.method == "POST": # 进行注册操作
# return HttpResponse("222222")
# 获取表单数据
account = request.POST.get("account")
password = request.POST.get("password")
tel = request.POST.get("tel")
print('1',tel,'2',account,'3',password)
# 验证账号
if 5<len(account)<19:
name_list =[]
users = User.objects.all()
for user in users:
name_list.append(user.account)
if account in name_list:
reg_data["register_error"] = "账号已存在"
return render(request, "register.html", reg_data)
else:
# 验证通过，存入数据
user = User()
user.account = account
user.password = encryption(password)
user.tel = tel
user.token = str(uuid.uuid5(uuid.uuid4(), 'register'))
user.save()
# 重定向到首页
response = redirect("wykl:index")
# 状态保持
# request.sessino["tokon"] = user.token
response.set_cookie("account",account)
return response
# return redirect("wykl:index")
# return render(request, "index.html")
else:
reg_data["register_error"] = "账号已存在"
return render(request, "login.html", reg_data)
# 登陆
def login(request):
log_data= {
"login_error": ""
}
if request.method == "GET":
# print("GET")
return render(request, "login.html")
elif request.method == "POST":
# print("POST")
account = request.POST.get("account")
password = encryption(request.POST.get("password"))
user = User.objects.filter(account=account).filter(password=password)
if user.exists():
response = redirect("wykl:index")
# 设置 cookie
response.set_cookie("account", account)
return response
else:
log_data["login_error"] = "用户名或密码错误"
return render(request,"login.html", log_data)
# 退出
def logout(request):
response = redirect("wykl:index")
response.delete_cookie("account")
return response
# 详情
def shop(request, goodsid):
# 获取 cookie
account = request.COOKIES.get("account")
# 获取商品
good = Goods.objects.get(goodsid=goodsid)
# print(good.goodsid,"id")
return render(request, "shop.html", context={'good': good, "account": account})
# 注册账号验证
def verify(request):
# account = request.GET.get("_account")
# print(account,1111111111)
return None
# 加入购物车
def addcart(request):
print("加++++")
data = {
"msg": "",
"status": 1
}
account = request.COOKIES.get("account")
# 判断登陆状态
if account:
print("有account")
goodsid = request.GET.get("goodsid")
goods = Goods.objects.get(goodsid=goodsid)
user = User.objects.get(account=account)
number = request.GET.get("number")
# print(goods.goodsid, number,user.id)
carts = Cart.objects.filter(goods=goods.id).filter(user=user.id)
print(type(carts), carts)
# print(type(carts.number), carts.number,carts)
# 判断本用户是否曾添加此商品
if carts.exists():
print("有记录")
cart = carts[0]
print(type(cart.number),cart.number)
cart.number += int(number)
cart.save()
data["msg"] = "添加成功"
data["status"] = 1
return JsonResponse(data)
else:
print("无记录 ")
cart = Cart()
cart.goods = goods
cart.number = number
cart.user = user
cart.save()
data["msg"] = "添加成功"
data["status"] = 1
return JsonResponse(data)
else:
data["msg"] = "添加失败"
data["status"] = -1
return JsonResponse(data)
# 购物车减操作
def subtract(request):
print("减----")
cartid = request.GET.get("cartid")
cart = Cart.objects.get(id=cartid)
cart.number -= 1
if cart.number:
cart.save()
data = {
"number": cart.number
}
return JsonResponse(data)
else:
return JsonResponse()
# 购物车加操作
def addcart1(request):
print("加----")
cartid = request.GET.get("cartid")
cart = Cart.objects.get(id=cartid)
cart.number += 1
cart.save()
data = {
"number": cart.number
}
return JsonResponse(data)
# 购物车删除操作
def delcart(request):
data = {
"status": 1,
}
cartid = request.GET.get("cartid")
# goodsid = request.GET.get("goodsid")
print(cartid)
cart = Cart.objects.get(id=cartid)
cart.delete()
return JsonResponse(data)
# 购物车选中操作
def select(request):
data = {
"status": 2,
}
print("选中")
cartid = request.GET.get("cartid")
cart = Cart.objects.get(id=cartid)
cart.isselect = not(cart.isselect)
cart.save()
return JsonResponse(data) | {"/WYKL/views.py": ["/WYKL/models.py"]} |
70,443 | xdhome/my | refs/heads/master | /WYKL/migrations/0001_initial.py | # -*- coding: utf-8 -*-
# Generated by Django 1.11.4 on 2018-11-09 08:02
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
initial = True
dependencies = [
]
operations = [
migrations.CreateModel(
name='Goods',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('goodsid', models.CharField(max_length=5)),
('goodsimg', models.CharField(max_length=100)),
('goodsname', models.CharField(max_length=256)),
('price', models.IntegerField()),
('descript', models.CharField(max_length=100)),
],
options={
'db_table': 'goods',
},
),
migrations.CreateModel(
name='Nav',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('imgpath', models.CharField(max_length=30)),
],
options={
'db_table': 'nav',
},
),
migrations.CreateModel(
name='User',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('account', models.CharField(max_length=50, unique=True)),
('password', models.CharField(max_length=40)),
('tel', models.CharField(max_length=20)),
('token', models.CharField(max_length=256)),
],
),
migrations.CreateModel(
name='Wheel',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('imgpath', models.CharField(max_length=30)),
],
options={
'db_table': 'wheel',
},
),
]
| {"/WYKL/views.py": ["/WYKL/models.py"]} |
70,444 | xdhome/my | refs/heads/master | /WYKL/models.py | from django.db import models
# Create your models here.
# 用户数据
class User(models.Model):
account = models.CharField(max_length=50, unique=True)
password = models.CharField(max_length=40)
tel = models.CharField(max_length=20)
token = models.CharField(max_length=256)
# 轮播图数据
class Wheel(models.Model):
imgpath = models.CharField(max_length=30)
class Meta:
db_table = "wheel"
# 导航栏数据
class Nav(models.Model):
imgpath = models.CharField(max_length=30)
class Meta:
db_table = "nav"
# 首页商品展示数据
class Goods(models.Model):
goodsid = models.CharField(max_length=5)
goodsimg = models.CharField(max_length=100)
goodsname = models.CharField(max_length=256)
price = models.IntegerField()
descript = models.CharField(max_length=100)
class Meta:
db_table = "goods"
# 购物车数据
class Cart(models.Model):
# 外键关联用户
user = models.ForeignKey(User)
# 外键关联商品
goods = models.ForeignKey(Goods)
# 商品数量
number = models.IntegerField()
# 是否选中
isselect = models.BooleanField(default=True)
class Meta:
db_table = "cart"
| {"/WYKL/views.py": ["/WYKL/models.py"]} |
70,445 | xdhome/my | refs/heads/master | /WYKL/apps.py | from django.apps import AppConfig
class WyklConfig(AppConfig):
name = 'WYKL'
| {"/WYKL/views.py": ["/WYKL/models.py"]} |
70,446 | xdhome/my | refs/heads/master | /WYKL/urls.py | from django.conf.urls import url
from WYKL import views
urlpatterns = [
# url(r'^$', views.index),
url(r'^index/$', views.index, name="index"), # 首页
url(r'^detail/$', views.detail, name="detail"), # 商品展示
url(r'^cart/$', views.cart, name="cart"), # 购物车
url(r'^login/$', views.login, name="login"), # 登陆
url(r'^register/$', views.register, name="register"), # 注册
url(r'^shop/(\d+)/$', views.shop, name='shop'), # 商品详情展示
url(r'^logout/$', views.logout, name='logout'), # 退出
url(r"^verify/$", views.verify, name='verify'), # 注册账号验证
url(r'^addcart/$', views.addcart, name='addcart'), # 加入购物车
url(r'^subtract/$', views.subtract, name='subtract'), # 购物车减操作
url(r"^addcart1/$", views.addcart1, name="addcart1"), # 购物车加操作
url(r"^delcart/$", views.delcart, name="delcart"), # 购物车删除操作
url(r"^select/$", views.select, name="select"), # 购物车选中操作
] | {"/WYKL/views.py": ["/WYKL/models.py"]} |
70,468 | thiagodiasg/ProjetoSeguro | refs/heads/master | /Frames.py | from tkinter import*
from Orcamento import *
from login import *
def fim(janela):
janela.destroy()
def orcamentos(janela):
print("dashboard")
janela.destroy()
janela = Tk()
janela['bg'] = '#03467B'
janela.title("Lider Prev - v3.7")
janela.resizable(0, 0)
janela.iconbitmap('imagesico (2).ico')
lb1 = Label(janela, width = 35 , text = "*Você pode criar um Orçamento novo ou \n consultar Orçamentos Anteriores", font="Helvetica 9 bold", foreground = "#00A654", bg = "#03467B")
bt1 = Button(janela, width=20, text="Novo Orçamento", font="Helvetica 9 bold", bg='white', command=lambda: novoOrcamento(janela))
bt2 = Button(janela, width=20, text="Orçamentos", font="Helvetica 9 bold", bg='white', command=lambda: updateOrcamento(janela))
bt3 = Button(janela, width=20, text="Voltar", font="Helvetica 9 bold", bg='white',command=lambda: dashBoard(janela))
bt1.place(x=75, y=50)
bt2.place(x=75, y=90)
bt3.place(x=75, y=130)
lb1.place(x = 25, y = 250 )
janela.geometry('300x300+500+100')
janela.mainloop()
'''def consulta(janela):
print("usuarios")
janela.destroy()
janela = Tk()
janela.title("Lider Prev - v3.7")
janela.iconbitmap('imagesico (2).ico')
janela['bg'] = '#03467B'
janela.resizable(0, 0)
lb1 = Label(janela, width=40, text="*Buscar editar ou deletar\n um Orçamento feito", foreground="#00A654", bg="#03467B",font="Helvetica 9 bold")
bt1 = Button(janela, width=20, text="Buscar", font="Helvetica 9 bold", bg='white',command=lambda: updateUsuario(janela))
bt2 = Button(janela, width=20, text="Editar", font="Helvetica 9 bold", bg='white', command=lambda: deleteOrcamento(janela))
bt3 = Button(janela, width=20, text="Deletar", font="Helvetica 9 bold", bg='white', command=lambda: dashBoard(janela))
bt4 = Button(janela, width=20, text="Voltar", font="Helvetica 9 bold", bg='white', command=lambda: orcamentos(janela))
bt1.place(x=75, y=50)
bt2.place(x=75, y=90)
bt3.place(x=75, y=130)
bt4.place(x=75,y = 170)
lb1.place(x=5, y=250)
janela.geometry('300x300+500+100')'''
def usuarios(janela):
print("usuarios")
janela.destroy()
janela = Tk()
janela['bg'] = '#03467B'
janela.title("Lider Prev - v3.7")
janela.resizable(0, 0)
janela.geometry('300x300+500+100')
janela.iconbitmap('imagesico (2).ico')
lb1 = Label(janela, width=30, text="*Você pode editar sua senha de Usuario\n ou deletar um usuário", foreground="#00A654", bg="#03467B",font="Helvetica 9 bold")
bt1 = Button(janela, width=20, text="Editar senha usuário", font="Helvetica 9 bold", bg='white', command=lambda: alterarSenha(janela))
bt2 = Button(janela, width=20, text="Deletar usuário", font="Helvetica 9 bold", bg='white', command=lambda: deleteUsuario(janela))
bt3 = Button(janela, width=20, text="Voltar", font="Helvetica 9 bold", bg='white', command = lambda: dashBoard(janela))
bt1.place(x=75, y=50)
bt2.place(x=75, y=90)
bt3.place(x=75, y=130)
lb1.place(x=45, y=250)
def dashBoard(janela):
print("novoOrçameto")
janela.destroy()
janela = Tk()
janela.iconbitmap('imagesico (2).ico')
janela.title("Lider Prev - v3.7")
janela.geometry('300x300+500+100')
janela.resizable(0, 0)
janela['bg'] = '#03467B'
lb1 = Label(janela, width=30, text="*Você pode gerenciar Orçamentos ou\n editar sua senha de Usuario", foreground = "#00A654", bg = "#03467B",font="Helvetica 9 bold")
bt1 = Button(janela, width=20, text="Orçamentos", font="Helvetica 9 bold", bg='white', command= lambda: orcamentos(janela))
bt2 = Button(janela, width=20, text= "Usuarios", font="Helvetica 9 bold", bg='white', command= lambda: usuarios(janela))
bt3 = Button(janela, width=20, text="Sair", font="Helvetica 9 bold", bg='white', command=lambda: fim(janela))
bt1.place(x=75, y=50)
bt2.place(x=75, y=90)
bt3.place(x=75, y=130)
lb1.place(x=45, y=250)
def novoOrcamento(janela):
janela.destroy()
orc = Orcamento()
def alterarSenha(janela):
print("updateUsuario")
print("deleteUsuario")
janela.destroy()
janela = Tk()
janela.iconbitmap('imagesico (2).ico')
janela.title("Lider Prev - v3.7")
janela.resizable(0, 0)
janela['bg'] = '#03467B'
janela.geometry('300x300+500+100')
lb1 = Label(janela, width=40, text="Digite a senha antiga:", foreground="white", bg="#03467B", font="Helvetica 9 bold")
lb2 = Label(janela, width=40, text="Digite a nova senha:", foreground="white", bg="#03467B",font="Helvetica 9 bold")
bt1 = Button(janela, width=8, text="Alterar", font="Helvetica 9 bold", bg='white', command=lambda: readOrcamento)
bt2 = Button(janela, width=8, text="Voltar", font="Helvetica 9 bold", bg='white', command=lambda: orcamentos(janela))
senhaAntiga = Entry(janela, bg='white', fg='black', font="Helvetica 13 bold", width='15', textvariable="id",show='*')
senhaNova = Entry(janela, bg='white', fg='black', font="Helvetica 13 bold", width='15', textvariable="novoid",show='*')
bt2.place(x=8, y=270)
bt1.place(x=230, y=270)
lb1.place(x=8, y=40)
lb2.place(x=5, y=100)
senhaAntiga.place(x=78, y=60)
senhaNova.place(x=78, y=120)
def condicaoSenha(janela):
janela = Tk()
janela.iconbitmap('imagesico (2).ico')
janela.title("Lider Prev - v3.7")
janela.geometry('300x300+500+100')
janela.resizable(0, 0)
janela['bg'] = '#03467B'
#if senha != senhaAntiga.get:
def updateOrcamento(janela):
print("deleteUsuario")
janela.destroy()
janela = Tk()
janela.iconbitmap('imagesico (2).ico')
janela.title("Lider Prev - v3.7")
janela.geometry('300x300+500+100')
janela.resizable(0, 0)
janela['bg'] = '#03467B'
janela.iconbitmap('imagesico (2).ico')
janela['bg'] = '#03467B'
janela.resizable(0, 0)
lb1 = Label(janela, width=40, text="Digite o ID do orçamento:", foreground="white", bg="#03467B", font="Helvetica 9 bold")
bt1 = Button(janela, width=8, text="Buscar", font="Helvetica 9 bold", bg='white',command=lambda: readOrcamento)
bt2 = Button(janela, width=8, text="Voltar", font="Helvetica 9 bold", bg='white',command=lambda: orcamentos(janela))
bt3 = Button(janela, width=8, text="Deletar", font="Helvetica 9 bold", bg='white',command=lambda: deleteOrcamento())
entrada = Entry(janela, bg='white', fg='black', font="Helvetica 9 bold", width='20', textvariable="id")
bt2.place(x=8, y=270)
bt3.place(x=160, y=270)
bt1.place(x=230, y=270)
lb1.place(x=8, y=40)
entrada.place(x=78,y=80)
janela.geometry('300x300+500+100')
'''def reset_janela (window) :
_list = window.winfo_children()
for item in _list :
if item.winfo_children() :
_list.extend(item.winfo_children())
widget_list = _list
for item in widget_list:
item.pack_forget()'''
| {"/Frames.py": ["/Orcamento.py", "/login.py"], "/Main.py": ["/login.py"], "/login.py": ["/banco.py", "/Frames.py"], "/Orcamento.py": ["/Frames.py", "/banco.py"]} |
70,469 | thiagodiasg/ProjetoSeguro | refs/heads/master | /banco.py | import sqlite3
def createTables():
conexao = sqlite3.connect('liderPrev.db')
cursor = conexao.cursor()
try:
cursor.execute("""
CREATE TABLE usuarios(
id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
user TEXT NOT NULL,
senha varchar(12),
nomeCompleto varchar(50)
);
""")
cursor.execute("""
CREATE TABLE orcamento(
id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
user TEXT NOT NULL,
preco FLOAT,
marca TEXT NOT NULL,
modelo TEXT NOT NULL,
ano VARCHAR(4),
mensalidade FLOAT,
acionamento FLOAT
);
""")
print("Tabela criada")
except:
print("Não conseguiu criar as tabelas!! ")
def insertUsuarios(user,senha,nomeCompleto):
conexao = sqlite3.connect('liderPrev.db')
cursor = conexao.cursor()
cursor.execute("""
INSERT INTO usuarios (user, senha, nomeCompleto)
VALUES (?,?,?)
""", (user, senha, nomeCompleto))
conexao.commit()
conexao.close()
def readUsuarios():
conexao = sqlite3.connect('liderPrev.db')
cursor = conexao.cursor()
listaUsuarios = []
cursor.execute("""SELECT * FROM usuarios""")
for i in cursor.fetchall():
listaUsuarios.append(i[1])
return listaUsuarios
#Update pra alterar senha
def updateUsuarios(novaSenha,usuario):
conexao = sqlite3.connect('liderPrev.db')
cursor = conexao.cursor()
cursor.execute("""
UPDATE usuarios
SET senha = ?
WHERE user = ?
""", (novaSenha, usuario))
conexao.commit()
conexao.close()
def deleteUsuarios(usuarioDeletado):
conexao = sqlite3.connect('liderPrev.db')
cursor = conexao.cursor()
cursor.execute("""
DELETE FROM usuarios
WHERE user = ?
""", (usuarioDeletado,))
conexao.commit()
conexao.close()
def insertOrcamento():
#
conexao = sqlite3.connect('liderPrev.db')
cursor = conexao.cursor()
cursor.execute("""
INSERT INTO orcamento (user, preco, marca, modelo, ano, mensalidade, acionamento)
VALUES (?,?,?,?,?,?,?)
""", (dicio["user"], dicio["preco"], dicio["marca"], dicio["modelo"], dicio["ano"], dicio["mensalidade"], dicio["acionamento"]))
conexao.commit()
conexao.close()
def readOrcamento():
conexao = sqlite3.connect('liderPrev.db')
cursor = conexao.cursor()
cursor.execute("""SELECT * FROM orcamento""")
for i in cursor.fetchall():
print(i)
def deleteOrcamento(orcamentoDeletado):
conexao = sqlite3.connect('liderPrev.db')
cursor = conexao.cursor()
cursor.execute("""
DELETE FROM orcamento
WHERE user = ?
""", (orcamentoDeletado,))
conexao.commit()
conexao.close()
def login(usuario,senha):
verificaSenha = 000
verificaUser = 'Nulo'
conexao = sqlite3.connect('liderPrev.db')
cursor = conexao.cursor()
cursor.execute("""
SELECT senha FROM usuarios
WHERE user = ?
""", (usuario,))
x = cursor.fetchall()
if len(x) > 0:
verificaSenha = x[0][0]
cursor.execute("""
SELECT user FROM usuarios
WHERE user = ?
""", (usuario,))
x = cursor.fetchall()
if len(x) > 0:
verificaUser = x[0][0]
if senha == verificaSenha and verificaUser == usuario:
return True
else:
return False
| {"/Frames.py": ["/Orcamento.py", "/login.py"], "/Main.py": ["/login.py"], "/login.py": ["/banco.py", "/Frames.py"], "/Orcamento.py": ["/Frames.py", "/banco.py"]} |
70,470 | thiagodiasg/ProjetoSeguro | refs/heads/master | /liderseguro.py | import functools
import tkinter as t
class Tela(t.Frame):
def __init__(self, parent, nome):
t.Frame.__init__(self, parent)
self.nome = nome
t.Label(self, text='Voce esta na ' + self.nome).pack()
class Menu(t.Frame):
def __init__(self, parent, *subtelas):
t.Frame.__init__(self, parent)
self.current_frame = self
for subtela in subtelas:
t.Button(subtela, text='Voltar',
command=functools.partial(self.muda_tela, self)).pack()
t.Button(self, text=subtela.nome,
command=functools.partial(self.muda_tela, subtela)).pack()
def muda_tela(self, qual):
self.current_frame.pack_forget()
qual.pack()
self.current_frame = qual
if __name__ == '__main__':
root = t.Tk()
root.resizable(0, 0)
t1 = Tela(root, 'Primeira tela')
t2 = Tela(root, 'Segunda tela')
t3 = Tela(root, 'Terceira tela')
m = Menu(root, t1, t2, t3)
m.pack()
root.mainloop() | {"/Frames.py": ["/Orcamento.py", "/login.py"], "/Main.py": ["/login.py"], "/login.py": ["/banco.py", "/Frames.py"], "/Orcamento.py": ["/Frames.py", "/banco.py"]} |
70,471 | thiagodiasg/ProjetoSeguro | refs/heads/master | /talysongay.py | from tkinter import *
import os
# Define a função de cadastro
def register():
global register_screen
register_screen = Toplevel(main_screen)
register_screen.resizable(0, 0)
register_screen.title("Cadastrar Novo Cliente")
register_screen.geometry("900x600+120+130")
register_screen.configure(bg='gray17')
global name
global idade
global email
global cpf
global rg
global sexo
global data_cadastro
global code_client
global vencimento
global vencimento_entry
global name_entry
global idade_entry
global email_entry
global sexo_entry
global data_cadastro_entry
global cpf_entry
global code_client_entry
global rg_entry
name = StringVar()
idade = StringVar()
email = StringVar()
sexo = StringVar()
data_cadastro = StringVar()
code_client = StringVar()
cpf = StringVar()
rg = StringVar()
vencimento = StringVar()
Label(register_screen, text="Cadastre os dados abaixo", bg="gray17", fg='white', width="300", height="1",
font=("Calibri", 13)).pack()
name_lable = Label(register_screen, text="Nome:", bg="gray17", fg='white')
name_lable.place(x=5, y=50)
name_entry = Entry(register_screen, bg='gray30', fg='white', width='40', textvariable=name)
name_entry.place(x=50, y=50)
idade_label = Label(register_screen, text='Idade:', bg="gray17", fg='white')
idade_label.place(x=320, y=50)
idade_entry = Entry(register_screen, bg='gray30', fg='white', width='5', textvariable=idade)
idade_entry.place(x=390, y=50)
email_label = Label(register_screen, text="Email:", bg="gray17", fg='white')
email_label.place(x=5, y=100)
email_entry = Entry(register_screen, width='40', bg='gray30', fg='white', textvariable=email)
email_entry.place(x=50, y=100)
sexo_label = Label(register_screen, text='Sexo(M/F):', bg='gray17', fg='white')
sexo_label.place(x=320, y=100)
sexo_entry = Entry(register_screen, width='5', bg='gray30', fg='white', textvariable=sexo)
sexo_entry.place(x=390, y=100)
data_cadastro_label = Label(register_screen, text="Data do Cadastro:", bg="gray17", fg='white')
data_cadastro_label.place(x=460, y=50)
data_cadastro_entry = Entry(register_screen, width='15', bg='gray30', fg='white', textvariable=data_cadastro)
data_cadastro_entry.place(x=570, y=50)
code_client_label = Label(register_screen, text='Código:', bg='gray17', fg='white')
code_client_label.place(x=460, y=100)
code_client_entry = Entry(register_screen, width='15', bg='gray30', fg='white', textvariable=code_client)
code_client_entry.place(x=570, y=100)
cpf_entry_label = Label(register_screen, text='CPF:', bg='gray17', fg='white')
cpf_entry_label.place(x=5, y=150)
cpf_entry = Entry(register_screen, width='40', bg='gray30', fg='white', textvariable=cpf)
cpf_entry.place(x=50, y=150)
rg_label = Label(register_screen, text='RG:', bg='gray17', fg='white')
rg_label.place(x=320, y=150)
rg_entry = Entry(register_screen, width='15', bg='gray30', fg='white', textvariable=rg)
rg_entry.place(x=390, y=150)
vencimento_label = Label(register_screen, text='Vencimento:', bg='gray17', fg='white')
vencimento_label.place(x=690, y=50)
vencimento_entry = Entry(register_screen, bg='gray30', fg='white', width='15', textvariable=vencimento)
vencimento_entry.place(x=775, y=50)
finalizar = Button(register_screen, text="Finalizar", width='20', height='1', bg="gray30", fg='white',
command=register_user)
voltar = Button(register_screen, text='Cancelar', bg='gray30', fg='white', width='10', height='1',
command=delete_register)
voltar.pack(side=BOTTOM)
Label(register_screen, text='', bg='gray17', height='1').pack(side=BOTTOM)
finalizar.pack(side=BOTTOM)
# Função de realizar o cadastro no sistema e criar o arquivo com as informações
def register_user():
name_info = name.get()
idade_info = idade.get()
email_info = email.get()
sexo_info = sexo.get()
data_cad_info = data_cadastro.get()
code_info = code_client.get()
cpf_info = cpf.get()
rg_info = rg.get()
vencimento_info = vencimento.get()
file = open(code_info, "w")
file.write(code_info + "\n")
file.write(name_info + "\n")
file.write(idade_info + "\n")
file.write(sexo_info + "\n")
file.write(data_cad_info + "\n")
file.write(email_info + '\n')
file.write(cpf_info + '\n')
file.write(rg_info + '\n')
file.write(vencimento_info + '\n')
file.close()
name_entry.delete(0, END)
idade_entry.delete(0, END)
sexo_entry.delete(0, END)
email_entry.delete(0, END)
data_cadastro_entry.delete(0, END)
cpf_entry.delete(0, END)
rg_entry.delete(0, END)
vencimento_entry.delete(0, END)
# list_of_files = os.listdir()
success_register()
# Função de editar o cadastro/arquivo de informações
def edit_register_user():
name_info = name.get()
idade_info = idade.get()
email_info = email.get()
sexo_info = sexo.get()
data_cad_info = data_cadastro.get()
code_info = code_client.get()
cpf_info = cpf.get()
rg_info = rg.get()
vencimento_info = vencimento.get()
file = open(code_info, "w")
file.write(code_info + "\n")
file.write(name_info + "\n")
file.write(idade_info + "\n")
file.write(sexo_info + "\n")
file.write(data_cad_info + "\n")
file.write(email_info + '\n')
file.write(cpf_info + '\n')
file.write(rg_info + '\n')
file.write(vencimento_info + '\n')
file.close()
name_entry.delete(0, END)
idade_entry.delete(0, END)
sexo_entry.delete(0, END)
email_entry.delete(0, END)
data_cadastro_entry.delete(0, END)
cpf_entry.delete(0, END)
rg_entry.delete(0, END)
vencimento_entry.delete(0, END)
code_client_entry.delete(0, END)
success_edit_register()
# Popup que informa o sucesso ao realizar o cadastro
def success_register():
global you_are_register_now
you_are_register_now = Toplevel(register_screen)
you_are_register_now.resizable(0, 0)
you_are_register_now.title('Nice!!')
you_are_register_now.geometry("250x110+460+400")
you_are_register_now.configure(bg='gray17')
Label(you_are_register_now, text="Cadastro realizado com sucesso.", bg='gray17', fg='white', height='3').pack()
Label(you_are_register_now, text='', bg='gray17')
Button(you_are_register_now, text="OK", bg='gray30', fg='white', command=delete_register).pack()
# Popup que informa o sucesso ao editar o cadastro
def success_edit_register():
global you_are_edited_now
you_are_edited_now = Toplevel(edit_register_screen)
you_are_edited_now.resizable(0, 0)
you_are_edited_now.title('Nice!!')
you_are_edited_now.geometry("250x110+460+400")
you_are_edited_now.configure(bg='gray17')
Label(you_are_edited_now, text="Cadastro editado com sucesso.", bg='gray17', fg='white', height='3').pack()
Label(you_are_edited_now, text='', bg='gray17')
Button(you_are_edited_now, text="OK", bg='gray30', fg='white', command=delete_edit_register).pack()
'''
def due_date():
code_entry5 = client_verify.get()
due_date_file = os.listdir()
file3 = open(code_entry5, "r")
#Lê o arquivo e divide as linhas em lista
verify3 = file3.read().splitlines()
verify3[8].split('/')
'''
# Função de verificaçõa: Verifica se o codigo que foi digitado em
# start_access() está cadastrado no sistema
def login_verify():
global list_of_files
global code_entry1
code_entry1 = client_verify.get()
list_of_files = os.listdir()
# Realiza da verificação do código
if code_entry1 in list_of_files:
show_info_access()
access_allowed()
else:
access_denied()
# Informa acesso negado, caso o codigo não esteja cadastrado no sistema
def access_denied():
code_entry.delete(0, END)
def countdown(time):
if time == -1:
popup.destroy()
else:
popup.after(500, countdown, time - 1)
popup = Toplevel(access_permission)
popup.geometry('300x200+950+300')
popup.configure(bg='gray17')
Label(popup, text='', bg='gray17', height='5').pack()
label = Label(popup, text='Acesso negado', bg='gray17', fg='red', font=('calibri', 15)).pack()
countdown(2)
popup.mainloop()
# Informa acesso permitido, caso o codigo esteja cadastrado no sistema
def access_allowed():
code_entry.delete(0, END)
def countdown(time):
if time == -1:
popup.destroy()
else:
popup.after(500, countdown, time - 1)
popup = Toplevel(access_permission)
popup.geometry('300x200+950+300')
popup.configure(bg='gray17')
Label(popup, text='', bg='gray17', height='5').pack()
label = Label(popup, text='Acesso permitido', bg='gray17', fg='#20FD3A', font=('calibri', 15)).pack()
countdown(2)
popup.mainloop()
# Define a tela de "login" com o código do cliente
def start_access():
global access_permission
global client_verify
global code_entry
access_permission = Toplevel(main_screen)
access_permission.resizable(0, 0)
access_permission.title('Academia GG EZ')
access_permission.configure(bg='gray17')
access_permission.geometry('300x200+950+300')
Label(access_permission, bg='gray17').pack()
client_verify = StringVar()
code_entry = Entry(access_permission, bg='gray40', fg='white', width='30', textvariable=client_verify)
code_entry.pack()
Label(access_permission, bg='gray17').pack()
# Envia o codigo digitado para a função de verificação
confirm_bt = Button(access_permission, text='Ok', width='3', height='1', bg='gray30', fg='white',
command=login_verify)
confirm_bt.pack()
Label(access_permission, bg='gray17', height='5').pack()
fechar_bt = Button(access_permission, text='Fechar', width='5', height='1', bg='gray30', fg='white',
command=delete_start_access)
fechar_bt.pack()
# Define a tela para procurar o codigo/arquivo para editar
def select_file():
global code_select
global select_file_screen
code_select = StringVar()
select_file_screen = Toplevel(main_screen)
select_file_screen.resizable(0, 0)
select_file_screen.title('Editar cadastro')
select_file_screen.configure(bg='gray17')
select_file_screen.geometry('300x200+450+300')
Label(select_file_screen, text='Digite o número do cadastro', bg='gray17', fg='white', height='3').pack()
select_entry = Entry(select_file_screen, bg='gray40', fg='white', textvariable=code_select)
select_entry.pack()
Label(select_file_screen, text='', bg='gray17').pack()
select_bt = Button(select_file_screen, text='Ok', bg='gray30', fg='white', width='5', command=edit_register)
select_bt.pack()
# Define a tela de editar cadastro
def edit_register():
global edit_register_screen
code_entry3 = code_select.get()
list_of_files3 = os.listdir()
# Verifica se o código digitasdo está cadastrado
if code_entry3 in list_of_files3:
# Abre o arquivo com o nome do código digitado
# em modo "r"(read)
file2 = open(code_entry3, "r")
# Lê o arquivo e divide as linhas em lista
verify2 = file2.read().splitlines()
select_file_screen.destroy()
edit_register_screen = Toplevel(main_screen)
edit_register_screen.resizable(0, 0)
edit_register_screen.geometry("900x600+120+130")
edit_register_screen.title("Academia GG EZ")
edit_register_screen.configure(bg='gray17')
global name
global idade
global email
global cpf
global rg
global sexo
global data_cadastro
global code_client
global vencimento
global vencimento_entry
global name_entry
global idade_entry
global email_entry
global sexo_entry
global data_cadastro_entry
global cpf_entry
global code_client_entry
global rg_entry
name = StringVar()
idade = StringVar()
email = StringVar()
sexo = StringVar()
data_cadastro = StringVar()
code_client = StringVar()
cpf = StringVar()
rg = StringVar()
vencimento = StringVar()
# Adiciona nas entradas os indices da lista que foi dividida acima
# Ex.: .insert(0, verify2[1]) / 0 = posição onde vai inserir o item / verify[1] = Adiciona
# o indice 1 da lista verify, que neste caso é o nome.
Label(edit_register_screen, text="Editar cadastro", bg="gray17", fg='white', width="300", height="1",
font=("Calibri", 13)).pack()
name_lable = Label(edit_register_screen, text="Nome:", bg="gray17", fg='white')
name_lable.place(x=5, y=50)
name_entry = Entry(edit_register_screen, bg='gray30', fg='white', width='40', textvariable=name)
name_entry.place(x=50, y=50)
name_entry.insert(0, verify2[1])
idade_label = Label(edit_register_screen, text='Idade:', bg="gray17", fg='white')
idade_label.place(x=320, y=50)
idade_entry = Entry(edit_register_screen, bg='gray30', fg='white', width='5', textvariable=idade)
idade_entry.place(x=390, y=50)
idade_entry.insert(0, verify2[2])
email_label = Label(edit_register_screen, text="Email:", bg="gray17", fg='white')
email_label.place(x=5, y=100)
email_entry = Entry(edit_register_screen, width='40', bg='gray30', fg='white', textvariable=email)
email_entry.place(x=50, y=100)
email_entry.insert(0, verify2[5])
sexo_label = Label(edit_register_screen, text='Sexo(M/F):', bg='gray17', fg='white')
sexo_label.place(x=320, y=100)
sexo_entry = Entry(edit_register_screen, width='5', bg='gray30', fg='white', textvariable=sexo)
sexo_entry.place(x=390, y=100)
sexo_entry.insert(0, verify2[3])
data_cadastro_label = Label(edit_register_screen, text="Data do Cadastro:", bg="gray17", fg='white')
data_cadastro_label.place(x=460, y=50)
data_cadastro_entry = Entry(edit_register_screen, width='15', bg='gray30', fg='white',
textvariable=data_cadastro)
data_cadastro_entry.place(x=570, y=50)
data_cadastro_entry.insert(0, verify2[4])
code_client_label = Label(edit_register_screen, text='Código:', bg='gray17', fg='white')
code_client_label.place(x=460, y=100)
code_client_entry = Entry(edit_register_screen, width='15', bg='gray30', fg='white', textvariable=code_client)
code_client_entry.place(x=570, y=100)
code_client_entry.insert(0, code_entry3)
cpf_entry_label = Label(edit_register_screen, text='CPF:', bg='gray17', fg='white')
cpf_entry_label.place(x=5, y=150)
cpf_entry = Entry(edit_register_screen, width='40', bg='gray30', fg='white', textvariable=cpf)
cpf_entry.place(x=50, y=150)
cpf_entry.insert(0, verify2[6])
rg_label = Label(edit_register_screen, text='RG:', bg='gray17', fg='white')
rg_label.place(x=320, y=150)
rg_entry = Entry(edit_register_screen, width='15', bg='gray30', fg='white', textvariable=rg)
rg_entry.place(x=390, y=150)
rg_entry.insert(0, verify2[7])
vencimento_label = Label(edit_register_screen, text='Vencimento:', bg='gray17', fg='white')
vencimento_label.place(x=690, y=50)
vencimento_entry = Entry(edit_register_screen, bg='gray30', fg='white', width='15', textvariable=vencimento)
vencimento_entry.place(x=775, y=50)
vencimento_entry.insert(0, verify2[8])
finalizar = Button(edit_register_screen, text="Finalizar", width='20', height='1', bg="gray30", fg='white',
command=edit_register_user)
voltar = Button(edit_register_screen, text='Cancelar', bg='gray30', fg='white', width='10', height='1',
command=delete_edit_register)
voltar.pack(side=BOTTOM)
Label(edit_register_screen, text='', bg='gray17', height='1').pack(side=BOTTOM)
finalizar.pack(side=BOTTOM)
# Informa que o código não está cadastrado
else:
popup2 = Toplevel(main_screen)
popup2.geometry('300x200+450+300')
popup2.configure(bg='gray17')
# Popup automatico
def countdown(time):
if time == -1:
popup2.destroy()
else:
popup2.after(500, countdown, time - 1)
Label(popup2, text='', bg='gray17', height='5').pack()
label = Label(popup2, text='Código não localizado', bg='gray17', fg='red', font=('calibri', 14)).pack()
countdown(2)
popup2.mainloop()
# informações sobre o aplicativo
def app_info():
global app_info_screen
app_info_screen = Toplevel(main_screen)
app_info_screen.resizable(0, 0)
app_info_screen.title('Informações')
app_info_screen.geometry("900x600+120+130")
app_info_screen.configure(bg='gray17')
Label(app_info_screen, bg='gray17', height='7').pack()
Label(app_info_screen,
text='Aplicativo desenvolvido para projeto universitário.\nDesenvolvido por:\n\nThalison Vinícius\nNatália\nDandara\nMikaelle\nLudmila',
bg='gray17', fg='white', height='20').pack()
Button(app_info_screen, text='Voltar', bg='gray30', fg='white', command=delete_app_info).pack()
# Adiciona o nome na ListBox
def show_info_access():
code_entry2 = client_verify.get()
list_of_files2 = os.listdir()
if code_entry2 in list_of_files2:
file1 = open(code_entry2, "r")
verify = file1.read().splitlines()
add_nome = verify[1].split()
for i in range (len(lista_nomes)):
if verify[0] in lista_nomes[i][0]:
del(lista_nomes[i])
list_clients2 = Listbox(main_screen, width=30, height=28, bg='gray25', fg='#20FD3A', font=("Helvetica", 12))
list_clients2.pack(side=LEFT, fill="y")
elif i == len(lista_nomes):
list_clients.insert(END, '{} - {}'.format(verify[0], add_nome[0]))
lista_nomes.insert((verify[0], add_nome[0]))
for x in range(len(lista_nomes)):
list_clients2.insert(END, '{} - {}'.format(lista_nomes[x][0], lista_nomes[x][1]))
list_clients = list_clients2
# Deleta popups e screens
def delete_start_access():
access_permission.destroy()
def delete_app_info():
app_info_screen.destroy()
def delete_register():
register_screen.destroy()
def delete_edit_register():
edit_register_screen.destroy()
# Define a janela inicial
class Screen:
list_clients = 0
def __init__(self):
self.main_account_screen()
def main_account_screen(self):
global main_screen
main_screen = Tk()
main_screen.resizable(0, 0)
main_screen.geometry("900x600+120+130")
main_screen.title("Academia GG EZ")
main_screen.configure(bg='gray17')
info_btt = Button(main_screen, text='?', width='4', bg='gray30', fg='white', command=app_info)
info_btt.place(x=220, y=572)
iniciar = Button(main_screen, text='Iniciar', width='5', bg='gray30', fg='white', command=start_access)
iniciar.place(x=852, y=572)
cad_bt = Button(main_screen, text='Cadastrar novo cliente', bg='gray30', fg='white', command=register)
cad_bt.place(x=632, y=572)
self.list_clients = Listbox(main_screen, width=30, height=28, bg='gray25', fg='#20FD3A', font=("Helvetica", 12))
self.list_clients.pack(side=LEFT, fill="y")
Label(self.list_clients, text='LISTA DE ENTRADA:', bg='gray20', fg='white', width=30).pack()
edit_bt = Button(main_screen, text='Editar cadastro', bg='gray30', fg='white', command=select_file)
edit_bt.place(x=762, y=572)
scrollbar = Scrollbar(self.list_clients, orient="vertical")
scrollbar.config(command=self.list_clients.yview)
scrollbar.pack(side=RIGHT, fill="y")
self.list_clients.configure(yscrollcommand=scrollbar.set)
self.list_clients.insert(0, '')
main_screen.mainloop()
def funcao1(self):
print()
def funcao2(self):
print()
lista_nomes = []
tela = Screen() | {"/Frames.py": ["/Orcamento.py", "/login.py"], "/Main.py": ["/login.py"], "/login.py": ["/banco.py", "/Frames.py"], "/Orcamento.py": ["/Frames.py", "/banco.py"]} |
70,472 | thiagodiasg/ProjetoSeguro | refs/heads/master | /Main.py | from login import *
telaLogin(Tk()) | {"/Frames.py": ["/Orcamento.py", "/login.py"], "/Main.py": ["/login.py"], "/login.py": ["/banco.py", "/Frames.py"], "/Orcamento.py": ["/Frames.py", "/banco.py"]} |
70,473 | thiagodiasg/ProjetoSeguro | refs/heads/master | /login.py | from tkinter import *
from banco import *
from Frames import *
import Frames
def telaLogin(janela):
janela.destroy()
janela = Tk()
janela.iconbitmap('imagesico (2).ico')
janela.title("Lider Prev - v3.7")
janela.geometry('300x300+500+100')
janela.resizable(0, 0)
janela['bg'] = '#03467B'
janela.iconbitmap('imagesico (2).ico')
janela['bg'] = '#03467B'
janela.resizable(0, 0)
janela.geometry('300x300+500+100')
labelUser = Label(janela, text="Usuario:",foreground="white", bg="#03467B", font="Helvetica 9 bold")
labelUser.pack()
caixaUser = Entry(janela, bg='white', fg='black', font="Helvetica 9 bold")
caixaUser.pack()
labelSenha = Label(janela, text="Senha:", foreground="white", bg="#03467B", font="Helvetica 9 bold")
labelSenha.pack()
caixaSenha = Entry(janela, bg='white', fg='black', font="Helvetica 9 bold",show = '*')
caixaSenha.pack()
butaoEntrar = Button(janela, text="Entrar", font="Helvetica 9 bold", bg='white',command=lambda : auxiliar(caixaUser.get(),caixaSenha.get(),janela))
#funcao pra o butao entrar
butaoEntrar.pack()
labelSemCad = Label(janela, text="Não tem cadastro?", foreground="white", bg="#03467B", font="Helvetica 9 bold")
labelSemCad.pack()
butaoCadastrar = Button(janela,font="Helvetica 9 bold", bg='white', text="Cadastrar-se",command=cadastro)
#funcao pra o butao cadastrar
butaoCadastrar.pack()
janela.geometry('300x300+500+100')
janela.mainloop()
def auxiliar(user,senha,janela):
if (login(user, senha) == True and user != ""):
Frames.dashBoard(janela)
else:
print("aaa")
def cadastro():
print("ENTORU")
janela = Tk()
janela.iconbitmap('imagesico (2).ico')
janela.title("Lider Prev - v3.7")
janela['bg'] = '#03467B'
janela.resizable(0, 0)
janela.geometry('300x300+500+100')
labelNomeCompleto = Label(janela, text="Nome Completo:",foreground="white", bg="#03467B", font="Helvetica 9 bold")
labelNomeCompleto.pack()
caixaNomeCompleto = Entry(janela, bg='white', fg='black', font="Helvetica 9 bold",)
caixaNomeCompleto.pack()
# nome = str(input("{:s}".format("Nome Completo: ",end="")))
labelUser = Label(janela, text="Usuario:",foreground="white", bg="#03467B", font="Helvetica 9 bold")
labelUser.pack()
caixaUser = Entry(janela, bg='white', fg='black', font="Helvetica 9 bold",)
caixaUser.pack()
# usuario = str(input("{:s}".format("USUÁRIO: ",end="")))
labelSenha = Label(janela, text="Senha:",foreground="white", bg="#03467B", font="Helvetica 9 bold")
labelSenha.pack()
caixaSenha = Entry(janela, bg='white', fg='black', font="Helvetica 9 bold",show = '*')
caixaSenha.pack()
# senha = getpass.getpass("SENHA: ")
nomeCompleto = caixaNomeCompleto.get()
user = caixaUser.get()
senha = caixaSenha.get()
butaoCadastrar = Button(janela,text="Cadastrar",font="Helvetica 9 bold", bg='white', command=lambda:insertUsuarios(caixaUser.get(),caixaSenha.get(),caixaNomeCompleto.get()))
butaoCadastrar.pack()
#butaoCadastrar["command"] = inserir(nomeCompleto,cpf,user,senha)
janela.mainloop() | {"/Frames.py": ["/Orcamento.py", "/login.py"], "/Main.py": ["/login.py"], "/login.py": ["/banco.py", "/Frames.py"], "/Orcamento.py": ["/Frames.py", "/banco.py"]} |
70,474 | thiagodiasg/ProjetoSeguro | refs/heads/master | /novoOrcamento.py | from tkinter import *
import tkinter.filedialog
root = Tk()
menubar = Menu(root)
root.config(menu=menubar)
root.title('Tk Menu')
root.geometry('400x400')
filemenu = Menu(menubar)
filemenu2 = Menu(menubar)
filemenu3 = Menu(menubar)
menubar.add_cascade(label='Orçamento', menu=filemenu2)
menubar.add_cascade(label='Develops', menu=filemenu)
menubar.add_cascade(label='Ajuda', menu=filemenu3)
def Open(): tkFileDialog.askopenfilename()
def Save(): tkFileDialog.asksaveasfilename()
def Quit(): root.destroy()
def novoOrcamento():
master = Tk()
master.geometry("400x400+0+0")
var = StringVar(master)
var.set("MARCAS:") # initial value
option = OptionMenu(master, var, "FIAT", "HYUNDAY", "VW", "JEEP")
option.pack()
#
# test stuff
def ok():
var2 = StringVar(master)
var2.set("MODELOS:") # initial value
option = OptionMenu(master, var2, "FIAT", "HYUNDAY", "VW", "JEEP")
print(type(option))
button = Button(master, text="OK", command=ok)
button.pack()
mainloop()
def ColorRed(): Text(background='red').pack()
def ColorBlack(): Text(background='black').pack()
def AlterarOrcamento(): Text(background='black').pack()
def Help():
text = Text(root)
text.pack();
text.insert('insert', 'Ao clicar no botão da\n'
'respectiva cor, o fundo da tela\n'
'aparecerá na cor escolhida.')
filemenu.add_command(label='Abrir...', command=Open)
filemenu.add_command(label='Salvar como...', command=Save)
filemenu.add_separator()
filemenu.add_command(label='Sair', command=Quit)
filemenu2.add_command(label='Novo', command=novoOrcamento)
filemenu2.add_command(label='Consultar', command=ColorRed)
filemenu2.add_command(label='Apagar', command=ColorBlack)
filemenu2.add_command(label='Alterar',command=AlterarOrcamento)
filemenu3.add_command(label='Ajuda', command=Help)
root.mainloop()
| {"/Frames.py": ["/Orcamento.py", "/login.py"], "/Main.py": ["/login.py"], "/login.py": ["/banco.py", "/Frames.py"], "/Orcamento.py": ["/Frames.py", "/banco.py"]} |
70,475 | thiagodiasg/ProjetoSeguro | refs/heads/master | /Liderprev.py | from funções import *
from tkinter import*
import sqlite3
def MarcasCarro():
print("Bt click")
bt1 = Button(janela, width=20, text="Fiat")
bt2 = Button(janela, width=20, text="Chevrolet")
bt3 = Button(janela, width=20, text="Toyota")
bt4 = Button(janela, width=20, text="Jeep")
bt5 = Button(janela, width=20, text="Ford")
bt6 = Button(janela, width=20, text="Honda")
bt7 = Button(janela, width=20, text="Volkswagem")
bt8 = Button(janela, width=20, text="Nissan")
bt9 = Button(janela, width=20, text="Mitsubish")
bt10 = Button(janela, width=20, text="Hyundai")
bt11 = Button(janela, width=15, text="Voltar", command = inicial)
bt1.place(x=25, y=20)
bt2.place(x=25, y=60)
bt3.place(x=25, y=100)
bt4.place(x=25, y=140)
bt5.place(x=25, y=180)
bt6.place(x=25, y=220)
bt7.place(x=25, y=260)
bt8.place(x=25, y=300)
bt9.place(x=25, y=340)
bt10.place(x=25, y=380)
bt11.place(x=40, y=420)
janela.geometry("300x480+200+200")
def inicial():
global janela
janela.destroy()
janela = Tk()
janela['bg'] = "black"
bt1 = Button(janela, width=20, text="Linha Leve",font="MalgunGothic 9 bold",bg = 'white' ,command= MarcasCarro)
bt2 = Button(janela, width=20, text="Linha Pesada",font="MalgunGothic 9 bold",bg = 'white', command=MarcasCarro)
bt3 = Button(janela, width=20, text="Motocicletas",font="MalgunGothic 9 bold",bg = 'white', command=MarcasCarro)
bt4 = Button(janela, width=15, text="Log out",font="MalgunGothic 9 bold",bg = 'white', command = Escolha)
bt1.place(x=25, y=20)
bt2.place(x=25, y=60)
bt3.place(x=25, y=100)
bt4.place(x=40, y=140)
janela.geometry("190x190+500+200")
def Escolha():
global janela
janela.destroy()
janela = Tk()
janela['bg'] = 'black'
bt1 = Button(janela, width=20, text="Login",font = "MalgunGothic 9 bold",bg = 'white', command=logindados)
bt2 = Button(janela, width=20, text="Cadastrar-se",font = "MalgunGothic 9 bold",bg = 'white', command=inicial)
bt3 = Button(janela, width=20, text="Desenvolvedores",font = "MalgunGothic 9 bold",bg = 'white' ,command=Desenvolvedores)
bt1.place(x=25,y=20)
bt2.place(x=25, y=60)
bt3.place(x=25, y=100)
janela.geometry("190x190+500+200")
def logindados():
global janela
janela.destroy()
janela = Tk()
entrada1 = Entry(janela,width = 15)
entrada2 = Entry(janela, width = 15)
lb1 = Label(janela,text = "Login: ")
lb2 = Label(janela,text="Senha: ")
btlogin = Button(janela, width =15 , text = "Logar", command = inicial)
lb1.place(x = 25 , y = 60)
lb2.place(x = 22, y = 90)
entrada1.place(x=70,y = 60)
entrada2.place(x=70,y=90)
btlogin.place(x=50,y = 120)
janela.geometry("190x190+500+200")
def Desenvolvedores():
global janela
janela.destroy()
janela = Tk()
lb90 = Label(janela, text = "Este programa foi desevolvido para finalidades\n educacionais, Desevolvido por um grupo de aluno \nda UEPB, para um projeto de Algoritmos", )
lb90.place(x=10, y=120)
bt4 = Button(janela, width=15, text="Voltar", command = Voltar)
bt4.place(x=40, y=190)
janela.geometry("300x300+200+200")
def Voltar():
global janela
janela.destroy()
janela = Tk()
Escolha()
global janela
janela = Tk()
Escolha()
janela.mainloop()
'''from tkinter import *
import sqlite3
def banco():
conexao = sqlite3.connect('liderPrev.db')
cursor = conexao.cursor()
# criando a tabela (schema)
cursor.execute("""
CREATE TABLE usuario (
id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
nome TEXT NOT NULL,
cpf VARCHAR(11) NOT NULL,
user VARCHAR(10),
senha VARCHAR(10)
);
""")
print('Tabela criada com sucesso.')
conexao.close()
def login():
verificaSenha = 000
verificaUser = 'Nulo'
usuario = caixaUser.get()
senha = caixaSenha.get()
# recebe na entrada usuario e senha
# Conectando o BANCO liderPrev
conexao = sqlite3.connect('liderPrev.db')
cursor = conexao.cursor()
# VERIFICANDO SE A SENHA ESTÁ DENTRO DO BANCO
cursor.execute("""
SELECT senha FROM usuario
WHERE user = ?
""", (usuario,))
x = cursor.fetchall()
if len(x) > 0:
verificaSenha = x[0][0]
cursor.execute("""
SELECT user FROM usuario
WHERE user = ?
""", (usuario,))
x = cursor.fetchall()
if len(x) > 0:
verificaUser = x[0][0]
if senha == verificaSenha and verificaUser == usuario:
print("senha Correta")
else:
print("senha e/ou usuario incorreto")
def cadastro():
janela2 = Tk()
janela2.title("Cadastro Usuario")
janela2.geometry("600x600+150+150")
conn = sqlite3.connect('liderPrev.db')
cursor = conn.cursor()
labelNomeCompleto = Label(janela2, text="Nome Completo:")
labelNomeCompleto.pack()
caixaNomeCompleto = Entry(janela2)
caixaNomeCompleto.pack()
# nome = str(input("{:s}".format("Nome Completo: ",end="")))
labelUser = Label(janela2, text="Usuario:")
labelUser.pack()
caixaUser = Entry(janela2)
caixaUser.pack()
# usuario = str(input("{:s}".format("USUÁRIO: ",end="")))
labelSenha = Label(janela2, text="Senha:")
labelSenha.pack()
caixaSenha = Entry(janela2)
caixaSenha.pack()
# senha = getpass.getpass("SENHA: ")
labelCpf = Label(janela2, text="CPF:")
labelCpf.pack()
caixaCpf = Entry(janela2)
caixaCpf.pack()
# cpf = str(input("{:s}".format("CPF: ",end="")))
# CAIO gAY
def inserir():
cursor.execute("""INSERT INTO usuario (nome, cpf, user, senha) VALUES (?, ?, ?, ?)""",
(caixaNomeCompleto.get(), caixaCpf.get(), caixaUser.get(), caixaSenha.get()))
butao = Button(janela2, text="Cadastrar")
butao.pack()
butao["command"] = inserir
janela2.mainloop()
# inserindo dados na tabela
# gravando no bd
conn.commit()
print('Usuario cadastrado com sucesso!! ')
conn.close()
janela = Tk()
janela.title("LiderPrev 1.0 ")
labelUser = Label(janela, text="Usuario:")
labelUser.pack()
caixaUser = Entry(janela)
caixaUser.pack()
labelSenha = Label(janela, text="Senha:")
labelSenha.pack()
caixaSenha = Entry(janela)
caixaSenha.pack()
butaoEntrar = Button(janela, text="Entrar")
butaoEntrar["command"] = login
butaoEntrar.pack()
labelSemCad = Label(janela, text="Não tem cadastro?")
labelSemCad.pack()
butaoCadastrar = Button(janela, text="Cadastrar-se")
butaoCadastrar["command"] = cadastro
butaoCadastrar.pack()
janela.geometry("200x200+100+100")
janela.mainloop()
conexao = sqlite3.connect("liderPrev.db")
cursor = conexao.cursor()
# for i in range(20):
# cursor.execute("DELETE FROM usuario WHERE id = ?",(i,))
cursor.execute("SELECT * FROM usuario")
for i in cursor.fetchall():
print(i)
''' | {"/Frames.py": ["/Orcamento.py", "/login.py"], "/Main.py": ["/login.py"], "/login.py": ["/banco.py", "/Frames.py"], "/Orcamento.py": ["/Frames.py", "/banco.py"]} |
70,476 | thiagodiasg/ProjetoSeguro | refs/heads/master | /Orcamento.py | import tkinter as tk
from tkinter import*
from tkinter import ttk
import Frames
import banco
class Orcamento:
marcas = ["Fiat", "Honda", "Volkswagen", "Chevrolet", "Toyota"]
modelos = []
anos = []
lista_orcament = {"user" : 0, "preco" : 0, "marca" : 0, "modelo" : 0, "ano" : 0, "mensalidade" : 0, "acionamento" : 0}
marca = 0
modelo = 0
ano = 0
comboMarcas = 0
comboModelo = 0
comboAno = 0
entrada = 0
acionamento = 0
mensalidade = 0
janela2 = 0
valor = 0
def __init__(self):
self.set_labels()
def atualiza_Modelo(self, marca):
if marca == "Honda":
self.modelos = ["Civic", "CRV", "HRV", "Fit", "City"]
elif marca == "Fiat":
self.modelos = ["Uno", "Palio", "Mobi", "Doblo", "Siena", "Strada"]
elif marca == "Volkswagen":
self.modelos = ["Gol", "Up", "Voyage", "Fox", "Golf", "Saveiro"]
elif marca == "Chevrolet":
self.modelos = ["Celta", "Classic", "Corsa", "Onix", "Cruze"]
elif marca == "Toyota":
self.modelos = ["Corola", "Etios", "Hilux", "SW4"]
self.comboModelo['values'] = self.modelos
self.comboModelo.current(0)
self.atualiza_Ano()
def atualiza_Ano(self):
#Depois fazer validacao
ano = self.comboAno.get()
for i in range(2005, 2021):
self.anos.append(str(i))
self.comboAno['values'] = self.anos
self.comboAno.current(0)
def main(self):
self.lista_orcament["marca"] = self.comboMarcas.get()
self.lista_orcament["modelo"] = self.comboModelo.get()
self.lista_orcament["ano"] = self.comboAno.get()
if self.lista_orcament["modelo"] == "" or self.lista_orcament["marca"] == "" or self.lista_orcament["ano"] == "" or self.entrada.get == "":
print("preencha tudo")
janela = Tk()
janela['bg'] = '#03467B'
janela.geometry('290x100+550+150')
janela.title("Lider Prev - v3.7")
janela.resizable(0, 0)
janela.iconbitmap('imagesico (2).ico')
labelMarca = tk.Label(janela, text="Error: Você deve preencher tudo!", font="Helvetica 12 bold", foreground="white",bg="#03467B")
labelMarca.place(x=16,y=30)
bt = Button(janela,text = "OK",font="Helvetica 12 bold", foreground="black",bg="white",command = janela.destroy)
bt.place(x=125,y=60)
else:
try:
self.lista_orcament["preco"] = float(self.entrada.get())
print(self.lista_orcament["preco"])
self.calcular(self.lista_orcament["preco"], self.lista_orcament["marca"], self.lista_orcament["modelo"], self.lista_orcament["ano"])
except:
print("Digite um numero animal")
janela = Tk()
janela['bg'] = '#03467B'
janela.geometry('290x100+550+150')
janela.title("Lider Prev - v3.7")
janela.iconbitmap('imagesico (2).ico')
labelMarca = tk.Label(janela, text="Error: Você deve preencher tudo!", font="Helvetica 12 bold",
foreground="white", bg="#03467B")
labelMarca.place(x=16, y=30)
bt = Button(janela, text="OK", font="Helvetica 12 bold", foreground="black", bg="white",
command=janela.destroy)
bt.place(x=125, y=60)
def calcular(self, valor, marca, modelo, ano):
self.janela2.destroy()
self.janela2 = tk.Tk()
janela = self.janela2
janela['bg'] = '#03467B'
janela.geometry('270x230+500+100')
janela.title("Lider Prev - v3.7")
janela.resizable(0, 0)
janela.iconbitmap('imagesico (2).ico')
self.lista_orcament["acionamento"] = round(valor * 0.04,2)
self.lista_orcament["mensalidade"] = round(valor * 0.003,2)
if self.lista_orcament["acionamento"] < 1000 :
self.lista_orcament["acionamento"]= 1000
if self.lista_orcament["mensalidade"] < 150:
self.lista_orcament["mensalidade"] = 150
container = Frame(janela)
container.pack()
container2 = Frame(janela)
container2.pack()
container3 = Frame(janela)
container3.pack()
container4 = Frame(janela)
container4.pack()
container5 = Frame(janela)
container5.pack()
container6 = Frame(jenela)
container6.pack()
labelMarca = tk.Label(container, text="Marca: ", font="Helvetica 12 bold", foreground="white", bg="#03467B")
labelMarca2 = tk.Label(container, text=marca, font="Helvetica 12 bold", foreground="white", bg="#03467B")
labelModelo = tk.Label(container2, text="Modelo: ", font="Helvetica 12 bold", foreground="white", bg="#03467B")
labelModelo2 = tk.Label(container2, text=modelo, font="Helvetica 12 bold", foreground="white", bg="#03467B")
labelAno = tk.Label(container3, text="Ano: ", font="Helvetica 12 bold", foreground="white", bg="#03467B")
labelAno2 = tk.Label(container3, text=ano, font="Helvetica 12 bold", foreground="white", bg="#03467B")
labelvalor = tk.Label(container6, text="Valor: ", font="Helvetica 12 bold", foreground="white", bg="#03467B")
labelvalor2 = tk.Label(container6, text=valor, font="Helvetica 12 bold", foreground="white", bg="#03467B")
# melhorar calculo da taxa de acionamentoa.ge
labelTaxaacionamento = tk.Label(container4, text="Taxa de acionamento: R$", font="Helvetica 12 bold",
foreground="white", bg="#03467B")
labelTaxamensalidade = tk.Label(container4, text= self.lista_orcament["acionamento"], font="Helvetica 12 bold", foreground="white",
bg="#03467B")
# melhorar calculo da mensalidade
labelMensalidade = tk.Label(container5, text="Mensalidade: R$", font="Helvetica 12 bold", foreground="white",
bg="#03467B")
labelMensalidade2 = tk.Label(container5, text= self.lista_orcament["mensalidade"], font="Helvetica 12 bold", foreground="white", bg="#03467B")
labelTop = tk.Label(janela, text="Adicionais\n\n", font="Helvetica 12 bold", foreground="white", bg="#03467B")
labelvalor.pack(side=LEFT)
labelvalor2.pack(side=RIGHT)
labelMarca.pack(side=LEFT)
labelMarca2.pack(side=RIGHT)
labelModelo.pack(side=LEFT)
labelModelo2.pack(side=RIGHT)
labelAno.pack(side=LEFT)
labelAno2.pack(side=RIGHT)
labelTaxaacionamento.pack(side=LEFT)
labelTaxamensalidade.pack(side=RIGHT)
labelMensalidade.pack(side=LEFT)
labelMensalidade2.pack(side=RIGHT)
btvoltar = Button(janela, width=8, text="Refazer", font="Helvetica 9 bold", bg='white', command=self.voltar)
btvoltar.place(x=90, y=199)
btvoltar1 = Button(janela, width=8, text="Salvar", font="Helvetica 9 bold", bg='white', command=self.salvar)
btvoltar1.place(x=190, y=199)
def callback(self, eventObject):
self.atualiza_Modelo(eventObject.widget.get())
def set_labels(self):
self.janela2 = tk.Tk()
janela = self.janela2
janela.resizable(0, 0)
janela.geometry('450x275+500+100')
janela['bg'] = '#03467B'
janela.title("Lider Prev - v3.7")
photo = PhotoImage(file="images (2).png")
photo = photo.subsample(2, 2)
label = Label(janela, image=photo, bg='#03467B')
label.configure()
label.place(x=230, y=40)
self.comboMarcas = ttk.Combobox(janela, values=self.marcas, font="Helvetica 9",state = "readonly")
self.comboModelo = ttk.Combobox(janela, values=self.modelos, font="Helvetica 9",state = "readonly")
self.comboAno = ttk.Combobox(janela, values=self.anos, font="Helvetica 9",state = "readonly")
self.entrada = Entry(janela, bg='white', fg='black', font="Helvetica 9 bold", width='20', textvariable="Preço")
self.comboMarcas.place(x=20, y=40)
self.comboMarcas.current(0)
self.comboMarcas.bind("<<ComboboxSelected>>", self.callback)
self.comboModelo.place(x=20, y=100)
self.comboAno.place(x=20, y=160)
self.entrada.place(x=20, y=220)
janela.iconbitmap('imagesico (3).ico')
labelTop = tk.Label(janela, text="Escolha seu modelo:", font="Helvetica 12 bold", foreground="white",
bg="#03467B")
labelTop.place(x=17, y=79)
labelTop = tk.Label(janela, text="Escolha o ano do modelo:", font="Helvetica 12 bold", foreground="white",
bg="#03467B")
labelTop.place(x=17, y=139)
labelTop = tk.Label(janela, text="Digite o valor:", font="Helvetica 12 bold ", foreground="white", bg="#03467B")
labelTop.place(x=17, y=195)
labelTop = tk.Label(janela, text="Escolha sua marca:", font="Helvetica 12 bold", foreground="white",
bg="#03467B")
labelTop.place(x=17, y=15)
bt3 = Button(janela, width=5, text="OK", font="Helvetica 10 bold", bg='white', command=self.main)
bt3.place(x=397, y=243)
btvoltar = Button(janela, width=5, text="Voltar", font="Helvetica 10 bold", bg='white', command=lambda: Frames.orcamentos(janela))
btvoltar.place(x=332, y=243)
#print(dict(self.comboMarcas))
janela.mainloop()
def voltar (self):
self.janela2.destroy()
self.set_labels()
def salvar(self):
banco.insertOrcamento(self.lista_orcament)
self.janela2.destroy()
self.set_labels(janela)
| {"/Frames.py": ["/Orcamento.py", "/login.py"], "/Main.py": ["/login.py"], "/login.py": ["/banco.py", "/Frames.py"], "/Orcamento.py": ["/Frames.py", "/banco.py"]} |
70,494 | astromitts/who-data | refs/heads/master | /who_data/views/api.py | from pyramid.response import Response # noqa
from pyramid.view import view_config
from collections import OrderedDict
import math
from pyramid.httpexceptions import HTTPNotFound
from who_data.models.who import Country, WHODisease, WHODiseaseReport
from who_data.models.v_report_search import ReportSearch
class APIBase(object):
_valid_versions = {
'v1': 1,
}
def __init__(self, request):
self.request = request
self.api_version = self._valid_versions.get(
request.matchdict['api_version']
)
# bail if unknown version
if not self.api_version:
raise HTTPNotFound
self.api_version_string = request.matchdict['api_version']
class APISearchablePage(APIBase):
"""
Base class for API pages that accept search parameters and pagination
"""
_per_page_limit = None
model = None
def __init__(self, request):
super(APISearchablePage, self).__init__(request)
# bet base URL for use in metadata links
self._link_base = self.request.host_url + self.request.path
# determine the page and offset, default to 1
self._page = int(self.request.GET.get('_page', '1'))
if self._per_page_limit:
self._offset = (self._page - 1) * self._per_page_limit
self.search_terms = {}
query_strings = []
for param in self.request.GET:
if param != '_page':
self.search_terms[param] = self.request.GET[param]
query_strings.append(
'%s=%s' % (param, self.request.GET[param])
)
if len(query_strings) > 0:
self.query_string = '&'.join(query_strings)
else:
self.query_string = None
self.return_dict = OrderedDict()
# all searches should return the following properties:
self.return_dict['meta'] = OrderedDict([
('self_link', self.request.url),
('next_link', None),
('prev_link', None),
('api_version', self.api_version)
])
self.return_dict['results'] = OrderedDict([
('total_items', 0),
('total_pages', 0),
('total_page_items', 0),
('page', self._page),
('items', []),
])
def __call__(self):
self.__fetch_items__()
self.__set_result_meta__()
return self.return_dict
def __set_result_meta__(self):
total_items = self.return_dict['results']['total_items']
if self._per_page_limit:
total_pages = math.ceil(total_items / self._per_page_limit)
total_page_items = len(self.return_dict['results']['items'])
else:
total_pages = 1
total_page_items = self.return_dict['results']['total_items']
self.return_dict['results']['total_pages'] = total_pages
self.return_dict['results']['total_page_items'] = total_page_items
if self.query_string:
meta_link_base = self._link_base + '?%s&' % self.query_string
else:
meta_link_base = self._link_base + '?'
# set previous link
if self._page == 2:
self.return_dict['meta']['prev_link'] = meta_link_base[:-1]
elif self._page > 1:
self.return_dict['meta']['prev_link'] = (
meta_link_base + '_page=%s' % (self._page - 1)
)
# set next link
if self._page < total_pages:
self.return_dict['meta']['next_link'] = (
meta_link_base + '_page=%s' % (self._page + 1)
)
def __format_results__(self, result_rows):
"""
Format result rows and add them to api return structure
By default, just append the rows as-is
Override this function for resource specific formatting
"""
for row in result_rows:
self.return_dict['results']['items'].append(row)
def __fetch_items__(self):
count, rows = self.model.search(
limit=self._per_page_limit,
offset=self._offset,
search_terms=self.search_terms
)
self.return_dict['results']['total_items'] = count
self.__format_results__(rows)
@view_config(route_name='api_v1_ping', renderer='json')
class APIPing(APISearchablePage):
def __fetch_items__(self):
pass
@view_config(route_name='api_v1_country_search', renderer='json')
class APICountryLanding(APISearchablePage):
_per_page_limit = 25
model = Country
def __format_results__(self, result_rows):
"""
Override result format function
"""
for row in result_rows:
self.return_dict['results']['items'].append(
{
'name': row['name'],
'link': self.request.route_url(
'api_v1_country_resource',
api_version=self.api_version_string,
url_name=row['url_name']
)
}
)
@view_config(route_name='api_v1_disease_landing', renderer='json')
class APIDiseaseLanding(APISearchablePage):
_per_page_limit = 25
model = WHODisease
def __format_results__(self, result_rows):
"""
Override result format function
"""
for row in result_rows:
self.return_dict['results']['items'].append(
{
'name': row['name'],
'link': self.request.route_url(
'api_v1_disease_resource',
api_version=self.api_version_string,
url_name=row['id']
),
'search_link': self.request.route_url(
'api_v1_disease_search',
api_version=self.api_version_string,
url_name=row['id']
),
'information_link': row['info_link']
}
)
@view_config(route_name='api_v1_disease_search', renderer='json')
class APIDiseaseSearch(APISearchablePage):
_per_page_limit = 25
model = ReportSearch
def __format_results__(self, result_rows):
"""
Format result rows and add them to api return structure
By default, just append the rows as-is
Override this function for resource specific formatting
"""
for result in result_rows:
self.return_dict['results']['items'].append(
OrderedDict([
('count', result['count']),
('year', result['year']),
('country', {
'id': result['country_id'],
'link': self.request.route_url(
'api_v1_country_resource',
api_version=self.api_version_string,
url_name=result['country_url_name']
),
},
),
])
)
def __fetch_items__(self):
disease_id = self.request.matchdict['url_name']
self.search_terms.update(
{
'disease_id': disease_id,
}
)
count, rows = self.model.search(
limit=self._per_page_limit,
offset=self._offset,
search_terms=self.search_terms
)
self.return_dict['results']['total_items'] = count
self.__format_results__(rows)
class APIResourcePage(APIBase):
"""
Base class for API pages that represent a resource - these should point
to a single instance of an object type, it is not searchable or paginated
"""
def __init__(self, request):
super(APIResourcePage, self).__init__(request)
# all resources should return the following properties:
self.return_dict = OrderedDict()
self.return_dict['meta'] = OrderedDict([
('self_link', self.request.url),
('api_version', self.api_version)
])
self.return_dict['resource'] = OrderedDict()
def __call__(self):
return self.return_dict
@view_config(route_name='api_v1_country_resource', renderer='json')
class APICountryResource(APIResourcePage):
def __call__(self):
url_name = self.request.matchdict['url_name']
resource = Country.fetch_first(url_name=url_name)
if resource:
self.return_dict['resource']['country'] = {
'name': resource['name'],
'alias': resource['alias'],
'id': resource['id'],
}
report_rows = WHODiseaseReport.get_for_country(
country_id=resource['id']
)
report_dicts = OrderedDict()
for report in report_rows:
report_dicts[report.id] = report_dicts.get(
report.id,
OrderedDict([
('disease', {
'name': report.name,
'link': self.request.route_url(
'api_v1_disease_resource',
api_version=self.api_version_string,
url_name=report.id
)
}),
('reports', []),
])
)
report_dicts[report.id]['reports'].append(
{
'year': report.year,
'count': report.report_count,
'link': self.request.route_url(
'api_v1_disease_year_resource',
api_version=self.api_version_string,
url_name=report.id,
year=report.year,
)
}
)
self.return_dict['resource']['disease_reports'] = []
for key, rd in report_dicts.items():
self.return_dict['resource']['disease_reports'].append(rd)
else:
raise HTTPNotFound
return self.return_dict
@view_config(route_name='api_v1_disease_resource', renderer='json')
class APIDiseaseResource(APIResourcePage):
def __call__(self):
disease_id = self.request.matchdict['url_name']
resource = WHODisease.fetch_first(id=disease_id)
if resource:
self.return_dict['resource']['disease'] = OrderedDict([
('name', resource['name']),
('information_link', resource['info_link']),
('available_years', []),
])
years_available = WHODiseaseReport.fetch_distinct_years(
disease_id=disease_id
)
year_list = (
self.return_dict['resource']['disease']['available_years']
)
for year in years_available:
year_list.append(
{
'year': year.year,
'link': self.request.route_url(
'api_v1_disease_year_resource',
api_version=self.api_version_string,
url_name=disease_id,
year=year.year
)
}
)
else:
raise HTTPNotFound
return self.return_dict
@view_config(route_name='api_v1_disease_year_resource', renderer='json')
class APIDiseaseYearResource(APIResourcePage):
def __call__(self):
disease_id = self.request.matchdict['url_name']
year = int(self.request.matchdict['year'])
# optionally return only non-zero counts:
nonzero = self.request.GET.get('nonzero', 'false') == 'true'
resource = WHODisease.fetch_first(id=disease_id)
if resource:
self.return_dict['resource']['disease'] = OrderedDict([
('name', resource['name']),
('information_link', resource['info_link']),
('reports_by_country', []),
])
country_reports = WHODiseaseReport.get_for_year(
disease_id=disease_id,
year=year,
nonzero=nonzero
)
reports = (
self.return_dict['resource']['disease']['reports_by_country']
)
for cr in country_reports:
reports.append(
{
'country': cr.name,
'link': self.request.route_url(
'api_v1_country_resource',
url_name=cr.url_name,
api_version=self.api_version_string
),
'count': cr.report_count
}
)
else:
raise HTTPNotFound
return self.return_dict
| {"/who_data/views/api.py": ["/who_data/models/who.py", "/who_data/models/v_report_search.py"], "/who_data/bin/ingest/tests/who_file_parser.py": ["/who_data/bin/ingest/lib/who_file_parser.py"], "/who_data/bin/ingest/ingest.py": ["/who_data/lib/countries/__init__.py", "/who_data/bin/ingest/lib/who_file_parser.py", "/who_data/bin/ingest/__init__.py", "/who_data/models/who.py", "/who_data/lib/urlizer.py", "/who_data/models/base.py"], "/who_data/models/v_report_search.py": ["/who_data/models/base.py"], "/who_data/tests/api.py": ["/who_data/tests/__init__.py"], "/who_data/bin/ingest/lib/who_file_parser.py": ["/who_data/bin/ingest/lib/file_hash.py"], "/who_data/tests/lib_urlizer.py": ["/who_data/lib/urlizer.py"], "/who_data/models/who.py": ["/who_data/models/base.py"], "/who_data/bin/ingest/tests/lib.py": ["/who_data/bin/ingest/lib/file_hash.py"]} |
70,495 | astromitts/who-data | refs/heads/master | /who_data/bin/ingest/tests/who_file_parser.py | '''
Tests for the WHOFileParser class
'''
from who_data.bin.ingest.tests import TestBase
class WHOFileParser(TestBase):
def parse(self):
from who_data.bin.ingest.lib.who_file_parser import WHOFileParser
test_file_path = (
'who_data/bin/ingest/tests/who-sample-file.csv'
)
parsed_data = WHOFileParser('test', test_file_path)
parsed_data.parse()
# there are 6 rows of data in the sample file
self.assertTrue(len(parsed_data.data) == 6)
test_row = parsed_data.data[3]
# the 4th data row should be Cote d'Ivoire
self.assertTrue(test_row['country'] == "Cote d'Ivoire")
# there should be the following years in the test row:
for i in range(1989, 2011):
self.assertTrue(i in test_row['reports_by_year'])
self.assertTrue(test_row['reports_by_year'][2004] == 21)
| {"/who_data/views/api.py": ["/who_data/models/who.py", "/who_data/models/v_report_search.py"], "/who_data/bin/ingest/tests/who_file_parser.py": ["/who_data/bin/ingest/lib/who_file_parser.py"], "/who_data/bin/ingest/ingest.py": ["/who_data/lib/countries/__init__.py", "/who_data/bin/ingest/lib/who_file_parser.py", "/who_data/bin/ingest/__init__.py", "/who_data/models/who.py", "/who_data/lib/urlizer.py", "/who_data/models/base.py"], "/who_data/models/v_report_search.py": ["/who_data/models/base.py"], "/who_data/tests/api.py": ["/who_data/tests/__init__.py"], "/who_data/bin/ingest/lib/who_file_parser.py": ["/who_data/bin/ingest/lib/file_hash.py"], "/who_data/tests/lib_urlizer.py": ["/who_data/lib/urlizer.py"], "/who_data/models/who.py": ["/who_data/models/base.py"], "/who_data/bin/ingest/tests/lib.py": ["/who_data/bin/ingest/lib/file_hash.py"]} |
70,496 | astromitts/who-data | refs/heads/master | /who_data/lib/countries/__init__.py | #!/usr/bin/python
# -*- coding: utf-8 -*-
import pycountry
# these countries are known variations from WHO compared to the
# pycountry library, so they need to be mapped
known_name_mapping = {
'Bolivia, Plurinational State of': ['Bolivia (Plurinational State of)'],
'Côte d\'Ivoire': ['Cote d\'Ivoire'],
'Cape Verde': ['Cabo Verde'],
'Korea, Democratic People\'s Republic of': [
'Democratic People\'s Republic of Korea'
],
'Korea, Republic of': ['republic of korea'],
'Congo, The Democratic Republic of the': [
'Democratic Republic of the Congo'
],
'Moldova, Republic of': ['republic of moldova'],
'Macedonia, Republic of': ['the former yugoslav republic of macedonia'],
'United Kingdom': [
'united kingdom of great britain and northern ireland',
'UK'
],
'Tanzania, United Republic of': ['united republic of tanzania'],
'United States': ['united states of america', 'USA'],
}
def sanitize_country_name(name):
return name.replace('(', '').replace(')', '').replace(',', '').lower()
Countries = {}
CountryAlias = {}
for country in pycountry.countries:
Countries[sanitize_country_name(country.name)] = country
if country.name in known_name_mapping:
for alias in known_name_mapping[country.name]:
Countries[
sanitize_country_name(alias)
] = country
CountryAlias[country.name] = known_name_mapping[country.name]
| {"/who_data/views/api.py": ["/who_data/models/who.py", "/who_data/models/v_report_search.py"], "/who_data/bin/ingest/tests/who_file_parser.py": ["/who_data/bin/ingest/lib/who_file_parser.py"], "/who_data/bin/ingest/ingest.py": ["/who_data/lib/countries/__init__.py", "/who_data/bin/ingest/lib/who_file_parser.py", "/who_data/bin/ingest/__init__.py", "/who_data/models/who.py", "/who_data/lib/urlizer.py", "/who_data/models/base.py"], "/who_data/models/v_report_search.py": ["/who_data/models/base.py"], "/who_data/tests/api.py": ["/who_data/tests/__init__.py"], "/who_data/bin/ingest/lib/who_file_parser.py": ["/who_data/bin/ingest/lib/file_hash.py"], "/who_data/tests/lib_urlizer.py": ["/who_data/lib/urlizer.py"], "/who_data/models/who.py": ["/who_data/models/base.py"], "/who_data/bin/ingest/tests/lib.py": ["/who_data/bin/ingest/lib/file_hash.py"]} |
70,497 | astromitts/who-data | refs/heads/master | /who_data/bin/ingest/ingest.py | import sys
import transaction
from copy import deepcopy
from who_data.lib.countries import (
Countries,
CountryAlias,
sanitize_country_name
)
from who_data.bin.ingest.lib.who_file_parser import WHOFileParser
from who_data.bin.ingest import ABSOLUTE_FILE_PATH, primary_entity_file_map
from who_data.models.who import Country, WHODisease, WHODiseaseReport
from who_data.lib.urlizer import urlize
def main(ini_file):
from who_data.models.base import Base, DBSession, set_engine
set_engine(ini_file, Base, DBSession)
for entity_key, entity_data in primary_entity_file_map.items():
file_path = ABSOLUTE_FILE_PATH + entity_data['file']
parsed_file = WHOFileParser(entity_key, file_path)
parsed_file.parse()
transaction.begin()
who_disease = WHODisease.upsert(
id=entity_key,
name=entity_data['name'],
info_link=entity_data['information-link'],
)
disease_id = deepcopy(who_disease.id)
transaction.commit()
for row in parsed_file.data:
safe_country_name = sanitize_country_name(row['country'])
py_country = Countries[safe_country_name]
alias = CountryAlias.get(py_country.name)
transaction.begin()
country = Country().upsert(
id=py_country.alpha2,
name=py_country.name,
url_name=urlize(py_country.name),
alias=alias
)
country_id = deepcopy(country.id)
transaction.commit()
transaction.begin()
for year, report_count in row['reports_by_year'].items():
WHODiseaseReport.upsert(
country_id=country_id,
disease_id=disease_id,
year=year,
report_count=report_count,
)
transaction.commit()
if __name__ == "__main__":
ini_file = sys.argv[1]
sys.exit(main(ini_file))
| {"/who_data/views/api.py": ["/who_data/models/who.py", "/who_data/models/v_report_search.py"], "/who_data/bin/ingest/tests/who_file_parser.py": ["/who_data/bin/ingest/lib/who_file_parser.py"], "/who_data/bin/ingest/ingest.py": ["/who_data/lib/countries/__init__.py", "/who_data/bin/ingest/lib/who_file_parser.py", "/who_data/bin/ingest/__init__.py", "/who_data/models/who.py", "/who_data/lib/urlizer.py", "/who_data/models/base.py"], "/who_data/models/v_report_search.py": ["/who_data/models/base.py"], "/who_data/tests/api.py": ["/who_data/tests/__init__.py"], "/who_data/bin/ingest/lib/who_file_parser.py": ["/who_data/bin/ingest/lib/file_hash.py"], "/who_data/tests/lib_urlizer.py": ["/who_data/lib/urlizer.py"], "/who_data/models/who.py": ["/who_data/models/base.py"], "/who_data/bin/ingest/tests/lib.py": ["/who_data/bin/ingest/lib/file_hash.py"]} |
70,498 | astromitts/who-data | refs/heads/master | /who_data/models/v_report_search.py | from sqlalchemy import (
Column,
Integer,
Text,
)
from sqlalchemy import func
from .base import DatastoreBase
class ReportSearch(DatastoreBase):
__tablename__ = 'v_reports_search'
disease_id = Column(Text, primary_key=True)
country_id = Column(Text, primary_key=True)
year = Column(Integer, primary_key=True)
count = Column(Integer)
country_name = Column(Text)
country_url_name = Column(Text)
disease_name = Column(Text)
@classmethod
def order_search(cls, q):
q = q.order_by(cls.country_name)
q = q.order_by(cls.year)
q = q.order_by(cls.count)
return q
@classmethod
def filter_country(cls, q, phrase):
if len(phrase) == 2:
q = q.filter(cls.country_id == phrase.upper())
else:
q = q.filter(func.lower(cls.country_name) == phrase.lower())
return q
| {"/who_data/views/api.py": ["/who_data/models/who.py", "/who_data/models/v_report_search.py"], "/who_data/bin/ingest/tests/who_file_parser.py": ["/who_data/bin/ingest/lib/who_file_parser.py"], "/who_data/bin/ingest/ingest.py": ["/who_data/lib/countries/__init__.py", "/who_data/bin/ingest/lib/who_file_parser.py", "/who_data/bin/ingest/__init__.py", "/who_data/models/who.py", "/who_data/lib/urlizer.py", "/who_data/models/base.py"], "/who_data/models/v_report_search.py": ["/who_data/models/base.py"], "/who_data/tests/api.py": ["/who_data/tests/__init__.py"], "/who_data/bin/ingest/lib/who_file_parser.py": ["/who_data/bin/ingest/lib/file_hash.py"], "/who_data/tests/lib_urlizer.py": ["/who_data/lib/urlizer.py"], "/who_data/models/who.py": ["/who_data/models/base.py"], "/who_data/bin/ingest/tests/lib.py": ["/who_data/bin/ingest/lib/file_hash.py"]} |
70,499 | astromitts/who-data | refs/heads/master | /who_data/views/notfound.py | from pyramid.view import notfound_view_config
@notfound_view_config(renderer='json')
def notfound_view(request):
request.response.status = 404
return {
"status": "error",
"message": "resource not found",
"code": 404,
}
| {"/who_data/views/api.py": ["/who_data/models/who.py", "/who_data/models/v_report_search.py"], "/who_data/bin/ingest/tests/who_file_parser.py": ["/who_data/bin/ingest/lib/who_file_parser.py"], "/who_data/bin/ingest/ingest.py": ["/who_data/lib/countries/__init__.py", "/who_data/bin/ingest/lib/who_file_parser.py", "/who_data/bin/ingest/__init__.py", "/who_data/models/who.py", "/who_data/lib/urlizer.py", "/who_data/models/base.py"], "/who_data/models/v_report_search.py": ["/who_data/models/base.py"], "/who_data/tests/api.py": ["/who_data/tests/__init__.py"], "/who_data/bin/ingest/lib/who_file_parser.py": ["/who_data/bin/ingest/lib/file_hash.py"], "/who_data/tests/lib_urlizer.py": ["/who_data/lib/urlizer.py"], "/who_data/models/who.py": ["/who_data/models/base.py"], "/who_data/bin/ingest/tests/lib.py": ["/who_data/bin/ingest/lib/file_hash.py"]} |
70,500 | astromitts/who-data | refs/heads/master | /alembic/versions/640180a77a25_add_info_link_field_to_disease_resource_.py | """add info-link field to disease resource table
Revision ID: 640180a77a25
Revises: ec62d954c1c3
Create Date: 2016-09-04 10:36:30.283377
"""
# revision identifiers, used by Alembic.
revision = '640180a77a25'
down_revision = 'ec62d954c1c3'
branch_labels = None
depends_on = None
from alembic import op
def upgrade():
op.execute('ALTER TABLE datastore.disease ADD COLUMN info_link TEXT')
def downgrade():
op.execute('ALTER TABLE datastore.disease DROP COLUMN info_link')
| {"/who_data/views/api.py": ["/who_data/models/who.py", "/who_data/models/v_report_search.py"], "/who_data/bin/ingest/tests/who_file_parser.py": ["/who_data/bin/ingest/lib/who_file_parser.py"], "/who_data/bin/ingest/ingest.py": ["/who_data/lib/countries/__init__.py", "/who_data/bin/ingest/lib/who_file_parser.py", "/who_data/bin/ingest/__init__.py", "/who_data/models/who.py", "/who_data/lib/urlizer.py", "/who_data/models/base.py"], "/who_data/models/v_report_search.py": ["/who_data/models/base.py"], "/who_data/tests/api.py": ["/who_data/tests/__init__.py"], "/who_data/bin/ingest/lib/who_file_parser.py": ["/who_data/bin/ingest/lib/file_hash.py"], "/who_data/tests/lib_urlizer.py": ["/who_data/lib/urlizer.py"], "/who_data/models/who.py": ["/who_data/models/base.py"], "/who_data/bin/ingest/tests/lib.py": ["/who_data/bin/ingest/lib/file_hash.py"]} |
70,501 | astromitts/who-data | refs/heads/master | /who_data/tests/api.py | """ Tests for search views in the WHO Data Pyramid App
"""
from who_data.tests import IntegrationTestBase
class APITests(IntegrationTestBase):
def invalid_version(self):
self.TestApp.get('/api/v2/ping', status=404)
def ping(self):
'''
Test that the basic search JSON logic works and has expected structure
'''
page = self.TestApp.get('/api/v1/ping', status=200)
self.assertTrue('meta' in page.json)
self.assertTrue('self_link' in page.json['meta'])
self.assertTrue('next_link' in page.json['meta'])
self.assertTrue('prev_link' in page.json['meta'])
self.assertTrue('api_version' in page.json['meta'])
self.assertTrue('results' in page.json)
self.assertTrue('total_items' in page.json['results'])
self.assertTrue('total_pages' in page.json['results'])
self.assertTrue('total_page_items' in page.json['results'])
self.assertTrue('page' in page.json['results'])
self.assertTrue('items' in page.json['results'])
def country_search_page(self):
page = self.TestApp.get('/api/v1/countries', status=200)
self.assertTrue(page.json['results']['total_items'] > 0)
self.assertEquals(
page.json['meta']['self_link'],
'http://localhost/api/v1/countries'
)
self.assertEquals(
page.json['meta']['next_link'],
'http://localhost/api/v1/countries?_page=2'
)
self.assertEquals(
page.json['meta']['prev_link'],
None
)
page = self.TestApp.get(
'/api/v1/countries?_page=%s' % (
page.json['results']['total_pages']
),
status=200
)
self.assertEquals(
page.json['meta']['self_link'],
'http://localhost/api/v1/countries?_page=%s' % (
page.json['results']['total_pages']
)
)
self.assertEquals(
page.json['meta']['prev_link'],
'http://localhost/api/v1/countries?_page=%s' % (
page.json['results']['total_pages'] - 1
)
)
self.assertEquals(
page.json['meta']['next_link'],
None
)
def country_resource_page(self):
page = self.TestApp.get(
'/api/v1/countries/brunei-darussalam',
status=200
)
self.assertTrue('meta' in page.json)
self.assertTrue('self_link' in page.json['meta'])
self.assertTrue('api_version' in page.json['meta'])
self.assertTrue('resource' in page.json)
self.assertEquals(
page.json['resource']['country']['name'],
'Brunei Darussalam'
)
self.assertTrue('disease_reports' in page.json['resource'])
self.assertTrue(
len(page.json['resource']['disease_reports']) >= 3
)
def country_resource_notfound(self):
self.TestApp.get(
'/api/v1/countries/narnia',
status=404
)
def disease_search_logic(self):
def test_results(items):
'''
verify that returned items are within requested params
'''
for item in items:
self.assertTrue(item['count'] >= 5000)
self.assertTrue(item['year'] >= 1989)
self.assertTrue(item['year'] <= 1995)
# verify a searches for a range of matches on number fields
page = self.TestApp.get(
'/api/v1/diseases/guinea-worm/search?year=1989:1995&count=5000:',
status=200
)
self.assertEquals(
page.json['meta']['next_link'],
'http://localhost/api/v1/diseases/guinea-worm/'
'search?year=1989:1995&count=5000:&_page=2'
)
test_results(page.json['results']['items'])
page = self.TestApp.get(
'/api/v1/diseases/guinea-worm/search?year='
'1989:1995&count=5000:&_page=2',
status=200
)
self.assertEquals(
page.json['meta']['prev_link'],
'http://localhost/api/v1/diseases/guinea-worm/'
'search?year=1989:1995&count=5000:'
)
test_results(page.json['results']['items'])
# verify a search for an exact match on a number field
page = self.TestApp.get(
'/api/v1/diseases/guinea-worm/search?year='
'1989:1995&count=5029',
status=200
)
for item in page.json['results']['items']:
self.assertTrue(item['count'] == 5029)
| {"/who_data/views/api.py": ["/who_data/models/who.py", "/who_data/models/v_report_search.py"], "/who_data/bin/ingest/tests/who_file_parser.py": ["/who_data/bin/ingest/lib/who_file_parser.py"], "/who_data/bin/ingest/ingest.py": ["/who_data/lib/countries/__init__.py", "/who_data/bin/ingest/lib/who_file_parser.py", "/who_data/bin/ingest/__init__.py", "/who_data/models/who.py", "/who_data/lib/urlizer.py", "/who_data/models/base.py"], "/who_data/models/v_report_search.py": ["/who_data/models/base.py"], "/who_data/tests/api.py": ["/who_data/tests/__init__.py"], "/who_data/bin/ingest/lib/who_file_parser.py": ["/who_data/bin/ingest/lib/file_hash.py"], "/who_data/tests/lib_urlizer.py": ["/who_data/lib/urlizer.py"], "/who_data/models/who.py": ["/who_data/models/base.py"], "/who_data/bin/ingest/tests/lib.py": ["/who_data/bin/ingest/lib/file_hash.py"]} |
70,502 | astromitts/who-data | refs/heads/master | /who_data/bin/ingest/lib/who_file_parser.py | """
Class for a standard WHO Data file for a tropical disease cases reported
CSV File
This class should take in an absolute filepath to a CSV and parse the file,
storing the information in a dictionary
"""
import csv
from who_data.bin.ingest.lib.file_hash import file_hash
class WHOFileParser(object):
def __init__(self, pkey, file_path):
self.pkey = pkey
self._file_path = file_path
self.file_hash = file_hash(file_path)
self.header_years = []
self.data = []
def _parse_header_years(self, header_row):
'''
Take in a list of file headers and parse out the year, returning
only a list of the years as the headers
Luckily, we know for now that each WHO file header is in the same
format: "something something something; YYYY" so just grab the last
4 characters of each header
'''
parsed_header = [int(i[-4:]) for i in header_row]
return parsed_header
def parse(self):
'''
Do the actual file parsing here
This function should return a list of dictionaries which represents
reported cases by year, where each entry looks like:
{
'country': 'country-name',
'reports_by_year':{
1990: 123,
1991: 176,
[...]
}
}
'''
file = open(self._file_path, 'r')
reader = csv.reader(file)
raw_header = reader.__next__()
raw_header.remove('Country')
self.header_years = self._parse_header_years(raw_header)
result_rows = []
for row in reader:
country = row[0]
reports_by_year = {}
position = 1
for year in self.header_years:
try:
reports_by_year[year] = int(row[position])
except Exception:
reports_by_year[year] = None
position += 1
result_rows.append(
{
'country': country,
'reports_by_year': reports_by_year
}
)
self.data = result_rows
| {"/who_data/views/api.py": ["/who_data/models/who.py", "/who_data/models/v_report_search.py"], "/who_data/bin/ingest/tests/who_file_parser.py": ["/who_data/bin/ingest/lib/who_file_parser.py"], "/who_data/bin/ingest/ingest.py": ["/who_data/lib/countries/__init__.py", "/who_data/bin/ingest/lib/who_file_parser.py", "/who_data/bin/ingest/__init__.py", "/who_data/models/who.py", "/who_data/lib/urlizer.py", "/who_data/models/base.py"], "/who_data/models/v_report_search.py": ["/who_data/models/base.py"], "/who_data/tests/api.py": ["/who_data/tests/__init__.py"], "/who_data/bin/ingest/lib/who_file_parser.py": ["/who_data/bin/ingest/lib/file_hash.py"], "/who_data/tests/lib_urlizer.py": ["/who_data/lib/urlizer.py"], "/who_data/models/who.py": ["/who_data/models/base.py"], "/who_data/bin/ingest/tests/lib.py": ["/who_data/bin/ingest/lib/file_hash.py"]} |
70,503 | astromitts/who-data | refs/heads/master | /who_data/routes.py | def includeme(config):
config.add_static_view('static', 'static', cache_max_age=3600)
config.route_prefix = config.get_settings().get('url_prefix')
routes = [
('home', ''),
('api_v1_ping', '/api/{api_version}/ping'),
('api_v1_country_search', '/api/{api_version}/countries'),
('api_v1_country_resource', '/api/{api_version}/countries/{url_name}'),
('api_v1_disease_landing', '/api/{api_version}/diseases'),
('api_v1_disease_resource', '/api/{api_version}/diseases/{url_name}'),
('api_v1_disease_search',
'/api/{api_version}/diseases/{url_name}/search'),
('api_v1_disease_year_resource',
'/api/{api_version}/diseases/{url_name}/{year}'),
]
config.add_route
for route in routes:
config.add_route(route[0], route[1])
| {"/who_data/views/api.py": ["/who_data/models/who.py", "/who_data/models/v_report_search.py"], "/who_data/bin/ingest/tests/who_file_parser.py": ["/who_data/bin/ingest/lib/who_file_parser.py"], "/who_data/bin/ingest/ingest.py": ["/who_data/lib/countries/__init__.py", "/who_data/bin/ingest/lib/who_file_parser.py", "/who_data/bin/ingest/__init__.py", "/who_data/models/who.py", "/who_data/lib/urlizer.py", "/who_data/models/base.py"], "/who_data/models/v_report_search.py": ["/who_data/models/base.py"], "/who_data/tests/api.py": ["/who_data/tests/__init__.py"], "/who_data/bin/ingest/lib/who_file_parser.py": ["/who_data/bin/ingest/lib/file_hash.py"], "/who_data/tests/lib_urlizer.py": ["/who_data/lib/urlizer.py"], "/who_data/models/who.py": ["/who_data/models/base.py"], "/who_data/bin/ingest/tests/lib.py": ["/who_data/bin/ingest/lib/file_hash.py"]} |
70,504 | astromitts/who-data | refs/heads/master | /alembic/versions/ec62d954c1c3_initialize_database_structure.py | """Initialize database structure
Revision ID: ec62d954c1c3
Revises:
Create Date: 2016-09-02 20:25:17.058257
"""
# revision identifiers, used by Alembic.
revision = 'ec62d954c1c3'
down_revision = None
branch_labels = None
depends_on = None
from alembic import op
import sqlalchemy as sa
from sqlalchemy.dialects import postgresql
def upgrade():
op.execute('create schema if not exists datastore')
op.create_table(
'country',
sa.Column('id', sa.Text, nullable=False),
sa.Column('name', sa.Text, nullable=False),
sa.Column('url_name', sa.Text, nullable=False),
sa.Column('alias', postgresql.ARRAY(sa.String())),
sa.PrimaryKeyConstraint('id', name='pk_country_id'),
sa.UniqueConstraint('name', name='uq_country_name'),
sa.UniqueConstraint('url_name', name='uq_country_url_name'),
schema='datastore'
)
op.execute(
'create index ix_country_name_lower on datastore.country(lower(name))'
)
op.execute(
'create index ix_country_alias_lower on datastore.country '
'using gin ("alias")'
)
op.create_table(
'disease',
sa.Column('id', sa.Text, nullable=False),
sa.Column('name', sa.Text, nullable=False),
sa.PrimaryKeyConstraint('id', name='pk_disease_id'),
sa.UniqueConstraint('name', name='uq_disease_name'),
schema='datastore'
)
op.execute(
'create index ix_disease_name on datastore.disease(name)'
)
op.create_table(
'disease_report',
sa.Column('id', sa.INTEGER, autoincrement=True, nullable=False),
sa.Column('country_id', sa.Text, nullable=False),
sa.Column('disease_id', sa.Text, nullable=False),
sa.Column('year', sa.INTEGER, nullable=False),
sa.Column('report_count', sa.INTEGER),
sa.PrimaryKeyConstraint('id', name='pk_disease_report_id'),
sa.UniqueConstraint(
'year',
'country_id',
'disease_id',
name='uq_disease_report_year_country_disease'
),
sa.ForeignKeyConstraint(
name='fk_disease_report_disease_id',
columns=['disease_id'], refcolumns=['datastore.disease.id']
),
sa.ForeignKeyConstraint(
name='fk_disease_report_country_id',
columns=['country_id'], refcolumns=['datastore.country.id']
),
schema='datastore'
)
op.execute(
'create index ix_disease_report_count on '
'datastore.disease_report(report_count)'
)
def downgrade():
op.drop_table('disease_report', schema='datastore')
op.drop_table('country', schema='datastore')
op.drop_table('disease', schema='datastore')
op.execute('drop schema datastore')
| {"/who_data/views/api.py": ["/who_data/models/who.py", "/who_data/models/v_report_search.py"], "/who_data/bin/ingest/tests/who_file_parser.py": ["/who_data/bin/ingest/lib/who_file_parser.py"], "/who_data/bin/ingest/ingest.py": ["/who_data/lib/countries/__init__.py", "/who_data/bin/ingest/lib/who_file_parser.py", "/who_data/bin/ingest/__init__.py", "/who_data/models/who.py", "/who_data/lib/urlizer.py", "/who_data/models/base.py"], "/who_data/models/v_report_search.py": ["/who_data/models/base.py"], "/who_data/tests/api.py": ["/who_data/tests/__init__.py"], "/who_data/bin/ingest/lib/who_file_parser.py": ["/who_data/bin/ingest/lib/file_hash.py"], "/who_data/tests/lib_urlizer.py": ["/who_data/lib/urlizer.py"], "/who_data/models/who.py": ["/who_data/models/base.py"], "/who_data/bin/ingest/tests/lib.py": ["/who_data/bin/ingest/lib/file_hash.py"]} |
70,505 | astromitts/who-data | refs/heads/master | /who_data/models/base.py | from sqlalchemy import create_engine
import configparser
import re
from .meta import Base, DBSession
NUMERICAL_RANGE_PATTERN = re.compile("^[0-9]*:[0-9]*$")
def set_engine(ini, Base, DBSession):
config_ini = configparser.ConfigParser()
config_ini.read(ini)
engine = create_engine(config_ini['app:main']['sqlalchemy.url'])
DBSession.configure(bind=engine)
Base.metadata.bind = engine
class DatastoreBase(Base):
__abstract__ = True
__table_args__ = {
'schema': 'datastore',
}
session = DBSession
@classmethod
def row_to_dict(cls, row):
row_dict = {}
for c in row.__table__._columns:
row_dict[c.name] = getattr(row, c.name)
return row_dict
@classmethod
def order_search(cls, q):
return q
@classmethod
def search(cls, to_dict=True, limit=None, offset=None,
search_terms={}, **kw):
q = cls.session.query(cls)
for k, w in kw.items():
if w == 'notnull':
q = q.filter(getattr(cls, k) != None)
else:
q = q.filter(getattr(cls, k) == w)
for field, phrase in search_terms.items():
if hasattr(cls, 'filter_{}'.format(field)):
filter_func = getattr(cls, 'filter_{}'.format(field))
q = filter_func(q, phrase)
else:
if phrase == 'notnull':
q = q.filter(getattr(cls, field) != None)
elif NUMERICAL_RANGE_PATTERN.match(phrase):
ranges = phrase.split(':')
if ranges[0]:
q = q.filter(getattr(cls, field) >= ranges[0])
if ranges[1]:
q = q.filter(getattr(cls, field) <= ranges[1])
else:
q = q.filter(getattr(cls, field) == phrase)
count = q.count()
q = cls.order_search(q)
if limit:
q = q.limit(limit)
if offset:
q = q.offset(offset)
res = q.all()
if to_dict:
json_res = []
for row in res:
json_res.append(cls.row_to_dict(row))
return count, json_res
else:
return count, res
@classmethod
def fetch_first(cls, to_dict=True, **kw):
q = cls.session.query(cls)
for k, w in kw.items():
q = q.filter(getattr(cls, k) == w)
res = q.first()
if to_dict and res:
return cls.row_to_dict(res)
return res
| {"/who_data/views/api.py": ["/who_data/models/who.py", "/who_data/models/v_report_search.py"], "/who_data/bin/ingest/tests/who_file_parser.py": ["/who_data/bin/ingest/lib/who_file_parser.py"], "/who_data/bin/ingest/ingest.py": ["/who_data/lib/countries/__init__.py", "/who_data/bin/ingest/lib/who_file_parser.py", "/who_data/bin/ingest/__init__.py", "/who_data/models/who.py", "/who_data/lib/urlizer.py", "/who_data/models/base.py"], "/who_data/models/v_report_search.py": ["/who_data/models/base.py"], "/who_data/tests/api.py": ["/who_data/tests/__init__.py"], "/who_data/bin/ingest/lib/who_file_parser.py": ["/who_data/bin/ingest/lib/file_hash.py"], "/who_data/tests/lib_urlizer.py": ["/who_data/lib/urlizer.py"], "/who_data/models/who.py": ["/who_data/models/base.py"], "/who_data/bin/ingest/tests/lib.py": ["/who_data/bin/ingest/lib/file_hash.py"]} |
70,506 | astromitts/who-data | refs/heads/master | /who_data/lib/urlizer.py | from unidecode import unidecode
def urlize(str_in):
url_name_chars = []
prev_c = ''
safe_c = ''
if str_in:
for char in str_in.strip():
if char and char.isalnum():
safe_c = unidecode(char).lower()
url_name_chars.append(safe_c)
elif (char == ' ' or not char.isalnum()) and prev_c != '-':
safe_c = '-'
url_name_chars.append(safe_c)
prev_c = safe_c
urlname = ''.join(url_name_chars)
if urlname.endswith('-'):
urlname = urlname[:-1]
return urlname
return None
| {"/who_data/views/api.py": ["/who_data/models/who.py", "/who_data/models/v_report_search.py"], "/who_data/bin/ingest/tests/who_file_parser.py": ["/who_data/bin/ingest/lib/who_file_parser.py"], "/who_data/bin/ingest/ingest.py": ["/who_data/lib/countries/__init__.py", "/who_data/bin/ingest/lib/who_file_parser.py", "/who_data/bin/ingest/__init__.py", "/who_data/models/who.py", "/who_data/lib/urlizer.py", "/who_data/models/base.py"], "/who_data/models/v_report_search.py": ["/who_data/models/base.py"], "/who_data/tests/api.py": ["/who_data/tests/__init__.py"], "/who_data/bin/ingest/lib/who_file_parser.py": ["/who_data/bin/ingest/lib/file_hash.py"], "/who_data/tests/lib_urlizer.py": ["/who_data/lib/urlizer.py"], "/who_data/models/who.py": ["/who_data/models/base.py"], "/who_data/bin/ingest/tests/lib.py": ["/who_data/bin/ingest/lib/file_hash.py"]} |
70,507 | astromitts/who-data | refs/heads/master | /alembic/versions/e465c6f15d1b_add_a_search_view.py | """add a search view
Revision ID: e465c6f15d1b
Revises: 640180a77a25
Create Date: 2016-09-06 20:02:50.663766
"""
# revision identifiers, used by Alembic.
revision = 'e465c6f15d1b'
down_revision = '640180a77a25'
branch_labels = None
depends_on = None
from alembic import op
def upgrade():
op.execute(
"create view datastore.v_reports_search as "
"select "
"country.id as country_id, "
"country.name as country_name, "
"country.url_name as country_url_name, "
"disease.id as disease_id, "
"disease.name as disease_name, "
"disease_report.year, "
"disease_report.report_count as count "
"from datastore.disease_report "
"join datastore.country on disease_report.country_id = country.id "
"join datastore.disease on disease_report.disease_id = disease.id; "
)
def downgrade():
op.execute("drop view datastore.v_reports_search")
| {"/who_data/views/api.py": ["/who_data/models/who.py", "/who_data/models/v_report_search.py"], "/who_data/bin/ingest/tests/who_file_parser.py": ["/who_data/bin/ingest/lib/who_file_parser.py"], "/who_data/bin/ingest/ingest.py": ["/who_data/lib/countries/__init__.py", "/who_data/bin/ingest/lib/who_file_parser.py", "/who_data/bin/ingest/__init__.py", "/who_data/models/who.py", "/who_data/lib/urlizer.py", "/who_data/models/base.py"], "/who_data/models/v_report_search.py": ["/who_data/models/base.py"], "/who_data/tests/api.py": ["/who_data/tests/__init__.py"], "/who_data/bin/ingest/lib/who_file_parser.py": ["/who_data/bin/ingest/lib/file_hash.py"], "/who_data/tests/lib_urlizer.py": ["/who_data/lib/urlizer.py"], "/who_data/models/who.py": ["/who_data/models/base.py"], "/who_data/bin/ingest/tests/lib.py": ["/who_data/bin/ingest/lib/file_hash.py"]} |
70,508 | astromitts/who-data | refs/heads/master | /who_data/tests/__init__.py | import unittest
from pyramid import testing
class IntegrationTestBase(unittest.TestCase):
"""
Base class for tests that require fully integrated
Pyramid application stack
"""
def setUp(self):
from who_data import main
from webtest import TestApp
import configparser
config_ini = configparser.ConfigParser()
config_ini.read('development.ini')
self.config = testing.setUp()
self.app = main({}, settings=config_ini._sections)
self.TestApp = TestApp(self.app)
def tearDown(self):
testing.tearDown()
| {"/who_data/views/api.py": ["/who_data/models/who.py", "/who_data/models/v_report_search.py"], "/who_data/bin/ingest/tests/who_file_parser.py": ["/who_data/bin/ingest/lib/who_file_parser.py"], "/who_data/bin/ingest/ingest.py": ["/who_data/lib/countries/__init__.py", "/who_data/bin/ingest/lib/who_file_parser.py", "/who_data/bin/ingest/__init__.py", "/who_data/models/who.py", "/who_data/lib/urlizer.py", "/who_data/models/base.py"], "/who_data/models/v_report_search.py": ["/who_data/models/base.py"], "/who_data/tests/api.py": ["/who_data/tests/__init__.py"], "/who_data/bin/ingest/lib/who_file_parser.py": ["/who_data/bin/ingest/lib/file_hash.py"], "/who_data/tests/lib_urlizer.py": ["/who_data/lib/urlizer.py"], "/who_data/models/who.py": ["/who_data/models/base.py"], "/who_data/bin/ingest/tests/lib.py": ["/who_data/bin/ingest/lib/file_hash.py"]} |
70,509 | astromitts/who-data | refs/heads/master | /who_data/tests/lib_urlizer.py | #!/usr/bin/python
# -*- coding: utf-8 -*-
"""
Tests for who-data lib urlizer function
"""
import unittest
class urlizer(unittest.TestCase):
def setUp(self):
pass
def tearDown(self):
pass
def test(self):
from who_data.lib.urlizer import urlize
expected_results = {
"United States": "united-states",
"Cöte D'Ivore": "cote-d-ivore",
"Congo (republic of)": "congo-republic-of",
}
for name_in, name_out in expected_results.items():
url_name = urlize(name_in)
self.assertEquals(name_out, url_name)
| {"/who_data/views/api.py": ["/who_data/models/who.py", "/who_data/models/v_report_search.py"], "/who_data/bin/ingest/tests/who_file_parser.py": ["/who_data/bin/ingest/lib/who_file_parser.py"], "/who_data/bin/ingest/ingest.py": ["/who_data/lib/countries/__init__.py", "/who_data/bin/ingest/lib/who_file_parser.py", "/who_data/bin/ingest/__init__.py", "/who_data/models/who.py", "/who_data/lib/urlizer.py", "/who_data/models/base.py"], "/who_data/models/v_report_search.py": ["/who_data/models/base.py"], "/who_data/tests/api.py": ["/who_data/tests/__init__.py"], "/who_data/bin/ingest/lib/who_file_parser.py": ["/who_data/bin/ingest/lib/file_hash.py"], "/who_data/tests/lib_urlizer.py": ["/who_data/lib/urlizer.py"], "/who_data/models/who.py": ["/who_data/models/base.py"], "/who_data/bin/ingest/tests/lib.py": ["/who_data/bin/ingest/lib/file_hash.py"]} |
70,510 | astromitts/who-data | refs/heads/master | /who_data/bin/ingest/__init__.py | from collections import OrderedDict
ABSOLUTE_FILE_PATH = 'who_data/bin/data/who-source-files/'
primary_entity_file_map = OrderedDict([
('rabies', {
'file': 'rabies.csv',
'name': 'Rabies',
'information-link': 'http://www.who.int/rabies/en/',
}),
('river-blindness', {
'file': 'onchocerciasis-river-blindeness.csv',
'name': 'Onchocerciasis (river blindeness)',
'information-link': 'http://www.who.int/topics/onchocerciasis/en/',
}),
('leprosy', {
'file': 'leprosy.csv',
'name': 'Leprosy',
'information-link': 'http://www.who.int/lep/en/',
}),
('sleeping-sickness', {
'file': 'humanafrican-trypanosomiasis-sleeping-sickness.csv',
'name': 'Humanafrican Trypanosomiasis (sleeping sickness)',
'information-link': 'http://www.who.int/trypanosomiasis_african/en/',
}),
('guinea-worm', {
'file': 'dracunculiasis-guinea-worm.csv',
'name': 'Dracunculiasis (guinea worm)',
'information-link': 'http://www.who.int/dracunculiasis/en/',
}),
('buruli-ulcer', {
'file': 'buruli-ulcer.csv',
'name': 'Buruli Ulcer',
'information-link': (
'http://www.who.int/mediacentre/factsheets/fs199/en/'
),
})
])
| {"/who_data/views/api.py": ["/who_data/models/who.py", "/who_data/models/v_report_search.py"], "/who_data/bin/ingest/tests/who_file_parser.py": ["/who_data/bin/ingest/lib/who_file_parser.py"], "/who_data/bin/ingest/ingest.py": ["/who_data/lib/countries/__init__.py", "/who_data/bin/ingest/lib/who_file_parser.py", "/who_data/bin/ingest/__init__.py", "/who_data/models/who.py", "/who_data/lib/urlizer.py", "/who_data/models/base.py"], "/who_data/models/v_report_search.py": ["/who_data/models/base.py"], "/who_data/tests/api.py": ["/who_data/tests/__init__.py"], "/who_data/bin/ingest/lib/who_file_parser.py": ["/who_data/bin/ingest/lib/file_hash.py"], "/who_data/tests/lib_urlizer.py": ["/who_data/lib/urlizer.py"], "/who_data/models/who.py": ["/who_data/models/base.py"], "/who_data/bin/ingest/tests/lib.py": ["/who_data/bin/ingest/lib/file_hash.py"]} |
70,511 | astromitts/who-data | refs/heads/master | /who_data/bin/ingest/lib/file_hash.py | '''
Take in a given file path and return an MD5 hash
'''
import hashlib
def file_hash(file_path):
hash_md5 = hashlib.md5()
with open(file_path, "rb") as f:
for chunk in iter(lambda: f.read(4096), b""):
hash_md5.update(chunk)
return hash_md5.hexdigest()
| {"/who_data/views/api.py": ["/who_data/models/who.py", "/who_data/models/v_report_search.py"], "/who_data/bin/ingest/tests/who_file_parser.py": ["/who_data/bin/ingest/lib/who_file_parser.py"], "/who_data/bin/ingest/ingest.py": ["/who_data/lib/countries/__init__.py", "/who_data/bin/ingest/lib/who_file_parser.py", "/who_data/bin/ingest/__init__.py", "/who_data/models/who.py", "/who_data/lib/urlizer.py", "/who_data/models/base.py"], "/who_data/models/v_report_search.py": ["/who_data/models/base.py"], "/who_data/tests/api.py": ["/who_data/tests/__init__.py"], "/who_data/bin/ingest/lib/who_file_parser.py": ["/who_data/bin/ingest/lib/file_hash.py"], "/who_data/tests/lib_urlizer.py": ["/who_data/lib/urlizer.py"], "/who_data/models/who.py": ["/who_data/models/base.py"], "/who_data/bin/ingest/tests/lib.py": ["/who_data/bin/ingest/lib/file_hash.py"]} |
70,512 | astromitts/who-data | refs/heads/master | /who_data/views/home.py | from pyramid.response import Response # noqa
from pyramid.view import view_config
from collections import OrderedDict
@view_config(route_name='home', renderer='json')
def home_view(request):
hello = OrderedDict()
hello['message'] = (
'Hello. some day, this page will be a pretty HTML document. '
'Right now though, you can just use it to link to other pages '
'in the app that are complete.'
),
hello['links'] = [
request.route_url('api_v1_country_search', api_version='v1'),
request.route_url('api_v1_disease_landing', api_version='v1'),
]
hello['search-examples'] = [
'%s?count=100:&year=1995:' % (
request.route_url(
'api_v1_disease_search',
api_version='v1',
url_name='buruli-ulcer'
)
),
'%s?count=100000:200000' % (
request.route_url(
'api_v1_disease_search',
api_version='v1',
url_name='guinea-worm'
)
),
'%s?country=us' % (
request.route_url(
'api_v1_disease_search',
api_version='v1',
url_name='rabies'
)
),
]
return hello
| {"/who_data/views/api.py": ["/who_data/models/who.py", "/who_data/models/v_report_search.py"], "/who_data/bin/ingest/tests/who_file_parser.py": ["/who_data/bin/ingest/lib/who_file_parser.py"], "/who_data/bin/ingest/ingest.py": ["/who_data/lib/countries/__init__.py", "/who_data/bin/ingest/lib/who_file_parser.py", "/who_data/bin/ingest/__init__.py", "/who_data/models/who.py", "/who_data/lib/urlizer.py", "/who_data/models/base.py"], "/who_data/models/v_report_search.py": ["/who_data/models/base.py"], "/who_data/tests/api.py": ["/who_data/tests/__init__.py"], "/who_data/bin/ingest/lib/who_file_parser.py": ["/who_data/bin/ingest/lib/file_hash.py"], "/who_data/tests/lib_urlizer.py": ["/who_data/lib/urlizer.py"], "/who_data/models/who.py": ["/who_data/models/base.py"], "/who_data/bin/ingest/tests/lib.py": ["/who_data/bin/ingest/lib/file_hash.py"]} |
70,513 | astromitts/who-data | refs/heads/master | /who_data/models/who.py | from sqlalchemy import (
Column,
Integer,
Text,
or_,
)
from sqlalchemy import func
from sqlalchemy.dialects import postgresql
from .base import DatastoreBase
class WHODisease(DatastoreBase):
__tablename__ = 'disease'
id = Column(Text, primary_key=True)
name = Column(Text)
info_link = Column(Text)
@classmethod
def upsert(cls, id, name, info_link):
q = cls.session.query(cls).filter(cls.id == id)
existing = q.first()
if existing:
existing.name = name
existing.info_link = info_link
cls.session.flush()
return existing
new_cls = cls(
id=id,
name=name,
info_link=info_link,
)
cls.session.add(new_cls)
cls.session.flush()
return new_cls
class WHODiseaseReport(DatastoreBase):
__tablename__ = 'disease_report'
disease_id = Column(Text, primary_key=True)
country_id = Column(Text, primary_key=True)
year = Column(Integer, primary_key=True)
report_count = Column(Integer)
@classmethod
def upsert(cls, disease_id, country_id, year, report_count):
q = cls.session.query(cls)
q = q.filter(cls.disease_id == disease_id)
q = q.filter(cls.country_id == country_id)
q = q.filter(cls.year == year)
existing = q.first()
if existing:
existing.report_count = report_count
cls.session.flush()
return existing
new_cls = cls(
country_id=country_id,
disease_id=disease_id,
year=year,
report_count=report_count
)
cls.session.add(new_cls)
cls.session.flush()
return new_cls
@classmethod
def get_for_country(cls, country_id):
q = cls.session.query(cls).filter(cls.country_id == country_id)
q = q.filter(cls.report_count != None)
q = q.join(WHODisease, cls.disease_id == WHODisease.id)
q = q.add_column(cls.year)
q = q.add_column(cls.report_count)
q = q.add_column(WHODisease.name)
q = q.add_column(WHODisease.id)
q = q.order_by(WHODisease.id)
q = q.order_by(cls.year.desc())
res = q.all()
return res
@classmethod
def fetch_distinct_years(cls, disease_id):
q = cls.session.query(cls.year).distinct()
q = q.filter(cls.disease_id == disease_id)
q = q.order_by(cls.year.desc())
return q.all()
@classmethod
def get_for_year(cls, disease_id, year, nonzero=False):
q = cls.session.query(cls)
q = q.filter(cls.year == year)
q = q.filter(cls.disease_id == disease_id)
q = q.filter(cls.report_count != None)
if nonzero:
q = q.filter(cls.report_count > 0)
q = q.join(Country, cls.country_id == Country.id)
q = q.add_column(cls.year)
q = q.add_column(cls.country_id)
q = q.add_column(cls.report_count)
q = q.add_column(Country.name)
q = q.add_column(Country.url_name)
q = q.order_by(Country.name)
res = q.all()
return res
class Country(DatastoreBase):
__tablename__ = 'country'
id = Column(Text, primary_key=True) # this should be a 2 char country code
name = Column(Text)
alias = Column(postgresql.ARRAY(Text))
url_name = Column(Text)
@classmethod
def filter_name(cls, q, phrase):
'''
specific filter logic for filtering on the name field so that
the name field and the alias field and the country code (ID) field
are all searched on
'''
search_phrase = '%%%s%%' % phrase.lower()
alias_phrase = '{"%s"}' % (phrase.lower())
# if 2 characters were provided, search for country code and alias
# matches only
if len(phrase) == 2:
q = q.filter(
or_(
cls.id == phrase.upper(),
cls.alias.contains(alias_phrase),
)
)
else:
q = q.filter(
or_(
func.lower(cls.name).like(search_phrase),
cls.alias.contains(alias_phrase),
)
)
return q
@classmethod
def upsert(cls, id, name, url_name, alias):
'''
update object by id if it exists, otherwise create it
'''
if not alias:
alias = []
q = cls.session.query(cls).filter(cls.id == id)
existing = q.first()
if existing:
existing.name = name
existing.url_name = url_name
if alias:
for a in alias:
if a.lower() not in existing.alias:
existing.alias.append(a.lower())
cls.session.flush()
return existing
new_cls = cls(
id=id,
name=name,
url_name=url_name,
alias=[a.lower() for a in alias]
)
cls.session.add(new_cls)
cls.session.flush()
return new_cls
| {"/who_data/views/api.py": ["/who_data/models/who.py", "/who_data/models/v_report_search.py"], "/who_data/bin/ingest/tests/who_file_parser.py": ["/who_data/bin/ingest/lib/who_file_parser.py"], "/who_data/bin/ingest/ingest.py": ["/who_data/lib/countries/__init__.py", "/who_data/bin/ingest/lib/who_file_parser.py", "/who_data/bin/ingest/__init__.py", "/who_data/models/who.py", "/who_data/lib/urlizer.py", "/who_data/models/base.py"], "/who_data/models/v_report_search.py": ["/who_data/models/base.py"], "/who_data/tests/api.py": ["/who_data/tests/__init__.py"], "/who_data/bin/ingest/lib/who_file_parser.py": ["/who_data/bin/ingest/lib/file_hash.py"], "/who_data/tests/lib_urlizer.py": ["/who_data/lib/urlizer.py"], "/who_data/models/who.py": ["/who_data/models/base.py"], "/who_data/bin/ingest/tests/lib.py": ["/who_data/bin/ingest/lib/file_hash.py"]} |
70,514 | astromitts/who-data | refs/heads/master | /who_data/bin/ingest/tests/lib.py | """
Tests for who-data ingest module's library functions and classes
"""
from who_data.bin.ingest.tests import TestBase
class file_hash(TestBase):
def test(self):
from who_data.bin.ingest.lib.file_hash import file_hash
test_hash = file_hash(
'who_data/bin/ingest/tests/test_file_for_md5.txt'
)
self.assertEquals(
test_hash,
'22913813f7586afbc34b168468027a2d'
)
| {"/who_data/views/api.py": ["/who_data/models/who.py", "/who_data/models/v_report_search.py"], "/who_data/bin/ingest/tests/who_file_parser.py": ["/who_data/bin/ingest/lib/who_file_parser.py"], "/who_data/bin/ingest/ingest.py": ["/who_data/lib/countries/__init__.py", "/who_data/bin/ingest/lib/who_file_parser.py", "/who_data/bin/ingest/__init__.py", "/who_data/models/who.py", "/who_data/lib/urlizer.py", "/who_data/models/base.py"], "/who_data/models/v_report_search.py": ["/who_data/models/base.py"], "/who_data/tests/api.py": ["/who_data/tests/__init__.py"], "/who_data/bin/ingest/lib/who_file_parser.py": ["/who_data/bin/ingest/lib/file_hash.py"], "/who_data/tests/lib_urlizer.py": ["/who_data/lib/urlizer.py"], "/who_data/models/who.py": ["/who_data/models/base.py"], "/who_data/bin/ingest/tests/lib.py": ["/who_data/bin/ingest/lib/file_hash.py"]} |
70,569 | Megaprotas/work_project | refs/heads/master | /permits/urls.py | from django.urls import path
from .views import PermitOpenListView, PermitClosedListView, GeneralPermitDetailView, HotWorksPermitDetailView, ElectricalWorksPermitDetailView, GeneralPermitCreateView, HotWorkslPermitCreateView, ElectricalWorkslPermitCreateView, GeneralEditView, HotWorksEditView, ElectricalEditView
urlpatterns = [
path('permits/', PermitOpenListView.as_view(), name='permits_open'),
path('permits/closed', PermitClosedListView.as_view(), name='permits_closed'),
path('permits/general/<int:pk>/', GeneralPermitDetailView.as_view(), name='general_detail_view'),
path('permits/hotworks/<int:pk>/', HotWorksPermitDetailView.as_view(), name='hotworks_detail_view'),
path('permits/electrical/<int:pk>/', ElectricalWorksPermitDetailView.as_view(), name='electrical_detail_view'),
path('permit/general_new/', GeneralPermitCreateView.as_view(), name='general_permit_create'),
path('permit/hotworks_new/', HotWorkslPermitCreateView.as_view(), name='hotworks_permit_create'),
path('permit/electrical_new/', ElectricalWorkslPermitCreateView.as_view(), name='electrical_permit_create'),
path('permit/<int:pk>/general_edit/', GeneralEditView.as_view(), name='general_edit'),
path('permit/<int:pk>/hotworks_edit/', HotWorksEditView.as_view(), name='hotworks_edit'),
path('permit/<int:pk>/electrical_edit/', ElectricalEditView.as_view(), name='electrical_edit'),
] | {"/permits/urls.py": ["/permits/views.py"], "/permits/views.py": ["/permits/models.py", "/permits/forms.py"], "/my_app/urls.py": ["/my_app/views.py"], "/permits/forms.py": ["/permits/models.py"], "/my_app/forms.py": ["/my_app/models.py"], "/my_app/admin.py": ["/my_app/models.py"], "/my_app/views.py": ["/my_app/models.py", "/my_app/forms.py"], "/permits/admin.py": ["/permits/models.py"], "/accounts/forms.py": ["/accounts/models.py"]} |
70,570 | Megaprotas/work_project | refs/heads/master | /permits/views.py | from django.shortcuts import render, HttpResponse
from .models import Permit, General, HotWorks, ElectricalWorks
from .forms import GeneralForm, HotWorksForm, ElectricalWorksForm
from django.urls import reverse_lazy
from django.contrib.auth.mixins import LoginRequiredMixin
from django.views.generic import TemplateView, ListView, DetailView, CreateView, UpdateView, DeleteView
from django.utils import timezone
new_success_message = "Instance was created successfully"
#List Views of all permits
class PermitOpenListView(ListView):
template_name = 'permit.html'
paginate_by = 20
queryset = Permit.objects.all()
def get_context_data(self, **kwargs):
context = super(PermitOpenListView, self).get_context_data(**kwargs)
context['general'] = General.objects.filter(status_closed=False)
context['hotworks'] = HotWorks.objects.filter(status_closed=False)
context['electrical'] = ElectricalWorks.objects.filter(status_closed=False)
return context
class PermitClosedListView(ListView):
template_name = 'permit.html'
paginate_by = 20
queryset = Permit.objects.all()
def get_context_data(self, **kwargs):
context = super(PermitClosedListView, self).get_context_data(**kwargs)
context['general'] = General.objects.filter(status_closed=True)
context['hotworks'] = HotWorks.objects.filter(status_closed=True)
context['electrical'] = ElectricalWorks.objects.filter(status_closed=True)
return context
#Permit detail Views
class GeneralPermitDetailView(DetailView):
model = General
template_name = 'general_detail_view.html'
def generate_pdf(self):
from reportlab.pdfgen import canvas
response = HttpResponse(content_type='pdf')
response['Content-Disposition'] = 'attachment; filename="permit.pdf"'
p = canvas.Canvas(response)
p.drawString(100, 100, "Company Name")
p.showPage()
p.save()
print(p)
return response
def get(self, request, *args, **kwargs):
if self.request.GET.get('zip', None):
return self.generate_pdf()
return super(GeneralPermitDetailView, self).get(request, *args, **kwargs)
class HotWorksPermitDetailView(DetailView):
model = HotWorks
template_name = 'general_detail_view.html'
class ElectricalWorksPermitDetailView(DetailView):
model = ElectricalWorks
template_name = 'general_detail_view.html'
#Create Views
class GeneralPermitCreateView(CreateView):
login_url = 'login'
model = General
form_class = GeneralForm
success_message = new_success_message
template_name = 'create_form.html'
redirect_field_name = 'general_detail_view.html'
def form_valid(self, form):
self.object = form.save(commit=False)
self.object.profile = self.request.user
self.object.save()
return super().form_valid(form)
class HotWorkslPermitCreateView(CreateView):
login_url = 'login'
model = HotWorks
form_class = HotWorksForm
success_message = new_success_message
template_name = 'create_form.html'
redirect_field_name = 'general_detail_view.html'
def form_valid(self, form):
self.object = form.save(commit=False)
self.object.profile = self.request.user
self.object.save()
return super().form_valid(form)
class ElectricalWorkslPermitCreateView(CreateView):
login_url = 'login'
model = ElectricalWorks
form_class = ElectricalWorksForm
success_message = new_success_message
template_name = 'create_form.html'
redirect_field_name = 'general_detail_view.html'
def form_valid(self, form):
self.object = form.save(commit=False)
self.object.profile = self.request.user
self.object.save()
return super().form_valid(form)
#Update Views
class GeneralEditView(LoginRequiredMixin, UpdateView):
login_url = 'login'
model = General
form_class = GeneralForm
success_message = "Instance was updated successfully"
template_name = 'create_form.html'
redirect_field_name = 'general_detail_view.html'
class HotWorksEditView(LoginRequiredMixin, UpdateView):
login_url = 'login'
model = HotWorks
form_class = HotWorksForm
success_message = "Instance was updated successfully"
template_name = 'create_form.html'
redirect_field_name = 'hotworks_detail_view.html'
class ElectricalEditView(LoginRequiredMixin, UpdateView):
login_url = 'login'
model = ElectricalWorks
form_class = ElectricalWorksForm
success_message = "Instance was updated successfully"
template_name = 'create_form.html'
redirect_field_name = 'electrical_detail_view.html' | {"/permits/urls.py": ["/permits/views.py"], "/permits/views.py": ["/permits/models.py", "/permits/forms.py"], "/my_app/urls.py": ["/my_app/views.py"], "/permits/forms.py": ["/permits/models.py"], "/my_app/forms.py": ["/my_app/models.py"], "/my_app/admin.py": ["/my_app/models.py"], "/my_app/views.py": ["/my_app/models.py", "/my_app/forms.py"], "/permits/admin.py": ["/permits/models.py"], "/accounts/forms.py": ["/accounts/models.py"]} |
70,571 | Megaprotas/work_project | refs/heads/master | /permits/migrations/0001_initial.py | # Generated by Django 3.0.5 on 2020-05-27 17:48
from django.db import migrations, models
import django.db.models.deletion
import django.utils.timezone
class Migration(migrations.Migration):
initial = True
dependencies = [
('accounts', '0001_initial'),
]
operations = [
migrations.CreateModel(
name='Permit',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('contractor', models.CharField(default='', max_length=100)),
('contractor_name', models.CharField(default='', max_length=100)),
('facility', models.CharField(default='', max_length=100)),
('date_of_arrival', models.DateField(default=django.utils.timezone.now)),
('time_of_arrival', models.TimeField(default=django.utils.timezone.now)),
('date_of_finish', models.DateField(default=django.utils.timezone.now)),
('time_of_finish', models.TimeField(default=django.utils.timezone.now)),
('job_location', models.CharField(default='', max_length=100)),
('job_spec', models.TextField(default='', max_length=500)),
('equipment', models.TextField(default='', max_length=100)),
('status_closed', models.BooleanField(default=False)),
('works_completed', models.BooleanField(default=False)),
('profile', models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, to='accounts.Profile')),
],
),
migrations.CreateModel(
name='ElectricalWorks',
fields=[
('permit_ptr', models.OneToOneField(auto_created=True, on_delete=django.db.models.deletion.CASCADE, parent_link=True, primary_key=True, serialize=False, to='permits.Permit')),
('location1', models.CharField(default='', max_length=100)),
('location2', models.CharField(default='', max_length=100)),
('location3', models.CharField(default='', max_length=100)),
],
options={
'verbose_name': 'Electrical Works Permit',
'verbose_name_plural': 'Electrical Works Permits',
'ordering': ('date_of_arrival',),
},
bases=('permits.permit',),
),
migrations.CreateModel(
name='General',
fields=[
('permit_ptr', models.OneToOneField(auto_created=True, on_delete=django.db.models.deletion.CASCADE, parent_link=True, primary_key=True, serialize=False, to='permits.Permit')),
('safety_precautions', models.TextField(default='', max_length=200)),
('ra_ready', models.BooleanField(default=False)),
('ms_ready', models.BooleanField(default=False)),
('confined_space_entry', models.BooleanField(default=False)),
],
options={
'verbose_name': 'General Permit',
'verbose_name_plural': 'General Permits',
'ordering': ('date_of_arrival',),
},
bases=('permits.permit',),
),
migrations.CreateModel(
name='HotWorks',
fields=[
('permit_ptr', models.OneToOneField(auto_created=True, on_delete=django.db.models.deletion.CASCADE, parent_link=True, primary_key=True, serialize=False, to='permits.Permit')),
('ppe', models.BooleanField(default=False)),
('welding_screen', models.BooleanField(default=False)),
('smoke_heat_isolated', models.BooleanField(default=False)),
],
options={
'verbose_name': 'Hot Works Permit',
'verbose_name_plural': 'Hot Works Permits',
'ordering': ('date_of_arrival',),
},
bases=('permits.permit',),
),
]
| {"/permits/urls.py": ["/permits/views.py"], "/permits/views.py": ["/permits/models.py", "/permits/forms.py"], "/my_app/urls.py": ["/my_app/views.py"], "/permits/forms.py": ["/permits/models.py"], "/my_app/forms.py": ["/my_app/models.py"], "/my_app/admin.py": ["/my_app/models.py"], "/my_app/views.py": ["/my_app/models.py", "/my_app/forms.py"], "/permits/admin.py": ["/permits/models.py"], "/accounts/forms.py": ["/accounts/models.py"]} |
70,572 | Megaprotas/work_project | refs/heads/master | /my_app/migrations/0001_initial.py | # Generated by Django 3.0.5 on 2020-05-27 19:23
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
import django.utils.timezone
class Migration(migrations.Migration):
initial = True
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]
operations = [
migrations.CreateModel(
name='Callout',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(default='', max_length=20)),
('facility', models.CharField(choices=[('BWD', 'BWD'), ('CCH', 'CCH'), ('HND', 'HND'), ('SYO', 'SYO')], default='BWD', max_length=20)),
('callout_date', models.DateField(default=django.utils.timezone.now)),
('notification_time', models.TimeField(default=django.utils.timezone.now)),
('arrival_time', models.TimeField(default=django.utils.timezone.now)),
('completion_time', models.TimeField(default=django.utils.timezone.now)),
('mileage', models.DecimalField(decimal_places=2, default=0.0, max_digits=6)),
('ref_number', models.PositiveIntegerField(default=0)),
('findings', models.TextField(max_length=500)),
('actions_taken', models.TextField(max_length=500)),
('resolved_status', models.BooleanField()),
('follow_up_status', models.BooleanField()),
('support_required_status', models.BooleanField()),
('priority_status', models.CharField(choices=[('C1', 'C1'), ('C2', 'C2'), ('C3', 'C3')], default='C1', max_length=5)),
('fault_case', models.CharField(choices=[('electrical', 'electrical'), ('leak', 'leak'), ('alarm', 'alarm'), ('medical_gas', 'medical_gas'), ('drainage_block', 'drainage_block'), ('temp_issues', 'temp_issues'), ('wear_tear', 'wear_tear')], default='C1', max_length=20)),
('published_date', models.DateField(default=django.utils.timezone.now)),
('views', models.IntegerField(default=0)),
('engineer', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
],
options={
'verbose_name': 'Callout',
'verbose_name_plural': 'Callouts',
'ordering': ('callout_date',),
},
),
]
| {"/permits/urls.py": ["/permits/views.py"], "/permits/views.py": ["/permits/models.py", "/permits/forms.py"], "/my_app/urls.py": ["/my_app/views.py"], "/permits/forms.py": ["/permits/models.py"], "/my_app/forms.py": ["/my_app/models.py"], "/my_app/admin.py": ["/my_app/models.py"], "/my_app/views.py": ["/my_app/models.py", "/my_app/forms.py"], "/permits/admin.py": ["/permits/models.py"], "/accounts/forms.py": ["/accounts/models.py"]} |
70,573 | Megaprotas/work_project | refs/heads/master | /my_app/urls.py | from django.urls import path
from .views import CalloutListView, CalloutDetailView, CalloutCreateView, CalloutDeleteView, CalloutEditView, IndexPageView
urlpatterns = [
path('', IndexPageView.as_view(), name='index'),
path('callout/', CalloutListView.as_view(), name='callout'),
path('callout/<int:pk>/', CalloutDetailView.as_view(), name='callout_detail'),
path('callout/new/', CalloutCreateView.as_view(), name='callout_create'),
path('callout/<int:pk>/edit/', CalloutEditView.as_view(), name='callout_edit'),
path('callout/<int:pk>/delete/', CalloutDeleteView.as_view(), name='callout_confirm_delete'),
] | {"/permits/urls.py": ["/permits/views.py"], "/permits/views.py": ["/permits/models.py", "/permits/forms.py"], "/my_app/urls.py": ["/my_app/views.py"], "/permits/forms.py": ["/permits/models.py"], "/my_app/forms.py": ["/my_app/models.py"], "/my_app/admin.py": ["/my_app/models.py"], "/my_app/views.py": ["/my_app/models.py", "/my_app/forms.py"], "/permits/admin.py": ["/permits/models.py"], "/accounts/forms.py": ["/accounts/models.py"]} |
70,574 | Megaprotas/work_project | refs/heads/master | /permits/forms.py | from django import forms
from .models import General, HotWorks, ElectricalWorks
form_styles = {'contractor': forms.TextInput(attrs={'class': 'textinputfield'}),
'contractor_name': forms.TextInput(attrs={'class': 'textinputfield'}),
'facility': forms.TextInput(attrs={'class': 'textinputfield'}),
'date_of_arrival': forms.DateInput(attrs={'class': 'textinputfield'}),
'time_of_arrival': forms.TimeInput(attrs={'class': 'textinputfield'}),
'date_of_finish': forms.DateInput(attrs={'class': 'textinputfield'}),
'time_of_finish': forms.TimeInput(attrs={'class': 'textinputfield'}),
'job_location': forms.TextInput(attrs={'class': 'textinputfield'}),
'job_spec': forms.TextInput(attrs={'class': 'textinputfield'}),
'equipment': forms.TextInput(attrs={'class': 'textinputfield'}),
'safety_precautions': forms.TextInput(attrs={'class': 'textinputfield'}),
'location1': forms.TextInput(attrs={'class': 'textinputfield'}),
'location2': forms.TextInput(attrs={'class': 'textinputfield'}),
'location3': forms.TextInput(attrs={'class': 'textinputfield'}),
}
field_order_list = ('contractor', 'contractor_name', 'facility', 'date_of_arrival',
'time_of_arrival', 'date_of_finish', 'time_of_finish', 'job_location', 'job_spec', 'equipment',)
general_field_list = ('safety_precautions', 'ra_ready', 'ms_ready', 'confined_space_entry')
hotworks_field_list = ('ppe', 'welding_screen', 'smoke_heat_isolated')
electrical_field_list = ('location1', 'location2', 'location3')
class GeneralForm(forms.ModelForm):
class Meta:
model = General
exclude = ('profile', )
widgets = form_styles
field_order = ['status_closed', 'works_completed', field_order_list, general_field_list]
def __init__(self, *args, **kwargs):
super(GeneralForm, self).__init__(*args, **kwargs)
self.fields['date_of_finish'].label = 'Date of Completion'
self.fields['time_of_finish'].label = 'Time of Completion'
self.fields['ra_ready'].label = 'Risk Assessment Ready'
self.fields['ms_ready'].label = 'Method Statement Ready'
class HotWorksForm(forms.ModelForm):
class Meta:
model = HotWorks
exclude = ('profile', )
widgets = form_styles
field_order = ['status_closed', 'works_completed', field_order_list, hotworks_field_list]
def __init__(self, *args, **kwargs):
super(HotWorksForm, self).__init__(*args, **kwargs)
self.fields['date_of_finish'].label = 'Date of Completion'
self.fields['time_of_finish'].label = 'Time of Completion'
self.fields['ppe'].label = 'PPE ready'
self.fields['welding_screen'].label = 'Welding Screen Required'
self.fields['smoke_heat_isolated'].label = 'Smoke/Heat Detectors Isolated'
class ElectricalWorksForm(forms.ModelForm):
class Meta:
model = ElectricalWorks
exclude = ('profile', )
widgets = form_styles
field_order = ['status_closed', 'works_completed', field_order_list, electrical_field_list]
def __init__(self, *args, **kwargs):
super(ElectricalWorksForm, self).__init__(*args, **kwargs)
self.fields['date_of_finish'].label = 'Date of Completion'
self.fields['time_of_finish'].label = 'Time of Completion'
self.fields['location1'].label = 'Location 1'
self.fields['location2'].label = 'Location 2'
self.fields['location3'].label = 'Location 3' | {"/permits/urls.py": ["/permits/views.py"], "/permits/views.py": ["/permits/models.py", "/permits/forms.py"], "/my_app/urls.py": ["/my_app/views.py"], "/permits/forms.py": ["/permits/models.py"], "/my_app/forms.py": ["/my_app/models.py"], "/my_app/admin.py": ["/my_app/models.py"], "/my_app/views.py": ["/my_app/models.py", "/my_app/forms.py"], "/permits/admin.py": ["/permits/models.py"], "/accounts/forms.py": ["/accounts/models.py"]} |
70,575 | Megaprotas/work_project | refs/heads/master | /my_app/models.py | from django.db import models
from django.shortcuts import reverse
from django.utils import timezone
from django.contrib.auth.models import User
class Callout(models.Model):
BWD = 'BWD'
CCH = 'CCH'
HND = 'HND'
SYO = 'SYO'
FACILITY = (
(BWD, 'BWD'),
(CCH, 'CCH'),
(HND, 'HND'),
(SYO, 'SYO')
)
C1 = 'C1'
C2 = 'C2'
C3 = 'C3'
PRIORITY = (
(C1, 'C1'),
(C2, 'C2'),
(C3, 'C3')
)
ELECTRICAL = 'electrical'
LEAK = 'leak'
ALARM = 'alarm'
MEDICAL_GAS = 'medical_gas'
DRAINAGE_BLOCK = 'drainage_block'
TEMP_ISSUES = 'temp_issues'
WEAR_TEAR = 'wear_tear'
FAULT_CAUSE = (
(ELECTRICAL, 'electrical'),
(LEAK, 'leak'),
(ALARM, 'alarm'),
(MEDICAL_GAS, 'medical_gas'),
(DRAINAGE_BLOCK, 'drainage_block'),
(TEMP_ISSUES, 'temp_issues'),
(WEAR_TEAR, 'wear_tear')
)
engineer = models.ForeignKey(User, blank=True, null=True, on_delete=models.CASCADE)
name = models.CharField(max_length=20, default='')
facility = models.CharField(max_length=20, choices=FACILITY, default=BWD)
callout_date = models.DateField(auto_now_add=False, default=timezone.now)
notification_time = models.TimeField(auto_now_add=False, default=timezone.now)
arrival_time = models.TimeField(auto_now_add=False, default=timezone.now)
completion_time = models.TimeField(auto_now_add=False, default=timezone.now)
mileage = models.DecimalField(default=0.0, max_digits=6, decimal_places=2)
ref_number = models.PositiveIntegerField(default=0)
findings = models.TextField(max_length=500)
actions_taken = models.TextField(max_length=500)
resolved_status = models.BooleanField()
follow_up_status = models.BooleanField()
support_required_status = models.BooleanField()
priority_status = models.CharField(max_length=5, choices=PRIORITY, default=C1)
fault_case = models.CharField(max_length=20, choices=FAULT_CAUSE, default=C1)
published_date = models.DateField(default=timezone.now)
views = models.IntegerField(default=0)
def __str__(self):
return f'%s to %s' % (self.notification_time, self.facility)
def get_absolute_url(self):
return reverse('callout_detail', kwargs={'pk': self.pk})
class Meta:
verbose_name = 'Callout'
verbose_name_plural = 'Callouts'
ordering = ('callout_date', )
| {"/permits/urls.py": ["/permits/views.py"], "/permits/views.py": ["/permits/models.py", "/permits/forms.py"], "/my_app/urls.py": ["/my_app/views.py"], "/permits/forms.py": ["/permits/models.py"], "/my_app/forms.py": ["/my_app/models.py"], "/my_app/admin.py": ["/my_app/models.py"], "/my_app/views.py": ["/my_app/models.py", "/my_app/forms.py"], "/permits/admin.py": ["/permits/models.py"], "/accounts/forms.py": ["/accounts/models.py"]} |
70,576 | Megaprotas/work_project | refs/heads/master | /my_app/forms.py | from django import forms
from .models import Callout
from django.contrib.auth.models import User
class CalloutForm(forms.ModelForm):
class Meta:
model = Callout
exclude = ('engineer', 'published_date', 'views', )
widgets = {
'callout_date': forms.DateInput(attrs={'class': 'textinputfield'}),
'notification_time': forms.TimeInput(attrs={'class': 'textinputfield'}),
'arrival_time': forms.TimeInput(attrs={'class': 'textinputfield'}),
'completion_time': forms.TimeInput(attrs={'class': 'textinputfield'}),
'mileage': forms.NumberInput(attrs={'class': 'textinputfield'}),
'ref_number': forms.NumberInput(attrs={'class': 'textinputfield'}),
'findings': forms.Textarea(attrs={'class': 'textareafield',
'placeholder': 'Please specify findings'}),
'actions_taken': forms.Textarea(attrs={'class': 'textareafield',
'placeholder': 'Please specify actions'})
}
def clean(self):
super(CalloutForm, self).clean()
findings = self.cleaned_data.get('findings')
actions_taken = self.cleaned_data.get('actions_taken')
mileage = self.cleaned_data.get('mileage')
error1 = ['Minimum 10 characters required']
error2 = ['You will not be compensated for fuel if mileage is 0']
if len(findings) < 10:
self._errors['findings'] = self.error_class(error1)
if len(actions_taken) < 10:
self._errors['actions_taken'] = self.error_class(error1)
if mileage <= 0:
self._errors['mileage'] = self.error_class(error2)
def __init__(self, *args, **kwargs):
super(CalloutForm, self).__init__(*args, **kwargs)
self.fields['name'].label = 'Requester\' Name'
self.fields['facility'].label = 'Facility/Hospital'
self.fields['ref_number'].required = False
| {"/permits/urls.py": ["/permits/views.py"], "/permits/views.py": ["/permits/models.py", "/permits/forms.py"], "/my_app/urls.py": ["/my_app/views.py"], "/permits/forms.py": ["/permits/models.py"], "/my_app/forms.py": ["/my_app/models.py"], "/my_app/admin.py": ["/my_app/models.py"], "/my_app/views.py": ["/my_app/models.py", "/my_app/forms.py"], "/permits/admin.py": ["/permits/models.py"], "/accounts/forms.py": ["/accounts/models.py"]} |
70,577 | Megaprotas/work_project | refs/heads/master | /accounts/models.py | from django.db import models
from django.contrib.auth.models import User
from PIL import Image
class Profile(models.Model):
user = models.OneToOneField(User, on_delete=models.CASCADE)
first_name = models.CharField(max_length=20, default='')
surname = models.CharField(max_length=20, default='')
position = models.CharField(max_length=20, default='')
photo = models.ImageField(default='default.jpg', upload_to='upload_pics')
class Meta:
verbose_name = 'Profile Info'
verbose_name_plural = 'Profiles'
ordering = ('first_name', 'surname')
def __str__(self):
return f'{self.user.username}'
def save(self, *args, **kwargs):
super(Profile, self).save(*args, **kwargs)
photo = Image.open(self.photo.path)
if photo.height > 100 or photo.width > 100:
new_size = (100, 100)
photo.thumbnail(new_size)
photo.save(self.photo.path)
| {"/permits/urls.py": ["/permits/views.py"], "/permits/views.py": ["/permits/models.py", "/permits/forms.py"], "/my_app/urls.py": ["/my_app/views.py"], "/permits/forms.py": ["/permits/models.py"], "/my_app/forms.py": ["/my_app/models.py"], "/my_app/admin.py": ["/my_app/models.py"], "/my_app/views.py": ["/my_app/models.py", "/my_app/forms.py"], "/permits/admin.py": ["/permits/models.py"], "/accounts/forms.py": ["/accounts/models.py"]} |
70,578 | Megaprotas/work_project | refs/heads/master | /permits/models.py | from django.db import models
from django.utils import timezone
from django.shortcuts import reverse
from django.contrib.auth.models import User
class Permit(models.Model):
profile = models.ForeignKey(User, blank=True, null=True, on_delete=models.CASCADE)
contractor = models.CharField(max_length=100, default='')
contractor_name = models.CharField(max_length=100, default='')
facility = models.CharField(max_length=100, default='')
date_of_arrival = models.DateField(auto_now_add=False, default=timezone.now)
time_of_arrival = models.TimeField(auto_now_add=False, default=timezone.now)
date_of_finish = models.DateField(auto_now_add=False, default=timezone.now)
time_of_finish = models.TimeField(auto_now_add=False, default=timezone.now)
job_location = models.CharField(max_length=100, default='')
job_spec = models.TextField(max_length=500, default='')
equipment = models.TextField(max_length=100, default='')
status_closed = models.BooleanField(default=False)
works_completed = models.BooleanField(default=False)
def __str__(self):
return f'%s %s on %s' % (self.contractor, self.contractor_name, self.date_of_arrival)
class General(Permit):
safety_precautions = models.TextField(max_length=200, default='')
ra_ready = models.BooleanField(default=False)
ms_ready = models.BooleanField(default=False)
confined_space_entry = models.BooleanField(default=False)
def __str__(self):
return f'%s from %s on %s' % (self.contractor_name, self.contractor, self.date_of_arrival)
def get_absolute_url(self):
return reverse('general_detail_view', kwargs={'pk': self.pk})
class Meta:
verbose_name = 'General Permit'
verbose_name_plural = 'General Permits'
ordering = ('date_of_arrival', )
class HotWorks(Permit):
ppe = models.BooleanField(default=False)
welding_screen = models.BooleanField(default=False)
smoke_heat_isolated = models.BooleanField(default=False)
def __str__(self):
return f'%s from %s on %s' % (self.contractor_name, self.contractor, self.date_of_arrival)
def get_absolute_url(self):
return reverse('hotworks_detail_view', kwargs={'pk': self.pk})
class Meta:
verbose_name = 'Hot Works Permit'
verbose_name_plural = 'Hot Works Permits'
ordering = ('date_of_arrival', )
class ElectricalWorks(Permit):
location1 = models.CharField(max_length=100, default='')
location2 = models.CharField(max_length=100, default='')
location3 = models.CharField(max_length=100, default='')
def __str__(self):
return f'%s from %s on %s' % (self.contractor_name, self.contractor, self.date_of_arrival)
def get_absolute_url(self):
return reverse('electrical_detail_view', kwargs={'pk': self.pk})
class Meta:
verbose_name = 'Electrical Works Permit'
verbose_name_plural = 'Electrical Works Permits'
ordering = ('date_of_arrival', )
| {"/permits/urls.py": ["/permits/views.py"], "/permits/views.py": ["/permits/models.py", "/permits/forms.py"], "/my_app/urls.py": ["/my_app/views.py"], "/permits/forms.py": ["/permits/models.py"], "/my_app/forms.py": ["/my_app/models.py"], "/my_app/admin.py": ["/my_app/models.py"], "/my_app/views.py": ["/my_app/models.py", "/my_app/forms.py"], "/permits/admin.py": ["/permits/models.py"], "/accounts/forms.py": ["/accounts/models.py"]} |
70,579 | Megaprotas/work_project | refs/heads/master | /my_app/admin.py | from django.contrib import admin
from .models import Callout
admin.site.register(Callout) | {"/permits/urls.py": ["/permits/views.py"], "/permits/views.py": ["/permits/models.py", "/permits/forms.py"], "/my_app/urls.py": ["/my_app/views.py"], "/permits/forms.py": ["/permits/models.py"], "/my_app/forms.py": ["/my_app/models.py"], "/my_app/admin.py": ["/my_app/models.py"], "/my_app/views.py": ["/my_app/models.py", "/my_app/forms.py"], "/permits/admin.py": ["/permits/models.py"], "/accounts/forms.py": ["/accounts/models.py"]} |
70,580 | Megaprotas/work_project | refs/heads/master | /my_app/views.py | from django.shortcuts import render
from .models import Callout
from .forms import CalloutForm
from django.urls import reverse_lazy
from django.contrib.auth.mixins import LoginRequiredMixin
from django.views.generic import TemplateView, ListView, DetailView, CreateView, UpdateView, DeleteView
from django.utils import timezone
class IndexPageView(TemplateView):
template_name = 'index.html'
class CalloutListView(ListView):
model = Callout
template_name = 'callout.html'
paginate_by = 10
queryset = Callout.objects.all()
def get_queryset(self):
return Callout.objects.filter(published_date__lte=timezone.now()).order_by('-name')
class CalloutDetailView(DetailView):
model = Callout
template_name = 'callout_detail.html'
def get_context_data(self, **kwargs):
context = super(DetailView, self).get_context_data(**kwargs)
object = self.get_object()
object.views += 1
object.save()
return context
class CalloutCreateView(LoginRequiredMixin, CreateView):
login_url = 'login'
model = Callout
form_class = CalloutForm
success_message = "Instance was created successfully"
template_name = 'callout_form.html'
redirect_field_name = 'callout_detail.html'
def form_valid(self, form):
self.object = form.save(commit=False)
self.object.engineer = self.request.user
self.object.save()
return super().form_valid(form)
class CalloutEditView(LoginRequiredMixin, UpdateView):
login_url = 'login'
model = Callout
form_class = CalloutForm
success_message = "Instance was updated successfully"
template_name = 'callout_form.html'
redirect_field_name = 'callout_detail.html'
def get_queryset(self):
return super(CalloutEditView, self).filter(profile=self.request.user)
class CalloutDeleteView(LoginRequiredMixin, DeleteView):
model = Callout
success_message = "Permanently removed"
template_name = 'callout_confirm_delete.html'
success_url = reverse_lazy('callout')
| {"/permits/urls.py": ["/permits/views.py"], "/permits/views.py": ["/permits/models.py", "/permits/forms.py"], "/my_app/urls.py": ["/my_app/views.py"], "/permits/forms.py": ["/permits/models.py"], "/my_app/forms.py": ["/my_app/models.py"], "/my_app/admin.py": ["/my_app/models.py"], "/my_app/views.py": ["/my_app/models.py", "/my_app/forms.py"], "/permits/admin.py": ["/permits/models.py"], "/accounts/forms.py": ["/accounts/models.py"]} |
70,581 | Megaprotas/work_project | refs/heads/master | /permits/admin.py | from django.contrib import admin
from .models import Permit, General, HotWorks, ElectricalWorks
admin.site.register(Permit)
admin.site.register(General)
admin.site.register(HotWorks)
admin.site.register(ElectricalWorks)
| {"/permits/urls.py": ["/permits/views.py"], "/permits/views.py": ["/permits/models.py", "/permits/forms.py"], "/my_app/urls.py": ["/my_app/views.py"], "/permits/forms.py": ["/permits/models.py"], "/my_app/forms.py": ["/my_app/models.py"], "/my_app/admin.py": ["/my_app/models.py"], "/my_app/views.py": ["/my_app/models.py", "/my_app/forms.py"], "/permits/admin.py": ["/permits/models.py"], "/accounts/forms.py": ["/accounts/models.py"]} |
70,582 | Megaprotas/work_project | refs/heads/master | /accounts/forms.py | from django import forms
from django.contrib.auth.models import User
from django.contrib.auth.forms import UserCreationForm
from .models import Profile
form_styles = {
'first_name': forms.TextInput(attrs={'class': 'textinputfield'}),
'username': forms.TextInput(attrs={'class': 'textinputfield'}),
'surname': forms.TextInput(attrs={'class': 'textinputfield'}),
'position': forms.TextInput(attrs={'class': 'textinputfield'}),
'email': forms.EmailInput(attrs={'class': 'textinputfield'}),
'password1': forms.PasswordInput(attrs={'class': 'textinputfield'}),
'password2': forms.PasswordInput(attrs={'class': 'textinputfield'}),
}
class UserRegisterForm(UserCreationForm):
email = forms.EmailField()
class Meta:
model = User
fields = ['username', 'email', 'password1', 'password2']
widgets = form_styles
def __init__(self, *args, **kwargs):
super(UserRegisterForm, self).__init__(*args, **kwargs)
self.fields['username'].label = 'User Name'
self.fields['email'].label = 'E-mail'
self.fields['password1'].label = 'Password'
self.fields['password2'].label = 'Repeat Password'
class UserUpdateForm(forms.ModelForm):
email = forms.EmailField()
class Meta:
model = User
fields = ['username', 'email']
widgets = form_styles
def __init__(self, *args, **kwargs):
super(UserUpdateForm, self).__init__(*args, **kwargs)
self.fields['username'].label = 'User Name'
self.fields['email'].label = 'E-mail'
class ProfileUpdateForm(forms.ModelForm):
class Meta:
model = Profile
fields = ['first_name', 'surname', 'position']
def __init__(self, *args, **kwargs):
super(ProfileUpdateForm, self).__init__(*args, **kwargs)
self.fields['first_name'].label = 'Name'
self.fields['surname'].label = 'Family Name'
self.fields['position'].label = 'Position'
| {"/permits/urls.py": ["/permits/views.py"], "/permits/views.py": ["/permits/models.py", "/permits/forms.py"], "/my_app/urls.py": ["/my_app/views.py"], "/permits/forms.py": ["/permits/models.py"], "/my_app/forms.py": ["/my_app/models.py"], "/my_app/admin.py": ["/my_app/models.py"], "/my_app/views.py": ["/my_app/models.py", "/my_app/forms.py"], "/permits/admin.py": ["/permits/models.py"], "/accounts/forms.py": ["/accounts/models.py"]} |
70,583 | Megaprotas/work_project | refs/heads/master | /accounts/migrations/0001_initial.py | # Generated by Django 3.0.5 on 2020-05-27 17:04
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
initial = True
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]
operations = [
migrations.CreateModel(
name='Profile',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('first_name', models.CharField(default='', max_length=20)),
('surname', models.CharField(default='', max_length=20)),
('position', models.CharField(default='', max_length=20)),
('photo', models.ImageField(default='default.jpg', upload_to='upload_pics')),
('user', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
],
options={
'verbose_name': 'Profile Info',
'verbose_name_plural': 'Profiles',
'ordering': ('first_name', 'surname'),
},
),
]
| {"/permits/urls.py": ["/permits/views.py"], "/permits/views.py": ["/permits/models.py", "/permits/forms.py"], "/my_app/urls.py": ["/my_app/views.py"], "/permits/forms.py": ["/permits/models.py"], "/my_app/forms.py": ["/my_app/models.py"], "/my_app/admin.py": ["/my_app/models.py"], "/my_app/views.py": ["/my_app/models.py", "/my_app/forms.py"], "/permits/admin.py": ["/permits/models.py"], "/accounts/forms.py": ["/accounts/models.py"]} |
70,607 | nss-day-cohort-18/bank-teller | refs/heads/master | /teller.py | import os
from bank import *
class Teller():
"""This class is the interface to a customer's bank acccount
Methods:
main_menu
"""
def __init__(self):
self.account = BankAccount()
def build_menu(self):
os.system('cls' if os.name == 'nt' else 'clear')
print("1. Add money")
print("2. Withdraw money")
print("3. Show balance")
print("4. Quit")
def main_menu(self):
"""Show teller options
Arguments: None
"""
self.build_menu()
choice = input(">> ")
if choice == "1":
deposit = input("How much? ")
self.account.add_money(deposit)
if choice == "2":
withdrawal = input("How much? ")
self.account.withdraw_money(withdrawal)
if choice == "3":
print(self.account.show_balance())
input()
if choice != "4":
self.main_menu()
if __name__ == "__main__":
teller = Teller()
teller.main_menu()
| {"/teller.py": ["/bank.py"]} |
70,608 | nss-day-cohort-18/bank-teller | refs/heads/master | /bank.py | import locale
class BankAccount():
def __init__(self):
self.balance = 0
self.account = None
def add_money(self, amount):
"""Add money to a bank account
Arguments:
amount - A numerical value by which the bank account's balance will increase
"""
self.balance += float(amount)
def withdraw_money(self, amount):
"""Withdraw money to a bank account
Arguments:
amount - A numerical value by which the bank account's balance will decrease
"""
pass
self.balance -= float(amount)
def show_balance(self):
"""Show formatted balance
Arguments:
None
"""
locale.setlocale( locale.LC_ALL, '' )
return locale.currency(self.balance, grouping=True)
| {"/teller.py": ["/bank.py"]} |
70,618 | pncnmnp/Movie-Recommendation | refs/heads/master | /collaborative_filtering.py | from surprise import Reader, Dataset, KNNBaseline
import pandas as pd
from file_paths import *
from content_based import ContentBased
from numpy import array
from os.path import isfile
import joblib
DEFAULT_ID = 700
RATING_ATTR = ["userId", "movieId", "rating"]
LIMIT = 20
class CollaborativeFiltering:
def __init__(self):
self.df_credits = pd.read_csv(PATH_CREDITS)
self.m_id_to_tmdb = pd.read_csv(PATH_MOVIELENS_TO_TMDB)
self.df_movies = pd.read_csv(PATH_MOVIES)
def get_tmdb_id(self, movieId):
"""
param: movieId - movieId of the movie (as seen in MovieLens dataset)
return: tmdbId corresponding to the movieID
"""
try:
return self.m_id_to_tmdb["tmdbId"][
self.m_id_to_tmdb.index[self.m_id_to_tmdb["movieId"] == movieId][0]
]
except:
pass
def get_m_id(self, tmdbId):
"""
param: tmdbId - tmdbId of the movie (as seen in TMDB dataset)
return: movieId corresponding to the tmdbId
"""
try:
return self.m_id_to_tmdb["movieId"][
self.m_id_to_tmdb.index[self.m_id_to_tmdb["tmdbId"] == tmdbId][0]
]
except:
pass
def get_title_index(self, title):
"""
param: title - movie title (as in TMDB dataset)
return: if title found - returns index value of the title from df_credits
"""
try:
return self.df_credits["id"][
self.df_credits.index[self.df_credits["title"] == title][0]
]
except:
raise ValueError("No film : " + title + " found!")
def get_movie_title(self, m_id):
"""
param: m_id - index value (id) (corresponding to df_movies)
return: movie title corresponding to m_id (as in df_movies)
"""
try:
vals = self.df_movies.iloc[
self.df_movies.index[self.df_movies["id"] == m_id][0]
][
[
"title",
"id",
"vote_average",
"vote_count",
"popularity",
"release_date",
]
].values
return vals
except:
return None
def get_movie_ids(self):
"""
param: None
return: List of all the unique movieIds (from PATH_RATINGS path)
"""
return pd.read_csv(PATH_RATINGS)["movieId"].unique().tolist()
def train_knn(self, df, userId, user_m_ids, movies_watched):
"""
param: df - movies pandas DataFrame
userId - user ID to predict movies with
user_m_ids - List of movieIDs of movies to be recommended upon
(as seen in TMDB dataset)
movies_watched - List of movie titles watched
(as seen in TMDB dataset)
return: pandas DataFrame of the recommended movies with attributes -
title, id, vote_average, vote_count, popularity, release date
Collaborative filtering is done using KNN-Baseline and prediction is
done using pearson_baseline. The technique used is item-item based.
"""
reader = Reader(rating_scale=(1, 5))
movie_ids = self.get_movie_ids()
rec_result = dict()
sim_options = {"name": "pearson_baseline", "user_based": False}
data = Dataset.load_from_df(df[RATING_ATTR], reader)
if isfile(PATH_COLL_FILTERING_CACHE):
model = joblib.load(PATH_COLL_FILTERING_CACHE)
else:
trainset = data.build_full_trainset()
model = KNNBaseline(sim_options=sim_options)
model.fit(trainset)
joblib.dump(model, PATH_COLL_FILTERING_CACHE)
inn_id = model.trainset.to_inner_iid(user_m_ids[0])
# print(self.get_movie_title(self.get_tmdb_id(user_m_ids[0])))
inn_id_neigh = model.get_neighbors(inn_id, k=10)
# print(inn_id_neigh)
df_pref = pd.DataFrame(
columns=[
"title",
"id",
"vote_average",
"vote_count",
"popularity",
"release_date",
]
)
index = 0
for m_id in inn_id_neigh:
title_df = self.get_movie_title(
self.get_tmdb_id(model.trainset.to_raw_iid(m_id))
)
try:
if title_df[0] not in movies_watched:
df_pref.loc[index] = array(
[
title_df[0],
title_df[1],
title_df[2],
title_df[3],
title_df[4],
title_df[5],
]
)
index += 1
except:
pass
return df_pref
def store_pref(self, pref, userId, index, rating):
"""
param: pref - dict with keys - userId, movieId, rating
userId - userId to be inserted (int)
index - movieId to be inserted (int)
rating - rating on a scale of (1-5)
return: pref with userId, index and rating values appended
"""
pref[RATING_ATTR[0]].append(userId)
pref[RATING_ATTR[1]].append(index)
pref[RATING_ATTR[2]].append(rating)
return pref
def user_model(self, movies_watched, limit=LIMIT):
"""
param: movies_watched - dict of form -
{'movieName1': rating1,
'movieName2': rating2,
.....}
limit - no. of movies to display
(default = LIMIT)
"""
LIMIT = limit
userId = DEFAULT_ID
pref = dict()
user_m_ids = list()
for attribute in RATING_ATTR:
pref[attribute] = list()
for title in movies_watched:
index = self.get_title_index(title)
m_index = self.get_m_id(index)
user_m_ids.append(m_index)
pref = self.store_pref(pref, userId, m_index, movies_watched[title])
df_rating = pd.read_csv(PATH_RATINGS)
df_pref_rating = df_rating.append(
pd.DataFrame(pref), sort=False, ignore_index=True
)
return self.train_knn(df_pref_rating, userId, user_m_ids, movies_watched)
if __name__ == "__main__":
rec = CollaborativeFiltering()
print(
rec.user_model(
{
"Apollo 13": 5
}
)
)
| {"/collaborative_filtering.py": ["/file_paths.py", "/content_based.py"], "/fetch_posters.py": ["/file_paths.py"], "/recommendation.py": ["/file_paths.py"], "/get_posters.py": ["/file_paths.py"], "/server.py": ["/get_posters.py", "/content_based.py", "/file_paths.py", "/recommendation.py"], "/content_based.py": ["/recommendation.py", "/file_paths.py"], "/hybrid.py": ["/content_based.py", "/collaborative_filtering.py"]} |
70,619 | pncnmnp/Movie-Recommendation | refs/heads/master | /fetch_posters.py | from file_paths import *
import pandas as pd
import requests
from PIL import Image
import time
import os
POSTER_BASE_URL = "https://image.tmdb.org/t/p/w185"
poster_df = pd.read_csv(PATH_POSTERS)
poster_df["poster_path"] = POSTER_BASE_URL + poster_df["poster_path"]
movie_ids = pd.read_csv(PATH_MOVIES)["id"].tolist()
for i in range(0, 45466):
if os.path.exists("./flask/static/posters/" + poster_df["id"][i] + ".jpg"):
if int(poster_df["id"][i]) in movie_ids:
movie_ids.remove(int(poster_df["id"][i]))
print("DUPLICATE: " + poster_df["id"][i])
continue
elif int(poster_df["id"][i]) in movie_ids:
url = poster_df["poster_path"][i]
img = Image.open(requests.get(url, stream=True).raw)
img.save("./flask/static/posters/" + poster_df["id"][i] + ".jpg")
print("SAVED: " + poster_df["id"][i] + "LEFT: " + str(len(movie_ids)))
time.sleep(0.5)
movie_ids.remove(int(poster_df["id"][i]))
if len(movie_ids) < 1000:
break | {"/collaborative_filtering.py": ["/file_paths.py", "/content_based.py"], "/fetch_posters.py": ["/file_paths.py"], "/recommendation.py": ["/file_paths.py"], "/get_posters.py": ["/file_paths.py"], "/server.py": ["/get_posters.py", "/content_based.py", "/file_paths.py", "/recommendation.py"], "/content_based.py": ["/recommendation.py", "/file_paths.py"], "/hybrid.py": ["/content_based.py", "/collaborative_filtering.py"]} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.