def formatData(resultData, sensor, startTs, stopTs, precision):
# Check if the first timestamp we get is meaningful
if startTs:
if int(startTs) < int(sensor.firstTs):
startTs = sensor.firstTs
else :
startTs = sensor.firstTs
if not stopTs:
stopTs = str(int(startTs) + utils.DEFAULT_TIME_INT)
# Get the column steps
colSteps = cPickle.loads(str(sensor.steps))
# Get the column names.
colNames = resultData["colNames"]
## Initializing structures for making us creating a result data
## structure with approximated values
# Dict containing the latest timestamps at which we encounter values
# for each column. We initialize it with the starting timestamp of the
# data we want to retrieve, so that we don't generate values
# occurring before this timestamp
latestTimes = {}
# Structure that we will populate to compute our final list
# of values
resultDict = {}
# Init the latest timestamps
for cn in colNames:
latestTimes[cn] = int(startTs) - 1
# Populate the data structure
for row in resultData["rows"] :
for cn in row["columns"].keys():
# Get the latest time for the given column
latestTime = latestTimes[cn]
# Initializes the timestamp as being the one of the row
timestamp = int(row["id"])
# If the timestamp is after the stopRow, we align directly with
# the stop timestamp
if timestamp > int(stopTs):
timestamp = int(utils.alignTs(stopTs, sensor.firstTs, sensor.recInt))
# As long as our timestamp is below the timestamp of the
# preceding value in the table for this column, we
# compute values and put them into our data structure
while(timestamp > latestTime):
ts = str(timestamp)
if ts not in resultDict:
resultDict[ts] = {"id": ts, "columns": {}}
resultDict[ts]["columns"][cn] = computeValue(row["columns"][cn], timestamp, cn[:2])
timestamp -= colSteps[cn[3:]]
latestTimes[cn] = int(row["id"])
# We get the values of the data structure (since it is a dict),
# and sort them into a list in ascending order of timestamps
resultData = {"rows": sorted(resultDict.values(), key = lambda row: int(row["id"])),
"colNames": colNames}
return resultData
# latest_model_value = lm.getFormattedValue()
# Add the value to the model and retrieve the new values
new_values = lm.add(float(index), float(row[cn]))
# If the maxdist is bigger than the error
if new_values["maxDist"] > variables.err_th:
# Get the latest value for this column
latest_value = latest_values["lm:" + cn]
# Put it to the values to commit if its timestamp is not ""
lv_ts = latest_value["timestamp"]
if lv_ts:
# Round the timestamp so it matches the recording
# frequency. We do this for correcting unalignments
# in the data.
lv_ts = alignTs(lv_ts, firstTs, variables.recInt)
if lv_ts not in values_to_commit:
values_to_commit[lv_ts] = {}
values_to_commit[lv_ts]["lm:" + cn] = latest_value["value"]
# Reset the model object
lm.reset()
# Add the values to the model object and retrieve the new values
lm.add(float(index), float(row[cn]))
# Update the latest value for the given column with the new values
latest_values["lm:" + cn]["timestamp"] = index
latest_values["lm:" + cn]["value"] = lm.getFormattedValues()
## Update the value for the constant model
# Get the model corresponding to this value
cm = constant_models["cm:" + cn]