def input(self):
if self._login is None or self._password is None:
return None
if self._dashboard is None:
self._dashboard = Dashboard(self.driver)
self._dashboard.input(self._login, self._password)
return self
def run(voc, config):
# FIXME: Allow MQTT credentials in voc.conf
client_id = 'voc_{hostname}_{time}'.format(hostname=hostname(),
time=time())
mqtt_config = read_mqtt_config()
mqtt = paho.Client(client_id=client_id, clean_session=False)
mqtt.username_pw_set(username=mqtt_config['username'],
password=mqtt_config['password'])
mqtt.tls_set(certs.where())
mqtt.on_connect = on_connect
mqtt.on_disconnect = on_disconnect
mqtt.on_publish = on_publish
mqtt.on_message = on_message
mqtt.on_subscribe = on_subscribe
mqtt.event_connected = Event()
mqtt.connect(host=mqtt_config['host'], port=int(mqtt_config['port']))
mqtt.loop_start()
interval = int(config['interval'])
_LOGGER.info(f'Polling every {interval} seconds')
entities = {}
while True:
if not mqtt.event_connected.is_set():
_LOGGER.debug('Waiting for MQTT connection')
mqtt.event_connected.wait()
_LOGGER.debug('Connected')
available = True
for vehicle in voc.vehicles:
if vehicle not in entities:
_LOGGER.debug('creating vehicle %s', vehicle)
dashboard = Dashboard(vehicle)
dashboard.configurate(**config)
entities[vehicle] = [
Entity(mqtt, instrument, config)
for instrument in dashboard.instruments
]
for entity in entities[vehicle]:
_LOGGER.debug('%s: %s', entity.instrument.full_name,
entity.state)
entity.publish_discovery()
entity.publish_availability(available)
if available:
entity.publish_state()
sleep(interval)
available = voc.update()
class Login(QWidget):
def __init__(self):
super().__init__()
uic.loadUi("ui/login.ui", self)
username = self.findChild(QLineEdit, 'username')
password = self.findChild(QLineEdit, 'password')
login = self.findChild(QPushButton, 'login')
login.clicked.connect(self.clicked_login)
def clicked_login(self):
# get data from user
txtusername = self.username.text()
txtpass = self.password.text()
# get data from userdata.json file
userdata = jsondata()
info = userdata.getdata()
if txtusername == info['username'] and txtpass == info['pass']:
self.dashboard = Dashboard()
self.dashboard.location_on_the_screen()
self.dashboard.show()
self.close()
else:
QMessageBox.about(self, "Error",
"Username or password is incorrect.")
def location_on_the_screen(self):
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
def POST(self):
input = web.input()
print input
dashboard = Dashboard()
dashboard.add_server(input.hostname, input.ip, input.user,
input.password, input.os, input.desc)
raise web.seeother('/dashboard?username={0}&fullname={1}'.format(
session.username, session.fullname))
def __init__(self, parent=None):
super().__init__(parent)
self.dashboard = Dashboard()
self.createUi()
self.dashboardUpdateTimer = QTimer(self)
self.dashboardUpdateTimer.setInterval(5)
self.dashboardUpdateTimer.timeout.connect(self.updateDashboard)
def GET(self):
input = web.input()
if session.logged_in:
dashboard = Dashboard()
dashboard.checkin_server(input.username, input.id, input.hostname,
input.os)
raise web.seeother('/dashboard?username={0}&fullname={1}'.format(
session.username, session.fullname))
else:
raise web.seeother('/loginFailed')
def run():
# set initial time
start_time = time.time()
# dump hyper parameters settings
print(time.strftime('%Y-%m-%d %H:%M:%S') + ' Hyper-parameters setting')
# get configuration
args = config.get()
# check for save_sample_image model
save_best_model = ModelCheckpoint(
filepath=args.model_file_train, verbose=1,
save_best_only=True) # , save_best_only=True
if os.path.isfile(args.model_file_train):
print(time.strftime('%Y-%m-%d %H:%M:%S') + ' Load model from file...')
skip_gram_model = load_model(args.model_file_train)
else:
# get embedding model
print(time.strftime('%Y-%m-%d %H:%M:%S') + ' Build model...')
skip_gram_model = model.get(args)
# dashboard
watch_board = Dashboard(folder=config.FOLDER,
dump_file="dashboard.dump",
statistic_file="statistic.txt",
model=skip_gram_model,
show_board=True)
# begin training
print(time.strftime('%Y-%m-%d %H:%M:%S') + " Begin training..")
# Train the model each generation and show predictions against the
# validation dataset
for iteration in range(1, args.iterations):
print(
time.strftime('%Y-%m-%d %H:%M:%S') + ' Iteration %d ' % iteration)
skip_gram_model.fit_generator(
zhwiki_corpus.skip_gram_generator(batch_size=args.batch_size,
context_window_size=5,
negative_samples=10),
steps_per_epoch=args.steps_per_epoch,
epochs=args.epochs,
callbacks=[save_best_model, watch_board],
# callbacks=[save_best_model],
validation_data=zhwiki_corpus.skip_gram_generator(
batch_size=args.batch_size,
context_window_size=5,
negative_samples=10),
validation_steps=100,
verbose=0)
# close_board windows
watch_board.close_board()
print("task took %.3fs" % (float(time.time()) - start_time))
def initialize_threads(self):
""" Initializes io threads"""
super().initialize_threads()
self.dashboard_interval = int(self.ping_interval * 2)
self.topic_fastclock_pub = self.publish_topics[Global.FASTCLOCK]
self.topic_dashboard_pub = self.publish_topics[Global.DASHBOARD]
self.topic_node_pub = self.publish_topics[Global.NODE]
self.topic_ping_sub = self.subscribed_topics[Global.PING]
# print("!!! ping sub: "+self.topic_ping_sub)
self.topic_sensor_sub = self.subscribed_topics[Global.SENSOR]
self.topic_backup_sub = self.subscribed_topics[Global.BACKUP]
# print("!!! backup sub: "+self.topic_backup_sub)
if Global.CONFIG in self.config:
if Global.OPTIONS in self.config[Global.CONFIG]:
if Global.TIME in self.config[Global.CONFIG][Global.OPTIONS]:
if Global.FAST in self.config[Global.CONFIG][
Global.OPTIONS][Global.TIME]:
if Global.RATIO in self.config[Global.CONFIG][
Global.OPTIONS][Global.TIME][Global.FAST]:
self.fast_ratio = int(
self.config[Global.CONFIG][Global.OPTIONS][
Global.TIME][Global.FAST][Global.RATIO])
if Global.INTERVAL in self.config[Global.CONFIG][
Global.OPTIONS][Global.TIME][Global.FAST]:
self.fast_interval = int(
self.config[Global.CONFIG][Global.OPTIONS][
Global.TIME][Global.FAST][Global.INTERVAL])
if Global.PING in self.config[Global.CONFIG][Global.OPTIONS]:
self.ping_interval = self.config[Global.CONFIG][
Global.OPTIONS][Global.PING]
if Global.BACKUP in self.config[Global.CONFIG][Global.OPTIONS]:
self.backup_path = self.config[Global.CONFIG][
Global.OPTIONS][Global.BACKUP]
self.roster = Roster(self.log_queue,
file_path=Global.DATA + "/" + Global.ROSTER +
".json")
self.switches = Switches(self.log_queue,
file_path=Global.DATA + "/" +
Global.SWITCHES + ".json")
self.warrants = Warrants(self.log_queue,
file_path=Global.DATA + "/" +
Global.WARRANTS + ".json")
self.signals = Signals(self.log_queue,
file_path=Global.DATA + "/" + Global.SIGNALS +
".json")
self.layout = Layout(self.log_queue,
file_path=Global.DATA + "/" + Global.LAYOUT +
".json")
self.dashboard = Dashboard(self.log_queue,
file_path=Global.DATA + "/" +
Global.DASHBOARD + ".json")
self.sensors = Sensors(self.log_queue,
file_path=Global.DATA + "/" + Global.SENSORS +
".json")
class Settings(QWidget):
def __init__(self):
super().__init__()
uic.loadUi("ui/setting.ui", self)
# finding chields
self.setpath = self.findChild(QLineEdit, 'databasepath')
setpathbtn = self.findChild(QPushButton, 'newpathbtn')
self.existingpath = self.findChild(QLineEdit, 'existingpath')
findpathbtn = self.findChild(QPushButton, 'existingpathbtn')
savesettings = self.findChild(QPushButton, 'save')
# set signal for this btn
setpathbtn.clicked.connect(self.setdatabasepath)
findpathbtn.clicked.connect(self.findexistingpath)
savesettings.clicked.connect(self.savesettings_func)
def location_on_the_screen(self):
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
def setdatabasepath(self):
folderpath = QFileDialog.getExistingDirectory()
self.setpath.setText(folderpath)
def findexistingpath(self):
folderpath = QFileDialog.getExistingDirectory()
self.existingpath.setText(folderpath)
def savesettings_func(self):
if self.existingpath.text() == '':
path = self.setpath.text()
userdata = jsondata()
userdata.setdatapath(path + '/pdm_database')
# creating pdm_database folder according to given path
dirpath = os.path.join(path, 'pdm_database')
os.mkdir(dirpath)
dirpath = os.path.join(dirpath, 'images')
os.mkdir(dirpath)
# open dashboard
self.dashboard = Dashboard()
self.dashboard.location_on_the_screen()
self.dashboard.show()
self.close()
elif self.setpath.text() == '':
path = self.existingpath.text()
userdata = jsondata()
userdata.setdatapath(path)
self.close()
elif self.existingpath.text() != '' and self.setpath.text() != '':
QMessageBox.about(self, "Error",
"You must provide only one of them.")
def __init__(self):
"""
Sets up the initial conditions of the game
:param width: Screen width
:param height: Screen height
"""
super().__init__()
self.background = arcade.load_texture("images/space1.png")
self._keys = set()
self.score = 0
self.lives = PLAYER_LIVES
self.delay = START_DELAY
self.window.set_mouse_visible(False)
#Objects
self.dashboard = Dashboard()
self.ship = Ship()
# bullet Sprites
self.bullets = SpriteList()
# how many bullets you're allowed to make
self.ammo = 5
self.meteors = SpriteList()
self.animations = SpriteList()
self.lifeList = SpriteList()
#Explosion Frames
self.explosion_texture_list = createExplosionTextureList()
self.animationsLoaded = False
self.load_animantion_frames()
# Load sounds. Sounds from kenney.nl
self.gun_sound = arcade.sound.load_sound(
":resources:sounds/laser2.wav")
self.hit_sound = arcade.sound.load_sound(
":resources:sounds/explosion2.wav")
arcade.set_background_color(arcade.color.ARSENIC)
#This is for the lives
start_x = 20
x = 0
start_y = SCREEN_HEIGHT - 125
for life in range(self.lives):
heart = Sprite('images/heart.png')
heart.scale = 0.1
x = start_x + (life * (heart.width / 2) + 10)
heart.center_x = x
heart.center_y = start_y
self.lifeList.append(heart)
def dashboard_startup(cfg):
# Create dashboard
dashbrd = Dashboard(cfg["name"], cfg["init-param"])
dashboardPool.append(dashbrd)
# Create dashboard
#
name = html_generate_dashboard_page(cfg["name"])
if name:
dashbrd.setHtmlDashboard(name)
# Find and load recent incomplete builds in DB and update dashboard
#
bldDB.retrieve_incomplete_builds(cfg["name"])
# Find and load last successful build in DB if not exist
if dashbrd.getLastSuccessfulBuild() == 0:
bldNum = bldDB.find_prev_build(cfg["name"], "lastSuccessfulBuild")
if bldNum != 0:
dashbrd.setLastSuccessfulBuild(bldNum)
# Find and load last build that passed validation in DB
dashbrd.start()
return dashbrd
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.setGeometry(525, 225, 1080, 720)
title = 'MedRec'
self.setWindowTitle(title)
self.conn = sqlite3.connect(path + '/databases/medi_colab.db')
#initialize and set a central widget
self.central_widget = QStackedWidget()
self.setCentralWidget(self.central_widget)
#initialize empty common names list
self.common_names = []
#initialize empty scientific names list
self.scientific_names = []
if self.checkInternetConn:
#fetch token from offline database
token = self.retrieve_token()
if self.verify_token(token):
dashboard_widget = Dashboard(self)
#log in to dashboard
dashboard = Dashboard(self)
self.central_widget.addWidget(dashboard)
self.central_widget.setCurrentWidget(dashboard)
#define methods to access on clicking buttons
dashboard.makeRecordEntryButton.clicked.connect(
self.chooseCase)
dashboard.viewProfileButton.clicked.connect(self.viewProfile)
dashboard.registerPatientButton.clicked.connect(
self.register_patient)
dashboard.viewPatientRecordButton.clicked.connect(
self.viewRecord)
else:
global start_widget
#initialize a login widget
start_widget = Login(self)
start_widget.loginButton.clicked.connect(self.login)
else:
start_widget = Register(self)
start_widget.registerButton.clicked.connect(self.register)
#make it initial widget
self.central_widget.addWidget(start_widget)
self.central_widget.setCurrentWidget(start_widget)
class Game:
settings: Settings
def __init__(self):
pygame.init()
self.settings = Settings()
self.settings.reset()
self.screen = pygame.display.set_mode((self.settings.screen_width, self.settings.screen_height))
self.intro = Intro(self.screen, self.settings)
self.menu = Menu(self.screen, self.settings)
pygame.display.set_caption("Pacman Portal")
self.maze = Maze(self.screen, mazefile='pacmap.txt')
self.pacman = Pacman(self.screen)
self.dashboard = Dashboard(self.screen)
self.portal_enter = Portal("Enter", self.screen, self.settings)
self.portal_exit = Portal("Exit", self.screen, self.settings)
scoresheet = open('scoresheet.txt', 'r')
self.settings.score_high = int(scoresheet.read())
def __str__(self): return 'Game(Pacman Portal), maze=' + str(self.maze) + ')'
def play(self):
eloop = EventLoop(finished=False)
while not eloop.finished:
eloop.check_events(self.pacman, self.menu, self.portal_enter, self.portal_exit, self.settings)
self.update_screen()
def update_screen(self):
self.screen.fill((0, 0, 0))
if self.settings.mode == "Game":
self.maze.check_pac_conditions(self.pacman, self.settings, self.portal_enter, self.portal_exit)
self.maze.blitme(self.settings)
self.pacman.blitme(self.settings)
self.dashboard.blitme(self.settings)
self.portal_enter.blitme()
self.portal_exit.blitme()
elif self.settings.mode == "Menu":
self.menu.blitme()
pass
elif self.settings.mode == "Intro":
self.intro.blitme()
pygame.display.flip()
async def main(argv):
user = ''
password = ''
try:
opts, args = getopt.getopt(argv, "hu:p:", ["user="******"password="******"-u", "--user"):
user = arg
elif opt in ("-p", "--password"):
password = arg
if (user == '' or password == ''):
printHelp()
sys.exit()
account = AudiConnectAccount(user, password)
await account.update()
for vehicle in account.vehicles:
dashboard = Dashboard(vehicle)
for instrument in dashboard.instruments:
print(str(instrument), instrument.str_state)
def __init__(self, model, noise_H=AR1(), noise_K=AR1(), dashboard=False):
'''
Gibbs sampler class (object):
- params : dic of parameters with initial values
- data : data used in simulation
- laws : dic (same keys as params) -> functions for simulating param knowing the others
ex: laws[key] = f where:
def f(params, data):
....
return np.random.?(???)
To run Gibbs sampler, use method: Gibbs_object.run()
To get history (simulated parameters), use Gibbs_object.get_history(key)
'''
self.model = model
self.history = {} # keep record of simulated parameters
self.T_check = []
self.x_ord = OrdinalScale()
self.y_sc = LinearScale()
self.x_data = np.array([])
self.noise_H = noise_H
self.noise_K = noise_K
for key in model.params.keys():
self.history[key] = []
if dashboard:
self.dashboard = Dashboard(self.model)
else:
self.dashboard = None
def dashboard(self, name, options={}):
if not options.get('width'): options['width'] = self.width
if not options.get('height'): options['height'] = self.height
if not options.get('from'): options['from'] = self.time_from
if not options.get('until'): options['until'] = self.until
return Dashboard(name, self.graph_templates, self.name, options,
self.graphite_render)
def openlogin(self):
self.window = QtWidgets.QMainWindow()
self.ui = Dashboard()
self.ui.setupUi(self.window)
self.window.hide()
ui.setupUi(Form)
Form.show()
def clicked_login(self):
# get data from user
txtusername = self.username.text()
txtpass = self.password.text()
# get data from userdata.json file
userdata = jsondata()
info = userdata.getdata()
if txtusername == info['username'] and txtpass == info['pass']:
self.dashboard = Dashboard()
self.dashboard.location_on_the_screen()
self.dashboard.show()
self.close()
else:
QMessageBox.about(self, "Error",
"Username or password is incorrect.")
def level_up(self):
self.level += 1
self.state = const.PLAYING
self.dashboard = Dashboard(self.surface) # reset dash
self.ship = Ship(self.surface, LEVEL_DATA[self.level]['start_fire']) # reset ship
self.active_text_box = None # clear text box
self.last_f_tick = time.time()
self.last_s_tick = time.time() - 0.5 # offset so they don't happen simultaneously
self.lightyears_left = 9
self.last_lightyear_tick = time.time()
self.is_paused = False
self.time_paused = None
self.begin_level()
def __init__(self) -> None:
self.bridge = CvBridge()
self.sensors = Sensor(PUBLISHER_MSGS, SUBSCRIBER_MSGS)
pygame.init()
self.window = pygame.display.set_mode((WIDTH, HEIGHT))
self.window.fill(WHITE)
self.dash = Dashboard(WIDTH, DASH_HEIGHT, self.sensors)
self.keys_pressed = pygame.key.get_pressed()
def __init__(self, controller=None):
Service.__init__(self, 'dispatcher')
self.handlers[Message.TYPE_LOGIN] = self.handle_login
self.handlers[Message.TYPE_IMAGE] = self.handle_image
self.handlers[Message.TYPE_RESULT] = self.handle_result
self.server = Server(self, cfg.SERVER_PORT)
self.protocols = {}
self.nodes = {}
if cfg.DASHBOARD:
self.dashboard = Dashboard()
self.dashboard.start()
else:
self.dashboard = None
measure_period = float(cfg.CONTROLLER_LOOP_TIME)/cfg.MEASURES_PER_LOOP
self.monitor = Monitor(self.process_measurements, measure_period)
self.monitor.register_item(self.ITEM_FPS, Monitor.ITEM_RATE)
self.monitor.register_item(self.ITEM_MAKESPAN, Monitor.ITEM_AVG)
self.monitor.register_item(self.ITEM_THROUGHPUT, Monitor.ITEM_RATE)
self.controller = controller
self.controller.dashboard = self.dashboard
self.controller.dispatcher = self
if self.dashboard:
self.dashboard.controller = controller
self.imagebuf = Queue.Queue() # Buffer of encoded images
# (time stamp, image data)
# Initialize probe to blank image
self.probe_image = self.generate_probe_image()
self.tokens = Queue.Queue()
self.job_id = 0
self.job_image_cache = {}
self.sub_loop = 0
return
def openwindow(self):
self.window = QtWidgets.QMainWindow()
self.ui = Dashboard()
self.ui.setupUi(self.window)
Form.hide()
self.window.show()
self.ui.btn_logout.clicked.connect(self.logout)
self.ui.btn_add.clicked.connect(self.ui.registerUser)
self.ui.btn_settings.clicked.connect(self.settings)
def get_details(self):
username = self.username.get()
password = self.password.get()
print(username, password)
#just a dummy case, insert a db query method to validate the user in the below space
user = is_user_valid(username, password)
user1 = is_doc_valid(username)
if user is None and user1 is None:
#here comes the db query
self.confirmation_label.config(text='Invalid Username or password',
fg='red')
else:
if user is None:
self.root.destroy()
Dashboard(user1)
else:
self.root.destroy()
Dashboard(user)
def before_all(context):
context.browser = webdriver.Chrome("..\\Drivers\\chromedriver")
context.cp = ComicPage(context.browser)
context.dash = Dashboard(context.browser)
j = jsonParser()
settings = j.readJSON(path="../../lineniumSettings.json")
context.url = settings["comicURL"]
context.noCommentURL = settings["noCommentURL"]
context.commentsURL = settings["commentsURL"]
def __init__(self, num_threads, seeds, cont_to_crawl):
self.num_workers = num_threads
self.dash = Dashboard(num_threads)
self.workers = []
self.frontier = Frontier(num_threads, self.dash)
self.db = Storage()
# Create the workers
for i in range(num_threads):
self.workers.append(CrawlerThread(i, 'CrawlerThread' + str(i), self.frontier, self.dash))
# print("Workers created")
# insert seeds in to serve
if not cont_to_crawl:
self.frontier.push_to_serve(seeds, 0)
# print("seeds pushed")
self.frontier.distribute()
# print("seeds distributed")
else:
self.frontier.load_to_crawl()
def main():
"""This function is the main function to be executed to play the game."""
pygame.init()
# we build the labyrinth, with the player and the tools to be found
csv_path = os.path.join("data", "grid.csv")
game_laby = Labyrinth(LabyViewer.LABY_WIDTH, LabyViewer.LABY_HEIGHT,
csv_path)
game_laby.initialize_player_location()
game_player = game_laby.player
game_tools = game_laby.tools
# we initialize the main window with our game interface
window = pygame.display.set_mode(
(Interface.SCREEN_WIDTH, Interface.SCREEN_HEIGHT))
game_back = pygame.image.load("sprites\\backs\\blue_sky.png").convert()
game_labyviewer = LabyViewer(game_laby)
game_dashboard = Dashboard("game")
game_interface = Interface(game_back, game_labyviewer, game_dashboard)
window.blit(game_back, Interface.SCREEN_ORIGIN)
# we load our sprites
m_gyver = pygame.image.load("sprites\\laby\\m_gyver.png").convert()
m_gyver.set_colorkey((255, 255, 255)) # set white as transparent
sand_path = pygame.image.load("sprites\\laby\\path.png").convert()
wall = pygame.image.load("sprites\\laby\\wall.png").convert()
guard = pygame.image.load("sprites\\laby\\guard.png").convert()
guard.set_colorkey((255, 255, 255)) # set white as transparent
# we improve our window
mac_g_a = pygame.image.load("sprites\\laby\\m_gyver.png").convert_alpha()
mac_g_a.set_colorkey((255, 255, 255)) # set white as transparent
pygame.display.set_icon(mac_g_a)
pygame.display.set_caption("Mac Gyverinth - game mode - by etienne86")
pygame.display.flip()
# we display our labyrinth with walls, paths, guard and player
sprites_dict = {
"wall": wall,
"sand_path": sand_path,
"guard": guard,
"m_gyver": m_gyver
}
game_labyviewer.display_labyrinth(window, sprites_dict)
# we display our tools in the labyrinth
game_labyviewer.display_tools_in_labyrinth(window)
# we display our dashboard
game_interface.display_dashboard(window, game_tools)
# we execute our game loop
game_loop(window, game_interface, game_laby, game_player, sprites_dict)
pygame.quit()
def __init__(self):
pygame.init()
self.settings = Settings()
self.settings.reset()
self.screen = pygame.display.set_mode((self.settings.screen_width, self.settings.screen_height))
self.intro = Intro(self.screen, self.settings)
self.menu = Menu(self.screen, self.settings)
pygame.display.set_caption("Pacman Portal")
self.maze = Maze(self.screen, mazefile='pacmap.txt')
self.pacman = Pacman(self.screen)
self.dashboard = Dashboard(self.screen)
self.portal_enter = Portal("Enter", self.screen, self.settings)
self.portal_exit = Portal("Exit", self.screen, self.settings)
scoresheet = open('scoresheet.txt', 'r')
self.settings.score_high = int(scoresheet.read())
def Login(self):
username = self.txt_username.text()
password = self.txt_pwd.text()
if username == "" and password == "":
QMessageBox.about(
self, 'Error',
'Provide a Valid username and password to continue')
else:
cursor = connection.cursor()
sql = "Select * from users where username=%s and pwd=%s"
cursor.execute(sql, (username, password))
result = cursor.fetchall()
if int(len(result)) <= 0:
QMessageBox.about(
self, "Error", "Invalid username and password. "
"Provide a valid username and password to continue ")
else:
self.__dashboard__ = Dashboard()
self.__dashboard__.show()
self.close()
def start_game():
pygame.init()
settings = Settings()
screen = pygame.display.set_mode(
(settings.screen_width, settings.screen_height))
pygame.display.set_caption("Miner by Cristhianxy")
game_stats = GameStats(settings)
menu_items = Group()
title_top = Menu_Item("MINER", 70, screen, 50)
btn_start = Menu_Item("Start", 30, screen, 135, "start")
btn_hs = Menu_Item("High Score", 30, screen, 175, "high_score")
btn_exit = Menu_Item("EXIT", 30, screen, 215, "exit")
sub_title_1 = Menu_Item("Code by Cristhian Ferreira", 15, screen, 345)
sub_title_2 = Menu_Item("Created with Pygame and Love", 15, screen, 380)
menu_items.add(title_top, btn_start, btn_hs, btn_start, btn_exit,
sub_title_1, sub_title_2)
player = Player(settings, screen)
bullets = Group()
ground_grid = Group()
jewels = Group()
gf.create_ground(settings, screen, player, ground_grid)
brian = Monster(settings, screen, 406.6, 506.3)
brian2 = Monster(settings, screen, 500, 403)
brian3 = Monster(settings, screen, 744, 502)
brian4 = Monster(settings, screen, 755, 323)
monsters = Group()
monsters.add(brian, brian2, brian3, brian4)
gf.create_jewels(screen, settings, jewels)
game_stats.reset_game()
dashboard = Dashboard(screen, settings, game_stats)
key_pressed = ""
"""MAIN LOOP"""
while True:
if not game_stats.game_status:
gf.menu_init(menu_items)
gf.event_listener(screen, settings, player, bullets, menu_items,
game_stats)
if game_stats.game_status:
player.update()
brian.move_y()
brian2.move_x()
brian3.move_y()
brian4.move_x()
gf.update_bullets(settings, screen, bullets)
gf.update_screen(settings, screen, player, bullets, ground_grid,
monsters, jewels, dashboard, game_stats,
dashboard)
def tabsClicked(self, event, source_object=None):
print("Clicked, from: ", source_object[0].objectName())
tab = source_object[0].objectName()
if tab == "Dashboard":
# self.window.emit(1)
source_object[1].hide()
view = Dashboard(source_object[1])
elif tab == "Employees":
# self.window.emit(2)
source_object[1].hide()
view = Employee(source_object[1])
elif tab == "Users":
source_object[1].hide()
view = Users(source_object[1])
elif tab == "Tables":
# self.window.emit(3)
source_object[1].hide()
view = Table(source_object[1])
elif tab == "Reservations":
# self.window.emit(4)
source_object[1].hide()
view = Reservations(source_object[1])
elif tab == "Category":
# self.window.emit(5)
source_object[1].hide()
view = Category(source_object[1])
elif tab == "Menu":
# self.window.emit(8)
source_object[1].hide()
view = Menu(source_object[1])
elif tab == "Orders":
# self.window.emit(7)
source_object[1].hide()
view = Orders(source_object[1])
elif tab == "Bill":
# self.window.emit(9)
source_object[1].hide()
view = Bill(source_object[1])
elif tab == "Settings":
# self.window.emit(6)
source_object[1].hide()
view = Settings(source_object[1])
elif tab == "Logout":
query = "update admin set logged_in='no' where logged_in='yes'"
values = ()
data = self.db.execute(query, values)
source_object[1].hide()
view = Logout(source_object[1])
def GET(self):
input = web.input()
if session.logged_in:
dashboard = Dashboard()
dashboard.servers(input.username)
fields = ['os']
aggregation = {
'aggr_fun': 'COUNT',
'aggr_field': 'id',
'alias': 'osCount',
'groupby': 'os'
}
user_data = dashboard.server_distribution(input.username,
aggregation=aggregation,
fields=fields)
aggregation['alias'] = 'serverCount'
all_data = dashboard.server_distribution('NULL',
aggregation=aggregation,
fields=fields)
return render.dashboard(input.username, input.fullname, user_data,
all_data)
else:
raise web.seeother('/loginFailed')
def post(self, request):
#Create new canvas
username = request.POST['username']
color_id = request.POST['color_id']
dashboard_id = request.POST.get('dashboard_id', None)
if not dashboard_id:
dashboard = Dashboard(username)
dashboard_id = dashboard.dashboard_id
else:
dashboard = get_dashboard(dashboard_id)
if dashboard:
dashboard_id = dashboard.dashboard_id
else:
dashboard = Dashboard(username)
dashboard_id = dashboard.dashboard_id
dashboard.add_buddy(Buddy(username, color_id))
dashboard.save()
request.session["color_id"] = color_id
return redirect(dashboard.get_absolute_url())
def post(self, request):
# Create new canvas
username = request.POST["username"]
color_id = request.POST["color_id"]
dashboard_id = request.POST.get("dashboard_id", None)
if not dashboard_id:
dashboard = Dashboard(username)
dashboard_id = dashboard.dashboard_id
else:
dashboard = get_dashboard(dashboard_id)
if dashboard:
dashboard_id = dashboard.dashboard_id
else:
dashboard = Dashboard(username)
dashboard_id = dashboard.dashboard_id
dashboard.add_buddy(Buddy(username, color_id))
dashboard.save()
request.session["color_id"] = color_id
# Notify all clients of new user
return redirect(dashboard.get_absolute_url())
def dashboard():
board = Dashboard(widgets)
board.configure(user_profile(1))
return render_template('dashboard.html', dashboard = board)
if timerangetype == "month":
sdate = raw_input("please enter start month in YYYY-MM-DD format: ")
edate = raw_input("please enter end month in YYYY-MM-DD format: ")
if timerangetype == "year":
sdate = raw_input("please enter start month in YYYY-MM-DD format: ")
edate = raw_input("please enter end month in YYYY-MM-DD format: ")
self.timerange = (timerangetype,sdate,edate)
def getparams(self):
print "please enter the dimensions you want.You have the following options: "
for item in self.mart.dimensions.keys():
print item
self.params = self.mart.dimensions.keys()
#mygreeter = greeter()
#unique_id,mart,metric,aggregation,timeseries,timerange,params = mygreeter.main()
unique_id,mart,metric,aggregation,timeseries,timerange,params = 'Abhishek','flight_paymentdetails','Gross Margin','SUM','bookingdate',('date','2012-05-14','2012-05-14'),['airline','source','destination','sector','city','status','bookingflag','typeoftravel']
mydashboard = Dashboard(unique_id,mart,metric,aggregation,timeseries,timerange,params)
def ask():
choice = raw_input("Press 0 to continue and 1 to exit : ")
if choice == '1' :
mydashboard.exit()
else :
mydashboard.interact()
ask()
mydashboard.process()
mydashboard.render()
ask()
