@trillboards/edge-sdk 0.2.246 → 0.2.254

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (141) hide show
  1. package/deploy/detector/README.md +15 -0
  2. package/deploy/detector/pyproject.toml +1 -1
  3. package/deploy/detector/tests/test_actor_tracking.py +136 -0
  4. package/deploy/detector/tests/test_actor_tracking_wire.py +11 -0
  5. package/deploy/detector/tests/test_face_identity.py +448 -0
  6. package/deploy/detector/tests/test_loader.py +28 -1
  7. package/deploy/detector/tests/test_registry.py +53 -0
  8. package/deploy/detector/trillboards_detector/_version.py +2 -2
  9. package/deploy/detector/trillboards_detector/actor_tracking.py +95 -9
  10. package/deploy/detector/trillboards_detector/face_contract.py +166 -0
  11. package/deploy/detector/trillboards_detector/face_identity.py +467 -0
  12. package/deploy/detector/trillboards_detector/loader.py +40 -0
  13. package/deploy/detector/trillboards_detector/registry.py +72 -2
  14. package/deploy/detector/trillboards_detector/server.py +48 -6
  15. package/deploy/detector/trillboards_detector/tasks.py +12 -1
  16. package/deploy/windows/build-windows.ps1 +1 -0
  17. package/deploy/windows/ci/test-detector-looks-field.ps1 +15 -3
  18. package/deploy/windows/ci/test-detector-reinstall.ps1 +173 -2
  19. package/deploy/windows/ci/test-main-stream-gpu-decode.ps1 +119 -0
  20. package/deploy/windows/ci/test-rollout-proofs.ps1 +3 -2
  21. package/deploy/windows/ensure-detector.ps1 +255 -0
  22. package/deploy/windows/install-update.ps1 +4 -3
  23. package/deploy/windows/stop-existing.ps1 +1 -0
  24. package/deploy/windows/trillboards-edge.cmd +10 -22
  25. package/dist/CloudSensingManager.d.ts +14 -0
  26. package/dist/CloudSensingManager.d.ts.map +1 -1
  27. package/dist/CloudSensingManager.js +51 -5
  28. package/dist/CloudSensingManager.js.map +1 -1
  29. package/dist/ConnectorStatusClient.d.ts +26 -1
  30. package/dist/ConnectorStatusClient.d.ts.map +1 -1
  31. package/dist/ConnectorStatusClient.js +9 -0
  32. package/dist/ConnectorStatusClient.js.map +1 -1
  33. package/dist/DetectorFields.d.ts +77 -1
  34. package/dist/DetectorFields.d.ts.map +1 -1
  35. package/dist/DetectorFields.js +34 -4
  36. package/dist/DetectorFields.js.map +1 -1
  37. package/dist/EdgeAgent.js +1 -1
  38. package/dist/FaceIdentity.d.ts +122 -0
  39. package/dist/FaceIdentity.d.ts.map +1 -0
  40. package/dist/FaceIdentity.js +256 -0
  41. package/dist/FaceIdentity.js.map +1 -0
  42. package/dist/FaceSightingUploader.d.ts +95 -0
  43. package/dist/FaceSightingUploader.d.ts.map +1 -0
  44. package/dist/FaceSightingUploader.js +214 -0
  45. package/dist/FaceSightingUploader.js.map +1 -0
  46. package/dist/FaceWatchLane.d.ts +297 -0
  47. package/dist/FaceWatchLane.d.ts.map +1 -0
  48. package/dist/FaceWatchLane.js +660 -0
  49. package/dist/FaceWatchLane.js.map +1 -0
  50. package/dist/FaceWatchPolicy.d.ts +154 -0
  51. package/dist/FaceWatchPolicy.d.ts.map +1 -0
  52. package/dist/FaceWatchPolicy.js +101 -0
  53. package/dist/FaceWatchPolicy.js.map +1 -0
  54. package/dist/LocalDetectorClient.d.ts +30 -0
  55. package/dist/LocalDetectorClient.d.ts.map +1 -1
  56. package/dist/LocalDetectorClient.js +72 -4
  57. package/dist/LocalDetectorClient.js.map +1 -1
  58. package/dist/MainStreamRing.d.ts +63 -1
  59. package/dist/MainStreamRing.d.ts.map +1 -1
  60. package/dist/MainStreamRing.js +101 -7
  61. package/dist/MainStreamRing.js.map +1 -1
  62. package/dist/NativeReadiness.d.ts +21 -2
  63. package/dist/NativeReadiness.d.ts.map +1 -1
  64. package/dist/NativeReadiness.js +32 -9
  65. package/dist/NativeReadiness.js.map +1 -1
  66. package/dist/OrderedReviewClient.d.ts +3 -0
  67. package/dist/OrderedReviewClient.d.ts.map +1 -1
  68. package/dist/OrderedReviewClient.js +3 -0
  69. package/dist/OrderedReviewClient.js.map +1 -1
  70. package/dist/ReviewPriority.d.ts +9 -0
  71. package/dist/ReviewPriority.d.ts.map +1 -1
  72. package/dist/ReviewPriority.js +6 -1
  73. package/dist/ReviewPriority.js.map +1 -1
  74. package/dist/ScopedVlmReview.d.ts +11 -2
  75. package/dist/ScopedVlmReview.d.ts.map +1 -1
  76. package/dist/ScopedVlmReview.js +43 -16
  77. package/dist/ScopedVlmReview.js.map +1 -1
  78. package/dist/SensingProfileClient.d.ts +14 -0
  79. package/dist/SensingProfileClient.d.ts.map +1 -1
  80. package/dist/SensingProfileClient.js +9 -0
  81. package/dist/SensingProfileClient.js.map +1 -1
  82. package/dist/TemporalReviewClient.d.ts +3 -0
  83. package/dist/TemporalReviewClient.d.ts.map +1 -1
  84. package/dist/TemporalReviewClient.js +3 -0
  85. package/dist/TemporalReviewClient.js.map +1 -1
  86. package/dist/UniformSceneStore.d.ts +6 -0
  87. package/dist/UniformSceneStore.d.ts.map +1 -1
  88. package/dist/UniformSceneStore.js +22 -1
  89. package/dist/UniformSceneStore.js.map +1 -1
  90. package/dist/VideoSegmentUploader.d.ts +11 -0
  91. package/dist/VideoSegmentUploader.d.ts.map +1 -1
  92. package/dist/VideoSegmentUploader.js +28 -2
  93. package/dist/VideoSegmentUploader.js.map +1 -1
  94. package/dist/VlmCandidateBuffer.d.ts +2 -0
  95. package/dist/VlmCandidateBuffer.d.ts.map +1 -1
  96. package/dist/VlmCandidateBuffer.js.map +1 -1
  97. package/dist/WatchlistClient.d.ts +55 -0
  98. package/dist/WatchlistClient.d.ts.map +1 -0
  99. package/dist/WatchlistClient.js +161 -0
  100. package/dist/WatchlistClient.js.map +1 -0
  101. package/dist/autoSense.d.ts.map +1 -1
  102. package/dist/autoSense.js +6 -0
  103. package/dist/autoSense.js.map +1 -1
  104. package/dist/cli.d.ts.map +1 -1
  105. package/dist/cli.js +6 -0
  106. package/dist/cli.js.map +1 -1
  107. package/dist/connectorUpdate.d.ts +34 -9
  108. package/dist/connectorUpdate.d.ts.map +1 -1
  109. package/dist/connectorUpdate.js +96 -9
  110. package/dist/connectorUpdate.js.map +1 -1
  111. package/dist/connectorUpdateApply.d.ts +20 -1
  112. package/dist/connectorUpdateApply.d.ts.map +1 -1
  113. package/dist/connectorUpdateApply.js +55 -1
  114. package/dist/connectorUpdateApply.js.map +1 -1
  115. package/dist/connectorUpdateApplyMac.d.ts +3 -1
  116. package/dist/connectorUpdateApplyMac.d.ts.map +1 -1
  117. package/dist/connectorUpdateApplyMac.js +6 -0
  118. package/dist/connectorUpdateApplyMac.js.map +1 -1
  119. package/dist/detectorEndpointState.d.ts +30 -0
  120. package/dist/detectorEndpointState.d.ts.map +1 -0
  121. package/dist/detectorEndpointState.js +125 -0
  122. package/dist/detectorEndpointState.js.map +1 -0
  123. package/dist/detectorLauncher.d.ts +23 -0
  124. package/dist/detectorLauncher.d.ts.map +1 -0
  125. package/dist/detectorLauncher.js +94 -0
  126. package/dist/detectorLauncher.js.map +1 -0
  127. package/dist/diagnose.d.ts +1 -1
  128. package/dist/diagnose.js +1 -1
  129. package/dist/hostCpu.d.ts +56 -0
  130. package/dist/hostCpu.d.ts.map +1 -0
  131. package/dist/hostCpu.js +113 -0
  132. package/dist/hostCpu.js.map +1 -0
  133. package/dist/localSensing.d.ts +86 -0
  134. package/dist/localSensing.d.ts.map +1 -1
  135. package/dist/localSensing.js +263 -30
  136. package/dist/localSensing.js.map +1 -1
  137. package/package.json +2 -2
  138. package/retained/ProfileAuthorityClient.cjs +4 -0
  139. package/retained/RetainedCaptureClient.cjs +6 -0
  140. package/retained/WebsiteAdmissionCaptureClient.cjs +3 -1
  141. package/retained/__tests__/website-admission-realtime.test.cjs +27 -2
@@ -30,8 +30,23 @@ POST /detect { image_b64, classes?, min_confidence }
30
30
  GET /health 200 when the PINNED model's load completed AND its probe
31
31
  inference succeeded; 503 otherwise, with the reason. Also
32
32
  reports which models are resident. Runs no inference.
33
+
34
+ POST /v1/faces { image_b64, detector:{modelId,sha256}, embedder:{modelId,sha256},
35
+ minScore, minEyePx, maxAbsYaw, minSharpness, maxFaces }
36
+ 200 { version, imageSha256, frameSize, detector, embedder,
37
+ faces: [{ box, score, landmarks, eyeDistancePx, yaw, sharpness,
38
+ quality, gate, embedding|null }], inferenceMs }
39
+ 400 / 409 / 503 / 500 malformed / another artifact / not resident / refused
33
40
  ```
34
41
 
42
+ `/v1/faces` (`face_contract.py`, `face_identity.py`) is the door camera's face
43
+ task: YuNet 2023mar finds each face and its five landmarks on the original
44
+ face-zone JPEG, a 5-point similarity warp aligns it to the ArcFace 112x112
45
+ template, and EdgeFace-XS (the ONNX twin of the tablet's TFLite) gives a face
46
+ that passes every bar a unit 512-d vector. Both artifacts are task models in
47
+ `tasks.py`, admitted together through the same portfolio; the answer is
48
+ re-checked field by field before it leaves.
49
+
35
50
  * `label` is the class **name**, never an index.
36
51
  * `box` is in **pixels of the submitted frame**, not normalised.
37
52
  * `classes` filters at the **service**, so the wire stays small. Absent means
@@ -10,7 +10,7 @@ name = "trillboards-detector"
10
10
  # constant, a `labels.py`-only change survives `uv tool install` AND
11
11
  # `uv tool install --force`; move the version and a bare `uv tool install`
12
12
  # reinstalls. See `stamp_version.py`.
13
- version = "0.2.0+src.740c359ba4b7"
13
+ version = "0.2.0+src.18ad6e3937e7"
14
14
  description = "On-device object-detector service for the Trillboards BYO-CCTV connector (loopback HTTP, ONNX Runtime)."
15
15
  requires-python = ">=3.10"
16
16
 
@@ -218,6 +218,142 @@ class ActorTrackingTest(unittest.TestCase):
218
218
  with self.assertRaisesRegex(TrackingError, "Corrupt"):
219
219
  self.track(1400)
220
220
 
221
+ # ── each frame's own records (server.py:669 Codex P2) ────────────────────
222
+
223
+ def track_and_records(self, at, detections=None, **kwargs):
224
+ return self.journal.track_and_records(
225
+ request(at, **kwargs), detections if detections is not None else [person()],
226
+ image_sha256=SHA, model_hashes=MODEL, frame_size=(640, 480))
227
+
228
+ def test_two_interleaved_requests_on_one_camera_each_get_their_own_records(self):
229
+ """The bug: the server read the records with a second lock acquisition after
230
+ track(), so a request for the camera's next frame could commit in between and this
231
+ frame was answered with the next frame's records. Here the next frame's request is
232
+ started from INSIDE this frame's transaction; it must wait, and each answer must be
233
+ its own frame's."""
234
+ import threading
235
+ self.track(1000)
236
+ original = self.journal._write_track_records
237
+ other = {}
238
+ def write_then_start_the_next_frame(*args):
239
+ original(*args)
240
+ if "thread" not in other:
241
+ other["thread"] = threading.Thread(
242
+ target=lambda: other.setdefault("answer", self.track_and_records(1400, [person(14, .9)])))
243
+ other["thread"].start()
244
+ other["thread"].join(.3) # it cannot get in: this frame still holds the journal
245
+ other["waited"] = other["thread"].is_alive()
246
+ self.journal._write_track_records = write_then_start_the_next_frame
247
+ result, records = self.track_and_records(1200)
248
+ other["thread"].join(10)
249
+ self.journal._write_track_records = original
250
+ self.assertTrue(other["waited"])
251
+ record, = records
252
+ self.assertEqual((record["lastSeenAtMs"], record["frames"], record["box"]["x"]), (1200, 1, 10))
253
+ self.assertEqual(record["actorId"], result["actors"][0]["actor"]["id"])
254
+ _, next_records = other["answer"]
255
+ self.assertEqual((next_records[0]["lastSeenAtMs"], next_records[0]["frames"],
256
+ next_records[0]["box"]["x"]), (1400, 2, 14))
257
+ # The live records moved on; the first answer did not move with them.
258
+ live, = self.journal.track_records("cam_a")
259
+ self.assertEqual((live.last_seen_ms, live.frames), (1400, 2))
260
+
261
+ def test_a_replay_serves_the_frames_own_saved_records_not_the_live_ones(self):
262
+ self.track(1000)
263
+ result, records = self.track_and_records(1200)
264
+ self.track(1400, [person(14, .9)])
265
+ self.assertEqual(self.track_and_records(1200), (result, records))
266
+ self.journal.close()
267
+ self.journal = ActorTrackerJournal(self.path)
268
+ self.assertEqual(self.track_and_records(1200), (result, records))
269
+ self.assertEqual(self.track(1200), result)
270
+
271
+ def test_a_frame_with_no_records_kept_replays_no_records(self):
272
+ """A frame journalled before the snapshot existed, or by an older build."""
273
+ import sqlite3
274
+ self.track(1000)
275
+ result, records = self.track_and_records(1200)
276
+ self.assertEqual(len(records), 1)
277
+ with sqlite3.connect(self.path) as db:
278
+ db.execute("DELETE FROM actor_frame_records WHERE frame_id='frame_1200'")
279
+ self.assertEqual(self.track_and_records(1200), (result, []))
280
+
281
+ def test_records_kept_for_different_bytes_under_the_same_frame_id_are_not_served(self):
282
+ import sqlite3
283
+ self.track(1000)
284
+ result, _ = self.track_and_records(1200)
285
+ with sqlite3.connect(self.path) as db:
286
+ db.execute("UPDATE actor_frame_records SET fingerprint=? WHERE frame_id='frame_1200'", ("d" * 64,))
287
+ self.assertEqual(self.track_and_records(1200), (result, []))
288
+
289
+ def test_a_journal_from_before_the_snapshot_gains_its_table_and_keeps_its_frames(self):
290
+ import sqlite3
291
+ self.track(1000)
292
+ result, _ = self.track_and_records(1200)
293
+ self.journal.close()
294
+ with sqlite3.connect(self.path) as db:
295
+ db.execute("DROP TABLE actor_frame_records")
296
+ self.journal = ActorTrackerJournal(self.path)
297
+ self.assertEqual(self.track_and_records(1200), (result, []))
298
+ _, records = self.track_and_records(1400)
299
+ self.assertEqual(records[0]["frames"], 2)
300
+ self.assertEqual(self.track_and_records(1400)[1], records)
301
+
302
+ def test_an_older_build_can_still_write_this_journal_after_a_rollback(self):
303
+ """Older builds insert frames by position (7 values): actor_frame keeps its columns."""
304
+ import sqlite3
305
+ self.track(1000)
306
+ with sqlite3.connect(self.path) as db:
307
+ self.assertEqual([r[1] for r in db.execute("PRAGMA table_info(actor_frame)")],
308
+ ["camera_id", "frame_id", "seq", "epoch", "fingerprint", "input_json", "result_json"])
309
+
310
+ def test_records_kept_beside_frames_are_pruned_with_them(self):
311
+ import sqlite3
312
+ for at in range(1000, 1000 + 300 * 200, 200):
313
+ self.track(at)
314
+ with sqlite3.connect(self.path) as db:
315
+ frames = db.execute("SELECT count(*) FROM actor_frame WHERE camera_id='cam_a'").fetchone()[0]
316
+ kept = db.execute("SELECT count(*) FROM actor_frame_records WHERE camera_id='cam_a'").fetchone()[0]
317
+ orphans = db.execute("SELECT count(*) FROM actor_frame_records r WHERE NOT EXISTS (SELECT 1 FROM "
318
+ "actor_frame f WHERE f.camera_id=r.camera_id AND f.frame_id=r.frame_id)").fetchone()[0]
319
+ self.assertLessEqual(frames, 256)
320
+ self.assertEqual((kept, orphans), (frames, 0))
321
+
322
+ def test_a_replay_serves_a_face_only_while_its_actor_still_holds_that_slot(self):
323
+ import sqlite3
324
+ from trillboards_detector.track_records import FaceSlot
325
+ who = self.confirmed()
326
+ face = FaceSlot("face_model", "c" * 64, (0.6, 0.8), "frame_1200", 1200, .7)
327
+ self.assertTrue(self.journal.record_face("cam_a", who["id"], face))
328
+ _, records = self.track_and_records(1400)
329
+ self.assertEqual(records[0]["face"], face.to_wire())
330
+ self.assertEqual(self.track_and_records(1400)[1], records)
331
+ # The journal row keeps the slot's digest, never the vector: a face never
332
+ # outlives its track (track_records.py).
333
+ with sqlite3.connect(self.path) as db:
334
+ stored = db.execute("SELECT records_json FROM actor_frame_records WHERE frame_id='frame_1400'").fetchone()[0]
335
+ self.assertNotIn("0.6", stored)
336
+ self.assertNotIn("face_model", stored)
337
+ # A newer slot on the live record is not the one this frame had.
338
+ newer = FaceSlot("face_model", "c" * 64, (0.8, 0.6), "frame_1400", 1400, .9)
339
+ self.assertTrue(self.journal.record_face("cam_a", who["id"], newer))
340
+ replayed, = self.track_and_records(1400)[1]
341
+ self.assertIsNone(replayed["face"])
342
+ self.assertEqual({k: v for k, v in replayed.items() if k != "face"},
343
+ {k: v for k, v in records[0].items() if k != "face"})
344
+ # And once the actor ends, no replay brings its face back.
345
+ self.assertTrue(self.journal.record_face("cam_a", who["id"], face))
346
+ self.track(10000)
347
+ self.assertIsNone(self.track_and_records(1400)[1][0]["face"])
348
+
349
+ def test_a_corrupt_records_snapshot_is_not_an_idempotent_success(self):
350
+ import sqlite3
351
+ self.confirmed()
352
+ with sqlite3.connect(self.path) as db:
353
+ db.execute("UPDATE actor_frame_records SET records_json='{\"not\":\"a list\"}' WHERE frame_id='frame_1200'")
354
+ with self.assertRaisesRegex(TrackingError, "Corrupt"):
355
+ self.track_and_records(1200)
356
+
221
357
 
222
358
  if __name__ == "__main__":
223
359
  unittest.main()
@@ -92,6 +92,17 @@ class ActorTrackingWireTest(unittest.TestCase):
92
92
  self.assertEqual(self.post(1400)[1]["tracks"][0]["frames"],2)
93
93
  self.assertNotIn("tracks",self.post(1600,tracking=None)[1])
94
94
 
95
+ def test_a_replayed_frame_serves_its_own_tracks_not_the_live_ones(self):
96
+ self.post(1000)
97
+ _,second=self.post(1200)
98
+ _,third=self.post(1400)
99
+ self.assertEqual(third["tracks"][0]["frames"],2)
100
+ status,replayed=self.post(1200)
101
+ self.assertEqual(status,200)
102
+ self.assertEqual(replayed["tracking"],second["tracking"])
103
+ self.assertEqual(replayed["tracks"],second["tracks"])
104
+ self.assertEqual(replayed["tracks"][0]["frames"],1)
105
+
95
106
  def test_invalid_or_unavailable_tracking_never_becomes_an_empty_scene(self):
96
107
  for change in [{"tracking":{}},{"min_confidence":.5},{"expected_model":None},
97
108
  {"classes":["cell phone"]}]:
@@ -0,0 +1,448 @@
1
+ """The door faces task: the wire, the answer check, the catalogue, the admission, the geometry.
2
+
3
+ Three lanes, like the other task suites. The wire refusals, the answer re-check,
4
+ the catalogue and the shared admission are stdlib only and run on every runner.
5
+ The alignment, the YuNet decode and the gates need numpy + OpenCV (the CPU SDK
6
+ lane). The real artifacts are OTA'd and never committed, so the end-to-end case
7
+ runs only where TRILLBOARDS_FACE_DETECTOR_MODEL / TRILLBOARDS_FACE_EMBEDDER_MODEL
8
+ name them (and TRILLBOARDS_FACE_TEST_FRAMES a directory of JPEGs with faces).
9
+ """
10
+ import base64
11
+ import copy
12
+ import hashlib
13
+ import importlib.util
14
+ import json
15
+ import math
16
+ import os
17
+ import tempfile
18
+ import threading
19
+ import unittest
20
+ import urllib.error
21
+ import urllib.request
22
+ from pathlib import Path
23
+
24
+ from trillboards_detector import face_contract as fc
25
+ from trillboards_detector.errors import DetectorNotReady, ModelVerificationError
26
+ from trillboards_detector.labels import RFDETR_MEDIUM
27
+ from trillboards_detector.registry import ModelEntry, ModelRegistry
28
+ from trillboards_detector.server import DetectorServer
29
+ from trillboards_detector.tasks import BUILTIN_TASK_MODELS, FACE_DETECTOR, FACE_EMBEDDER
30
+
31
+ _missing = [name for name in ("numpy", "cv2", "PIL", "onnxruntime") if importlib.util.find_spec(name) is None]
32
+ needs_numeric = unittest.skipIf(_missing, "detector[cpu] dependencies absent: " + ", ".join(_missing))
33
+ JPEG = b"\xff\xd8\xff\xe0 refused or faked before any decode"
34
+ DETECTOR_PIN = {"modelId": fc.FACE_DETECTOR_MODEL_ID, "sha256": fc.FACE_DETECTOR_SHA256}
35
+ EMBEDDER_PIN = {"modelId": fc.FACE_EMBEDDER_MODEL_ID, "sha256": fc.FACE_EMBEDDER_SHA256}
36
+ BARS = {"minScore": 0.6, "minEyePx": 12, "maxAbsYaw": 0.35, "minSharpness": 15.0, "maxFaces": 8}
37
+
38
+
39
+ def request_body(**over):
40
+ return {"image_b64": base64.b64encode(JPEG).decode(), "detector": dict(DETECTOR_PIN),
41
+ "embedder": dict(EMBEDDER_PIN), **BARS, **over}
42
+
43
+
44
+ def unit_vector(seed=1):
45
+ values = [math.sin(seed * (i + 1)) for i in range(fc.EMBEDDING_DIM)]
46
+ norm = math.sqrt(sum(v * v for v in values))
47
+ return [round(v / norm, 6) for v in values]
48
+
49
+
50
+ def face(gate="passed", score=0.9, eye=20.0, yaw=0.05, sharp=40.0, x=10.0):
51
+ return {"box": {"x": x, "y": 12.0, "width": 40.0, "height": 48.0}, "score": score,
52
+ "landmarks": [[x + 10, 30.0], [x + 30, 30.0], [x + 20, 40.0], [x + 12, 50.0], [x + 28, 50.0]],
53
+ "eyeDistancePx": eye, "yaw": yaw, "sharpness": sharp, "quality": 0.5, "gate": gate,
54
+ "embedding": unit_vector() if gate == "passed" else None}
55
+
56
+
57
+ def answer(faces, jpeg=JPEG):
58
+ return {"version": 1, "imageSha256": hashlib.sha256(jpeg).hexdigest(),
59
+ "frameSize": {"width": 640, "height": 480},
60
+ "detector": {**DETECTOR_PIN, "preprocessing": fc.FACE_DETECT_PREPROCESSING},
61
+ "embedder": {**EMBEDDER_PIN, "preprocessing": fc.FACE_EMBED_PREPROCESSING},
62
+ "faces": faces, "inferenceMs": {"detect": 4.1, "embed": 2.9}}
63
+
64
+
65
+ class RequestTest(unittest.TestCase):
66
+ def test_a_complete_request_parses(self):
67
+ jpeg, detector, embedder, bars = fc.validate_faces_request(request_body())
68
+ self.assertEqual(jpeg, JPEG)
69
+ self.assertEqual((detector, embedder), (DETECTOR_PIN, EMBEDDER_PIN))
70
+ self.assertEqual(bars, {**BARS, "minEyePx": 12.0})
71
+ self.assertIs(type(bars["maxFaces"]), int)
72
+
73
+ def test_refusals(self):
74
+ bad = [
75
+ {k: v for k, v in request_body().items() if k != "minEyePx"},
76
+ {**request_body(), "extra": 1},
77
+ request_body(image_b64=""), request_body(image_b64="!!not base64"),
78
+ request_body(detector={"modelId": "yunet_2023mar"}),
79
+ request_body(detector={"modelId": "rfdetr_medium", "sha256": "a" * 64}),
80
+ request_body(embedder={"modelId": fc.FACE_EMBEDDER_MODEL_ID, "sha256": "A" * 64}),
81
+ request_body(minScore=0), request_body(minScore=1.2), request_body(minScore=True),
82
+ request_body(minEyePx=0.5), request_body(maxAbsYaw=0), request_body(minSharpness=-1),
83
+ request_body(maxFaces=0), request_body(maxFaces=17), request_body(maxFaces=2.0),
84
+ request_body(minScore=float("nan")), "not an object",
85
+ ]
86
+ for body in bad:
87
+ with self.subTest(body=body if isinstance(body, str) else {k: v for k, v in body.items() if k != "image_b64"}):
88
+ with self.assertRaises(ValueError):
89
+ fc.validate_faces_request(body)
90
+
91
+ def test_a_right_model_with_another_sha_is_left_to_the_registry(self):
92
+ _, detector, _, _ = fc.validate_faces_request(request_body(detector={**DETECTOR_PIN, "sha256": "b" * 64}))
93
+ self.assertEqual(detector["sha256"], "b" * 64)
94
+
95
+
96
+ class AnswerCheckTest(unittest.TestCase):
97
+ def check(self, result, bars=BARS):
98
+ fc.check_faces_response(result, JPEG, DETECTOR_PIN, EMBEDDER_PIN, bars)
99
+
100
+ def test_a_consistent_answer_passes(self):
101
+ self.check(answer([face(), face("eye_distance", score=0.8, eye=9.0, x=100.0),
102
+ face("score", score=0.55, x=200.0)]))
103
+ self.check(answer([]))
104
+
105
+ def test_every_corruption_is_refused(self):
106
+ good = answer([face(), face("yaw", score=0.7, yaw=0.5, x=100.0)])
107
+ corruptions = {
108
+ "another image": lambda r: r.update(imageSha256="0" * 64),
109
+ "another detector": lambda r: r["detector"].update(sha256="c" * 64),
110
+ "another preprocessing": lambda r: r["embedder"].update(preprocessing="other"),
111
+ "extra key": lambda r: r.update(extra=1),
112
+ "box off the frame": lambda r: r["faces"][0]["box"].update(x=620.0),
113
+ "box without extent": lambda r: r["faces"][0]["box"].update(width=0),
114
+ "score above 1": lambda r: r["faces"][0].update(score=1.5),
115
+ "worse face first": lambda r: r["faces"].reverse(),
116
+ "mirrored eyes": lambda r: r["faces"][0]["landmarks"].reverse(),
117
+ "four landmarks": lambda r: r["faces"][0]["landmarks"].pop(),
118
+ "gate not from measures": lambda r: r["faces"][1].update(gate="passed", embedding=unit_vector()),
119
+ "vector it did not earn": lambda r: r["faces"][1].update(embedding=unit_vector()),
120
+ "passed without a vector": lambda r: r["faces"][0].update(embedding=None),
121
+ "short vector": lambda r: r["faces"][0].update(embedding=unit_vector()[:511]),
122
+ "vector not unit": lambda r: r["faces"][0].update(embedding=[v * 2 for v in unit_vector()]),
123
+ "non-finite vector": lambda r: r["faces"][0]["embedding"].__setitem__(3, float("nan")),
124
+ "unknown gate": lambda r: r["faces"][0].update(gate="maybe"),
125
+ "quality above 1": lambda r: r["faces"][0].update(quality=1.01),
126
+ "negative timing": lambda r: r["inferenceMs"].update(detect=-1),
127
+ }
128
+ for name, corrupt in corruptions.items():
129
+ result = copy.deepcopy(good)
130
+ corrupt(result)
131
+ with self.subTest(name), self.assertRaises(ValueError):
132
+ self.check(result)
133
+
134
+ def test_more_faces_than_asked_is_refused(self):
135
+ with self.assertRaises(ValueError):
136
+ self.check(answer([face(), face(x=100.0)]), {**BARS, "maxFaces": 1})
137
+
138
+
139
+ class CatalogueTest(unittest.TestCase):
140
+ def test_both_tasks_are_in_the_builtin_catalogue_with_their_measured_reservations(self):
141
+ self.assertIn(FACE_DETECTOR, BUILTIN_TASK_MODELS)
142
+ self.assertIn(FACE_EMBEDDER, BUILTIN_TASK_MODELS)
143
+ self.assertEqual((FACE_DETECTOR.model_name, FACE_DETECTOR.task, FACE_DETECTOR.sha256),
144
+ ("yunet_2023mar", "face_detection_landmarks5", fc.FACE_DETECTOR_SHA256))
145
+ self.assertEqual((FACE_EMBEDDER.model_name, FACE_EMBEDDER.task, FACE_EMBEDDER.sha256),
146
+ ("edgeface_xs_gamma_06", "face_identity_embedding", fc.FACE_EMBEDDER_SHA256))
147
+ self.assertEqual(FACE_DETECTOR.approx_ram_bytes, 256 * 1024**2)
148
+ self.assertEqual(FACE_EMBEDDER.approx_ram_bytes, 96 * 1024**2)
149
+
150
+
151
+ class FakeFaceSession:
152
+ def __init__(self, name, sha, result=None):
153
+ self.model_name, self.model_sha256, self.result, self.calls = name, sha, result, []
154
+
155
+ def estimate(self, jpeg, request, embedder):
156
+ self.calls.append((jpeg, request, embedder.model_name))
157
+ return self.result
158
+
159
+
160
+ class AdmissionTest(unittest.TestCase):
161
+ def registry(self, budget, result):
162
+ tmp = tempfile.TemporaryDirectory()
163
+ self.addCleanup(tmp.cleanup)
164
+ root = Path(tmp.name)
165
+ paths = {}
166
+ for name in ("det", fc.FACE_DETECTOR_MODEL_ID, fc.FACE_EMBEDDER_MODEL_ID):
167
+ paths[name] = root / f"{name}.onnx"
168
+ paths[name].write_bytes(name.encode())
169
+ self.loads = []
170
+
171
+ def factory(entry):
172
+ self.loads.append(entry.name)
173
+ if entry.name == fc.FACE_DETECTOR_MODEL_ID:
174
+ return FakeFaceSession(entry.name, fc.FACE_DETECTOR_SHA256, result)
175
+ return FakeFaceSession(entry.name, fc.FACE_EMBEDDER_SHA256)
176
+
177
+ reg = ModelRegistry([ModelEntry(RFDETR_MEDIUM, paths["det"], pinned=True),
178
+ ModelEntry(FACE_DETECTOR, paths[fc.FACE_DETECTOR_MODEL_ID]),
179
+ ModelEntry(FACE_EMBEDDER, paths[fc.FACE_EMBEDDER_MODEL_ID])],
180
+ factory, lambda session: None, budget, log=lambda line: None)
181
+ reg.refresh()
182
+ return reg
183
+
184
+ def test_both_sessions_are_admitted_together_and_counted(self):
185
+ reg = self.registry(2000 * 1024**2, answer([]))
186
+ out = reg.estimate_faces(JPEG, BARS, DETECTOR_PIN, EMBEDDER_PIN)
187
+ self.assertEqual(out["faces"], [])
188
+ self.assertEqual(self.loads, ["rfdetr_medium", fc.FACE_DETECTOR_MODEL_ID, fc.FACE_EMBEDDER_MODEL_ID])
189
+ snap = reg.snapshot()["models"]
190
+ self.assertEqual(snap[fc.FACE_DETECTOR_MODEL_ID]["detect_count"], 1)
191
+ self.assertEqual(snap[fc.FACE_EMBEDDER_MODEL_ID]["task"], "face_identity_embedding")
192
+
193
+ def test_a_different_pin_is_a_verification_error(self):
194
+ reg = self.registry(2000 * 1024**2, answer([]))
195
+ for detector, embedder in (({**DETECTOR_PIN, "sha256": "b" * 64}, EMBEDDER_PIN),
196
+ (DETECTOR_PIN, {**EMBEDDER_PIN, "sha256": "b" * 64}),
197
+ (EMBEDDER_PIN, DETECTOR_PIN)):
198
+ with self.subTest(detector=detector, embedder=embedder), self.assertRaises(ModelVerificationError):
199
+ reg.estimate_faces(JPEG, BARS, detector, embedder)
200
+
201
+ def test_an_answer_naming_another_contract_is_refused_and_counted(self):
202
+ wrong = answer([])
203
+ wrong["embedder"]["preprocessing"] = "something_else"
204
+ reg = self.registry(2000 * 1024**2, wrong)
205
+ with self.assertRaises(ModelVerificationError):
206
+ reg.estimate_faces(JPEG, BARS, DETECTOR_PIN, EMBEDDER_PIN)
207
+ self.assertEqual(reg.snapshot()["models"][fc.FACE_DETECTOR_MODEL_ID]["detect_failures"], 1)
208
+
209
+ def test_no_ram_ceiling_refuses_rather_than_answering_half(self):
210
+ reg = self.registry(None, answer([]))
211
+ with self.assertRaises(DetectorNotReady):
212
+ reg.estimate_faces(JPEG, BARS, DETECTOR_PIN, EMBEDDER_PIN)
213
+
214
+
215
+ class EndpointTest(unittest.TestCase):
216
+ def serve(self, loader):
217
+ server = DetectorServer(("127.0.0.1", 0), loader, log_line=lambda _m: None)
218
+ threading.Thread(target=lambda: server.serve_forever(poll_interval=0.02), daemon=True).start()
219
+ self.addCleanup(server.server_close)
220
+ self.addCleanup(server.shutdown)
221
+ host, port = server.server_address[:2]
222
+ return f"http://{host}:{port}/v1/faces"
223
+
224
+ def post(self, url, body):
225
+ request = urllib.request.Request(url, data=json.dumps(body).encode(), method="POST")
226
+ request.add_header("Content-Type", "application/json")
227
+ try:
228
+ with urllib.request.urlopen(request, timeout=10) as res:
229
+ return res.status, json.loads(res.read().decode())
230
+ except urllib.error.HTTPError as err:
231
+ with err:
232
+ return err.code, json.loads(err.read().decode())
233
+
234
+ def loader(self, result=None, error=None):
235
+ class Loader:
236
+ calls = []
237
+
238
+ def estimate_faces(self, jpeg, bars, detector, embedder):
239
+ self.calls.append((jpeg, bars, detector, embedder))
240
+ if error is not None:
241
+ raise error
242
+ return result
243
+
244
+ return Loader()
245
+
246
+ def test_answers_the_request(self):
247
+ loader = self.loader(answer([face()]))
248
+ status, out = self.post(self.serve(loader), request_body())
249
+ self.assertEqual(status, 200)
250
+ self.assertEqual(out["faces"][0]["gate"], "passed")
251
+ self.assertEqual(loader.calls[0][1], {**BARS, "minEyePx": 12.0})
252
+
253
+ def test_refuses_a_malformed_request_before_inference(self):
254
+ loader = self.loader(answer([]))
255
+ url = self.serve(loader)
256
+ for body in (request_body(maxFaces=0), {**request_body(), "x": 1}, request_body(image_b64="!!")):
257
+ with self.subTest(body={k: v for k, v in body.items() if k != "image_b64"}):
258
+ self.assertEqual(self.post(url, body)[0], 400)
259
+ self.assertEqual(loader.calls, [])
260
+
261
+ def test_status_codes_for_each_refusal(self):
262
+ for error, status in ((ModelVerificationError("other bytes"), 409), (DetectorNotReady("absent"), 503),
263
+ (ValueError("not a jpeg"), 400), (RuntimeError("boom"), 500)):
264
+ with self.subTest(error=type(error).__name__):
265
+ self.assertEqual(self.post(self.serve(self.loader(error=error)), request_body())[0], status)
266
+
267
+ def test_a_malformed_answer_is_a_500_not_a_200(self):
268
+ bad = answer([face()])
269
+ bad["faces"][0]["embedding"] = None
270
+ status, out = self.post(self.serve(self.loader(bad)), request_body())
271
+ self.assertEqual(status, 500)
272
+ self.assertIn("refused malformed face output", out["error"])
273
+
274
+ def test_an_older_loader_is_503(self):
275
+ class OldLoader:
276
+ pass
277
+
278
+ self.assertEqual(self.post(self.serve(OldLoader()), request_body())[0], 503)
279
+
280
+
281
+ @needs_numeric
282
+ class GeometryTest(unittest.TestCase):
283
+ """Golden numbers are the tablet's (FaceEmbeddingAlignmentTest.kt, from skimage/cv2)."""
284
+
285
+ def setUp(self):
286
+ import numpy as np
287
+
288
+ from trillboards_detector import face_identity as fi
289
+ self.np, self.fi = np, fi
290
+ self.ref = fi.ARCFACE_REFERENCE_112
291
+
292
+ def close(self, got, expected, tol=1e-3):
293
+ self.assertIsNotNone(got)
294
+ self.assertLess(float(self.np.max(self.np.abs(got.reshape(-1) - self.np.asarray(expected)))), tol)
295
+
296
+ def test_identity_scale_and_shift(self):
297
+ self.close(self.fi.umeyama(self.ref, self.ref), [1, 0, 0, 0, 1, 0], 1e-6)
298
+ src = self.ref * 2 + self.np.array([10.0, 20.0])
299
+ self.close(self.fi.umeyama(src, self.ref), [0.5, 0, -5, 0, 0.5, -10])
300
+
301
+ def test_rotation_and_realistic_goldens(self):
302
+ rotated = self.np.array([[16.468790714189396, 75.84533481235152], [56.79088068770203, 97.58467938422059],
303
+ [24.206694589922115, 109.75911116312703], [-5.165269981353294, 124.27159194683668],
304
+ [28.226224502304305, 142.2743599070328]])
305
+ self.close(self.fi.umeyama(rotated, self.ref), [0.6750635091464405, 0.36878887584938713, -0.7937954147865156,
306
+ -0.3687888758493872, 0.6750635091464408, 6.5693889432719885])
307
+ realistic = self.np.array([[120, 140], [180, 138], [150, 175], [128, 205], [176, 204]], float)
308
+ self.close(self.fi.umeyama(realistic, self.ref), [0.6093380958941857, -0.014717125930008273, -33.324792350509796,
309
+ 0.014717125930008275, 0.6093380958941859, -35.36845032240289])
310
+
311
+ def test_degenerate_points_have_no_transform(self):
312
+ self.assertIsNone(self.fi.umeyama(self.np.full((5, 2), 50.0), self.ref))
313
+ self.assertIsNone(self.fi.umeyama(self.np.zeros((2, 2)), self.np.zeros((2, 2))))
314
+
315
+ def test_order_is_by_image_position_not_by_name(self):
316
+ a = [[30, 50], [70, 52], [50, 70], [35, 90], [68, 91]]
317
+ b = [[70, 52], [30, 50], [50, 70], [68, 91], [35, 90]]
318
+ self.assertEqual(self.fi.arcface_order(a).tolist(), self.fi.arcface_order(b).tolist())
319
+ self.assertEqual(self.fi.arcface_order(b)[0].tolist(), [30, 50])
320
+
321
+ def test_yaw_is_signed_along_the_eye_line_and_zero_when_frontal(self):
322
+ chip = self.np.zeros((112, 112, 3), self.np.uint8)
323
+ frontal = [[40, 50], [70, 50], [55, 65], [45, 80], [65, 80]]
324
+ eye, yaw, sharp = self.fi.face_measures(frontal, chip)
325
+ self.assertAlmostEqual(eye, 30.0)
326
+ self.assertAlmostEqual(yaw, 0.0)
327
+ self.assertEqual(sharp, 0.0)
328
+ turned = [[40, 50], [70, 50], [64, 65], [45, 80], [65, 80]]
329
+ self.assertAlmostEqual(self.fi.face_measures(turned, chip)[1], 0.3)
330
+ # The same face rolled 90 degrees: still frontal along its own eye line.
331
+ rolled = [[50, 40], [50, 70], [35, 55], [20, 45], [20, 65]]
332
+ self.assertAlmostEqual(self.fi.face_measures(rolled, chip)[1], 0.0)
333
+
334
+ def test_gate_order_and_quality_bounds(self):
335
+ gate = self.fi.face_gate
336
+ self.assertEqual(gate(0.5, 5, 0.9, 1, BARS), "score")
337
+ self.assertEqual(gate(0.9, 11.99, 0.9, 1, BARS), "eye_distance")
338
+ self.assertEqual(gate(0.9, 12, -0.36, 1, BARS), "yaw")
339
+ self.assertEqual(gate(0.9, 12, 0.35, 14.99, BARS), "sharpness")
340
+ self.assertEqual(gate(0.9, 12, 0.35, 15, BARS), "passed")
341
+ self.assertEqual(self.fi.face_quality(1.0, 48, 0, 500), 1.0)
342
+ self.assertEqual(self.fi.face_quality(0.9, 12, 0.5, 30), 0.0)
343
+ self.assertAlmostEqual(self.fi.face_quality(0.8, 12, 0.25, 30), 0.8 * 0.5 * 0.5 * 0.5)
344
+
345
+ def test_decode_follows_opencv_on_constructed_heads(self):
346
+ np = self.np
347
+ pad_w, pad_h = 64, 32
348
+ outputs = {}
349
+ for stride in self.fi.YUNET_STRIDES:
350
+ n = (pad_w // stride) * (pad_h // stride)
351
+ outputs[f"cls_{stride}"] = np.zeros((1, n, 1), np.float32)
352
+ outputs[f"obj_{stride}"] = np.zeros((1, n, 1), np.float32)
353
+ outputs[f"bbox_{stride}"] = np.zeros((1, n, 4), np.float32)
354
+ outputs[f"kps_{stride}"] = np.zeros((1, n, 10), np.float32)
355
+ # One face at stride 8, anchor (row 1, col 2): score sqrt(0.81 * 1) = 0.9.
356
+ idx = 1 * (pad_w // 8) + 2
357
+ outputs["cls_8"][0, idx, 0], outputs["obj_8"][0, idx, 0] = 0.81, 1.2 # obj clamps to 1
358
+ outputs["bbox_8"][0, idx] = [0.5, 0.25, math.log(2), 0.0]
359
+ outputs["kps_8"][0, idx] = [0, 0, 1, 0, 0.5, 0.5, 0, 1, 1, 1]
360
+ # A weaker overlapping duplicate is suppressed by NMS; a below-threshold anchor never appears.
361
+ outputs["cls_8"][0, idx + 1, 0], outputs["obj_8"][0, idx + 1, 0] = 0.64, 1.0
362
+ outputs["bbox_8"][0, idx + 1] = [-0.5, 0.25, math.log(2), 0.0]
363
+ outputs["cls_16"][0, 0, 0], outputs["obj_16"][0, 0, 0] = 0.1, 0.1
364
+ rows = self.fi.decode_yunet(outputs, pad_w, pad_h, 0.5)
365
+ self.assertEqual(len(rows), 1)
366
+ x, y, w, h = rows[0][:4]
367
+ self.assertEqual([round(v, 4) for v in (x, y, w, h)], [12.0, 6.0, 16.0, 8.0])
368
+ self.assertEqual([round(v, 4) for v in rows[0][4:14]], [16, 8, 24, 8, 20, 12, 16, 16, 24, 16])
369
+ self.assertAlmostEqual(rows[0][14], 0.9, places=6)
370
+
371
+ def test_nms_matches_opencv_semantics(self):
372
+ np = self.np
373
+ boxes = np.array([[0, 0, 10, 10], [1, 1, 10, 10], [50, 50, 10, 10]], float)
374
+ scores = np.array([0.9, 0.8, 0.7])
375
+ self.assertEqual(self.fi.nms_boxes(boxes, scores, 0.5, 0.3, 5000).tolist(), [0, 2])
376
+ self.assertEqual(self.fi.nms_boxes(boxes, scores, 0.5, 0.3, 1).tolist(), [0])
377
+ # A score exactly at the threshold is dropped, as GetMaxScoreIndex drops it.
378
+ self.assertEqual(self.fi.nms_boxes(boxes, np.array([0.9, 0.5, 0.5]), 0.5, 0.3, 5000).tolist(), [0])
379
+
380
+
381
+ def _artifact(variable, model_id):
382
+ value = os.environ.get(variable, "").strip()
383
+ path = Path(value) if value else Path.home() / ".trillboards" / "models" / model_id / "model.onnx"
384
+ return path if path.is_file() else None
385
+
386
+
387
+ DETECTOR_ARTIFACT = _artifact("TRILLBOARDS_FACE_DETECTOR_MODEL", fc.FACE_DETECTOR_MODEL_ID)
388
+ EMBEDDER_ARTIFACT = _artifact("TRILLBOARDS_FACE_EMBEDDER_MODEL", fc.FACE_EMBEDDER_MODEL_ID)
389
+ FRAMES = Path(os.environ["TRILLBOARDS_FACE_TEST_FRAMES"]) if os.environ.get("TRILLBOARDS_FACE_TEST_FRAMES") else None
390
+
391
+
392
+ @needs_numeric
393
+ @unittest.skipUnless(DETECTOR_ARTIFACT and EMBEDDER_ARTIFACT, "face artifacts absent (they are OTA'd, never committed)")
394
+ class RealModelTest(unittest.TestCase):
395
+ """The real pinned artifacts: the answer passes the wire check; the decode is OpenCV's."""
396
+
397
+ @classmethod
398
+ def setUpClass(cls):
399
+ from trillboards_detector import face_identity as fi
400
+ cls.fi = fi
401
+ cls.detector = fi.YunetFaceDetector(DETECTOR_ARTIFACT, intra_op_threads=1)
402
+ cls.embedder = fi.EdgeFaceEmbedder(EMBEDDER_ARTIFACT, intra_op_threads=1)
403
+
404
+ def frames(self):
405
+ if FRAMES is None or not FRAMES.is_dir():
406
+ self.skipTest("TRILLBOARDS_FACE_TEST_FRAMES names no directory of JPEGs with faces")
407
+ return sorted(FRAMES.glob("*.jpg"))[:40]
408
+
409
+ def test_probes_complete(self):
410
+ self.detector.probe()
411
+ self.embedder.probe()
412
+
413
+ def test_answers_pass_the_wire_check_and_vectors_are_unit(self):
414
+ faces = 0
415
+ for path in self.frames():
416
+ jpeg = path.read_bytes()
417
+ out = self.detector.estimate(jpeg, BARS, self.embedder)
418
+ fc.check_faces_response(out, jpeg, DETECTOR_PIN, EMBEDDER_PIN, BARS)
419
+ faces += len(out["faces"])
420
+ self.assertGreater(faces, 0)
421
+
422
+ def test_landmarks_put_the_image_left_eye_first_and_match_opencv(self):
423
+ import cv2
424
+ import numpy as np
425
+
426
+ published = os.environ.get("TRILLBOARDS_FACE_DETECTOR_PUBLISHED")
427
+ compared = 0
428
+ for path in self.frames():
429
+ bgr = cv2.imread(str(path))
430
+ ours = self.detector.detect(bgr, 0.5)
431
+ for _box, _score, landmarks in ours:
432
+ self.assertLess(landmarks[0][0], landmarks[1][0])
433
+ if published:
434
+ reference = cv2.FaceDetectorYN.create(published, "", (bgr.shape[1], bgr.shape[0]), 0.5, 0.3, 5000)
435
+ _, rows = reference.detect(bgr)
436
+ rows = [] if rows is None else np.asarray(rows, np.float64).reshape(-1, 15)
437
+ self.assertEqual(len(rows), len(ours))
438
+ for (box, score, landmarks), row in zip(ours, rows):
439
+ got = np.concatenate([box, np.asarray(landmarks).reshape(-1)])
440
+ self.assertLess(float(np.max(np.abs(got - row[:14]))), 1e-2)
441
+ self.assertAlmostEqual(score, float(row[14]), places=4)
442
+ compared += 1
443
+ if published:
444
+ self.assertGreater(compared, 0)
445
+
446
+
447
+ if __name__ == "__main__":
448
+ unittest.main()