def setUp(self):
Driver.initialize()
self.homePage = Homepage.homepage()
self.experiencePage = ExperiencePage.experiencePage()
self.SearchPage = SearchResultPage.searchResultPage()
# Go to the set url
self.homePage.goToURL()
def alertDriver(self, data):
import Driver
output = data
output.append(self.gps.lat)
output.append(self.gps.long)
output.append(self.gps.time)
output.append(self.gps.speed)
Driver.sensorEmergency(output)
def setUpClass(cls):
for device in Driver.get_device_info():
d = Driver.Driver(device)
cls.driver = d.start_appium()
cls.driver.implicitly_wait(30)
cls.log = log.log()
cls.log.info('test start')
print "start"
def main():
parser = argparse.ArgumentParser(description="Rai Replay", fromfile_prefix_chars="@")
parser.add_argument(
"--download",
action="store",
default="update",
choices=["always", "update", "never", "shm"],
help="Default is update",
)
parser.add_argument("--format", action="store", choices=["h264", "ts", "tsmp4", "mms"])
parser.add_argument("--bwidth", action="store", default="high")
parser.add_argument("--ip", action="store_true", default=False)
parser.add_argument("--tor", action="store", help="coutry code for tor exit nodes")
parser.add_argument("--tor-pass", action="store")
parser.add_argument(
"--tor-only-metadata", action="store_true", default=False, help="do not use tor for actual download"
)
parser.add_argument("--proxy", action="store")
parser.add_argument("--overwrite", action="store_true", default=False, help="overwrite program")
parser.add_argument("--location", action="store", help="path where to download programs")
parser.add_argument("--ts-tries", action="store", default=20)
parser.add_argument("--page", action="store", help="RAI On Demand Page")
parser.add_argument("--replay", action="store_true", default=False, help="RAI Replay")
parser.add_argument("--ondemand", action="store_true", default=False, help="RAI On Demand List")
parser.add_argument("--tg", action="store_true", default=False, help="Telegiornali RAI")
parser.add_argument("--junior", action="store_true", default=False, help="RAI Junior")
parser.add_argument("--search", action="store", help="Search RAI TV")
parser.add_argument("--mediaset", action="store_true", default=False, help="Video Mediaset")
parser.add_argument("--tg5", action="store_true", default=False, help="TG Mediaset")
parser.add_argument("--pluzz", action="store_true", default=False, help="Pluzz France Television")
parser.add_argument("--m6", action="store_true", default=False, help="M6")
parser.add_argument("--tf1", action="store_true", default=False, help="MY TF1")
parser.add_argument("--item", action="store", help="RAI On Demand Item")
parser.add_argument("--m3u8", action="store", help="Playlist")
parser.add_argument("--date", action="store", help="Filter by date YYYY-MM-DD")
parser.add_argument("--channel", action="store", help="Filter by channel")
parser.add_argument("--follow", action="append")
parser.add_argument("--nolist", action="store_true", default=False)
parser.add_argument("--get", action="store_true", default=False, help="download program")
parser.add_argument("--info", action="store_true", default=False, help="print IP info")
parser.add_argument("--re", action="store_true", default=False, help="filters are RegExp")
parser.add_argument("pid", nargs="*")
args = parser.parse_args()
Driver.process(args)
print()
def callupdate(self):
t = Driver(self.source, self.destination, self.AdminName)
t.ReachDestination()
self.msg = QtWidgets.QMessageBox()
self.msg.setIcon(QMessageBox.Information)
self.msg.setWindowTitle("Info")
self.msg.setText("Stage of this parcel is now change")
self.msg.setStandardButtons(QMessageBox.Ok)
self.msg.show()
self.callDriverPage()
def Play(self, episods):
self.LoadModel(episods)
try:
while 10:
s = Driver.ReadAverage() - self.OptimalDistance
sindx = self.GetStateIndex(s)
aindx = self.GetAction(sindx)
Driver.Move(self.actions[aindx])
except:
Driver.StopEveryThing()
def getCurrentState(self):
domains = Driver.getActiveDomains()
virtualMachines = []
for domain in domains:
dom = Driver.getDomainByID(domain)
if dom.name() != "loadgen_sigmetrics":
vm = self.getDomainInfo(domain)
vm.setVcpus(self.getVcpusInfo(domain))
vm.setNodeset(self.getNodeSet(domain))
vm.setMemorySize(self.getMemorySize(domain))
virtualMachines.append(vm)
return virtualMachines
def setVcpus(domainID, vcpus):
try:
return Driver.setVcpus(domainID, vcpus)
except libvirt.libvirtError:
print('Failed to set number of vcpus')
sys.exit(1)
def startDrive(self, model_name):
if not self.driver:
model_path = os.path.join("~/models", model_name)
self.driver = Driver.Driver(model_path,
camera=self.raw,
controller=self)
self.driver.startDriving()
def park(self, regno, driver_age):
try:
if self.numOfOccupiedSlots < self.capacity:
if regno in self.regnos:
print(
"The car registration number is not unique. Inform the cops !!!"
)
exit(0)
slotid = self.getEmptySlot()
self.slots[slotid] = {
"reg_no": Vehicle.Car(regno),
"driver_age": Driver.Driver(driver_age)
}
self.slotid = self.slotid + 1
self.numOfOccupiedSlots = self.numOfOccupiedSlots + 1
self.regnos.append(regno)
return slotid + 1
else:
return -1
except AttributeError as error:
print(
"~~~ Please make sure to create the parking lot before retrieving the information from it."
)
exit(0)
def IsNotDisplayed(self, FindBy, search_criteria):
is_display_element = None
element = Driver.FindVisibleElement(FindBy, search_criteria)
if element is None:
is_display_element = False
return is_display_element
def getVcpusInfo(self, domainID):
try:
return Driver.getVcpusInfo(domainID)
except libvirt.libvirtError:
print('Failed to get vcpu info')
sys.exit(1)
def getNUMATopology(self):
capsXML = Driver.getNUMATopology()
caps = minidom.parseString(capsXML)
host = caps.getElementsByTagName('host')[0]
cells = host.getElementsByTagName('cell')
print(cells.length)
numa = []
# iterate through the xml object to get the NUMA topology
for cell in cells:
node_id = cell.getAttribute('id')
print(cell.firstChild.nodeValue)
memory = cell.getElementsByTagName(
'memory')[0].firstChild.nodeValue
distances = {
proc.getAttribute('id'): proc.getAttribute('value')
for proc in cell.getElementsByTagName('sibling')
} # if proc.getAttribute('id'): proc.getAttribute('value') not in distances }
cores = [
proc.getAttribute('id')
for proc in cell.getElementsByTagName('cpu')
]
node = {node_id: [memory, distances, cores]}
numa.append(node)
return numa
def run_test(self):
driver_source = Driver.DriverSource()
main_driver = driver_source.get_driver(1081)
for n in range(5):
trip = main_driver.get_data_random_trip()
plotTripData(trip.tang_accel_mag, trip.speed)
def getHostCPUMap():
try:
return Driver.getHostCPUMap()
except libvirt.libvirtError:
print('Failed to get host CPU Map')
sys.exit(1)
def __init__(self, gui, drvname):
self.gui = gui
gtk.Table.__init__(self, 10, 3, False)
import Driver
self.drv = Driver.Driver(drvname)
self.info = self.drv.info()
kv = KeyAndValue(self.info)
kv.show()
self.attach(kv, 0, 3, 0, 9)
b_add = gtk.Button('Add')
b_add.connect('clicked', self.callback_add, drvname)
b_add.show()
self.attach(b_add, 0, 1, 9, 10)
b_rem = gtk.Button('Remove')
b_rem.connect('clicked', self.callback_rem, drvname)
b_rem.show()
self.attach(b_rem, 1, 2, 9, 10)
b_reload = gtk.Button('Reload')
b_reload.connect('clicked', self.callback_reload, drvname)
b_reload.show()
self.attach(b_reload, 2, 3, 9, 10)
#b_change = gtk.Button( 'Change' )
#b_change.show()
#self.attach( b_change, 3, 4, 9, 10 )
self.show()
def getVcpusCpuMaps(domainID):
try:
return Driver.getVcpusCpuMaps(domainID)
except libvirt.libvirtError:
print('Failed to get vcpu map')
sys.exit(1)
def pinMemory(self, domainID, nodeset):
try:
print "Actuator.pinMemory"
return Driver.pinMemory(domainID, nodeset)
except libvirt.libvirtError:
print('Failed to pin memory')
sys.exit(1)
def callDriverUpdate(self):
self.selecteditem = self.ui.tableWidget.selectedItems()
a = self.selecteditem[0].text()
b = self.selecteditem[1].text()
c = self.selecteditem[2].text()
t = Driver(a, b, self.AdminName)
t.collected()
self.window = QtWidgets.QWidget()
self.ui = Ui_Form_Driver_Update()
self.ui.setupUi(self.window)
self.form.hide()
self.window.show()
self.ui.label_5.setText(a)
self.ui.destination_input.setText(b)
self.source = a
self.destination = b
self.ui.commandLinkButton.clicked.connect(self.callupdate)
def getVMCPUStat(domainName, perCPUStat=True):
conn, dom = Driver.connectToDomain(domainName)
stats = dom.getCPUStats(perCPUStat)
conn.close()
return stats
def pinVcpuToCore(self, domainID, vcpuno, core):
try:
print "Pinning vcpu: " + str(vcpuno) + " for domain " + str(domainID) + " to core " + str(core)
cpumap = "("
if core == 0:
cpumap += "1,0)"
return Driver.pinVcpuToCore(domainID, vcpuno, literal_eval(cpumap))
else:
for i in range(core):
cpumap += "0, "
cpumap += "1)"
cpulist = literal_eval(cpumap)
return Driver.pinVcpuToCore(domainID, vcpuno, cpulist)
except libvirt.libvirtError:
print('Failed to pin vcpu ')
sys.exit(1)
def getVMMemoryStat(domainName):
conn, dom = Driver.connectToDomain(domainName)
stats = dom.memoryStats()
conn.close()
return stats
def startApp():
print("*****WELCOME*****")
print("\n\t1:Customer\n\t2:Driver\n\t3:Exit")
ch = int(input("\nEnter your choice:"))
if (ch == 1):
Customer.displayChoice()
input()
startApp()
elif (ch == 2):
Driver.displayChoice()
input()
startApp()
elif (ch == 3):
print("Thank you....\n")
exit()
else:
print("Wrong input...!\nPlease Select a valid choice")
startApp()
def getDomainInfo(self, domain):
dom = Driver.getDomainByID(domain)
name = dom.name()
id = domain
host = hostname
type = "silver"
if name.lower().startswith("g"):
type = "gold"
vm = VirtualMachine.VirtualMachine(domain, name, id, host, type)
return vm
def getNetworkIOStat(domainName):
conn, dom = Driver.connectToDomain(domainName)
tree = ElementTree.fromstring(dom.XMLDesc())
iface = tree.find('devices/interface/target').get('dev')
stats = dom.interfaceStats(iface)
conn.close()
return stats
def post(self, request, *args, **kwargs):
text = request.POST.get('input_text', '')
min_x = int(request.POST.get('min_x', ''))
max_x = int(request.POST.get('max_x', ''))
min_y = int(request.POST.get('min_y', ''))
max_y = int(request.POST.get('max_y', ''))
number_of_points = int(request.POST.get('number_of_points', ''))
filepath = Driver.run(input_text = text, number_of_points = number_of_points,
rangeX = (min_x,max_x), rangeY = (min_y,max_y))
context = {'filepath':filepath}
return render(request, 'algorithms/convexhull.html', context)
def trying():
if 'username' in session and 'email' in session and 'phoneNum' in session:
username = escape(
session['username']) # getting username&email from the session
email = escape(session['email'])
phoneNum = escape(session['phoneNum'])
# Here comes the code of reseting his password without he knows etc (Selenium)
Driver.Initialize()
PasswordReset.connect_to_site(phoneNum)
return redirect(url_for('code'))
return render_template('error.html')
def saveNewPng(self):
now = datetime.datetime.now()
now_iso_format = now.isoformat(timespec="seconds")
new_png_file_name = now_iso_format + "Z.png"
path = os.path.join(self.path_to_dir, new_png_file_name)
driver = Driver.Driver()
driver.savePng(self.conf["url"], self.conf["css_selector"], path)
del (driver)
self.last["datetime"] = now_iso_format
self.last["png_file_name"] = new_png_file_name
self.last.save()
shutil.copy(path, os.path.join(self.path_to_dir, "last.png"))
def HomePage(self):
global driver
#打开浏览器，进入首页
self.driver = Driver.DriverFirefox()
driver = self.driver
driver.get("http://test.spb.riskeys.com")
time.sleep(1)
# 判断是否是首页内容
try:
self.assertEquals(u"安逸云保-场景化保险专家", driver.title, "title error")
except AssertionError as e:
print u"找不到这个标题"
def getDomainStat(self, domainName):
conn, dom = Driver.connectToDomain(domainName)
if dom == None:
print('Failed to find the domain ' + domainName, file=sys.stderr)
exit(1)
state, maxmem, mem, cpus, cpuTime = dom.info()
conn.close()
return state, maxmem, mem, cpus, cpuTime
def app_sort(ph, kind, test_case_removal, methods=["GET", "POST"]):
date = str(datetime.datetime.now().strftime("%Y-%m-%d"))
if ph == '1':
Driver.sort_ph1(test_case_removal)
uploads = '/var/www/html/flaskapp/Output/'
if kind == 'csv':
filename = 'Phase1 ' + date + '.csv'
if kind == 'excel':
filename = 'Phase1 ' + date + '.xlsx'
return send_from_directory(directory=uploads,
filename=filename,
cache_timeout=-1,
as_attachment=True)
if ph == '2':
Driver.sort_ph2(test_case_removal)
uploads = '/var/www/html/flaskapp/Output/'
if kind == 'csv':
filename = 'Phase2 ' + date + '.csv'
if kind == 'excel':
filename = 'Phase2 ' + date + '.xlsx'
return send_from_directory(directory=uploads,
filename=filename,
cache_timeout=-1,
as_attachment=True)
if ph == '3':
Driver.sort_ph3(test_case_removal)
uploads = '/var/www/html/flaskapp/Output/'
if kind == 'csv':
filename = 'No_Phase ' + date + '.csv'
if kind == 'excel':
filename = 'No_Phase ' + date + '.xlsx'
return send_from_directory(directory=uploads,
filename=filename,
cache_timeout=-1,
as_attachment=True)
def post(self, request, *args, **kwargs):
text = request.POST.get('input_text', '')
min_x = int(request.POST.get('min_x', ''))
max_x = int(request.POST.get('max_x', ''))
min_y = int(request.POST.get('min_y', ''))
max_y = int(request.POST.get('max_y', ''))
number_of_points = int(request.POST.get('number_of_points', ''))
filepath = Driver.run(input_text=text,
number_of_points=number_of_points,
rangeX=(min_x, max_x),
rangeY=(min_y, max_y))
context = {'filepath': filepath}
return render(request, 'algorithms/convexhull.html', context)
def doSchedule(parameters, savepath, bool = True):
try:
params = Utilities.WrappedDictionary("missing parameter", parameters)
validateAndMassageParameters(params)
logging.debug(params)
(stri, sched) = dr.makeSchedule(params)
if bool:
t.displayPoints(sched, params['dimensions'][0]['range'][1],
params['dimensions'][1]['range'][1])
outfile = open(savepath, 'w')
outfile.write(stri)
outfile.close()
except Exception, e:
logging.error(e)
raise
import Driver Driver.main()
def generateFeatures(driversDataPath, driverLimit = 10000):
import os
import glob
driverIndex = 0;
tripIndex = 0;
''' read drivers directory '''
for dId in sorted(os.listdir(driversDataPath)):
print " driver: index %s name %s " % (driverIndex, dId)
driver = Driver(driverIndex, dId)
tripIndex = 0
''' for each driver read the trip files, one file at a time and
compute the features and stores them in the Trip object
'''
folder = '%s/%s/*.csv'%(driversDataPath, dId)
for f in sorted( glob.glob(folder) ):
#print " f: ", f
fileName = os.path.basename(f)
[name, ext] = os.path.splitext(fileName)
tripMatrix = []
features = []
''' data sample rate is 1 sec '''
tripMatrix = np.loadtxt(f, delimiter=',', skiprows=1)
''' distances '''
distances = getDistances(tripMatrix)
medianDist = np.median(distances)
meanDist = np.mean(distances)
stdDist = np.std(distances)
maxDist = distances.max()
tripTime = len(tripMatrix)
tripDist = distances.sum()#np.sum(distances)
''' distance features '''
features.append(tripDist)
features.append(tripTime)
features.append(maxDist)
features.append(stdDist)
features.append(meanDist)
features.append(medianDist)
variances = getPCAVariance(tripMatrix)
xVariance = variances[0]
yVariance = variances[1]
''' xy variance features '''
features.append(xVariance)
features.append(yVariance)
''' stops '''
stopCount = getStops(tripMatrix)
dataJumpCount = getDataJumps(distances)
''' stops and jumps features '''
features.append(stopCount)
features.append(dataJumpCount)
'''speeds '''
speeds = distances
medianSpeed = np.median(speeds)
meanSpeed = np.mean(speeds)
maxSpeed = speeds.max()
mimSpeed = speeds.min()
stdSpeed = np.std(speeds)
'''speeds features '''
features.append(maxSpeed)
features.append(mimSpeed)
features.append(stdSpeed)
features.append(meanSpeed)
features.append(medianSpeed)
''' accelerations - derivative of speed'''
accels = np.diff(speeds)
[minAccel, maxAccel, totalAccel] = getMinMaxPos(accels)
[minDecel, maxDecel, totalDecel] = getMinMaxNeg(accels)
''' accelerations features '''
features.append(maxAccel)
features.append(minAccel)
features.append(totalAccel)
features.append(maxDecel)
features.append(minDecel)
features.append(totalDecel)
''' jerks - derivative of acceleration'''
jerks = np.diff(accels)
[minAccelJerk, maxAccelJerk, totalAccelJerck] = getMinMaxPos(jerks)
[minDecelJerk, maxDecelJerk, totalDecelJerck] = getMinMaxNeg(jerks)
''' jerk features '''
features.append(maxAccelJerk)
features.append(minAccelJerk)
features.append(totalAccelJerck)
features.append(maxDecelJerk)
features.append(minDecelJerk)
features.append(totalDecelJerck)
''' angles '''
angles, originAngles = getAngles(tripMatrix)
maxAngle = angles.max()
minAngle = angles.min()
totalAngle = angles.sum()
meanAngle = np.mean(angles)
medianAngle = np.median(angles)
''' angles features '''
features.append(maxAngle)
features.append(minAngle)
features.append(meanAngle)
features.append(medianAngle)
features.append(totalAngle)
''' angularVelocity '''
angularSpeeds = angles * speeds
maxAngularSpeed = angularSpeeds.max()
minAngularSpeed = angularSpeeds.min()
medianAngularSpeed = np.median(angularSpeeds)
meanAngularSpeed = np.mean(angularSpeeds)
features.append(maxAngularSpeed)
features.append(minAngularSpeed)
features.append(meanAngularSpeed)
features.append(medianAngularSpeed)
''' instantiate Trip object '''
trip = Trip(tripIndex, name, tripTime, tripDist)
''' add the feature list to the current trip'''
trip.setFeatureList(features)
''' add the trip to the driver '''
driver.addTrip(trip)
del trip #the local trip should be dealocated every loop
tripIndex += 1
''' add driver to the manager. At this point the driver has
all the trips with the corresponding features
'''
driverMgr.addDriver(driver);
del driver #the local driver should be dealocated every loop
driverIndex += 1
''' to get out of the drivers loop - for testing only '''
if driverIndex > driverLimit:
break
def __init__( self, parent, drvname = None ):
self.classes = None
self.src = None
self.dst = None
self.drvname = drvname
self.file = None
self.ident = None
self.perm = None
self.policy = None
self.priv = None
self.value = True
self.dialog = gtk.Dialog( "Add_drv arguments", parent, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, None )
table = gtk.Table( 9, 7, True )
def bindarg( lbl, ent, count ):
ent.select_region( 0, len( ent.get_text() ) )
lbl.show()
ent.show()
table.attach( lbl, 1, 2, count, count + 1 )
table.attach( ent, 3, 6, count, count + 1 )
lbl_drv = gtk.Label( "driver_name" )
ent_drv = gtk.Entry()
bindarg( lbl_drv, ent_drv, 0 )
if self.drvname:
ent_drv.set_text( self.drvname )
lbl_src = gtk.Label( "source_dir" )
ent_src = gtk.Entry()
bindarg( lbl_src, ent_src, 1 )
lbl_dst = gtk.Label( "destination_dir" )
cmb_dst = gtk.Combo()
cmb_dst.entry.set_text( '' )
import Driver
combotext = Driver.getDrvList()
cmb_dst.set_popdown_strings( combotext )
lbl_dst.show()
cmb_dst.show()
table.attach( lbl_dst, 1, 2, 2, 3 )
table.attach( cmb_dst, 3, 6, 2, 3 )
lbl_filel = gtk.Label( "file list" )
ent_filel = gtk.Entry()
bindarg( lbl_filel, ent_filel, 3 )
lbl_class = gtk.Label( "class_name" )
ent_class = gtk.Entry()
bindarg( lbl_class, ent_class, 4 )
lbl_ident = gtk.Label( "identify_name" )
ent_ident = gtk.Entry()
bindarg( lbl_ident, ent_ident, 5 )
lbl_permi = gtk.Label( "permission" )
ent_permi = gtk.Entry()
bindarg( lbl_permi, ent_permi, 6 )
lbl_polic = gtk.Label( "policy" )
ent_polic = gtk.Entry()
bindarg( lbl_polic, ent_polic, 7 )
lbl_privi = gtk.Label( "privilege" )
ent_privi = gtk.Entry()
bindarg( lbl_privi, ent_privi, 8 )
table.show()
self.dialog.vbox.pack_start( table )
btnok = gtk.Button( 'OK' )
self.dialog.action_area.pack_start( btnok, True, True, 0 )
def okcallback( widget, args ):
self.value = True
self.drv = ent_drv.get_text()
self.src = ent_src.get_text()
self.dst = cmb_dst.entry.get_text()
self.file = ent_filel.get_text().split( ';' )
self.classes = ent_class.get_text()
self.ident = ent_ident.get_text()
self.perm = ent_permi.get_text()
self.policy = ent_polic.get_text()
self.priv = ent_privi.get_text()
self.dialog.destroy()
btnok.connect( 'clicked', okcallback, None )
btnok.show()
btncan = gtk.Button( 'Cancel' )
self.dialog.action_area.pack_start( btncan, True, True, 0 )
def cancallback( widget, args ):
self.value = False
self.drv = None
self.src = None
self.dst = None
self.file = None
self.classes = None
self.ident = None
self.perm = None
self.policy = None
self.priv = None
self.dialog.destroy()
btncan.connect( 'clicked', cancallback, None )
btncan.show()
def getScheduleFromJsonObject(parameters):
params = Utilities.WrappedDictionary("missing parameter", parameters)
Parameters.validateAndMassageParameters(params)
logging.debug(params)
(stri, sched) = dr.makeSchedule(params)
return (stri, sched)
def find_solution(rectangles):
return Driver.find_naive_solution(rectangles) # a working example!
headers = analyzed_file.readline().split(',')[1:] # Headers
data = analyzed_file.readline().split(',')[1:] # actual data
features = dict(zip(headers,data))
return features
if __name__ == '__main__':
#test_sample = [{'raw':'The big dog ate the fox.'},{'raw':'The orange kitten exploded.'},{'raw':'Glass cut through his veins.'},{'raw':'He shoved a stick up his asshole'}]
#features = get_structure_features(test_sample)
#for k,v in features.iteritems():
# print 'feature: ' + str(k) + ' value: ' + str(v)
#thread = start_stanford_server() # Start the server
dvr.get_all_pickles()
#thread.stop_server()
#root = build_tree('u(ROOT\n (S\n (NP (DT The) (JJ quick) (JJ brown) (NN fox))\n (VP (VBD jumped)\n (PP (IN over)\n (NP (DT the) (JJ lazy) (NN dog))))\n (. .)))')
# process dbank control
#get_structure_features('stanford/processed/dbank/control', 'dbank/control_SCA')
# process dbank dementia
#get_structure_features('stanford/processed/dbank/dementia', 'dbank/dementia_SCA')
# print "Starting server"
# thread = start_stanford_server() # Start the server
# try:
# tree = get_parse_tree('The quick brown fox jumped over the lazy dog.')
# root = build_tree(tree)
# print get_VP_2_AUX(tree_node)
# build_tree('u(ROOT\n (S\n (NP (DT The) (JJ quick) (JJ brown) (NN fox))\n (VP (VBD jumped)\n (PP (IN over)\n (NP (DT the) (JJ lazy) (NN dog))))\n (. .)))')
# labels = list(unzipped_data[1])
# fraser_samples = []
# for sample in samples:
# features = {}
# for k, v in sample.iteritems():
# if k in fraser_feature_dict_mix.keys():
# features[fraser_feature_dict_mix[k]] = v
# fraser_samples.append(features)
# samples = zip(fraser_samples, labels)
# make_arff_file(file_name, samples)
if __name__ == "__main__":
op = dvr.get_optima_feature_data()
db = dvr.get_dementiabank_feature_data()
make_arff_file("optima_all_features",op)
make_arff_file("dbank_all_features",db)
# # Load clinical data sets.
# clinical_samples = dvr.get_clinical_feature_data()
# # Train on clinical and test on clinical with all features
# train_clinical_test_clinical(clinical_samples)
# # Train on clinical and test on clinical with fraser features
# train_clinical_test_clinical_fraser_features(clinical_samples)
# # Load the clinical and non-clinical data sets
