def download_data(cls,
freq,
instr,
symbols=None,
country=None,
outputsize=None,
start=None):
av = cls.get_av_instance(freq, instr)
if country is not None:
raw_data = SQL.get_symbols_per_country(country)
symbols = [item[0] for item in raw_data]
for symbol in symbols:
try:
param = av.get_api_query(freq, symbol, outputsize)
print('Downloading ' + symbol + ' data')
json = av.download_json(param, symbol)
print(symbol + ' data downloaded')
data = av.generate_tuple(json, symbol, instr, freq)
data = av.tz_to_utc(data)
SQL.insert_price_data(data, freq)
print(symbol + ' data inserted in database')
except NameError:
print('Symbol ' + symbol +
' does not exist in Alpha Vantage database')
time.sleep(1)
SQL.remove_price_duplicates(freq)
print('Duplicates removed')
print('Done')
class Survey_Info(object):
def __init__(self, siteid):
"""
Survey information for siteid
"""
self.db = SQL()
self.siteid = siteid
def get_dic(self, code):
"""
Reads preparer values from json
Inserts code and json values into dictionary
"""
dic = self.db.get_site_dic(self.siteid)
with open(self.db.get_json_file(self.siteid), 'r') as fpu:
preparer = json.load(fpu)
for dv in dic.values():
if isinstance(dv, dict):
for k, v in dv.items():
if v == vl.json_code:
dv[k] = code
if v == vl.json_first_name:
dv[k] = preparer[vl.json_first_name]
elif v == vl.json_last_name:
dv[k] = preparer[vl.json_last_name]
elif v == vl.json_email:
dv[k] = preparer[vl.json_email]
elif v == vl.json_phone_number:
dv[k] = preparer[vl.json_phone_number]
elif v == vl.json_postal_code:
dv[k] = preparer[vl.json_postal_code]
return dic
def load_by_id(home_username, friend_id):
sql_instance = SQL()
result = sql_instance.get_individual_friend_by_id(home_username, friend_id)
return Friend(username=result[0],
user_id=result[1],
first_name=result[2],
last_name=result[3])
def _is_registered(self):
sql = SQL()
sql._query_("SELECT user, password FROM user WHERE user_id = '" + str(self.uid) + "'")
data = sql.get_last_result()
if data is not None:
return True
return False
class Trabajadores(trabajadores.Ui_Dialog,
QDialog):
def __init__(self):
super(Trabajadores, self).__init__()
self.setupUi(self)
"""
self.tableWidget.setRowCount(10)
self.tableWidget.setColumnCount(10)
"""
self.trabajadores = SQL().personalShift
self.__row = 0
self.tableWidget.setRowCount(len(self.trabajadores.keys()))
for t, sch in self.trabajadores.items():
self.append([t, sch.capitalize()])
def append(self, item, column=0, table=None):
if type(item) == list:
for i in item:
newItem = QTableWidgetItem(i)
self.tableWidget.setItem(self.__row, column, newItem)
column += 1
index_increment = 1
else:
newItem = QTableWidgetItem(item)
index_increment = 1
self.tableWidget.setItem(self.__row, column, newItem)
self.__row += index_increment
def remove_price_duplicates(freq):
"""
:param freq: price frequency of the price table to be cleaned
Remove the duplicates entries of the price table
"""
SQL.remove_price_duplicates(freq)
print('Duplicates removed')
def get_info(self, symbol):
"""
Provides additional info to be inserted in the price data tuple
"""
dv_id = SQL.get_data_vendor_id(self.name)
symbol_id = SQL.get_symbol_id(symbol)
now = dt.datetime.now()
return dv_id, symbol_id, now
def __init__(self):
SQL.__init__(self)
self.hostname = get_config('postgresql_host', 'localhost')
self.port = get_config('postgresql_port', '5432')
self.username = get_config('postgresql_user', 'postgres')
self.password = get_config('postgresql_pass', 'postgres')
self.dbname = get_config('postgresql_db', 'syscall_popularity')
self.db = None
self.tables = []
def register(self, data):
# Parse input into dict, so we know all values are correctly specified
dat = dict()
for x in range(0, len(data), 2):
dat[data[x]] = data[x+1]
# Begin with the process
sql = SQL()
query = "SELECT registrar(" + str(self.uid) + ", '" + dat['user'] + "','" + dat['password'] + "')"
return sql.function(query)
def delete_user():
a = items['delete_number']
delete_number = a.get()
label = items['delete_label']
if delete_number != '':
SQL().user_operation(number=delete_number, delete=True)
items['delete_number'].delete(0, last='end')
label.config(text=delete_number + ' Успешно удален', fg='green')
print(SQL().get_users())
def __init__(self):
self.table_name = 'admins'
self.sql = SQL()
self.id = None
self.account = None
self.password = None
self.power = None
self.phone = None
self.email = None
self.info = None
def newQuery():
sql = SQL()
sql.connect()
data = request.get_json()
if "currQuery" not in session:
session["currQuery"] = ""
oldQuery = session["currQuery"]
newData = driver.new_tables(sql, oldQuery, data)
session["currQuery"] = newData["currentQuery"]
return jsonify(newData)
def fill_simulated_kiln(size):
kiln_state = []
wasted_fraction = []
firing_cycle = SQL().get_best_firing_cycle(mode='LEFT_TO_SIMULATE')
for x in range(1, 8):
state, fraction = fill_simulated_shelf(x, firing_cycle, size)
kiln_state.append(state)
wasted_fraction.append(fraction)
with SQL() as sql:
for a, b in state.iteritems():
sql.add_to_moulding_order(a, b)
def load_all_friends(home_username):
sql_instance = SQL()
results = sql_instance.get_friends(username=home_username)
friends = []
for friend in results:
friends.append(
Friend(username=friend[0],
user_id=friend[1],
first_name=friend[2],
last_name=friend[3]))
return friends
def fire_wheels():
next_kiln = SQL().get_setting('LAST_REAL_KILN_USED')
while True:
next_kiln = get_next_kiln(next_kiln)
params = SQL().get_kiln_params(next_kiln)
if int(params[1]) > 0:
break
fill_kiln(params[3])
with SQL() as s:
s.update_kiln_column_value(next_kiln, 'RUNS_LEFT', int(params[2]) - 1)
with SQL() as s:
s.update_setting('LAST_REAl_KILN_USED', next_kiln)
def getTable():
sql = SQL()
sql.connect()
data = request.get_json()
print(data)
tableName = data["table"]
page = int(data['page'])
if "currQuery" not in session:
session["currQuery"] = ""
query = session["currQuery"]
tableData = driver.get_table(sql, query, page, tableName)
return jsonify(tableData)
def __init__(self, siteid, headless=False):
"""
class Survey
"""
self.db = SQL()
self.siteid = siteid
self.headless = headless
self.file_path = os.path.dirname(os.path.abspath(__file__))
if self.db.validate_site_info(self.siteid):
self.url = self.db.get_site_url(siteid)
self.json_file = self.db.get_json_file(siteid)
self.init_driver()
self.run()
self.__del__()
def update_data(self, data):
# Parse input into dict, so we know all values are correctly specified
values = dict()
for x in range(0, len(data), 2):
values[data[x]] = data[x+1]
# Begin with the process
query = "SELECT actualiza(" + str(self.uid)
if 'user' in values and 'password' in values:
query += ", '" + values['user'] + "','" + values['password'] + "')"
elif 'user' in values:
query += ", '" + values['user'] + "', NULL)"
elif 'password' in values:
query += ", NULL, '" + values['password'] + "')"
else:
query += ", NULL, NULL)"
sql = SQL()
return sql.function(query)
def download_data(cls, freq, instr, symbols, outputsize=None, start=None):
po = Poloniex()
for symbol in symbols:
try:
param = cls.get_api_query(freq, symbol, start)
print('Downloading ' + symbol + ' data')
json = po.download_json(param, symbol)
print(symbol + ' data downloaded')
data = po.generate_tuple(json, symbol, instr, freq)
SQL.insert_price_data(data, freq)
print(symbol + ' data inserted in database')
except NameError:
print('Error while querying ' + symbol)
time.sleep(1)
SQL.remove_price_duplicates(freq)
print('Duplicates removed')
print('Done')
def __init__(self):
database = SQL()
database.loadChekInOutTable()
self.matriz = database.data_matrix
self.personal = sorted(jornada_personal.keys())
dates = database.dates
self.dates = [d for d in dates if d > datetime.date(2014, 1, 1)]
self.start_date = self.dates[0]
self.stop_date = self.dates[-1]
self.exceptions = None
self.workers_not_found = None
self.days_of_work = {} # contendrá los días de trabajo del archivo empaquetados en la clase Workday
self.validateCheck()
self.content = ()
self.thisday = DiasNoLaborables()
self.organizar_por_fecha()
def PayChecker():
while True:
users_db = SQL('users.db')
paylist = users_db.SelectPayUsers()
for i in paylist:
cht_id = i[0]
if (float(i[3]) * 10**-8) >= (float(i[6].split('_')[3])):
try:
paidout_value = str(
round(float(i[6].split('_')[3]) * 10**8) - 10)
print(paidout_value)
url = 'https://bitaps.com/api/use/redeemcode'
parameters = {
'redeemcode': str(i[2]),
'address': btc_adress,
'amount': 'All available',
'custom_fee': '50'
}
response = requests.post(url, data=json.dumps(parameters))
print(response.text)
tg.send_message(chat_id=i[0],
text='Payment received. Your adress: ')
temp = i[6].split('_')
f = open('text.txt', 'r+')
sold = open('sold.txt', 'a')
count = len(f.readlines())
f.seek(0)
for j in range(count):
line = f.readline()
if line.split('|')[:3] == temp[:3]:
f.seek(int(f.tell()) - len(line) - 1)
f.write(' ' * (len(line) - 1))
f.write('\n')
sold.write(line[:-1] + '* -' + time.ctime() + '\n')
sold.close()
tg.send_message(chat_id=cht_id, text=str(line))
f.close()
users_db.EditPayStatus(cht_id, 5)
break
except Exception as e:
tg.send_message(chat_id=i[0], text=e)
print('PAYCHECK')
time.sleep(10)
def add_user():
name = items['name'].get()
user_id = items['id'].get()
number = items['number'].get()
label = items['text_label']
if name != '' and user_id != '' and number != '':
result = SQL().user_operation(user_id, name, number)
if result:
print(SQL().get_users())
label.config(text='Новый пользователь ' + result + ' добавлен',
fg='green')
SQL().get_users()
else:
label.config(text='Такой пользователь уже есть ', fg='red')
else:
label.config(text='Не все поля заполнены')
def work_with_bonus(self, label, entry):
result = SQL().get_user(number=entry.get())
print(result)
if not result:
label.config(text='Такого пользователя нет')
return 0
else:
label.config(text='Пользователь найден')
def __init__(self):
self.table_name = 'articles'
self.sql = SQL()
self.tags = [('NOTICE', '通知'), ('SHOW', '展示'), ('EXP', '经验'),
('LOG', '日志')]
self.flags = [('ONLINE', '在线发布文档'), ('OFFLINE', '离线发布文档'),
('SYSTEM', '系统文档'), ('BACKUP', '备份文档')]
self.id = None
self.title = None
self.author = None
self.tag = None
self.flag = None
self.create_time = None
self.update_time = None
self.txt_markdown = None
self.txt_html = None
self.reading_times = None
self.admin_id = None
def test_insertTickerData(self):
from sql import SQL
s = SQL()
s.connect()
r = s.insertTickerData("TEST", 123.34, 1000, "2017-11-24 13:00:00")
s.close()
self.assertEqual(r, 1)
def fill_kiln(size):
kiln_state = []
wasted_fraction = []
firing_cycle = SQL().get_best_firing_cycle(mode='MOULDED')
for x in range(1, 8):
state, fraction = fill_shelf(x, firing_cycle, size)
kiln_state.append(state)
wasted_fraction.append(fraction)
#print kiln_state, wasted_fraction
return kiln_state
def start(self):
try:
SQL.add_user(self.user_id)
SQL.add_category('other',
self.user_id) # для несортированных расходов
SQL.add_category('income', self.user_id) # для доходов
SQL.add_category('fixed_income',
self.user_id) # для постоянных доходов
except Exception:
print("Unsuccessful, undefined error")
return 0
else:
return 1
def api_symbol_check(country=None, input_symbols=None):
if country is not None:
raw_data = SQL.get_symbols_per_country(country)
symbols = [item[0] for item in raw_data]
for symbol in symbols:
if symbol not in ['AC.PA', 'AI.PA', 'AIR.PA', 'AMS:MT', 'ATO.PA', 'CS.PA', 'BNP.PA', 'EN.PA', 'CAP.PA',
'CA.PA', 'ACA.PA', 'BN.PA', 'ENGI.PA', 'EI.PA', 'KER.PA', 'OR.PA', 'VTX:LHN', 'LR.PA',
'MC.PA', 'ML.PA', 'ORA.PA', 'RI.PA', 'UG.PA', 'PUB.PA', 'RNO.PA', 'SAF.PA', 'SGO.PA',
'SAN.PA', 'SU.PA', 'GLE.PA', 'SW.PA', 'SOLB.PA', 'STM.PA', 'FTI.PA', 'FP.PA', 'AMS:UL',
'FR.PA', 'VIE.PA', 'DG.PA', 'VIV.PA']:
import_data('Alpha Vantage', '1min', 'stock', [symbol], 'compact')
def __init__(self):
super(Trabajadores, self).__init__()
self.setupUi(self)
"""
self.tableWidget.setRowCount(10)
self.tableWidget.setColumnCount(10)
"""
self.trabajadores = SQL().personalShift
self.__row = 0
self.tableWidget.setRowCount(len(self.trabajadores.keys()))
for t, sch in self.trabajadores.items():
self.append([t, sch.capitalize()])
def __init__(self):
# Подключение SQL сервера, инициализация UI.
self.SQL_server, self.app = SQL('Diary'), QtWidgets.QApplication(sys.argv)
self.cursor, self.entered, self.main_window, self.ui, self.is_student, self.id, self.month_id = \
self.SQL_server.conn.cursor(), False, QtWidgets.QMainWindow(), \
Ui_Login(), True, 0, datetime.now().month
self.ui.setupUi(self.main_window)
self.main_window.show()
self.ui.button_enter.clicked.connect(self.login_button_pressed)
self.ui.button_register.clicked.connect(lambda: webbrowser.open("https://docs.google.com/forms/d/17OsG-ncuNbhOrxpRrUZKgSHclN2EpyKTEvcKgew-fng"))
locale.setlocale(locale.LC_ALL, ('RU', 'UTF8'))
self.main()
def update_kiln_data():
from sql import SQL
import openpyxl
wb = openpyxl.load_workbook('settings/kiln.xlsx')
sh = wb.active
with SQL() as sql:
sql.delete_kiln_data()
for x in range(2, sh.max_row + 1):
sql.add_kiln_params(
sh.cell(row=x, column=1).value,
sh.cell(row=x, column=2).value,
sh.cell(row=x, column=3).value)
def get_users(self):
conn = sqlite3.connect(DATABASE_LOCATION)
bliss = SQL(conn)
member_groups = bliss.all("SELECT group_id FROM node_group_links WHERE node_id=?", (self.node_id, ))
allowed_ids = []
for m in member_groups:
for u in bliss.all("SELECT user_id FROM node_group_permissions WHERE node_group_id=?", (m, )):
allowed_ids.append(bliss.one("SELECT access_id FROM users WHERE id=?", (u, )))
for u in bliss.all("SELECT user_id FROM node_permissions WHERE node_id=?", (self.node_id, )):
allowed_ids.append(bliss.one("SELECT access_id FROM users WHERE id=?", (u,)))
return allowed_ids
def loadBots(hash):
# Load all bots matching hash
bots = []
s = SQL()
s.connect()
rows = s.fetchBots(hash)
for r in rows:
#print("LOAD bot " + r['name'] + " --> " + r['data'])
lb = LongBot(r['name'], r['data'])
bots.append(lb)
s.close()
return bots
def update_results(self):
with SQL() as sql:
orders = sql.get_moulding_order()
if self.results_frame:
self.results_frame.destroy()
self.results_frame = table.DrawTable(self, len(orders), 2)
self.results_frame.pack(side="top", fill="x")
row = 0
for x in orders:
for i in range(0, 2):
self.results_frame.set(row, i, x[i])
row += 1
def fetch(freq):
fCnt = 0
if freq in ("hourly", "daily"):
# Do daily stuff
try:
s = SQL()
s.connect()
rows = s.fetchFromSource(freq)
http = urllib3.PoolManager()
#print("Fetch sources" + str(len(rows)))
for r in rows:
try:
cache = None
try:
cache = LongBot.getData(r['url'])
except Exception as e:
#print("Not in cache i guess")
None
if not cache:
print("INFO\tNot cached, loading " + r['url'])
res = http.request('GET', r['url'])
if res.status == 200:
Processor = getattr(
importlib.import_module("process_" +
r['handler']),
"Processor")
pres = Processor.process(str(res._body))
print(str(pres))
if pres['valid']:
LongBot.setData(pres['ticker'],
pres['last'])
fCnt = fCnt + 1
LongBot.setData(r['url'], True)
else:
print("WARN\tCould not download from " +
r['url'])
print(str(res._body))
else:
print("INFO\tCached, not loading " + r['url'])
fCnt = fCnt + 1
except Exception as e:
print("ERROR\t" + r['name'] + "\t" + str(e))
http.clear()
except Exception as e:
print(str(e))
finally:
s.close()
return fCnt
def BalanceUpdater():
while True:
users_db = SQL('users.db')
paylist = users_db.SelectAllUsers()
for i in paylist:
users_db.UpdateBalance(i[0], i[2])
if users_db.GetUser(i[0])[4] > i[4]:
tg.send_message(chat_id=i[0], text='Payment recived.')
users_db.EditPayStatus(i[0], 2)
print('BALANCECHECK')
time.sleep(15)
class YubiServeHandler:
def __init__(self, sql_connection, params, vclass):
self.sql = SQL(sql_connection)
self.params = params
self.vclass = vclass
def sign_message(self, answer, api_key):
data = ['%s=%s' % (k, v) for (k, v) in answer.iteritems()]
data.sort()
data = '&'.join(data)
otp_hmac = hmac.new(api_key, str(data), hashlib.sha1)
otp_hmac = base64.b64encode(otp_hmac.digest())
return otp_hmac
def build_answer(self, stat, answer, api_key=''):
answer['status'] = stat
answer['h'] = self.sign_message(answer, api_key)
data = '\r\n'.join(['%s=%s' % (k, v) for (k, v) in answer.iteritems()])
data += '\r\n'
return data
def do_validate(self):
answer = {'t': time.strftime("%Y-%m-%dT%H:%M:%S"), 'otp': ''}
# API id and OTP are required
if 'id' not in self.params or 'otp' not in self.params:
return self.build_answer(status.MISSING_PARAMETER, answer)
# ensure API id is valid
if not self.sql.select('get_api_secret', [self.params['id']]):
return self.build_answer(status.NO_SUCH_CLIENT, answer)
api_key = base64.b64decode(self.sql.result[0])
# do token validation
vclass = self.vclass(self.sql)
stat = vclass.set_params(self.params, answer)
if stat == status.OK:
stat = vclass.validate()
return self.build_answer(stat, answer, api_key)
def __init__(self, driver, uri=None, connection=None): # FIXME ugly hack
"""Initializing function
driver (string) - either 'SQLITE' or 'LDAP'
uri (string) - OPTIONAL The location of the SQLITE databse file or the
LDAP uri
connection (object) - OPTIONAL SQL Connection
"""
self.driver = driver
if driver not in self.__drivers:
self.driver = 'SQLITE'
if self.driver == 'SQLITE' and not connection:
sql_connection = connect_to_db(uri)
self.sql = SQL(sql_connection)
elif self.driver == 'SQLITE' and connection:
self.sql = connection
elif self.driver == 'LDAP':
self.ldap = LDAPConnection()
def show_grades(self):
sql = SQL()
sql._query_("SELECT user, password FROM user WHERE user_id = '" + str(self.uid) + "'")
data = sql.get_last_result()
self.sii.set_userdata(data['user'], data['password'])
return self.sii.get_grades()
def delete(self):
query = 'SELECT eliminar(' + str(self.uid) + ')'
sql = SQL()
return sql.function(query)
class Backend(object):
__drivers = ['SQLITE', 'LDAP']
def __init__(self, driver, uri=None, connection=None): # FIXME ugly hack
"""Initializing function
driver (string) - either 'SQLITE' or 'LDAP'
uri (string) - OPTIONAL The location of the SQLITE databse file or the
LDAP uri
connection (object) - OPTIONAL SQL Connection
"""
self.driver = driver
if driver not in self.__drivers:
self.driver = 'SQLITE'
if self.driver == 'SQLITE' and not connection:
sql_connection = connect_to_db(uri)
self.sql = SQL(sql_connection)
elif self.driver == 'SQLITE' and connection:
self.sql = connection
elif self.driver == 'LDAP':
self.ldap = LDAPConnection()
def get_key(self, userid):
"""Function that fetches the aeskey, internalname, counter and timestamp
from the data storage.
Params:
userid (string) - the userid (keyid) extracted from the OTP
Returns:
key (tuple) - (aeskey, internalname, counter, time) if the supplied
userid matches an entry in the Data Storage
"""
if self.driver == 'SQLITE':
if not self.sql.select('yubico_get_key', [userid]):
return status.BAD_OTP
aeskey, internalname, counter, time = self.sql.result
elif self.driver == 'LDAP':
dn, entry = self.ldap.search('yubico_get_key', [userid])[0]
aeskey = entry['aeskey'][0]
internalname = entry['internalname'][0]
counter = int(entry['counter'][0])
time = int(entry['time'][0])
return (aeskey, internalname, counter, time)
def update_counter(self, count, timestamp, userid):
"""Function that updates the counter in the data.
Params:
count (int) - the new count to updated
timestamp (int) - the timestamp from the otp
userid (string) - the userid for the key for which the counter has
to be updated.
"""
if self.driver == 'SQLITE':
self.sql.update('yubico_update_counter',
[count, timestamp, userid])
elif self.driver == 'LDAP':
dn, entry = self.ldap.search('yubico_get_key', [userid])[0]
self.ldap.update_d(dn, {'counter': str(count),
'time': str(timestamp)})
def get_user_keys(self, username):
"""LDAP only function that retrieves the keys of a user.
Params:
username (string) - the uid of the user in ldap
"""
if self.driver == 'LDAP':
dn, entry = self.ldap.search('get_keys', username)[0]
return entry['gluuOTPMetadata']
def update_key(self, username, key):
"""LDAP only function that updates the particular key of the user.
Params:
username (string) - the user whose key is to be updated
key (string) - the key dict as string with updated values
"""
dn, entry = self.ldap.search('get_keys', username)
# NOTE This way of updating restricts to one OTP key per person
self.ldap.update(dn, 'gluuOTPMetadata', key)
def __init__(self, sql_connection, params, vclass):
self.sql = SQL(sql_connection)
self.params = params
self.vclass = vclass
