def run(self):
self.running = True
self.session = db.Session()
self.session.add(self.search)
self.session.add(self.customer)
lr = LogReader(self.log_path, self.customer.get_safe_short_name(), \
self.search.start_dt, self.search.finish_dt)
self.search.status = Search.Status.RUNNING
self.search.count = 0
self.update_search()
while self.running == True:
event = lr.next()
if event == None:
break
row = self.sql_expression.evaluate(event)
if row != None:
#TODO: do we restrict the rows here?
self.fh.write(json.dumps(event))
self.fh.write("\n")
self.search.count += 1
self.update_search()
self.fh.close()
self.search.status = Search.Status.DONE
self.update_search()
self.session.close()
print "Done"
def getLength(strPath):
rdrLog = LogReader()
log = rdrLog.loadLog(sys.argv[1])
owl = log.getOwlData()
meta = owl["metadata"]
tti = owl["task-tree-individuals"]
root = tti[meta.subActions()[0]]
return root.time()
def test_exampleLog(self):
reader = LogReader('tests/example/test.log')
self.assertEqual(reader.injects, [(0.0, 123.0), (2.0, 10.0)])
self.assertEqual(reader.errors, [1.0, 20.0])
self.assertEqual(len(reader.algPackets), 1)
algSendingEntry = reader.algPackets[0]
self.assertEqual(algSendingEntry.packet, 123.0)
self.assertEqual(algSendingEntry.start, 2.0)
self.assertEqual(algSendingEntry.end, 20.0)
self.assertEqual(algSendingEntry.successful, False)
advSendingEntry = reader.advPackets[0]
self.assertEqual(advSendingEntry.packet, 10.0)
self.assertEqual(advSendingEntry.start, 2.0)
self.assertEqual(advSendingEntry.end, 12.0)
self.assertEqual(advSendingEntry.successful, True)
def __init__(self, logfile):
log_reader = LogReader(logfile)
log_reader.extract_string('"(0x)')
log_reader.extract_value('"(0x)')
self.value_list = log_reader.value_list
self.lines = log_reader.lines
self.functions_present = []
self.wheel_revolution_list = []
self.wheel_event_time_list = []
self.crank_revolution_list = []
self.crank_event_time_list = []
self.crank_rpm = []
self.power_list = []
self.speed = []
self.rpm = []
self.wheel_circumference = 2.132
self.value_converter = ValueConverter()
def __init__(self, logfile):
""" Constructor
Usage example:
patternfilter = ADPatternFilter(logfile)
Parameters
----------
logfile : string
the name of a text file generated as a log of the AD tool
Returns
----------
Instance of the class
"""
# Create an instance of LogReader
self.log = LogReader(logfile)
self.removedPatterns = []
self.defPatternlist = []
def toFile(self):
eventsForAt = []
eventsForAr = []
eventsForAudioDevice = []
for logFile in self.logFiles:
self.reader = LogReader(logFile)
for item in self.loggerEvent:
if item == "AT":
eventsForAt = eventsForAt + self.getAudioTrackEvent()
elif item == "AR":
eventsForAr = eventsForAr + self.getAudioRecordEvent()
elif item == "Device":
eventsForAudioDevice = eventsForAudioDevice + self.getAudioDevicePlugEvent()
else:
continue
events = ["="*50+"AudioTrack Event Begin"+"="*50] + \
eventsForAt + \
["="*50+"AudioTrack Event end"+"="*50, "\n"] + \
["=" * 50 + "AudioRecord Event Begin" + "=" * 50] + \
eventsForAr + \
["=" * 50 + "AudioRecord Event end" + "=" * 50, "\n"] + \
["=" * 50 + "AudioDevicePlug Event Begin" + "=" * 50] + \
eventsForAudioDevice + \
["=" * 50 + "AudioDevicePlug Event end" + "=" * 50, "\n"]
strings = ""
for item in events:
strings = strings + str(item) + "\n"
if strings == "":
return
fd = open("result", "w+")
fd.write(strings)
fd.close()
import configparser
import serial
import logging
from LogReader import LogReader
import math
import tkinter
logging.basicConfig(level=os.environ.get("LOGLEVEL", "INFO"))
config = configparser.ConfigParser()
config.read("config.ini")
serialPort1 = config["DEFAULT"]["SerialPort1"]
baudRate = config["DEFAULT"]["BaudRate"]
serial1 = serial.Serial(serialPort1, baudRate)
logReader = LogReader(serial1)
print("Monitoring log, press esc to stop")
stepsPerRotation = 9600
def calcXY(steps1, steps2):
ang1 = steps1 * math.pi * 2 / stepsPerRotation
ang2 = (stepsPerRotation/2 - steps2) * math.pi * 2 / stepsPerRotation
# print(steps1, steps2, ang1 * 180 / math.pi, ang2 * 180 / math.pi)
l1 = 92.5
l2 = 92.5
elbowX = math.sin(ang1) * l1
elbowY = math.cos(ang1) * l1
curX = elbowX + math.sin(ang2) * l2
curY = elbowY + math.cos(ang2) * l2
from flask import Flask
from LogReader import LogReader
from flask import Flask, render_template, flash, request
from wtforms import Form, TextField, TextAreaField, validators, StringField, SubmitField
app = Flask(__name__)
app.config.from_object(__name__)
app.config['SECRET_KEY'] = '7d441f27d441f27567d441f2b743254'
class ReusableForm(Form):
Exch = StringField('ExCh:', validators=[validators.required()])
Feed = StringField('Feed:', validators=[validators.required()])
lr = LogReader()
@app.route("/", methods=['GET', 'POST'])
def hello_world():
global lr
form = ReusableForm(request.form)
data={}
if request.method == 'POST':
exch = request.form['Exch']
feed = request.form['Feed']
global lr
good_data = lr.fake_data(start_date='1-Aug-2018',end_date='4-Aug-2018')
def __init__(self):
self.rdrLog = LogReader()
self.tti = {}
#!/usr/bin/python
from LogReader import LogReader
import sys
rdrLog = LogReader()
log = rdrLog.loadLog(sys.argv[1])
owl = log.getOwlData()
tti = owl["task-tree-individuals"]
count_eff = 0
count_eff_fail = 0
def hasSubActionUIMAPerceiveFailed(owlIndiv):
if owlIndiv.taskContext() == "UIMA-PERCEIVE":
if len(
owlIndiv.tagAttributeValues("knowrob:perceptionResult",
"rdf:resource")) == 0:
return True
else:
subactions = owlIndiv.subActions()
for subaction in subactions:
if hasSubActionUIMAPerceiveFailed(tti[subaction]):
return True
return False
stepsPerRot1 = float(config[robotName]["StepsPerRot1"])
stepsPerRot2 = float(config[robotName]["StepsPerRot2"])
unitsPerRot1 = float(config[robotName]["UnitsPerRot1"])
unitsPerRot2 = float(config[robotName]["UnitsPerRot2"])
Gearing1 = int(config[robotName]["Gearing1"])
Gearing2 = int(config[robotName]["Gearing2"])
sizeX = int(config[robotName]["SizeX"])
sizeY = int(config[robotName]["SizeY"])
originX = int(config[robotName]["OriginX"])
originY = int(config[robotName]["OriginY"])
robotGeom = config[robotName]["RobotGeom"]
dataReader = None
serial1 = serial.Serial(serialPort1, baudRate)
if monitorFromLog:
dataReader = LogReader(serial1, stepsPerRot1, stepsPerRot2)
else:
serial2 = serial.Serial(serialPort2, baudRate)
dataReader = EncoderReader(serial1, serial2)
print("Monitoring press esc to stop, c to clear, r to reset")
def calcSingleArmScara(degs1, degs2):
ang1 = degs1 * math.pi / 180
ang2 = (180 - degs2) * math.pi / 180
l1 = sizeX / 4
l2 = sizeX / 4
elbowX = math.sin(ang1) * l1
elbowY = math.cos(ang1) * l1
curX = elbowX + math.sin(ang2) * l2
def __init__(self):
self.rdrLog = LogReader()
self.arrColors = ["white", "red", "blue", "yellow", "black"]
args = argparser.parse_args()
logFilenames = args.logfile
outFilename = args.outfile
treefile = open(outFilename+".tree.tl", 'wb') # clear file
treefile.close()
treefile = open(outFilename+".tree.tl", 'r+b')
jsfile = open(outFilename+".js", "w")
jsfile.write('var data = {"tree": "'+outFilename+'.tree.tl", "dict": "'+outFilename+'.dict.tl", "treeFormat":"64,64,31,1,32"}');
jsfile.close()
readers = []
for logFilename in logFilenames:
readers.append(LogReader(logFilename))
#################################
old_textmap = ["bad"]
textmap = {}
textmap2 = []
def transform(info):
if len(info) < 2:
pass
elif info[1].isdigit():
info[1] = old_textmap[int(info[1])]
else:
old_textmap.append(info[1])
len(old_textmap)
def __init__(self):
self.tdTrainingData = TrainingData()
self.rdrLog = LogReader()
self.arrIgnoredTasks = []
self.arrAnnotatedParameters = []
if "BehaviorStateComplete" in frame.messages:
m, o = frame["BehaviorStateComplete"]
else:
m, o = frame["BehaviorStateSparse"]
return [m["robot_pose.x"], m["robot_pose.y"], m["fall_down_state"]]
except KeyError as k:
raise StopIteration
if __name__ == "__main__":
parser = BehaviorParser()
fileName = "./game.log"
log = LogReader(fileName, parser)#, filter=headYaw)
# we want only the frames which contain BehaviorState
b = [behavior(f) for f in log if "BehaviorStateComplete" in f.messages or "BehaviorStateSparse" in f.messages];
upright = filter(lambda m: m[2] == 1, b)
fall = filter(lambda m: m[2] != 1, b)
print "step 2"
du = zip(*upright)
df = zip(*fall)
pyplot.plot(du[0], du[1], '.')
pyplot.plot(df[0], df[1], 'o')
pyplot.ylabel('y')
#!/usr/bin/env python3
import sys
from matplotlib import pyplot
from itertools import accumulate
from LogReader import LogReader
if len(sys.argv) != 2:
print("Usage: {} <simulation.log>".format(sys.argv[0]))
sys.exit(1)
pyplot.rcParams["figure.figsize"] = [5.75, 4.0]
reader = LogReader(sys.argv[1])
def calculateQueue(packets):
timeQueue = {}
sentPackets = filter(lambda pe: pe.successful, packets)
injects = list(reader.injects)
queue = {}
def enqueue(packet):
if packet not in queue: queue[packet] = 0
queue[packet] += 1
def recordInTimeQueue(time):
for packet in queue:
if packet not in timeQueue: timeQueue[packet] = []
timeQueue[packet].append((time, queue[packet]))
for pe in sentPackets:
def __init__(self):
'''
Constructor
'''
self.log_reader = LogReader()
