def main():
print("start")
dbname = 'h28_30.db'
conn = sqlite3.connect(dbname)
cur = conn.cursor()
df1 = psql.read_sql(
"SELECT * FROM sample WHERE 発生年 = 2016 AND 甲_年齢 IN ('65～74歳', '75歳以上')",
conn)
print("df1 finished")
m1 = m.MarkClass(df1, 'blue', '2016')
m1.marker()
df2 = psql.read_sql(
"SELECT * FROM sample WHERE 発生年 = 2017 AND 甲_年齢 IN ('65～74歳', '75歳以上')",
conn)
m2 = m.MarkClass(df2, 'red', '2017')
m2.marker()
df3 = psql.read_sql(
"SELECT * FROM sample WHERE 発生年 = 2018 AND 甲_年齢 IN ('65～74歳', '75歳以上')",
conn)
m3 = m.MarkClass(df3, 'green', '2018')
m3.marker()
df4 = psql.read_sql(
"SELECT * FROM sample WHERE 甲_年齢 IN ('65～74歳', '75歳以上')", conn)
m4 = m.MarkClass(df4, '', 'all')
m4.marker()
cur.close()
conn.close()
def patch(self):
requestedArgs = getArguments([
'markId', 'classeId', 'studentId', 'teacherId', 'value', 'date',
'creationTime'
])
args = requestedArgs.parse_args()
mark = Mark.getMarksByMarkId(self.session, args['markId'])[0]
mark = dict_as_obj(args, mark)
return Mark.updateMark(self.session, mark)
def Run(self):
if self.ssSwich == 0 and self.dbSwitch == 0:
Log.war(
"No Function is running!Please check 'config.ini' to open switch!"
)
pass
else:
list = Utils.GetFileList(self.logPath, [])
count = len(list)
if len(list) > 0:
Log.info(">>>Run")
Log.info("find %s files" % (count))
else:
Log.info("%s is empty" % (self.logPath))
return
for e in list:
if os.path.isfile(e) and ('.now' in e) > 0:
pass
else:
if os.path.isfile(e) and ('.log' in e) > 0:
#u'D:\\Src\\MCWY_30001_1_CONSUME_2016-11-01-21-20.log'
nA = e.rfind('\\') + 1
strA = e[nA:-10]
nReadReturn = self.ReadFile(e)
if nReadReturn > 0:
desPath = self.backupPath + '\\' + strA
if not os.path.exists(desPath):
os.makedirs(desPath)
else:
pass
if os.system("copy %s %s" % (e, desPath)) == 0:
os.remove(e)
Mark.deleteMark()
else:
pass
elif nReadReturn < 0:
errDir = self.errPath + '\\' + strA
if not os.path.exists(errDir):
os.makedirs(errDir)
else:
pass
if os.system("copy %s %s" % (e, errDir)) == 0:
os.remove(e)
else:
pass
pass
elif nReadReturn == 0:
Log.war(
"No Function is running!Please check 'config.ini' to open switch!"
)
pass
else:
pass
Log.info(">>>Stop")
def get(self):
requestedArgs = getArguments([
'cmd', 'markId', 'classeId', 'studentId', 'teacherId', 'value',
'date', 'creationTime'
])
args = requestedArgs.parse_args()
if args['cmd'] == 'getMarksByClasseIdStudentId':
return Mark.getMarksByClasseIdStudentId(self.session,
args['classeId'],
args['studentId'])
if args['cmd'] == 'getMarksByStudentId':
return Mark.getMarksByStudentId(self.session, args['studentId'])
if args['cmd'] == 'getMarksByMarkId':
return Mark.getMarksByMarkId(self.session, args['markId'])
return Mark.getMarks(self.session)
def cmd_mark_add( self, item, args, rawline ):
"""add a new mark - Everytime in interactive mode"""
mark_input = ""
points = None
max_points = None
valuation = -1
avarage = None
date = None
save = True
try:
while mark_input == "":
mark_input = input( "Mark: " )
points = input( "Points []: " )
max_points = input( "Max Points []: " )
while valuation < 0 or valuation > 100:
valuation = input( "Valuation (In %) [100]: " )
if valuation == "":
valuation == 100
break
try:
valuation = float( valuation )
except ValueError:
valuation = -1
continue
avarage = input( "Avarage []: " )
while date is None:
date = input( "Date []: " )
if date == "":
date = None
break
try:
test = time.strptime( date, "%d.%m.%Y" )
break
except ValueError:
date = None
continue
save = input( "Do you want to save ([y]/n)? " )
save = (save == "y" or save == "")
except KeyboardInterrupt:
save = False
print( "" ) # To break down prompt to a new line
if save:
mark = Mark( self._connection )
mark.Termsubject = self._location.GetCurrentLocationValue( )
mark.Mark = mark_input
mark.Points = points
mark.MaxPoints = max_points
mark.Valuation = valuation
mark.Avarage = avarage
mark.Date = date
if mark.Insert( ):
cf.out.bold_green( "This mark has been successfully saved!" )
self._UpdateCDCommand( )
else:
cf.out.bold_red( "An error occured during the insert action of the mark" )
async def requestReceived(websocket, session, request):
global marksSubscribers
if websocket.authenticated == False:
await websocket.send(convertToJson({'operation' : 'tokenError', 'table' : 'TokenAuthentication'}))
return
#Websockets endpoints
if request['operation'] == 'get':
#get endpoint
marks = Mark.getMarks(session)
response = convertToJson({'operation' : 'get', 'table' : 'Marks', 'data' : marks})
await websocket.send(response)
elif request['operation'] == 'subscribe':
#subscription endpoint
marks = Mark.getMarks(session)
response = convertToJson({'operation' : 'get', 'table' : 'Marks', 'data' : marks})
marksSubscribers.add(websocket)
await websocket.send(response)
elif request['operation'] == 'add':
#add endpoint
if checkArguments(request, ['classeId', 'studentId', 'teacherId', 'value', 'date']) == False:
print('Not all parameters were provided for ADD in Marks')
await websocket.send(convertToJson({'error' : 'Invalid request'}))
return
mark = dict_as_obj(request['data'], Mark.Mark(), ['markId', 'creationTime'])
mark = Mark.addMark(session, mark)
response = convertToJson({'operation' : 'add', 'table' : 'Marks', 'data' : mark})
marksSubscribers = set(filter(removeClosedConnection, marksSubscribers))
for subscriber in marksSubscribers:
await subscriber.send(response)
elif request['operation'] == 'update':
#update endpoint
if checkArguments(request, ['markId']) == False:
print('Not all parameters were provided for UPDATE in Marks')
await websocket.send(convertToJson({'error' : 'Invalid request'}))
return
data = request['data']
mark = Mark.getMarksByMarkId(session, data['markId'])[0]
mark = dict_as_obj(data, mark)
mark = Mark.updateMark(session, mark)
response = convertToJson({'operation' : 'update', 'table' : 'Marks', 'data' : mark})
marksSubscribers = set(filter(removeClosedConnection, marksSubscribers))
for subscriber in marksSubscribers:
await subscriber.send(response)
elif request['operation'] == 'delete':
#delete endpoint
if checkArguments(request, ['markId']) == False:
print('Not all parameters were provided for DELETE in Marks')
await websocket.send(convertToJson({'error' : 'Invalid request'}))
return
mark = Mark.deleteMark(session, request['data']['markId'])
response = convertToJson({'operation' : 'delete', 'table' : 'Marks', 'data' : mark})
marksSubscribers = set(filter(removeClosedConnection, marksSubscribers))
for subscriber in marksSubscribers:
await subscriber.send(response)
def makeAthlete(self, event, year, athleteHTML):
data = athleteHTML.findAll('td')
"""Collects necessary data from HTML"""
id = re.sub('[^0123456789]', '', data[2].a['href'])
grade = data[1].text
time = re.sub('[^0123456789:.(]', '', data[4].a.text)
if '(' in time:
time = time[0:time.find('(')]
tds = athleteHTML.findAll('td', {'class':'text-muted'})
state = data[5].text
date = tds[1].text
mark = Mark.Mark(event, time, grade, year, date)
athlete = Athlete.Athlete(id, state)
athlete.addMark(mark)
return athlete
def AnalysisData(self, name, index, line):
strline = line
path = str(name)
val = str(index)
nA = path.rfind('\\') + 1
strHead = path[nA:]
curtime = Utils.GetCurTime()
arr = [path, val, curtime]
swith = 0
if 'errMark' in name:
tempdata = strline.split('<>>>')
strline = tempdata[2]
if 'errMark_ss' in name:
self.tableName = tempdata[1]
swith = 2 #ss error only
elif 'errMark_db' in name:
self.tableName = tempdata[1]
swith = 3 #db error only
else:
self.tableName = tempdata[1]
swith = 1 #both error
pass
pro = DataFactory.DataFactory(self.tableName,
strline.replace("\n", ""), swith)
nFlag = pro.work()
if nFlag == 1:
Mark.setMark(arr)
if nFlag == -1:
Mark.setErrMark_db(self.tableName, strHead, strline)
elif nFlag == -2:
Mark.setErrMark(self.tableName, strHead, strline)
elif nFlag == -3:
Mark.setErrMark_ss(self.tableName, strHead, strline)
elif nFlag == 0:
pass
return nFlag
encode = face_recognition.face_encodings(img)[0]
encodeList.append(encode)
return encodeList
encodedList=findEncodings(images)
print(len('Encoding Completed'))
cap =cv2.VideoCapture(0)
while(True):
success,img = cap.read()
imgS= cv2.resize(img,(0,0),None,0.25,0.25)
imgS = cv2.cvtColor(imgS, cv2.COLOR_BGR2RGB)
prev=''
facesCurFrame = face_recognition.face_locations(imgS)
encodesCurFrame = face_recognition.face_encodings(imgS,facesCurFrame)
for encodeFace,faceloc in zip(encodesCurFrame,facesCurFrame):
matches =face_recognition.compare_faces(encodedList, encodeFace)
faceDis = face_recognition.face_distance(encodedList, encodeFace)
#print(faceDis)
matchIndex = np.argmin(faceDis)
if(matches[matchIndex]):
name =classNames[matchIndex].upper()
Mark.attended(name)
y1,x2,y2,x1 = faceloc
y1,x2,y2,x1 = y1*4,x2*4,y2*4,x1*4
cv2.rectangle(img,(x1,y1),(x2,y2),(0,255,0),2)
cv2.rectangle(img,(x1,y2-35),(x2,y2),(0,255,0),cv2.FILLED)
cv2.putText(img,name,(x1+8,y2-8),cv2.FONT_HERSHEY_COMPLEX,1,(255,255,255),2)
cv2.imshow('Webcam',img)
cv2.waitKey(3)
import Mark
import Edit
import Init
import Move
import Remove
import Show
except ImportError, e:
try:
why = "(" + str(e) + ")"
except:
why = ""
print("Cannot import package's commands " + why + " ...")
sys.exit(-1)
commands = {
'add': Add.SubCommand(),
'clean': Clean.SubCommand(),
'config': Config.SubCommand(),
'mark': Mark.SubCommand(),
'edit': Edit.SubCommand(),
'init': Init.SubCommand(),
'move': Move.SubCommand(),
'remove': Remove.SubCommand(),
'show': Show.SubCommand(),
}
# Test
if (__name__ == '__main__'):
debug("Test completed")
sys.exit(0)
def delete(self):
requestedArgs = getArguments(['markId'])
args = requestedArgs.parse_args()
return Mark.deleteMark(self.session, args['markId'])
def post(self):
requestedArgs = getArguments(
['classeId', 'studentId', 'teacherId', 'value', 'date'])
args = requestedArgs.parse_args()
mark = dict_as_obj(args, Mark.Mark())
return Mark.addMark(self.session, mark)
# -*- coding: utf-8 -*-
import traceback
from os.path import abspath, pardir, join
from sys import path
from datetime import datetime
import Mark
from app.models import Calendar, model_list
from get_data import get_index_data
path.append(abspath(join(abspath(join(abspath(__file__), pardir)), pardir)))
if __name__ == '__main__':
if not Calendar.in_business(dt=Calendar.today(), day=True):
exit()
strategy = 'min30'
op = 'index_'
try:
get_index_data(strategy)
# a = datetime.now()
# dit = {'date': a, 'status': 200, 'kline': 'index_{}'.format(strategy), 'other': '正常'}
# model_list['kline_data_update_mark'].insert(dit)
Mark.update_mark_success(op + strategy)
exit()
except Exception as e:
x = '合并30异常:' + str(e.message) + "追踪：" + str(traceback.format_exc())
Mark.update_mark_fail(strategy=op + strategy, messages=x)
exit(1)
def ReadFile(self, dir):
nReturn = 1
file_object = open(dir, 'rb')
try:
name = file_object.name
nIndex = name.find('errMark')
if nIndex > 0:
self.tableName = name[nIndex:]
pass
else:
arr = name.split('_')
type = arr[3]
try:
getTableName = {
'CONSUME': lambda: self.getDayTableName(arr),
'OBTAIN': lambda: self.getDayTableName(arr),
'CREATECHAR': lambda: self.getDayTableName(arr),
'LOGIN': lambda: self.getDayTableName(arr),
'LOGOUT': lambda: self.getDayTableName(arr),
'RECHARGE': lambda: self.getDayTableName(arr),
'TASK': lambda: self.getDayTableName(arr),
'ARENA': lambda: self.getDayTableName(arr),
'ENTERMAP': lambda: self.getDayTableName(arr),
'QUITMAP': lambda: self.getDayTableName(arr),
'ONLINE': lambda: self.getDayTableName(arr),
'LISTENCHAT': lambda: self.getDayTableName(arr)
}
self.tableName = getTableName[type]()
except Exception as e:
Log.error("GetDBtablename err at : %s" % (dir))
Log.error("Func.ReadFile() error code: %s" % (str(e)))
return -1
#if self.db == None:
# pass
#else:
# if self.db.dbSwitch == 1 :
# bRet=self.db.createTable(self.tableName)
index = 0
arrMark = Mark.readMark()
if len(arrMark) == 3:
try:
if name in arrMark[0]:
for line in file_object:
index += 1
if index > int(arrMark[1]):
nRe = self.AnalysisData(name, index, line)
if nRe < 0:
nReturn = nRe
else:
pass
else:
pass
except Exception as e:
Log.error("DataFactory.work() error code: %s" % (str(e)))
else:
for line in file_object:
index += 1
nR = self.AnalysisData(name, index, line.decode())
if nR < 0:
nReturn = nR
index = 0
return nReturn
finally:
Log.debug("Close File:\n%s" % (dir))
if file_object == None:
pass
else:
file_object.close()