async def update(self, record: Record):
# Column name of value mapping
bindings = {self.parent.config.key: record.key}
# Features
features = record.features(self.parent.config.features.keys())
for feature_name, column_name in self.parent.config.features.items():
bindings[column_name] = features.get(feature_name, None)
# Predictions
predictions = record.predictions(self.parent.config.predictions.keys())
for (
feature_name,
(value_column_name, confidence_column_name),
) in self.parent.config.predictions.items():
bindings[value_column_name] = None
if confidence_column_name is not None:
bindings[confidence_column_name] = None
if feature_name in predictions:
bindings[value_column_name] = predictions[feature_name][
"value"
]
if confidence_column_name is not None:
bindings[confidence_column_name] = predictions[
feature_name
]["confidence"]
# Bindings should be the values for each column, where the value for the
# key is not repeated for the UPDATE. If using REPLACE INTO, don't
# repeat values
values = list(bindings.values())
if not "REPLACE" in self.parent.config.update.upper():
values += list(bindings.values())[1:]
# Execute the update query
await self.conn.execute(self.parent.config.update, values)
self.logger.debug("Updated: %s: %r", record.key, bindings)
async def update(self, record: Record):
db = self.parent.db
# Store feature data
feature_cols = self.parent.FEATURE_COLS
feature_data = OrderedDict.fromkeys(feature_cols)
feature_data.update(record.features(feature_cols))
await db.execute(
"INSERT OR REPLACE INTO features (key, " +
", ".join(feature_cols) + ") "
"VALUES(?, " + ", ".join("?" * len(feature_cols)) + ")",
[record.key] + list(feature_data.values()),
)
# Store prediction
try:
prediction = record.prediction("target_name")
prediction_cols = self.parent.PREDICTION_COLS
prediction_data = OrderedDict.fromkeys(prediction_cols)
prediction_data.update(prediction.dict())
await db.execute(
"INSERT OR REPLACE INTO prediction (key, " +
", ".join(prediction_cols) + ") "
"VALUES(?, " + ", ".join("?" * len(prediction_cols)) + ")",
[record.key] + list(prediction_data.values()),
)
except KeyError:
pass
class TestRecord(unittest.TestCase):
def setUp(self):
self.null = Record("null")
self.full = Record(
"full",
data=dict(
features=dict(dead="beef"),
extra=dict(extra="read all about it"),
),
extra=dict(half=True),
)
def test_dict(self):
data = self.full.dict()
self.assertIn("extra", data)
def test_repr(self):
repr(self.full)
def test_str(self):
self.full.prediction = RecordPrediction()
self.assertIn("Undetermined", str(self.full))
self.full.data.prediction = {
"Prediction": RecordPrediction(value="Good")
}
self.assertIn("Good", str(self.full))
self.full.extra.update(dict(hi=5))
self.assertIn("5", str(self.full))
self.full.extra = dict()
self.assertNotIn("5", str(self.full))
def test_merge(self):
null = Record("null")
null.merge(self.full)
self.assertIn("half", null.extra)
self.assertTrue(null.extra["half"])
def test_key(self):
return self.full.data.key
def test_evaluated(self):
old_last_updated = self.full.data.last_updated
results = {"new": "feature"}
self.full.evaluated({"feed": "face"})
self.assertIn("feed", self.full.data.features)
self.assertEqual("face", self.full.data.features["feed"])
self.full.evaluated(results, overwrite=True)
self.assertEqual(self.full.data.features, results)
self.assertLessEqual(old_last_updated, self.full.data.last_updated)
def test_features(self):
self.assertIn("dead", self.full.features())
self.assertIn("dead", self.full.features(["dead"]))
self.assertFalse(self.full.features(["dead", "beaf"]))
def test_predicted(self):
old_prediction = self.full.data.prediction.copy()
old_last_updated = self.full.data.last_updated
self.full.predicted("target_name", "feed", 1.00)
self.assertNotEqual(old_prediction, self.full.data.prediction)
self.assertLessEqual(old_last_updated, self.full.data.last_updated)
def test_prediction(self):
self.full.predicted("target_name", "feed", 1.00)
self.assertTrue(self.full.prediction("target_name"))
