def __init__(self) -> None: if Mailer.__instance is not None: raise Exception("This class is a singleton!") Mailer.__instance = self self.init_ok: bool = False self.msg: EmailMessage = None self.smtp_host: str = Config.get('MAILER', 'smtp_host') self.smtp_port: str = Config.get('MAILER', 'smtp_port') self.smtp_user: str = Config.get('MAILER', 'smtp_user') self.smtp_password: str = Config.get('MAILER', 'smtp_password') _sender = Config.get('MAILER', 'sender') try: _receivers = Config.get('MAILER', 'receivers', param_type="json") except JSONDecodeError: Logger.get(self.__class__.__name__).warn('Problems decoding email receivers from JSON in config!') _receivers = None if not _sender or not _receivers or not self.smtp_host or not self.smtp_port: Logger.get(self.__class__.__name__).warn('Emails not being sent!') return self.msg = EmailMessage() self.msg.set_charset('utf-8') self.msg['From'] = _sender self.msg['To'] = _receivers self.init_ok = True
def wrapper(*args, **kwargs): global query_counter start_time = time.perf_counter() with lock: query_counter += 1 query_id = query_counter Logger.info( f'Query: query_id: <{query_id}> method: <{request.method}>; path=<{request.path}>' ) return func(start_time=start_time, query_id=query_id, *args, **kwargs)
def __init__(self) -> None: self.url = Config.get('URL_FETCHER', 'url') try: self.headers = Config.get('URL_FETCHER', 'headers', param_type="json") except JSONDecodeError: Logger.get(self.__class__.__name__).warn( "Problem decoding URL headers from JSON in config!") self.headers = None self.content: Optional[str] = None
class AppMonitor(object): def __init__(self, config): self.name = config['name'] self.limits = config['limits'].split(",") self.setup() def setup(self): client_id = uuid.uuid3(uuid.NAMESPACE_DNS, self.name) self.logger = Logger(str(client_id)) def monitor(self, process): if not process.alive(): raise NoSuchProcess(self.process_id) state = process.get_current_state() if state['cpu_percent'] < float(self.limits[0]): return level = "CAREFUL" if state["cpu_percent"] >= float(self.limits[1]): level = "WARNING" if state["cpu_percent"] >= float(self.limits[2]): level = "CRITICAL" status = state.copy() status.update(self.host_status()) self.log(level, status) def host_status(self): # Add more stuff return { "system_cpu": psutil.cpu_percent() } def log(self, level, process): self.logger.log(level, process) def run(self, interval): process = Process(self.name) while True: try: with Timed(interval) as timed: self.monitor(process) time.sleep(timed.interval) except psutil.Error as e: if isinstance(e, AccessDenied): print "access denied:", e
def getDateAndTimeByKey(parameters, dt_key, task_id): dateValue = None timeValue = None if parameters.get("".join(["date", dt_key])): try: dateValue = parse(parameters.get("".join(["date", dt_key]))).date() except ValueError: Logger.warn( f"Bad date format. Continue running task without it. task_id: {task_id} \n" f"key=<{''.join(['date', dt_key])}>; value=<{parameters.get(''.join(['date', dt_key]))}>" ) if parameters.get("".join(["time", dt_key])): try: timeValue = parse(" ".join( ["1970-01-01", parameters.get("".join(["time", dt_key]))])).time() except ValueError: Logger.warn( f"Bad time format. Continue running task without it. task_id: {task_id} \n" f"key=<{''.join(['time', dt_key])}>; value=<{parameters.get(''.join(['time', dt_key]))}>" ) Logger.debug(dateValue) Logger.debug(timeValue) return (dateValue, timeValue)
def change_file(fileid, start_time, query_id): if not Files.query.filter_by(fileid=fileid).all(): code = 404 Logger.info( f"Response: Query failed. query_id: <{query_id}>; err_code: <{code}>; " f"time: <{calc_time(start_time)} ms>") abort(code) if 'file' not in request.files or not request.files['file'].filename: code = 400 Logger.info( f"Response: Query failed. query_id: <{query_id}>; err_code: <{code}>; " f"time: <{calc_time(start_time)} ms>") abort(code) # Изменение в бд with transaction(): try: Data.query.filter_by(fileid=fileid).delete() Files.query.filter_by(fileid=fileid).update( {'filename': request.files['file'].filename}) handleFile(fileid, request.files['file']) except HTTPException as ex: Logger.info( f"Response: Query failed. query_id: <{query_id}>; err_code: <{ex.code}>; " f"time: <{calc_time(start_time)} ms>") raise db.session.commit() Logger.info(f"Response: Query successed. query_id: <{query_id}>; " f"time: <{calc_time(start_time)} ms>") return '', 204
def fetch(self) -> None: # noinspection PyBroadException try: response = requests.get(self.url, headers=self.headers) except Exception as e: Logger.get(self.__class__.__name__).error(str(e)) self.content = None return if response.status_code >= 300: Logger.get(self.__class__.__name__).error('{}: {}'.format( response.status_code, response.reason)) self.content = None else: self.content = response.content.decode('utf-8')
def create_app(): Logger.info('Creating app...') app = Flask(__name__) Logger.info('App created') Logger.info('Configurating config...') app.config.from_object(app_config.currentConfig) Logger.info('Config configured') import app.server.queries.move_handler as move_handler app.register_blueprint(move_handler.move_handler) Logger.info('Blueprint registered') return app
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 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 send(cls, content: AbstractMailTemplate, subject: str = None) -> None: if Mailer.__instance is None: Mailer() if Mailer.__instance.init_ok: smtp = smtplib.SMTP_SSL("{}:{}".format(Mailer.__instance.smtp_host, Mailer.__instance.smtp_port)) try: smtp.login(Mailer.__instance.smtp_user, Mailer.__instance.smtp_password) except smtplib.SMTPAuthenticationError as e: Logger.get(cls.__name__).warn(str(e)) return Mailer.__instance.msg['Subject'] = subject if subject is not None else Config.get('MAILER', 'Subject') Mailer.__instance.msg.set_content(content.get()) try: smtp.send_message(Mailer.__instance.msg) except smtplib.SMTPDataError as e: Logger.get(cls.__name__).warn(str(e)) smtp.quit()
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 read_graphml(graph_file: str, log: Logger = None) -> ig.Graph: G = ig.Graph() G = G.Read_GraphML(graph_file) del (G.vs['id']) for attr in G.vs[0].attributes(): try: converter = node_attr_converters[Node(attr)] G.vs[attr] = [converter(value) for value in list(G.vs[attr])] except Exception: if (log is not None): log.warning(f'failed to read node attribute {attr}') for attr in G.es[0].attributes(): try: converter = edge_attr_converters[Edge(attr)] G.es[attr] = [converter(value) for value in list(G.es[attr])] except Exception: if (log is not None): log.warning(f'failed to read edge attribute {attr}') return G
def get_overlapping_paths(log: Logger, param_path: Path, compare_paths: List[Path], buffer_m: int = None) -> List[Path]: """Returns [compare_paths] that are within a buffered geometry of [param_path]. """ overlapping_paths = [param_path] path_geom_buff = param_path.geometry.buffer(buffer_m) for compare_path in [ compare_path for compare_path in compare_paths if compare_path.name != param_path.name ]: bool_within = compare_path.geometry.within(path_geom_buff) if (bool_within == True): overlapping_paths.append(compare_path) if (len(overlapping_paths) > 1): log.debug('found ' + str(len(overlapping_paths)) + ' overlapping paths for: ' + param_path.name + ' - ' + str([path.name for path in overlapping_paths])) return overlapping_paths
def file_info(fileid, start_time, query_id): if not Files.query.filter_by(fileid=fileid).all(): code = 404 Logger.info( f"Response: Query failed. query_id: <{query_id}>; err_code: <{code}>; " f"time: <{calc_time(start_time)} ms>") abort(code) try: # Соединение таблиц и получение информации fileinf = db.session.query(Files, func.count(Data.fileid).label('count_rows'))\ .join(Files.data)\ .group_by(Files.fileid)\ .having(Files.fileid == fileid)\ .first() except HTTPException as ex: Logger.info( f"Response: Query failed. query_id: <{query_id}>; err_code: <{ex.code}>; " f"time: <{calc_time(start_time)} ms>") raise Logger.info(f"Response: Query successed. query_id: <{query_id}>; " f"time: <{calc_time(start_time)} ms>") return jsonify(fileid=fileid, filename=fileinf[0].filename, first_download=fileinf[0].first_download, last_download=fileinf[0].last_download, data_count=fileinf.count_rows), 200
def get_unique_paths_by_geom_overlay(log: Logger, all_paths: List[Path], buffer_m: int = None, cost_attr: str = 'nei_norm') -> List[str]: """Filters a list of paths by comparing buffered line geometries of the paths and selecting only the unique paths by given buffer_m (m). Args: all_paths: Both short and green paths. buffer_m: A buffer size in meters with which the path geometries will be buffered when comparing path geometries. cost_attr: The name of a cost attribute to minimize when selecting the best of overlapping paths. Note: Filters out shortest path if an overlapping green path is found to replace it. Returns: A filtered list of paths having nearly unique line geometry with respect to the given buffer_m. None if PathSet contains only one path. """ if (len(all_paths) == 1): return None paths_already_overlapped = [] filtered_paths_names = [] for path in all_paths: if (path.name not in filtered_paths_names and path.name not in paths_already_overlapped): overlay_candidates = get_path_overlay_candidates_by_len( path, all_paths, len_diff=25) overlapping_paths = get_overlapping_paths(log, path, overlay_candidates, buffer_m) best_overlapping_path = get_least_cost_path(overlapping_paths, cost_attr=cost_attr) if (best_overlapping_path.name not in filtered_paths_names): filtered_paths_names.append(best_overlapping_path.name) paths_already_overlapped += [ path.name for path in overlapping_paths ] log.debug('filtered ' + str(len(filtered_paths_names)) + ' unique paths from ' + str(len(all_paths)) + ' unique paths by overlay') return filtered_paths_names
def parse(self) -> None: contents = self.html[self.html.index(Config.get('PARSER', 'start_tag') ) + len(Config.get('PARSER', 'start_tag')):self.html. index(Config.get('PARSER', 'end_tag'))].strip() if Config.get('PARSER', 'empty_pattern') in contents: Logger.get(self.__class__.__name__).info("No new contents.") self.has_new_content = False self.links = {} try: os.remove("{}/{}".format(Config.get('CRON', 'project_root'), Config.get('PARSER', 'cache_file'))) except OSError as e: if e.errno != errno.ENOENT: raise return with open(Config.get('PARSER', 'cache_file'), 'a+') as f: f.seek(0) if f.read() == contents: Logger.get(self.__class__.__name__).info("No new contents.") self.has_new_content = False self.links = {} else: Logger.get( self.__class__.__name__).info("New content detected.") self.has_new_content = True self._extract_links(contents) f.seek(0) f.truncate() f.write(contents)
def upload_file(start_time, query_id): if 'file' not in request.files or not request.files['file'].filename: code = 400 Logger.info( f"Response: Query failed. query_id: <{query_id}>; err_code: <{code}>; " f"time: <{calc_time(start_time)} ms>") abort(code) # Добавление в бд with transaction(): try: file = Files(filename=request.files['file'].filename) with transaction(): db.session.add(file) handleFile(file.fileid, request.files['file']) except HTTPException as ex: Logger.info( f"Response: Query failed. query_id: <{query_id}>; err_code: <{ex.code}>; " f"time: <{calc_time(start_time)} ms>") raise db.session.commit() Logger.info(f"Response: Query successed. query_id: <{query_id}>; " f"time: <{calc_time(start_time)} ms>") return jsonify(fileid=file.fileid), 200
def delete_file(fileid, start_time, query_id): if not Files.query.filter_by(fileid=fileid).all(): code = 404 Logger.info( f"Response: Query failed. query_id: <{query_id}>; err_code: <{code}>; " f"time: <{calc_time(start_time)} ms>") abort(code) # Удаление из бд with transaction(): try: Data.query.filter_by(fileid=fileid).delete() Files.query.filter_by(fileid=fileid).delete() except HTTPException as ex: Logger.info( f"Response: Query failed. query_id: <{query_id}>; err_code: <{ex.code}>; " f"time: <{calc_time(start_time)} ms>") raise db.session.commit() Logger.info(f"Response: Query successed. query_id: <{query_id}>; " f"time: <{calc_time(start_time)} ms>") return '', 204
class Transformer: AVAILABLE_STRATEGIES = [ 'remove_undefined_user_orders', 'keep_undefined_user_orders' ] def __init__(self, worker_name): self.logger = Logger(worker_name) def merge_users_and_orders(self, users, orders, strategy='remove_undefined_user_orders'): user_orders = [] users_dict = {} try: if strategy not in self.AVAILABLE_STRATEGIES: raise Exception('Undefined merging strategy') for user in users: user_id = user['user_id'] del user['user_id'] users_dict[user_id] = {f'user_{k}': v for k, v in user.items()} for order in orders: user_id = order['user_id'] user_order = order if user_id in users_dict.keys(): user_data = users_dict[user_id] user_order.update(user_data) user_orders.append(user_order) elif strategy == 'keep_undefined_user_orders': user_orders.append(user_order) return user_orders except Exception as error: self.logger.error(error) raise error
class Loader: def __init__(self, worker_name): self.logger = Logger(worker_name) def load(self, user_orders): connection = None sql_command = getInsert() try: connection = psycopg2.connect(user=Config.POSTGRES_USER, password=Config.POSTGRES_PASSWORD, host=Config.POSTGRES_HOST, port=Config.POSTGRES_PORT, database=Config.POSTGRES_DATABASE) cursor = connection.cursor() cursor.executemany(sql_command, user_orders) cursor.close() connection.commit() except (Exception, psycopg2.DatabaseError) as error: self.logger.error('PostgreSQL error') raise error finally: if connection is not None: connection.close()
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()
class OrdersWorker: 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) def process(self): self.logger.info('Started') orders = self.extractor.extract_orders('orders') self.logger.info(f'Extracted orders: {orders.count()}') users = self.extractor.extract_users('users') data = self.transformer.merge_users_and_orders(users, orders) self.loader.load(data) self.logger.info(f'Written records: {len(data)}') self.logger.info('Finished')
def uploadToDB(df): def insertChunk(inserterStatemant): for key in data_keys.keys(): if key in dicts[0].keys() or key == 'updated': try: norm_data_keys[key] = getattr(inserterStatemant.inserted, key) except AttributeError: pass inserterStatemant = inserterStatemant.on_duplicate_key_update( norm_data_keys ) try: db.session.execute(inserterStatemant) except (InternalError, DataError): raise RuntimeError(f"Data is not valid. " f"Problem finded in range " f"({last_boarder}, {min(last_boarder + chunkSize, len(dicts))}). " f"Try to check matching of values with its column names. " f"If you haven't find the problem, try to check the data in specified range.") dicts = df.to_dict('records') data_schema = DataSchema() data_keys = data_schema.dump(Data()).data norm_data_keys = {} last_boarder = 0 Logger.debug("Prepare to download") for i in range(chunkSize, len(dicts), chunkSize): inserterStatemant = insert(Data.__table__).values( dicts[i - chunkSize:i] ) insertChunk(inserterStatemant) Logger.debug(f"Downloaded chunk. Summary: {i}") last_boarder = i if last_boarder != len(dicts): inserterStatemant = insert(Data.__table__).values( dicts[last_boarder:len(dicts)] ) insertChunk(inserterStatemant) Logger.debug(f"Downloaded chunk. Summary: {len(dicts)}")
class Manager(object): 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() def get_states(self): return self.states def init_deck(self): # create the deck self.deck.create() # shuffle the deck self.deck.shuffle() def new_game(self, identifier): if self.is_new_game_requested is False: for _, state in self.states.items(): # make sure player is not ready state['is_ready'] = False # set back to false to allow deck refresh self.is_deck_refreshed = False # set to true to prevent executing this block on next call self.is_new_game_requested = True # increment the number of games played self.states[identifier]['games_played'] += 1 # unlock hand self.states[identifier]['hand_locked'] = False # empty the cards on hand self.states[identifier]['cards_on_hand'] = [] if self.logger != None: self.logger.log('new_game', "Starting a new game.") # TODO: throw error when number_of_cards is less than 1 def draw_cards(self, identifier, number_of_cards=2): drawn_cards = [] # do not invoke pluck when hand is locked if self.states[identifier]['hand_locked'] is False: drawn_cards = self.deck.pluck(number_of_cards) if identifier in self.states and not 'cards_on_hand' in self.states[ identifier]: self.states[identifier]['cards_on_hand'] = [] if identifier in self.states: for card in drawn_cards: self.states[identifier]['cards_on_hand'].append(card) if self.logger != None: self.logger.log( "Drawn card. State of %s modified" % identifier, self.states[identifier]) if self.logger != None: self.logger.log("Drawn card. Remaining cards", self.deck.get_remaining_cards()) return drawn_cards def get_player_cards(self, exclude_uids=None): result = {} for identifier, state in self.states.items(): # skip to the next iteration when the identifier needs to be excluded if exclude_uids is not None and identifier in exclude_uids: continue on_hand = [] if 'cards_on_hand' in state: on_hand = state['cards_on_hand'] result[identifier] = on_hand return result def get_player_card_total(self, identifier, count_only_first=False): card_total = 0 ace_counter = 0 if identifier in self.states: card_collection = self.states[identifier]['cards_on_hand'] # extract the first card if count_only_first is True and len(card_collection) > 0: card_collection = [card_collection[0]] for card in card_collection: card_obj = TextToCardTransformer(card).transform() card_value = card_obj.get_normalized_value() # increment the ace counter if we enconter one if card_obj.get_face_value() == 'A': ace_counter += 1 continue card_total += card_value if card_total <= 10 and ace_counter == 1: # add eleven to the card total when user has 1 ace card if the card total is less than or eq to 10 card_total += 11 elif card_total > 10 and ace_counter >= 1: # add 1 for each ace the user has when the card total is greater than 10 card_total += ace_counter elif card_total == 0 and ace_counter > 1: # if the user's card consists of all aces then add set the initial total to 11 # and add 1 for each remaining ace card card_total += (11 + (ace_counter - 1)) else: pass return card_total def determine_winners(self): is_all_locked = True # reset the flag self.is_new_game_requested = False scores_dict = {} for identifier, state in self.states.items(): if state['hand_locked'] is False: is_all_locked = False break card_total = self.get_player_card_total(identifier, False) tmp_score = self.winning_number - card_total # store identifiers and scores which is greater than or equal to 0 if tmp_score >= 0: scores_dict[identifier] = tmp_score # before we determine the actual winner, all states must be hand_locked! if is_all_locked is False: return None min_val = 0 if len(scores_dict) > 0: min_val = min(scores_dict.values()) winners = [] matching_score = 0 for f_identifier, score in scores_dict.items(): if score == min_val: winners.append(strip_uid(f_identifier)) matching_score = self.get_player_card_total( f_identifier, False) # recreate the deck to prevent error from getting no cards if self.deck.get_remaining_cards( ) <= 15 and self.is_deck_refreshed is False: self.init_deck() # set the flag to true to indicate that the deck has been refreshed self.is_deck_refreshed = True if self.logger != None: self.logger.log('new_game', "Creating new and shuffling the deck.") return {'winners': winners, 'score': matching_score} def lock_hand(self, identifier, lock=True): if identifier in self.states: self.states[identifier]['hand_locked'] = lock def lock_game(self, lock=True): self.room_locked = lock def make_ready(self, identifier, ready=True): if identifier in self.states: self.states[identifier]['is_ready'] = ready def is_room_ready(self): player_ready_count = self.player_ready_count() if player_ready_count > 1: return True return False def player_count(self): return len(self.states) def player_ready_count(self): counter = 0 for _, state in self.states.items(): if state['is_ready'] is True: counter += 1 return counter def get_player_uids(self): identifiter_list = [] for identifier, _ in self.states.items(): identifiter_list.append(identifier) return identifiter_list def disconnect(self, identifier): if identifier in self.states: del self.states[identifier] if self.logger != None: self.logger.log("Player left: %s" % identifier, self.states) return True return False def connect(self, name): if self.room_locked is True: if self.logger != None: self.logger.log( "connect", "Player: %s is trying to connect a locked game." % name) return False key = name + ':uid-' + rand_uid(10) self.states[key] = { 'games_played': 0, 'total_wins': 0, 'total_losses': 0, 'is_ready': False, 'hand_locked': False } if self.logger != None: self.logger.log("Player Joined: %s" % key, self.states[key]) return key
def create_app(): Logger.info('Creating app...') app = Flask(__name__) Logger.info('App created') Logger.info('Configure app...') app.config.from_object(appconfig.getConfig()) Logger.info('App configured') Logger.info('Initialize database...') db.init_app(app) Logger.info('Database initialized') import app.queries.preprocessors_handler as preprocessors_handler import app.queries.resources_handler as resources_handler import app.queries.models_handler as models_handler import app.queries.ml_handler as ml_handler app.register_blueprint(preprocessors_handler.preprocessors_handler) app.register_blueprint(resources_handler.resources_handler) app.register_blueprint(models_handler.models_handler) app.register_blueprint(ml_handler.ml_handler) return app
def setup(self): client_id = uuid.uuid3(uuid.NAMESPACE_DNS, self.name) self.logger = Logger(str(client_id))
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 migrate(app): engine = create_engine(getConfig().SQLALCHEMY_DATABASE_URI) Logger.info('Check database existence...') if not database_exists(engine.url): Logger.info('Creating database...') create_database(engine.url) Logger.info('Database created') else: Logger.info('Database already exists. Not need to create') assert database_exists(engine.url) Logger.info('Database exists') Logger.info('Creating tables...') with app.test_request_context(): db.create_all() Logger.info('Tables created')
def __init__(self, session): self.session = session self.logger = Logger.get(__name__)
def celeryLogSuccessAndEmail(task_id, start_time, email, result): message = f"Your request successed! The result is:\n" \ f"{result}" sendEmail(email, message) Logger.info(f"Response: Query successed. query_id: <{task_id}>; " f"time: <{calc_time(start_time)} ms>")