def locator(url,formatItem):
if(
isinstance(url,basestring)
&isinstance(formatItem,formator.formator)
):
try:
context = []
UserAgent = 'Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US) AppleWebKit/525.13 (KHTML, like Gecko) Chrome/0.2.149.27 Safari/525.13'
header = {'User-Agent':UserAgent}
request = urllib2.Request(url,headers=header)
response = urllib2.urlopen(request)
context = response.read()
for relocator in formatItem.RELocator:
context = re.findall(relocator,context)
return context
except urllib2.URLError:
logger.error('URLError happened on url: %s'%url)
change={
'errorHandler':{
'url':url,
'description':'URL reading Error',
'errorTime': datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
}
}
database.db(change=change,method="insert")
else:
logger.error('Illegal data type for locator')
raise TypeError
def register_chrome():
chrome_info = {"channelId":request.forms.channelId,"email":request.forms.email,"token":request.forms.token}
if db().chrome_info.find_one({'email':request.forms.email})== None:
db().chrome_info.insert(chrome_info)
else:
db().chrome_info.update({'email':request.forms.email},chrome_info)
return "sucess"
def userinfo(userid):
session_id = request.get_cookie('session_id')
user_info = db().user_info.find_one({"token_hash":session_id})
# from nose.tools import set_trace;set_trace()
if user_info == None or user_info['id'] != userid:
redirect(config.LOGIN_URL)
attached_devices = db().attached_devices.find({"email":user_info['email']})
return json.loads(dumps({"user_info":user_info,"attached_devices":attached_devices}))
def index():
session_id = request.get_cookie('session_id')
if session_id == None:
redirect(config.LOGIN_URL)
user_info = db().user_info.find_one({"token_hash":session_id})
attached_devices = []
if user_info!=None:
attached_devices = db().attached_devices.find({"email":user_info['email']})
return json.loads(dumps({"attached_devices":attached_devices,"userinfo":user_info}))
else:
redirect(config.LOGIN_URL)
def addrecord_pressed(self):
validator = Valid()
if self.id == "category":
text = self.ui.Add("Добавить категорию")
if not self.valid(validator.validString(text)):
return
self.ui.recordlist.addItem(text)
database = db()
row = database.ins_upd(
"INSERT INTO refereecat(category) VALUES(\"" + text + "\")")
elif self.id == "position":
text = self.ui.Add("Добавить позицию")
if not self.valid(validator.validString(text)):
return
self.ui.recordlist.addItem(text)
database = db()
row = database.ins_upd(
"INSERT INTO refereepos(position) VALUES(\"" + text + "\")")
elif self.id == "region":
text = self.ui.Add("Добавить регион")
if not self.valid(validator.validString(text)):
return
self.ui.recordlist.addItem(text)
database = db()
row = database.ins_upd("INSERT INTO region(region) VALUES(\"" +
text + "\")")
elif self.id == "weight":
text = self.ui.Add("Добавить весовую категорию")
if not self.valid(validator.validString(text)):
return
self.ui.recordlist.addItem(text)
database = db()
row = database.ins_upd(
"INSERT INTO weightcategory(wcategory) VALUES(\"" + text +
"\")")
def __init__(self, update=False):
super(AddMemberDialog, self).__init__()
self.id = 0
self.ui = AddMemberSlots()
self.ui.setupUi(self)
self.ui.addButton.clicked.connect(self.add_pressed)
self.ui.updateButton.clicked.connect(self.update_pressed)
self.ui.cancelButton.clicked.connect(self.cancel_pressed)
'''# TODO: заполнить списки выбора'''
database = db()
row = database.select("SELECT * FROM sex")
for i in row:
self.ui.sexCBox.addItem(i[1])
row = database.select("SELECT * FROM weightcategory")
for i in row:
self.ui.weightcatCBox.addItem(i[1])
row = database.select("SELECT * FROM category")
for i in row:
self.ui.categoryCBox.addItem(i[1])
if update:
self.ui.addButton.hide()
self.setWindowTitle("Изменить данные спортсмена")
else:
self.ui.updateButton.hide()
self.setWindowTitle("Добавить спортсмена")
return
def esc_auto(self):
# Banco de dados
try:
self.data = db()
except:
print("Erro no Banco de Dados")
quit()
print('Lendo arquivos')
if len(sys.argv) <= 1:
print('Falta arquivo "estação"')
quit()
if not self.read_auto():
quit()
# Primeiro sabado
self.sabado()
# Gera tabela
print('Gerando tabela')
self.gera_tabela()
print('Criando planilha')
gera_xls(self.escala)
print ("\nArquivo gerado no diretorio: ", self.escala[0][0])
self.pdf()
print ("PDF criado")
def edit_pressed(self):
# Get data from row
editable_row = self.ui.tableWidget.currentRow()
col = 0
col_count = self.ui.tableWidget.columnCount()
items = []
while col < col_count:
items.append(self.ui.tableWidget.item(editable_row, col).text())
col += 1
edit_members = AddMemberDialog(True)
edit_members.edit_member(items)
edit_members.exec_()
'''# TODO: Неправильно работает, проверить'''
# Get new data from base
database = db()
row = database.select("SELECT members.id, members.fio, members.bday, sex.sex, weightcategory.wcategory, category.category, members.club, members.region, members.city, members.trainer FROM members, sex, weightcategory, category WHERE members.id=\"" + str(items[0]) + "\" AND members.sex=sex.id AND members.weight=weightcategory.id AND members.category=category.id")
for i in row:
col =0
for y in i:
newitem = QtWidgets.QTableWidgetItem(re.sub(r'\\', r'', str(y)))
newitem.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.ui.tableWidget.setItem(editable_row, col, newitem)
self.ui.tableWidget.resizeColumnToContents(col)
col += 1
return
def edit_pressed(self):
# Get data from row
editable_row = self.ui.tableWidget.currentRow()
col = 0
col_count = self.ui.tableWidget.columnCount()
items = []
while col < col_count:
items.append(self.ui.tableWidget.item(editable_row, col).text())
col += 1
edit_referee = AddRefereeDialog(True)
edit_referee.edit_referee(items)
edit_referee.exec_()
# Get new data from base
database = db()
row = database.select(
"SELECT referee.id, referee.fio, refereepos.position, region.region, refereecat.category FROM referee, refereepos, region, refereecat WHERE referee.id=\""
+ str(items[0]) +
"\" AND referee.position=refereepos.id AND referee.region=region.id AND referee.category=refereecat.id"
)
for i in row:
col = 0
for y in i:
newitem = QtWidgets.QTableWidgetItem(str(y))
self.ui.tableWidget.setItem(editable_row, col, newitem)
self.ui.tableWidget.resizeColumnToContents(col)
col += 1
return
def add_pressed(self):
self.fio = self.ui.fioEdit.text()
database = db()
''' TODO: при добавлении id из связанных таблиц проверять соответсвие текста и id'''
# TODO: упростить вызов базы данных (вместо трех селектов добавить их в insert)
self.position = database.select(
"SELECT id FROM refereepos WHERE \"position\"=\"" +
self.ui.positionList.itemText(
self.ui.positionList.currentIndex()) + "\"")
self.region = database.select(
"SELECT id FROM region WHERE \"region\"=\"" +
self.ui.regionList.itemText(self.ui.regionList.currentIndex()) +
"\"")
self.category = database.select(
"SELECT id FROM refereecat WHERE \"category\"=\"" +
self.ui.categoryList.itemText(
self.ui.categoryList.currentIndex()) + "\"")
database.ins_upd(
"INSERT INTO referee(fio, position, region, category) VALUES(\"" +
self.fio + "\", " + str(self.position[0][0]) + ", " +
str(self.region[0][0]) + ", " + str(self.category[0][0]) + ")")
self.ui.positionList.setCurrentIndex(0)
self.ui.regionList.setCurrentIndex(0)
self.ui.categoryList.setCurrentIndex(0)
self.ui.fioEdit.clear()
return
def __init__(self, update=False):
super(AddRefereeDialog, self).__init__()
self.id = 0
self.ui = AddRefereeSlots()
self.ui.setupUi(self)
self.ui.add.clicked.connect(self.add_pressed)
self.ui.cancel.clicked.connect(self.cancel_pressed)
self.ui.update.clicked.connect(self.update_pressed)
'''TODO: заполнить списки выбора'''
database = db()
row = database.select("SELECT * FROM refereepos")
for i in row:
self.ui.positionList.addItem(i[1])
row = database.select("SELECT * FROM region")
for i in row:
self.ui.regionList.addItem(i[1])
row = database.select("SELECT * FROM refereecat")
for i in row:
self.ui.categoryList.addItem(i[1])
if update:
self.ui.add.hide()
self.setWindowTitle("Update referee")
else:
self.ui.update.hide()
self.setWindowTitle("Add referee")
def process_database_file(path_manager):
# loads in data file from the selected database directory
data_filename = path_manager.find_files(path_manager.get_current_selected_dir(), ".data")[0]
full_data_path = os.path.join(path_manager.get_current_selected_dir(), data_filename)
current_db_file = open(full_data_path, 'r')
db_data = []
for line in current_db_file:
# Converts the string line from the file into a set of values.
db_data.append(csv_to_set(line))
current_db_file.close()
if len(db_data[-1]) < 0:
db_data.pop()
elif db_data[-1][0] is "" and len(db_data[-1]) is 1:
db_data.pop()
attributes, classifier_column, classifier_attr_cols, missing_symbol = read_attributes(path_manager.get_current_selected_dir(), data_filename)
return db(db_data, attributes, classifier_column, classifier_attr_cols, missing_symbol)
def __init__(self,
db_name='plantdb',
port_list=['/dev/ttyACM0', '/dev/ttyACM1', '/dev/ttyACM2'],
grace=3):
'''
Initialise the Arduino interface, and connect to a database to store
the readings.
'''
serial_port = self.find_available_port(port_list)
if serial_port == None:
print port_list, 'were not available'
return
self.arduino = Arduino(serial_port)
self.db = database.db(db_name)
self.db.init_db()
self.db_up_to_date = False
print "Grace period for Arduino (", grace, " seconds)"
for _ in range(grace):
time.sleep(1)
print '.'
def __init__(self):
self.log = logging.getLogger(__name__)
self.log.setLevel(logging.DEBUG)
self.createCOM()
self.db = database.db()
def __init__(self, username, password):
self.db = db('aman', '192.168.56.102', 'hacker123', 'ARMS')
self.username = username
self.secret = password
self.authenticated = False
self.auth()
self.get_details()
self.get_devices()
def join_event():
username = request.json['user']
eventID = request.json['eventID']
email = request.json['email']
db = database.db('StudyGroups.db')
db.join_event(eventID, username, email)
db.close()
return '200'
def initializePortfolioAndMarket():
globals m,p,dba,sim_uuid
#initialize portfolio & market
sim_uuid=uuid.uuid1().hex
dba=db(sim_uuid,'r+')
m=stock_market(dba,0,refDix,False,portfolioValue)
p=investments(0,m,refDix,dba,sim_uuid,portfolio,cash)
def add_pressed(self):
database = db()
validator = Valid()
self.fio = self.ui.fioEdit.text()
bday_temp = self.ui.dateEdit.date()
self.bday = bday_temp.toPyDate()
self.sex = database.select(
"SELECT id FROM sex WHERE sex=\"" +
self.ui.sexCBox.itemText(self.ui.sexCBox.currentIndex()) + "\"")
self.weight = self.ui.weightcatCBox.itemText(
self.ui.weightcatCBox.currentIndex())
self.weightid = database.select(
"SELECT id FROM weightcategory WHERE wcategory=\"" +
self.ui.weightcatCBox.itemText(
self.ui.weightcatCBox.currentIndex()) +
"\"") # self.ui.weightEdit.text()
self.category = database.select(
"SELECT id FROM category WHERE category=\"" +
self.ui.categoryCBox.itemText(
self.ui.categoryCBox.currentIndex()) + "\"")
# if not self.valid(validator.validDigit(self.weight)):
# return
#self.category = self.ui.categoryEdit.text()
self.club = self.ui.clubEdit.text()
self.trainer = self.ui.trainerEdit.text()
self.region = self.ui.regionEdit.text()
self.city = self.ui.cityEdit.text()
if not (self.valid(
validator.validSString(self.fio, self.weight, self.club,
self.trainer, self.region, self.city))):
return
# TODO: сделать проверку корректности введенных данных QValidator
'''# TODO: настроить фокус на поле'''
database.ins_upd(
'INSERT INTO members(fio, bday, sex, weight, category, club, trainer, region, city) VALUES (\''
+ validator.escape(self.fio) + '\', \'' +
self.bday.strftime('%Y-%m-%d') + '\', \'' + str(self.sex[0][0]) +
'\', \'' + str(self.weightid[0][0]) + '\', \'' +
str(self.category[0][0]) + '\', \'' + validator.escape(self.club) +
'\', \'' + validator.escape(self.trainer) + '\', \'' +
validator.escape(self.region) + '\', \'' +
validator.escape(self.city) + '\')')
self.ui.fioEdit.clear()
self.ui.dateEdit.setDate(QtCore.QDate())
self.ui.sexCBox.setCurrentIndex(0)
# self.ui.weightEdit.clear()
# self.ui.categoryEdit.clear()
self.ui.clubEdit.clear()
self.ui.trainerEdit.clear()
self.ui.regionEdit.clear()
self.ui.cityEdit.clear()
self.ui.fioEdit.setFocus()
return
def __init__(self):
try:
self.db = db()
if db is None: raise Exception('No connection. Please, check your config.json or Postgre server')
except Exception as err:
print("Connection error! ", err)
exit(1)
def read(class_, id):
"""Return an instance of `class_`."""
session = db().session()
object_ = session.query(class_).get(id)
if object_ is None:
msg = "{} {} not found.".format(class_, id)
raise NoResultFound(msg)
return object_
def read(class_, id):
"""Return an instance of `class_`."""
session = db().session()
object_ = session.query(class_).get(id)
if object_ is None:
msg = "{} {} not found.".format(class_, id)
raise NoResultFound(msg)
return object_
def main_page():
with open("./config.json", "r", encoding='utf8') as read_file:
data = json.load(read_file)
if not data['shf'] == 'Yes':
if request.method == 'POST' and request.form.get('password'):
login = request.form.get('login')
password = request.form.get('password')
code = str(request.form.get('code'))
db = database.db('main.db')
if db.check_user({'login':login}):
if db.get_user_password(login) == password:
if not propperties.OTP:
cid = (str(uuid.uuid4())+str(uuid.uuid4())+str(uuid.uuid4())).replace('-','')
db.create_auth({'cid':cid,'login':login})
resp = redirect("/dashboard")
resp.set_cookie('sessionID', cid, max_age = 60*60*24*365)
return resp
totp = pyotp.TOTP(db.get_user_gaseed(login)[0][0])
otp = totp.now() == code
#print(totp.now())
if otp:
cid = (str(uuid.uuid4())+str(uuid.uuid4())+str(uuid.uuid4())).replace('-','')
db.create_auth({'cid':cid,'login':login})
resp = redirect("/dashboard")
resp.set_cookie('sessionID', cid, max_age = 60*60*24*365)
return resp
else:
resp = redirect("/login")
return resp
else:
resp = redirect("/login")
return resp
else:
resp = redirect("/login")
return resp
if not request.cookies.get('coockieid'):
resp = redirect("/setid")
resp.set_cookie('coockieid', str(uuid.uuid4()).split('-')[0], max_age = 60*60*24*365)
return(resp)
elif request.cookies.get('sessionID'):
resp = redirect("/dashboard")
return resp
else:
return render_template('login.html',projectname=propperties.PROJECTNAME,coockieid=str(request.cookies.get('coockieid')),image="bg{}.png".format(random.randint(1, 6)))
else:
return render_template('shf.html',projectname=propperties.PROJECTNAME,coockieid=str(request.cookies.get('coockieid')),image="bg{}.png".format(random.randint(1, 6)))
def add_event():
EventNames = request.json['EventName']
name = request.json['Name']
area = request.json['Area']
date = request.json['DateTime']
email = request.json['Email']
description = request.json['Description']
db = database.db('StudyGroups.db')
db.add_event(EventNames, name, area, date, email, description)
db.close()
return '200'
def __init__(self):
# system
self.__process = {}
self.__MemTotal = None
self.__MemFree = None
self.__Minor = None
self.__Major = None
self.__Version = None
self.__Kernel = None
self.__Disk = None
self.__ClockTicksPerSecond = None
self.__Cpu_usage = []
self.__cpu_total_time = 0
self.__cpu_idle_time = 0
self.__cpu_user_time = 0
self.__Cpu_user_usage = []
self.__cpu_sys_time = 0
self.__Cpu_sys_usage = []
self.__receivebytes = []
self.__last_receivebytes = 0
self.__receivepackets = []
self.__last_receivepackets = 0
self.__sendbytes = []
self.__last_sendbytes = 0
self.__sendpackets = []
self.__last_sendpackets = 0
#process
self.__Name = None
self.__Pid = None
self.__Started_at = None
self.__Executable = None
self.__Current_dir = None
self.__State = None
self.__User_time = None
self.__System_time = None
self.__VmSize = None
self.__VmRSS = None
self.__Threads = None
self.__Priority = None
self.__Nice = None
self.__response = []
self.__Process_cpu_usage = []
self.__proc_cpu_total_time = 0
self.__proc_cpu_use_time = 0
self.__proc_cpu_user_time = 0
self.__proc_cpu_user_usage = []
self.__proc_cpu_sys_time = 0
self.__proc_cpu_sys_usage = []
#Thread
self.__thread_cpu_total_time = 0
self.__thread_cpu_use_time = 0
self.__ip_db = database.db()
def main ():
config = ConfigParser.SafeConfigParser()
config.read('config.cfg')
Account = twitter.Api(username = config.get('user', 'name'), password = config.get('user', 'password'))
Account.PostUpdate('test')
data = database.db(config.get('file', 'database'))
data.join('matthewfl', 'something')
C = controler(Account, data)
def reg():
if request.method == 'POST' and request.form.get('password') and not request.form.get('otpk'):
login = request.form.get('login')
password = request.form.get('password')
db = database.db('main.db')
if not db.check_user({'login':login}):
otpk = db.create_user({'login':login,'pass':password})
img = qrcode.make(pyotp.totp.TOTP(request.form.get('otpk')).provisioning_uri("{}".format(login), issuer_name="Dashboard"))
img.save('./static/users/qrs/{}.png'.format(request.form.get('login')))
return render_template('register_qr.html',projectname='Astra',coockieid=request.cookies.get('coockieid'), qr = './static/users/qrs/{}.png'.format(request.form.get('login')),image="bg{}.png".format(random.randint(1, 6)))
return render_template('register.html',projectname='Astra',coockieid=request.cookies.get('coockieid'),image="bg{}.png".format(random.randint(1, 6)))
def __init__(self):
self.db = database.db()
self.trustedClientKeys = []
with open(KEYFILE, "r") as f:
keyfiles = f.read()
keyfiles = keyfiles.replace(
"\r", "") # Tribute to Microsoft. Just in case...
keyfiles = keyfiles.split("\n")
for f in keyfiles:
if f.endswith(".pem"):
self.trustedClientKeys.append(cryptostuff.loadKey(f, False))
def __init__(self,
minTraining,
cutoffdix,
train_uuid,
offset,
trainAll=True):
self.cutoffdix = cutoffdix
self.train_uuid = train_uuid
self.dba = db(self.train_uuid, 'r+')
self.offset = offset
self.trainAll = trainAll
self.minTraining = minTraining
def __init__(self, id=''):
super(RecordDialog, self).__init__()
self.id = id
self.ui = CreateRecordSlots()
self.ui.setupUi(self)
self.ui.add.clicked.connect(self.addrecord_pressed)
self.ui.cancel.clicked.connect(self.cancel_pressed)
'''# TODO: Заполнить список категорий'''
if self.id == "category":
self.setWindowTitle("Список судейских категорий")
database = db()
row = database.select("SELECT * FROM refereecat")
for i in row:
self.ui.recordlist.addItem(i[1])
elif self.id == "position":
self.setWindowTitle("Список должностей судей")
database = db()
row = database.select("SELECT * FROM refereepos")
for i in row:
self.ui.recordlist.addItem(i[1])
elif self.id == "region":
self.setWindowTitle("Список регионов")
database = db()
row = database.select("SELECT * FROM region")
for i in row:
self.ui.recordlist.addItem(i[1])
elif self.id == "weight":
self.setWindowTitle("Список весовых категорий")
database = db()
row = database.select("SELECT * FROM weightcategory")
for i in row:
self.ui.recordlist.addItem(i[1])
def create(class_, object_dict):
"""Return a newly created instance of `class_`."""
session = db().session()
object_ = class_(**object_dict)
try:
session.add(object_)
session.commit()
except:
print "Session rollback"
session.rollback()
object_ = None
return object_
def create(class_, object_dict):
"""Return a newly created instance of `class_`."""
session = db().session()
object_ = class_(**object_dict)
try:
session.add(object_)
session.commit()
except:
print "Session rollback"
session.rollback()
object_ = None
return object_
def __init__(self):
try:
self.data = db()
except:
print("Erro no Banco de Dados")
quit()
self.ests = {}
if len(sys.argv) <= 2:
self.read_input()
else:
self.read_input(sys.argv[1], int(sys.argv[2]))
def remove(self, id):
"""Remove a feed """
db = database.db()
db.connect()
# Removes from the feeds list
query = "delete from %s where id=?" % (self.FEEDS_TABLE)
db.cursor.execute(query, (id,))
db.conn.commit()
# Removes from the feed queue
query = "delete from %s where id=?" % (self.QUEUE_TABLE)
db.cursor.execute(query, (id,))
db.conn.commit()
db.close()
def main():
config = c(os.path.join(os.getcwd(), "scripts", "unflaired",
"config.toml"))
reddit = r(config.reddit_config())
database = db(config.db_config())
while True:
submissions = reddit.return_new_instance()
for submission in submissions:
if (reddit.check_submission_time(submission)
and reddit.check_submission_flair(submission)
and database.check(submission.id)):
reddit.report_submission(submission)
database.write(submission.id)
reddit.new_time()
def main(argv):
# Spawn a new database instance
instance = database.db()
# Create tables if they don't exist
instance.createTables()
if len(argv) > 1:
if argv[1] == 'plotly':
# Upload data to plotly
dump = instance.readTable()
plotly_upload.upload(dump)
elif argv[1] == 'gspread':
# Upload data to google
#spreadsheet = gspread.gspread()
#spreadsheet.write_sheet()
pass
elif argv[1] == 'calibrate':
# Calibrate BMP180 barometer
sensors.calibrateBMP()
elif argv[1] == 'export':
# Dump data to CSV & JSON files
with open('sensors.csv', 'wb') as csvfile:
dump = instance.readTable()
writer = csv.writer(csvfile)
writer.writerows(dump)
csvfile.close()
keys = [
'id', 'timestamp', 'cpu_temp', 'ds_temp', 'dht_humi',
'dht_temp', 'bmp_temp', 'bmp_pres', 'bmp_alti', 'bmp_slps'
]
csvfile = open('sensors.csv', 'r')
jsonfile = open('/home/pi/pi-station/www/sensors.json', 'w')
reader = csv.DictReader(csvfile, keys)
out = json.dumps([row for row in reader])
jsonfile.write(out)
jsonfile.close()
csvfile.close()
return None
elif argv[1] == 'read':
datetime = sensors.getDateTime()
ds = sensors.readDS()
bmp = sensors.readBMP()
dht = sensors.readDHT()
print datetime, ds, bmp, dht
else:
print "Unknown option."
else:
ReadSensors(instance)
def google_callback():
code = request.query.get('code')
if not code:
redirect('/google/login/error')
credential = config.FLOW.step2_exchange(code)
http = httplib2.Http()
http = credential.authorize(http)
user_info_service = build('oauth2','v2',http=http)
user_info = user_info_service.userinfo().get().execute()
# resp, content = http.request("https://www.googleapis.com/oauth2/v1/userinfo?alt=json", "GET")
if user_info and user_info.get('id'):
credential_dict = json.loads(credential.to_json())
user_info.update({'access_token':credential_dict['access_token'],'token_hash':credential_dict['id_token']['token_hash']})
if db().user_info.find_one({'id':user_info.get('id')}) == None:
db().user_info.insert(user_info)
else:
db().user_info.update({'id':user_info.get('id')},user_info)
response.set_cookie('session_id', credential_dict['id_token']['token_hash'])
redirect('/')
else:
return 'user auth error'
def main():
db = database.db(cfg.database_url)
db.create_all()
app = Application([
url(r'^/api2/data/([^/]+)/?$', notes_handler), # get/update/del note
url(r'^/api2/data/([^/]+)/(\d+)/?$', notes_handler), # note version
url(r'^/api2/data/?$', notes_handler), # create note
url(r'^/api2/index/?$', index_handler), # note index
url(r'^/api2/tags/?$', tags_index_handler), # tags index
url(r'^/api2/tags/(.+)$', tags_handler), # get/update/del tag
url(r'^/api/login/?$', login_handler), # login methods
],
debug=cfg.debug,
db=db
)
app.listen(cfg.listen_port, address=cfg.listen_host)
tornado.ioloop.IOLoop.current().start()
def add(self, url):
"""Add a feed to fetch
>>> f = Feed()
>>> f.add("http://www.gamers.fr/rss/actus")
>>> db = database.db()
>>> db.connect()
>>> db.cursor.execute("select * from feeds")
<sqlite3.Cursor object at 0x...>
>>> db.cursor.fetchall()
[(1, u'Gamers.fr - Actus', u'http://www.gamers.fr/', u'http://www.gamers.fr/rss/actus', 60)]
"""
d = feedparser.parse(url)
# There's no feed at this url
if 'title' not in d.feed:
return False
title = d.feed.title
website_url = d.feed.get('link', 'http://perdu.com')
feed_url = url
if d.status == 301:
feed_url = d.href
interval = d.feed.get('ttl', self.DEFAULT_TTL)
db = database.db()
db.connect()
# Add into feeds list
query = """insert into %s
(title, website_url, feed_url, interval)
values (:title, :website_url, :feed_url, :interval)""" % (self.FEEDS_TABLE)
db.cursor.execute(query, (title, website_url, feed_url, interval))
db.conn.commit()
# Add into feeds queue
query = """insert into %s
(id, last_etag, last_modified, last_checked, next_refresh)
values (:id, :last_etag, :last_modified, :last_checked, :next_refresh)""" % (self.QUEUE_TABLE)
db.cursor.execute(query, (db.cursor.lastrowid, "", "", "", ""))
db.conn.commit()
db.close()
def download_pageviews():
"""
New URL: http://dumps.wikimedia.org/other/pagecounts-raw/2011/2011-12/
Complele URL: http://dumps.wikimedia.org/other/pagecounts-raw/2011/2011-12/pagecounts-20111201-000000.gz
"""
today = datetime.datetime.today()
url = "%s/%s/%s-%s/" % ("http://dumps.wikimedia.org/other/pagecounts-raw", today.year, today.year, today.month)
text = urllib2.urlopen(url).read()
urls = re.findall('a href\="pagecounts\-(.*?)\.gz"', text)
db = database.db()
coll = db.get_collection("meta")
# value = re.compile('%s%s%s-([0-9]){6}' % (today.year, today.month,today.day))
cursor = coll.find()
fetched = []
total = cursor.count()
for x in xrange(0, total):
fetched.append(cursor[x])
# fetched=[x.strip() for x in file(FETCHED_FILE).readlines()]
missing = filter(lambda (x): not hash(x) in fetched, urls)
if settings.DEBUG:
missing = missing[0:1]
coll = db.get_collection("meta")
for i in missing:
name = "pagecounts-%s.gz" % i # .replace("-","_")#[:-4]
remote_file = "%s%s" % (url, name)
print "Downloading %s" % remote_file
success = fecthdata(remote_file, today)
if success:
coll.insert({hash(url): 1})
def update(class_, id, updated_dict):
"""Return an updated instance of `class_`."""
session = db().session()
object_ = class_.read(id)
try:
session.add(object_)
# update the object with the new attributes
for k, v in updated_dict.items():
# only update attributes that have changed
try:
if getattr(object_, k) != v:
setattr(object_, k, v)
except AttributeError:
setattr(object_, k, v)
session.commit()
except:
print "Session rollback"
session.rollback()
object_ = None
return object_
def fecthdata(url, date):
success = False
request = urllib2.Request(url)
request.add_header("Accept-encoding", "gzip,deflate")
response = urllib2.urlopen(request)
# make sure the response is compressed
isGZipped = response.headers.get("content-type", "").find("gzip") >= 0
if not isGZipped:
raise Exception("%s is not a valid gz file." % url)
d = zlib.decompressobj(16 + zlib.MAX_WBITS)
last_row = []
dr = "%s-%s" % (date.year, date.month)
content_length = int(response.headers.get("content-length", -1))
mongo_delta = 0
records = 0
total_records = 0
transferred = 0
db = database.db()
coll = db.get_collection("pageviews")
coll.ensure_index("hash")
while True:
data = response.read(settings.READ_BLOCK_SIZE)
transferred += len(data)
if not data:
# this just assumes that everything went smooth, needs probably some more tests
success = True
break
else:
# make a file like thing of the read bytes
data = d.decompress(data)
start = time.time()
data = data.split("\n")
if last_row != []:
ws = 0
ws += last_row.count(" ") + data[0].count(" ")
if ws == 3:
data[0] = "".join([last_row, data[0]])
else:
data[0] = " ".join([last_row, data[0]])
last_row = data[-1]
last_row = last_row.split()
if len(last_row) != 4 or (len(last_row) == 4 and not last_row[-1].endswith("\n")):
last_row = " ".join(last_row)
data = data[:-1]
else:
last_row = []
data = transform_data(data, date)
records += len(data)
batch_new, batch_update = split_data(coll, data)
if batch_new != []:
coll.insert(batch_new)
for dat in batch_update:
# print dat
key = "date.%s" % dr
# db.pageviews.update({'hash': dat['hash']}, { "$inc": {key:dat['date'][dr]}}).explain()
coll.update({"hash": dat["hash"]}, {"$inc": {key: dat["date"][dr]}})
# print 'done'
# print coll.find({'hash':dat['hash']}).explain()
mongo_delta += time.time() - start
if settings.DEBUG:
if records > 10000:
total_records += records
records = 0
print "Downloaded %s Kb (%s%%), processing speed: %s (avg. # records/sec), total records: %s" % (
transferred / 1024,
((transferred / 1024) / content_length) * 100,
total_records / mongo_delta,
total_records,
)
return success
import paho.mqtt.client as mqtt
import time
from config import *
from database import db
client=mqtt.Client()
db_obj = db('muthoot')
def on_connect(client,userdata,rc):
print "\nNode Connected to broker. rc=%d\n\n" %(rc)
client.subscribe("wa/node1")
def on_message(client,userdata,msg):
data = msg.payload
data = db_obj.parseData(data)
db_obj.insert(data)
print 'Packet recvd; Time: ',data['time']
def on_disconnect(client,userdata,rc):
print "Disconnected..rc=%d" %(rc)
def node():
client.on_connect = on_connect
client.on_message = on_message
client.on_disconnect = on_disconnect
client.connect(broker,1883,60)
client.loop_start()
while True:
pass
import paho.mqtt.client as mqtt
from database import db
import time
while True:
try:
db_sw = db("sw")
db_light = db("light")
break
except Exception as e:
print e
time.sleep(0.5)
prev_light_status = db_light.fetch()
#broker = "192.168.1.5"
broker = "test.mosquitto.org"
try:
print "\t%s" %(prev_light_status)
except Exception, e:
print e
def on_connect(client,userdata,rc):
print "\nNode Connected to broker. rc=%d\n\n" %(rc)
client.subscribe("wa/thread1/publish")
def on_message(client,userdata,msg):
global prev_light_status
cur_light_status = msg.payload
def orm(self):
return database.db()
def start():
fridge = database.db("fridge.db")
log = login.login
accounts = accountManagament.accountManagament
accounts.add_new_account(fridge,"benjamin","clarke","password","admin")
def get_database(self):
return db()
################################################################################
#
# Copyright 2015 Crown copyright (c)
# Land Information New Zealand and the New Zealand Government.
# All rights reserved
#
# This program is released under the terms of the new BSD license. See the
# LICENSE file for more information.
#
################################################################################
import database
import re
import sys
db = database.db()
dbc = db.cursor()
dbc.execute('set search_path=gazetteer_web, public')
def update_config_item( code, value, description="Description not available" ):
vfield = 'intval' if type(value) == int else 'value'
dbc.execute("select count(*) from gaz_web_config where code=%s",(code,))
if dbc.fetchone()[0]:
dbc.execute("update gaz_web_config set "+vfield+"=%s where code=%s",(value,code))
else:
dbc.execute("insert into gaz_web_config(code,description,"+vfield+") values (%s,%s,%s)",(code,description,value))
db.commit()
try:
with open('web_config/gazetteer_help.html') as hf:
help = hf.read()
import time
from database import db
try:
import led
except Exception, e:
print e
print "Importing led_dummy!!"
import led_dummy as led
client=mqtt.Client() # Global declaration
while True:
try:
db_obj=db("rpi")
break
except Exception as e:
print e
time.sleep(0.5)
stopThread = threading.Event()
broker = "192.168.1.5"
#broker = "test.mosquitto.org"
def on_connect(client,userdata,rc):
print "\nNode Connected to broker. rc=%d\n\n" %(rc)
client.subscribe("wa/thread2/publish")
def on_message(client,userdata,msg):
import getpass
import database
from database import User
import config
db = database.db(config.database_url)
# get username
email = input("Enter username or email address: ")
# get password
password = None
while True:
pass1 = getpass.getpass("Enter new password: "******"Enter password again: ")
if pass1 == pass2:
if len(pass2) < 2: # TODO: expand this to 8+ characters
print("Password should be at least 2 characters!")
else:
password = pass2
break
else:
print("Passwords didn't match!")
user = db.create_user(email, password)
print(user)
