def run(config_dict=None, db=None, config_id=None):
if not config_dict:
config_dict = get_config(config_id)
bootstrap(config_dict)
logs = get_logs_from_config_id(config_dict.general.id)
if not logs["config"]:
raise ValueError("Empty log file")
metric_keys = set(["imagination_log_likelihood", "loss", "time_taken"])
plot_dir = config_dict.plot.base_path
for mode in ["train", "val"]:
for key in logs[mode]:
if key in metric_keys:
plot(logs[mode][key], mode, key, plot_dir)
if (USE_DATABASE):
best_metric_logs = log_to_spreadsheet(logs)
try:
if (not db):
db = Database(connect_to_firebase=False)
db.update_job(job_id=config_dict.general.id,
project_id=PROJECT,
data_to_update={"status": "recorded"})
except FileNotFoundError as f:
print("Could not log results to journal")
return best_metric_logs
else:
return None
def run_all_synced():
'''Method to run all the tasks that have been completed'''
sample_config = get_sample_config()
db = Database(connect_to_firebase=False)
appid_list = map(lambda x: x["id"],
db.list_jobs(status="synced", project=PROJECT))
metrics = []
flag = False
appid_list_to_print = []
appid_list = list(map(lambda x: str(x), appid_list))
for app_id in appid_list:
flag = True
print(app_id)
remote_config = make_remote_config(sample_config, app_id)
# print(app_id)
try:
best_metric_logs = run(config_dict=remote_config, db=db)
metrics.append(best_metric_logs)
except ValueError as e:
print("Error for {}. Message: {}".format(app_id, e))
continue
appid_list_to_print.append(app_id)
sleep(2)
if (flag):
print(appid_list_to_print)
summary_file_path = os.path.join(sample_config.general.base_path,
"summary.json")
with open(summary_file_path, "w") as f:
f.write(json.dumps(metrics, indent=4))
def set_blank_user_record(self, user):
db = Database()
sql = """
INSERT INTO economy_users (reddit_id)
VALUES (?)
"""
db.connection.cursor().execute(sql, (user.id, ))
db.connection.commit()
db.close()
def test_retrieve_user_inventory(self):
# Should make a new record if one does not exist
economy = Economy(MockReddit(), self.BASE_CONFIG)
user = MockUser()
sql = 'SELECT * FROM economy_users WHERE economy_users.reddit_id = ?'
record = Database().connection.cursor().execute(sql, (user.id, )).fetchone()
self.assertIsNone(record)
blank_record = economy.retrieve_user_inventory(user)
self.assertIsNotNone(blank_record)
def store_changes(self, user, funds_delta=0, items_delta=0):
db = Database()
sql = """
UPDATE economy_users
SET items_available = items_available + ?, funds_available = funds_available + ?
WHERE economy_users.reddit_id = ?
"""
db.connection.cursor().execute(sql,
(items_delta, funds_delta, user.id))
db.connection.commit()
db.close()
def set_database_schema(self):
db = Database()
sql = """
CREATE TABLE IF NOT EXISTS economy_users (
id integer PRIMARY KEY,
reddit_id text NOT NULL UNIQUE,
items_available integer NOT NULL DEFAULT 0,
funds_available integer NOT NULL DEFAULT 0)
"""
db.connection.cursor().execute(sql).fetchone()
db.close()
def comm_sql_cmd(bot: Bot, update: Update):
"""/sql executes a mysql insert/update command on the pokemon database"""
txt = update.message.text
if len(txt) <= len("/sql_cmd "):
return # no parameter given
cmd = txt[len("/sql_cmd "):]
with Database() as database:
try:
database.cmd(cmd)
bot.send_message(update.message.chat_id, "Executed command without errors")
except MySQLError as e:
bot.send_message(update.message.chat_id, "{0}".format(e))
def retrieve_user_inventory(self, user):
db = Database()
sql = 'SELECT * FROM economy_users WHERE economy_users.reddit_id = ?'
user_record = db.connection.cursor().execute(sql,
(user.id, )).fetchone()
if user_record == None:
self.set_blank_user_record(user)
user_record = db.connection.cursor().execute(
sql, (user.id, )).fetchone()
db.close()
return user_record
def handle(bot_p: Bot, update: Update, _cmd_handlers):
with Database() as database:
trainer = Trainer(update.message.from_user.id)
menu_id = None
if trainer.does_exist(database):
trainer.load_values(values="menu_id", database=database)
menu_id = trainer.menu_id
if menu_id not in _cmd_handlers:
return
func = _cmd_handlers[menu_id]
use_db = self.uses_db(func)
if use_db:
func(bot_p, update, trainer, database)
if not use_db:
func(bot_p, update, trainer)
def comm_sql_get(self, bot: Bot, update: Update):
"""/sql executes a mysql select command on the pokemon database"""
txt = update.message.text
if len(txt) <= len("/sql_get "):
return # no parameter given
cmd = txt[len("/sql_get "):]
with Database() as database:
try:
result = database.get_data_sorted(cmd)
send_large_code_message(bot, update.message.chat_id,
json.dumps(result, default=self.jdefault, indent=4))
except MySQLError as e:
bot.send_message(update.message.chat_id, "{0}".format(e))
def _delete_account(self):
# curselection return Tuple. I converted to a list (This tuple returns line numbers or elements)
index = list(self.list_box.curselection())
# Index returning the first item in its list
accounts = self._get_accounts()
username = accounts[index[0]]
answer = messagebox.askyesno('Remove account!',
'Are you sure you want to remove?')
if answer:
db = Database()
is_deleted = db.delete_account(username[3])
if is_deleted:
accounts = db.get_accounts()
self._set_accounts(accounts)
self.frame_list_box.delete(0, END)
else:
messagebox.showerror('SQL Error',
'There is problem with delete function')
def init_schema(database):
with Database(database) as db:
db.execute("""CREATE TABLE IF NOT EXISTS chats (
chat_id INTEGER PRIMARY KEY,
lang VARCHAR(5) NOT NULL,
voice_enabled INTEGER,
photos_enabled INTEGER,
qr_enabled INTEGER,
active INTEGER,
ban INTEGER)
""")
db.execute("""CREATE TABLE IF NOT EXISTS stats (
month_year INTEGER PRIMARY KEY,
audio_num INTEGER,
min_tot_audio INTEGER,
min_transcribed_audio INTEGER,
num_pictures INTEGER)
""")
def run(storage_dir, db_collection, db_name, db_connection, batch_size):
"""A script for loading data from the MongoDB to the storage binary files.
"""
config = Config(
storage_dir=storage_dir,
db_collection=db_collection,
db_connection=db_connection,
db_name=db_name,
batch_size=batch_size,
)
session = Session(
config=config,
collection=get_db_collection(
connection_str=config.db_connection, db_name=config.db_name, collection_name=config.db_collection,
),
storage=Database(config.storage_dir),
)
start_data_watcher(session)
def button_handle(bot_p: Bot, update: Update):
id = ButtonId.from_string(update.callback_query.data)
if id not in self.buttonHandlers:
return
bttn_handlers = self.buttonHandlers[id]
with Database() as database:
trainer = Trainer(update.callback_query.from_user.id)
menu_id = None
if trainer.does_exist(database):
trainer.load_values(values="menu_id", database=database)
menu_id = trainer.menu_id
if menu_id not in bttn_handlers:
return
func = bttn_handlers[menu_id]
use_db = self.uses_db(func)
if use_db:
func(bot_p, update, trainer, database)
if not use_db:
func(bot_p, update, trainer)
async def websocket_endpoint(title: str, websocket: WebSocket):
title = title.replace("_", " ")
database = Database(sslmode=False)
with database.Session() as sess:
result = sess.query(WikiMap).filter_by(title=title, lpp=12).first()
logging.info(result)
graph = WikipediaGraph("Elon Musk", levels=3, lpp=12)
await websocket.accept()
steps = 0
delay = [1.5, 1, 0.75]
for json_chunk in graph.generate_from_wikimap(result, yield_size=15):
await websocket.send_json(json_chunk)
if steps < 3:
await asyncio.sleep(delay[0])
elif steps < 5:
await asyncio.sleep(delay[1])
else:
await asyncio.sleep(delay[2])
steps += 1
await websocket.close(code=1000)
def run(storage_dir):
"""The main user interface to select the query the stored data.
"""
config = Config(storage_dir=storage_dir, )
session = Session(
config=config,
storage=Database(config.storage_dir),
)
while True:
for index, question in enumerate(questions):
click.secho(f" {index+1} - {question.question}", fg="green")
value = click.prompt("Please choose the question number", type=int)
if value < 1 or value > len(questions):
click.secho("Bad number, choose again", fg="red")
continue
question = questions[value - 1]
click.secho(f"\n The chosen question: {question.question}", fg="green")
click.secho("Searching...", fg="green")
search_result = session.storage.count(question.collection_name,
limit=question.limit,
sorting=question.sorting)
results = search_result.results
click.secho("\nThe answer is:", fg="yellow")
if len(results) == 1:
click.secho(f" {results[0].value}", fg="yellow")
else:
for index, result in enumerate(results):
click.secho(f" {index+1}. {result.value}",
fg="yellow")
click.secho(
f"Searched {search_result.data_size} records in {search_result.time:0.2f} seconds."
)
click.secho("\nDo you want to search again?")
def _save(self, update_or_save):
database = Database()
name = self.name.get()
phone = self.phone.get()
username = self.username.get()
password = self.password.get()
if username != '' or password != '':
if update_or_save:
database.save_account(name, phone, username, password)
messagebox.showinfo('INFO', 'Account saved')
self._reset()
accounts = self._get_accounts()
self._set_accounts(accounts)
else:
database.update_account(name, phone, username, password)
messagebox.showinfo('INFO', 'Account update')
self._reset()
self.update_button.config(state='disabled')
accounts = self._get_accounts()
self._set_accounts(accounts)
else:
messagebox.showerror('Credentials',
'Please enter username or password')
def __init__(self):
super(ApplicationWindow, self).__init__()
self.db = Database()
self.ui = Ui_Schedule()
self.ui.setupUi(self)
self.check_for_first_exec()
self.ui.prevWeekButton.clicked.connect(self.render_prev_week)
self.ui.nextWeekButton.clicked.connect(self.render_next_week)
self.render_controller = SchedulerRender(self.db)
self.class_info = self.render_controller.get_week_schedule()[0]
for i in range(28):
day_number = i // 4
class_number = i % 4 + 1
property = getattr(
self.ui, self.day_translation[day_number] + 'CheckBox_' +
str(class_number))
property.stateChanged.connect(self.check_state_changed)
property = getattr(
self.ui, self.day_translation[day_number] + 'ClassButton_' +
str(class_number))
property.clicked.connect(self.class_clicked)
def __init__(self, db=None):
if db:
self.conn = db
else:
self.conn = Database().create_connection()
self.query_comanda_exists = """
"""
engine = create_engine(uri)
Base.metadata.drop_all(engine)
Base.metadata.create_all(engine)
engine.dispose()
def create_database(uri: str) -> None:
engine = create_engine(uri)
Base.metadata.create_all(engine)
engine.dispose()
def get_all(db):
sess = db.Session()
query = sess.query(WikiMap).order_by(WikiMap.title).all()
sess.close()
return query
if __name__ == "__main__":
database = Database(sslmode=False)
# delete_recreate_database(database.DATABASE_URI)
create_sample_entries(database.Session)
results = get_all(database)
print(results)
database.close()
# prod_url = config.get_production_config_locally()
# database = Database(prod_url)
def insert_todb(table_name, data):
db = Database()
db.add_table(table_name)
db.insert(table_name, data)
db.close_connection()
from callbacks.tones import TonesCallback
from database.services import DBServices
from callbacks.link import LinkCallback
from messages.messages import Messages
from database.db import Database
load_dotenv()
"""
favorite - Избранные композиции
chords - Поиск аккорда
help - Помощь
"""
bot = telebot.TeleBot(
os.environ.get('TOKEN', '1038924278:AAHoYHOuNnzlEEh3EH8wjc0Alw9GDXJ2pWI'))
db_session = Database().create_session()
query = {'query': '', 'count': 0, 'result': None}
cur_song = {'url': None, 'tonality': 0}
chords_list = {'list': []}
links = []
@bot.message_handler(commands=['start'])
def start_handler(message):
"""Handle "/start" command call"""
chat_id = message.chat.id
text = Messages.start_message()
bot.send_message(chat_id, text, parse_mode="Markdown")
@bot.message_handler(commands=['help'])
import asyncio
import re
import discord
from discord.ext import commands
from database.db import Database
from config import DATABASE_URL
db = Database(DATABASE_URL)
class Moderation(commands.Cog, name='модерация'):
def __init__(self, bot):
self.bot = bot
@commands.Cog.listener()
async def on_message(self, message):
banned_words = db.get_banword(message.channel.id)
banned_users = db.get_banned_users(message.channel.id)
if not message.author.bot:
for i in banned_words:
if message.content.startswith(i[0]) or re.search(
i[0], message.content):
await message.delete()
for i in banned_users:
if message.author.id == i[0]:
await message.delete()
@commands.command(
name='add',
help=
from database.db import Database
from k8s.k8s import Kube
from server.server import *
import os
server_config = {"host": "localhost", "port": 8080}
db_config = {
"host": "localhost",
"db_name": "ulti",
"user": "******",
"password": f"{os.environ['db_pass']}"
}
kube = Kube()
db_client = Database(db_config, kube.apis_api)
db_client.check_conn()
db_client.create_tables()
namespace_list = kube.get_namespaces()
db_client.insert_namespace(namespace_list)
db_client.insert_deployments(namespace_list)
conn = db_client.db_connect()
run_server(conn, server_config.get('port'), server_config.get('host'),
db_client, namespace_list)
def get_const_data_from_database():
global all_species, all_types, all_moves, all_growth_rates, all_move_effects
with Database() as database:
types_data = database.get_data_sorted("SELECT * FROM type ORDER BY id")
i = 0
for t_data in types_data:
if i != t_data['id']:
raise CorruptedDataError(
"database got corrupted table 'type'. No entry for id %d" %
i)
all_types.append(Type(t_data))
i += 1
effectives = database.get_data_sorted(
"SELECT * FROM type_efficiencies ORDER BY attack, defense")
if len(effectives) != len(all_types) * len(all_types):
raise CorruptedDataError(
"database got corrupted type_efficiencies. %d entries instead of expected %d entries"
% (len(effectives), len(all_types) * len(all_types)))
for e in effectives:
all_types[e['attack']].effectives[all_types[
e['defense']]] = e['effective']
growth_rates_data = database.get_data_sorted(
"SELECT * FROM growth_rate ORDER BY id")
i = 0
for g_data in growth_rates_data:
if i != g_data['id']:
raise CorruptedDataError(
"database got corrupted table 'growth_rate'. No entry for id %d"
% i)
all_growth_rates.append(GrowthRate(g_data))
i += 1
species_data = database.get_data_sorted(
"SELECT * FROM pokespecies ORDER BY id")
i = 1
for s_data in species_data:
if i != s_data['id']:
raise CorruptedDataError(
"database got corrupted table 'pokespecies'. No entry for id %d"
% i)
all_species.append(Pokespecies(s_data))
i += 1
move_effect_data = database.get_data_sorted(
"SELECT * FROM move_effect ORDER BY id")
i = 0
for m_data in move_effect_data:
if i != m_data['id']:
raise CorruptedDataError(
"database got corrupted table 'move_effect'. No entry for id %d"
% i)
all_move_effects.append(MoveEffect(m_data))
i += 1
moves_data = database.get_data_sorted("SELECT * FROM move ORDER BY id")
i = 0
for m_data in moves_data:
if i != m_data['id']:
raise CorruptedDataError(
"database got corrupted table 'move'. No entry for id %d" %
i)
all_moves.append(Move(m_data))
i += 1
learnable_moves_data = database.get_data_sorted(
"SELECT * FROM learnable_moves ORDER BY species_id, level")
for m_data in learnable_moves_data:
all_species[m_data['species_id'] - 1].learnable_moves.append(
LearnableMove(m_data))
status_data = database.get_data_sorted(
"SELECT * FROM states ORDER BY id")
for s_data in status_data:
setattr(State, s_data['name'], s_data['id'])
if post_url not in self.done_urls:
self.tasks.append(self.get_task(post_url, self.parse_post))
def _get_comments(self, post_id):
api_path = f"/api/v2/comments?commentable_type=Post&commentable_id={post_id}&order=desc"
response = self._get_response(urljoin(self.start_url, api_path))
data = response.json()
return data
def run(self):
#task = self.get_task(self.start_url, self.parse_feed)
#self.tasks.append(task)
#self.done_urls.add(self.start_url)
for task in self.tasks:
task_result = task()
if task_result:
self.db.create_post(task_result)
def save(self, data):
self.db.create_post(data)
if __name__ == '__main__':
database = Database("sqlite:///gb_blog.db")
parser = GbBlogParse("https://geekbrains.ru/posts", database)
parser.run()
from database.db import Database
db = Database()
def upsert_provider(params):
sql_params = [params['provider_name'], params['provider_name']]
sql_stmt = '''insert into providers
(provider) values (%s)
ON CONFLICT (provider) DO UPDATE
SET provider = %s RETURNING id'''
return db.run_query(sql_stmt, sql_params, 'one')
def update_provider(params, provider_id):
sql_params = [params['provider_name']]
sql_str = ''
if 'street_address' in params:
sql_str += ', street_address = %s'
sql_params.append(params['street_address'])
if 'phone' in params:
sql_str += ', phone = %s'
sql_params.append(params['phone'])
if 'speciality' in params:
sql_str += ', speciality = %s'
sql_params.append(params['speciality'])
if 'notes' in params:
sql_str += ', notes = %s'
sql_params.append(params['notes'])
if 'city' in params:
sql_str += ', city = %s'
sql_params.append(params['city'])
if 'state' in params:
'store format': (DataClassification.STRUCTURED, DataValueCategory.NUMERIC,
DataFormatCategory.PANEL),
'dtype':
'float64',
'rel_path':
'basicfactor.beta'
}]
start_time = '2014-01-01'
end_time = '2018-03-01'
db_path = r'C:\Users\c\Desktop\test\db_test'
if os_path.exists(db_path):
rmtree(db_path)
rmtree(r'C:\Users\c\Documents\DatabaseMetadata')
db = Database(db_path)
for factor in test_factors:
factor_data = fmanager.query(factor['name'], (start_time, end_time))
result = db.insert(factor_data, factor['rel_path'], factor['store format'],
factor['dtype'])
print(result)
unstruct_data = list(range(1000))
print(
db.insert(unstruct_data, 'unstruct_data.test',
(DataClassification.UNSTRUCTURED, )))
db.print_collections()
pprint(db.find_data('beta'))
print(db.find_collection('quote'))
def show(self):
print('\nCargando... Por favor espere')
db = Database()
backup = File('backup')
# Opciones CON base de datos
if db.connect():
os.system('cls')
print('>>> EL AHORCADO (x.x) <<< - ' + self.nickname)
db.updateData()
backup = File('backup')
if backup.count():
print('1. Jugar\n' + '2. Ver puntuaciones\n' +
'3. Agregar palabra (Hay ' + str(backup.count()) +
')\n' + '4. Revisar palabras (-.-)\n' +
'5. Salir\n\nElige una opción: ')
option = input().lower()
if option == '1':
game = Game('online')
while not game.isOver():
os.system('cls')
print(
'PALABRAS\t Total: ' + game.getWordTotal() +
' (Punt. máx.) \tRestante: ' +
game.getWordCount() +
'\n-----------------------------------------------------\n'
+ '\tNo. de intentos: ' + game.getAtt() +
'\tPuntaje: ' + game.getScore() +
'\n-----------------------------------------------------'
+ game.getHanged() + '\n' + game.getWordPrint())
print('\n' + game.play(
input(
"\nEscribe una letra ('end' para salir/terminar): "
).upper()))
input()
os.system('cls')
print("---------------------" + "| FIN DE LA PARTIDA |" +
"---------------------\n" + 'Puntaje: ' +
game.getScore())
if int(game.getScore()) > 0:
if db.connect():
db.regScore(self.nickname, game.getScore())
print("Partida registrada con exito")
else:
localScore = File('score').add(self.nickname +
'|' +
game.getScore())
print(
"Partida completada, intenta conectarte al servidor para que sea registrada"
)
input()
if option == '2':
os.system('cls')
print('---> Puntuaciones <---\n')
score = File('score').getWords()
print(
"JUGADOR \tPUNTAJE MÁX. \tPUNTAJE TOTAL \tPARTIDAS JUGADAS\n"
)
for row in score:
row = row.split('|')
print(row[0] + '\t\t' + str(row[1]) + '\t\t' +
str(row[2]) + '\t\t' + str(row[3]))
input()
elif option == '3':
word = input(
'\nEscribe la palabra a ingresar ("c" para cancelar):\n'
).upper()
if word != 'C':
db.insertWord(word)
elif option == '4':
os.system('cls')
print('Palabras guardadas (¡Esponja enloqueciste!)\n')
for word in backup.getWords():
print(word)
input()
elif option == '5':
backup.close()
db.close()
exit()
else:
print('1. Agregar palabras para jugar\n' +
'2. Salir\n\nElige una opción: ')
option = input().lower()
if option == '1':
word = input(
'\nEscribe la palabra a ingresar ("c" para cancelar):\n'
).upper()
if word != 'C':
db.insertWord(word)
elif option == '2':
db.close()
backup.close()
exit()
# Opciones SIN base de datos
else:
os.system('cls')
print(
'>>> EL AHORCADO (x.x) <<< - ' + self.nickname + '\n' +
'No hay conexión al servidor\n' +
'Tus partidas y palabras añadidas se guardarán cuando haya conexión\n'
)
backup = File('backup')
if backup.count():
print('1. Jugar\n' + '2. Ver palabras disponibles\n' +
'3. Conectarse al servidor\n' + '4. Ver puntuaciones\n' +
'5. Añadir palabras\n' +
'6. Salir\n\nElige una opción: ')
option = input().lower()
if option == '1':
game = Game('offline')
while not game.isOver():
os.system('cls')
print(
'PALABRAS\t Total: ' + game.getWordTotal() +
' (Punt. máx.) \tRestante: ' +
game.getWordCount() +
'\n-----------------------------------------------------\n'
+ '\tNo. de intentos: ' + game.getAtt() +
'\tPuntaje: ' + game.getScore() +
'\n-----------------------------------------------------'
+ game.getHanged() + '\n' + game.getWordPrint())
print('\n' + game.play(
input(
"\nEscribe una letra ('end' para salir/terminar): "
).upper()))
input()
os.system('cls')
print("---------------------" + "| FIN DE LA PARTIDA |" +
"---------------------\n" + 'Puntaje: ' +
game.getScore())
if int(game.getScore()) > 0:
if db.connect():
db.regScore(self.nickname, game.getScore())
print("Partida registrada con exito")
else:
localScore = File('unsaved_score').add(
self.nickname + '|' + game.getScore())
print(
"Partida completada, intenta conectarte al servidor para que sea registrada"
)
input()
if option == '2':
os.system('cls')
print('Palabras guardadas (¡Esponja enloqueciste!)\n')
for word in backup.getWords():
print(word)
input()
elif option == '4':
os.system('cls')
print('---> Puntuaciones <---\n')
score = File('score').getWords()
print(
"JUGADOR \tPUNTAJE MÁX. \tPUNTAJE TOTAL \tPARTIDAS JUGADAS\n"
)
for row in score:
row = row.split('|')
print(row[0] + '\t\t' + str(row[1]) + '\t\t' +
str(row[2]) + '\t\t' + str(row[3]))
unsavedScore = File('unsaved_score').getWords()
if len(unsavedScore):
print("\nPartidas por registrar:")
for row in unsavedScore:
row = row.split('|')
print(row[0] + '\t' + str(row[1]))
input()
elif option == '5':
word = ''
while word.lower() != 'n':
word = str(
input(
'\nEscribe la palabra a ingresar ("n" para terminar): '
))
if word.lower() != 'n':
backup.add(word)
elif option == '6':
backup.close()
exit()
else:
print('1. Agregar palabras para jugar\n' +
'2. Salir\n\nElige una opción: ')
option = input().lower()
if option == '1':
word = ''
while word.lower() != 'n':
word = str(
input(
'\nEscribe la palabra a ingresar ("n" para terminar): '
))
if word.lower() != 'n':
backup.add(word)
elif option == '2':
backup.close()
exit()
backup.close()
self.show()
if len(sys.argv) == 1:
cmds.print_help(sys.stderr)
sys.exit()
args = cmds.parse_args()
# Process the arguments
if args.version:
print("Version:", settings.VERSION)
sys.exit()
# Initialize all the nic1 subsystems to process the files
# If anything fails, exit
if args.files:
try:
DB = Database()
parse = Parser(DB)
authorizer = Authorizer()
except ValueError as err:
print(err.args)
exit(1) #abnormal exit
print("Compiling...")
# Loop through the specified files
for f in args.files:
f_path = pathlib.Path(f)
if f_path.is_dir():
for f_path in f_path.iterdir():
if f_path.is_file():
parse.parse_file(f_path.as_posix())
else: