def main():
# application configuration
config = os.path.join(os.getcwd(), "conf/main.yml")
window = GameWindow()
# override the default server settings when yaml file exists
if os.path.exists(config):
# open the file and store to the yaml_config variable
yaml_config = open(config)
# store the refernce to the config
config = yaml_load(yaml_config)
# PYRO:standard.deck@localhost:3000
game_manager = PyroProxy(
"PYRO:%s@%s:%d" %
(config['app']['manager']['object_name'],
config['app']['server']['host'], config['app']['server']['port']))
# set the game deck
window.set_game_manager(game_manager)
# enable logging
window.set_logger(Logger("BlackJack Client"))
# close the file since we do not need it anymore
yaml_config.close()
# start application
window.bootstrap()
def start(self):
"""
Função responsavel por rodar o Load Balance
"""
ttask = 5
while self.clock_tick < (len(self.users_per_clock_ticks) + ttask):
if self.clock_tick < len(
self.users_per_clock_ticks) and self.users_per_clock_ticks[
self.clock_tick] > 0:
self.user_manager(self.users_per_clock_ticks[self.clock_tick])
for server in self.servers:
server.run_tasks()
self.balance_servers()
for server in self.servers:
if server.users_online() == 0:
self.servers.remove(server)
self.sum_cost()
self.log_line()
self.clock_tick += 1
Logger(f'Total Cost: ${format(self.total_cost, ".2f")}' + '\n' * 2)
def log_line(self):
"""
Função que loga a linha no arquivo output.txt
"""
line = ''
for server in self.servers:
line += str(server.users_online()) + ','
line = line[:-1] + '\n'
Logger(line)
def __init__(self):
# create deck object
self.deck = SerializableDeck()
# save state
self.states = {}
# message logging
self.logger = Logger("BlackJack State Manager")
# boolean to determine whether a game is on going or not
self.room_locked = False
# boolean if new game is requested
self.is_new_game_requested = False
# boolean if deck newly created
self.is_deck_refreshed = False
# blackjack goal number
self.winning_number = 21
# create the game deck
self.init_deck()
socket.init_app(app, cors_allowed_origins="*")
mail = Mail(app)
print(f'MAIL USERNAME: {mail.username}\nMAIL PASSWORD: {mail.password}')
'''message = Message()
message.subject = 'TEST FROM OPT'
message.body = 'THIS MESSAGE WAS SENT FROM A LIVING APP'
message.add_recipient('*****@*****.**')
mail.send(message)
'''
fernet = Fernet(
base64.urlsafe_b64encode(os.getenv('FERNET_SECRET').encode('utf-8')))
logger = Logger(folder=app.config['LOG_FOLDER'], socket=socket)
logger.upd_log('App started', 9)
bu = Backupper()
logger.upd_log('Backupper init', 9)
from app import routes, models
bu.init_app(app,
tables=[
models.User, models.Client, models.Result, models.Message,
models.Userlog, models.Clientlog, models.Testsession,
models.Testbattery, models.Modaux, models.Module
],
logger=logger)
def __init__(self, worker_name):
self.logger = Logger(worker_name)
self.connect()
from os import listdir
import ast
import unittest
import pytest
import rasterio
import numpy as np
import pandas as pd
from app.aqi_processor import AqiProcessor
from app.graph_handler import GraphHandler
from app.graph_aqi_updater import GraphAqiUpdater
from app.logger import Logger
logger = Logger(b_printing=True, log_file='test_aqi_processor.log')
aqi_processor = AqiProcessor(logger,
aqi_dir='data/tests/aqi_cache/',
set_aws_secrets=False)
G = GraphHandler(logger,
subset=True,
add_wgs_center=True,
gdf_attrs=['length'])
class TestAqiProcessing(unittest.TestCase):
# def test_aqi_fetch_from_aws(self):
# aqi_processor.set_aws_secrets()
# enfuser_data_key, aqi_zip_name = aqi_processor.get_current_enfuser_key_filename()
# aqi_zip_name = aqi_processor.fetch_enfuser_data(enfuser_data_key, aqi_zip_name)
# filelist = listdir(aqi_processor.aqi_dir)
# self.assertIn(aqi_zip_name, filelist, msg='zip file not present in directory aqi_dir')
import app.files as file_utils
import utils.routing as rt
import utils.aq_exposures as aq_exps
import app.tests as tests
from app.path_aqi_attrs import PathAqiAttrs
from app.graph_handler import GraphHandler
from app.graph_aqi_updater import GraphAqiUpdater
from app.logger import Logger
# read data
walk = tests.get_update_test_walk_line()
walk_geom = walk.loc[0, 'geometry']
# noise_polys = file_utils.get_noise_polygons()
# initialize graph
logger = Logger(b_printing=True, log_file='test_utilities.log')
G = GraphHandler(logger, subset=True)
def find_edges_between_node_pair(self,
graph,
source: int,
target: int,
directed: bool = False) -> List[dict]:
try:
if (directed == True):
return [
e.attributes()
for e in self.graph.es.select(_source=source, _target=target)
]
else:
import unittest
import pytest
import time
import pandas as pd
from datetime import datetime
import app.files as file_utils
import utils.noise_exposures as noise_exps
import app.tests as tests
from app.graph_handler import GraphHandler
from app.graph_aqi_updater import GraphAqiUpdater
import utils.aq_exposures as aq_exps
from app.logger import Logger
from app.path_aqi_attrs import PathAqiAttrs
# initialize graph
logger = Logger(b_printing=True, log_file='test_green_paths_app.log')
G = GraphHandler(logger, subset=True, set_noise_costs=True)
expected_ecount = G.graph.ecount()
expected_vcount = G.graph.vcount()
aqi_updater = GraphAqiUpdater(logger,
G,
aqi_dir='data/tests/aqi_cache/',
start=False)
aqi_edge_updates_csv = 'aqi_2019-11-08T14.csv'
aqi_updater.read_update_aqi_to_graph(aqi_edge_updates_csv)
def get_quiet_path_stats(G, od_dict, logging=False):
FC = tests.get_short_green_paths(logger,
'quiet',
G,
def setup(self):
client_id = uuid.uuid3(uuid.NAMESPACE_DNS, self.name)
self.logger = Logger(str(client_id))
import logging
import os
import traceback
from tkinter import *
from tkinter import messagebox as tkMessageBox
from app.logger import Logger
from app.widget_holder import *
logFileName = "_log.txt"
pathToRootFolder = r"D:\Code_Storage\python\projects\create_text_file_through_the_menu\app\trials"
root = Tk()
logger = Logger(pathToRootFolder)
try:
widgetHolder = WidgetHolder(root, pathToRootFolder)
root.mainloop()
except Exception as e:
logging.exception(e)
with open(logger.pathToRootLogFile, "a") as file:
file.write("\n\n***********************************************\n")
file.write(traceback.format_exc())
file.write("\n***********************************************\n\n")
tkMessageBox.showerror(title="Please click Ok to continue",
message="Something went wrong")
def test_info():
Logger('test').info('Hello')
def test_debug():
Logger('test').debug('Hello')
def test_fatal():
Logger('test').fatal('Hello')
def test_error():
Logger('test').error('Hello')
def test_warning():
Logger('test').warning('Hello')
from flask import Flask
from app.db import MongoAlchemy
from flask_marshmallow import Marshmallow
from app.seed import init_seed_script
from app.logger import Logger
from app.rabbitmq import RabbitMQ, Queue
from app.exception_handler import init_error_handler
# Globally accessible libraries
db = MongoAlchemy()
ma = Marshmallow()
rbmq = RabbitMQ()
logger = Logger()
queue = Queue()
def create_app(**kwargs):
"""Initialize the core application."""
app = Flask(__name__)
app.config.from_pyfile('../config.py')
db.init_app(app)
ma.init_app(app)
logger.init_app(app)
rbmq.init_app(app, queue)
init_error_handler(app)
with app.app_context():
from app.blog.views import blog
# Register blueprint(s)
def __init__(self):
self.name = 'orders_worker'
self.extractor = Extractor(self.name)
self.transformer = Transformer(self.name)
self.loader = Loader(self.name)
self.logger = Logger(self.name)
