added Arduino firmware concept files
This commit is contained in:
@@ -0,0 +1,24 @@
|
||||
# Waveshare firmware validation — concept archive
|
||||
|
||||
Reviewed `BoomCast_Waveshare_Arduino_v0.1.0-concept.zip` as supplied. The README targets the non-touch ESP32-S3-ePaper-1.54 **V2**, but the physical board revision has not been inspected. Waveshare states that V1 and V2 example programs are not interchangeable. Confirm the V2 marking on the PCB before flashing. The official V2 has 8 MiB PSRAM, 8 MiB flash, ES8311 codec, microphone, and microSD slot. The firmware's SDMMC pins 39/40/41 match Waveshare's published pinout for this board.
|
||||
|
||||
## Source review
|
||||
|
||||
- **Microphone and capture:** `boomcast_audio.cpp` uses Waveshare's `audio_bsp` wrapper and a 16 kHz stereo read, selecting the louder slot per frame for mono. That slot selection is a heuristic; verify actual channel mapping and recorded playback on the board. A 2.5-second PSRAM ring and 2.5-second post-trigger buffer make an intended 5-second capture. The detector uses RMS/peak thresholds and cooldown. The first capture after boot can contain less pre-roll. Return values from `audio_playback_read` are not checked, so failed or short reads could enter recordings.
|
||||
- **WAV and storage:** `boomcast_queue.cpp` writes RIFF PCM mono 16-bit headers and a 16 kHz sample rate. Header arithmetic matches the intended sample count. The queue is on FAT microSD, but files are written directly to their final `.wav` names without a temporary file and atomic rename. Power loss or a full card can leave a truncated item that appears queued; `fwrite`, `fflush`, and `fclose` results are not checked.
|
||||
- **Network and uploads:** `boomcast_network.cpp` reconnects Wi-Fi and starts NTP. `boomcast_uploader.cpp` sends a conventional multipart body with CRLF boundaries and a `file` part. It sends a Bearer header if a token is set. The current fields are `event_id`, `trigger_type`, optional `detected_at`, and `file`; this **does not satisfy** the new `/api/pending/` contract's `sensor_id`, `captured_at`, `duration_seconds`, or `firmware_version`. It still targets `/fireworks/classify/`.
|
||||
- **TLS and credentials:** `TLS_ALLOW_INSECURE` defaults to true, and the HTTPS client has no CA certificate configured when it is false. `SENSOR_TOKEN` is in committed-style `boomcast_config.h`; move it into an ignored local header or provisioned NVS and configure a trusted CA before deployment. The setup AP also uses a fixed prototype password.
|
||||
- **Retries and duplicate safety:** the SD item remains after non-2xx or transport failure, and filename-derived `event_id` is stable across retries. The main loop only calls the uploader after an explicit local UI sync request; it does not automatically drain the queue after reconnection. The uploader treats any 2xx response as success without parsing the submission ID or status, and deletes the file immediately. Add bounded retry scheduling with backoff, parse the JSON receipt, and delete only after a matching accepted or duplicate receipt.
|
||||
- **Display and memory:** the ePaper shows capture and queue count, plus a transient upload message on the owner screen. It lacks distinct persistent queued, uploading, success, and failure indicators on the display. The upload path allocates the whole WAV plus multipart framing in PSRAM for each request; there is no measured heap or fragmentation data. Measure free and largest contiguous PSRAM before/after repeated uploads and Wi-Fi outages.
|
||||
|
||||
## Required firmware changes before an end-to-end trial
|
||||
|
||||
1. Confirm the physical V2 revision and use its matching official support files. Do not copy Atom Echo GPIO assignments.
|
||||
2. Point at `/api/pending/` and send `sensor_id`, stable `event_id`, UTC `captured_at`, measured `duration_seconds`, `firmware_version`, and `file`. Do not send a timestamp until NTP or the RTC is valid; preserve a reliable capture time with the queued file.
|
||||
3. Configure CA-backed HTTPS and store the sensor token outside committed source. Reject HTTP on deployed builds.
|
||||
4. Write queue items atomically, detect SD write errors, auto-retry with backoff, validate the JSON receipt, and retain files on ambiguous responses.
|
||||
5. Show distinct recording, queued, uploading, success, and failure states; log I2S read failures and memory metrics.
|
||||
|
||||
## Verification status
|
||||
|
||||
Automated Django tests cover authenticated submission, storage, classification response handling, duplicate retry, invalid token/sensor/audio, conflict, and classifier outage. A temporary local Django instance was inspected with Playwright at desktop and 390 px mobile width; its Pending Review sensor detail rendered and showed no console errors. **No physical Waveshare board was flashed or tested.** Microphone fidelity, trigger timing, HTTPS certificate validation, firmware build, offline queue recovery, and on-device RAM stability remain hardware test items. Use a real recording and a controlled Wi-Fi outage for final acceptance.
|
||||
@@ -0,0 +1,9 @@
|
||||
# Sensor submission contract (v1)
|
||||
|
||||
`POST /api/pending/` accepts `multipart/form-data` from an active, registered sensor. Send `Authorization: Bearer <sensor token>`. The token determines the sensor and owner; send the sensor's database ID in `sensor_id` as an assertion, never as authority.
|
||||
|
||||
Required parts: `file` (16-bit PCM mono WAV), `sensor_id`, `event_id` (1–100 ASCII letters, digits, `_` or `-`), `captured_at` (UTC ISO 8601 timestamp with offset or Unix seconds), `duration_seconds` (positive number matching the WAV within 0.1 seconds), and `firmware_version` (1–64 printable characters). Optional: `trigger_type` (short label), `signal_rms`, `signal_peak` (finite nonnegative numbers), and `latitude`/`longitude` (untrusted device claims, retained only as metadata). No client location is promoted to the trusted event location.
|
||||
|
||||
WAV data must be PCM, mono, 16-bit, at 16 kHz, at most 25 MiB, and 0.1–30 seconds long. A successful first submission returns HTTP 201 with `submission_id`, `status: pending`, and classifier results. A repeat of the same `(sensor, event_id)` returns HTTP 200 with the same `submission_id` and `duplicate: true`; a different body with the same ID returns HTTP 409. Errors have `code` and `detail` fields. HTTP 429 means retry after the `Retry-After` interval. HTTP 502 means classification failed and the device should retain the queued clip.
|
||||
|
||||
The existing `/fireworks/classify/` route remains available for older clients. New firmware should use this contract. Pending audio stays behind the staff-only playback route and follows the existing accept/reject workflow and storage lifetime.
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -68,6 +68,14 @@ class ClassificationAdmin(admin.ModelAdmin):
|
||||
@admin.register(PendingEvent)
|
||||
class PendingEventAdmin(ClassificationAdmin):
|
||||
actions = ("approve_selected", "deny_selected")
|
||||
list_display = ("original_filename", "source_type", "sensor", "sensor_owner", "captured_at", "created_at", "primary_label", "primary_score", "duration")
|
||||
readonly_fields = ClassificationAdmin.readonly_fields + ("sensor_owner", "captured_at", "firmware_version", "device_metadata")
|
||||
fields = ClassificationAdmin.fields + ("sensor_owner", "captured_at", "firmware_version", "device_metadata", "pretty_classifier_response")
|
||||
|
||||
@admin.display(description=gettext_lazy("Sensor owner"))
|
||||
def sensor_owner(self, obj):
|
||||
return obj.sensor.owner if obj.sensor and obj.sensor.owner_id else "—"
|
||||
|
||||
change_form_template = "admin/fireworks_detect/pending_change_form.html"
|
||||
|
||||
def get_urls(self):
|
||||
|
||||
@@ -0,0 +1,60 @@
|
||||
# Generated by Django 6.1.1 on 2026-10-09 13:05
|
||||
|
||||
import django.db.models.deletion
|
||||
import uuid
|
||||
from django.db import migrations, models
|
||||
|
||||
|
||||
class Migration(migrations.Migration):
|
||||
|
||||
dependencies = [
|
||||
('fireworks_detect', '0010_create_browser_processing_settings'),
|
||||
]
|
||||
|
||||
operations = [
|
||||
migrations.AddField(
|
||||
model_name='event',
|
||||
name='captured_at',
|
||||
field=models.DateTimeField(blank=True, null=True),
|
||||
),
|
||||
migrations.AddField(
|
||||
model_name='event',
|
||||
name='device_metadata',
|
||||
field=models.JSONField(blank=True, default=dict),
|
||||
),
|
||||
migrations.AddField(
|
||||
model_name='event',
|
||||
name='firmware_version',
|
||||
field=models.CharField(blank=True, max_length=64),
|
||||
),
|
||||
migrations.AddField(
|
||||
model_name='pendingevent',
|
||||
name='captured_at',
|
||||
field=models.DateTimeField(blank=True, null=True),
|
||||
),
|
||||
migrations.AddField(
|
||||
model_name='pendingevent',
|
||||
name='device_metadata',
|
||||
field=models.JSONField(blank=True, default=dict),
|
||||
),
|
||||
migrations.AddField(
|
||||
model_name='pendingevent',
|
||||
name='firmware_version',
|
||||
field=models.CharField(blank=True, max_length=64),
|
||||
),
|
||||
migrations.CreateModel(
|
||||
name='SensorSubmission',
|
||||
fields=[
|
||||
('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
|
||||
('event_id', models.CharField(max_length=100)),
|
||||
('audio_sha256', models.CharField(max_length=64)),
|
||||
('submission_id', models.UUIDField(default=uuid.uuid4, editable=False, unique=True)),
|
||||
('created_at', models.DateTimeField(auto_now_add=True)),
|
||||
('pending_event', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, to='fireworks_detect.pendingevent')),
|
||||
('sensor', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='submissions', to='fireworks_detect.sensor')),
|
||||
],
|
||||
options={
|
||||
'constraints': [models.UniqueConstraint(fields=('sensor', 'event_id'), name='unique_sensor_event_id')],
|
||||
},
|
||||
),
|
||||
]
|
||||
BIN
Binary file not shown.
@@ -1,5 +1,6 @@
|
||||
import math
|
||||
import secrets
|
||||
import uuid
|
||||
|
||||
from django.conf import settings
|
||||
from django.contrib.auth.hashers import check_password, make_password
|
||||
@@ -131,6 +132,9 @@ class ClassifiedAudio(models.Model):
|
||||
direction_accuracy_degrees = models.FloatField(null=True, blank=True)
|
||||
direction_source = models.CharField(max_length=32, blank=True)
|
||||
created_at = models.DateTimeField(auto_now_add=True)
|
||||
captured_at = models.DateTimeField(null=True, blank=True)
|
||||
firmware_version = models.CharField(max_length=64, blank=True)
|
||||
device_metadata = models.JSONField(default=dict, blank=True)
|
||||
|
||||
class Meta:
|
||||
abstract = True
|
||||
@@ -227,6 +231,9 @@ class PendingEvent(ClassifiedAudio):
|
||||
event = Event.objects.create(
|
||||
audio_file=self.audio_file.name,
|
||||
sensor=self.sensor,
|
||||
captured_at=self.captured_at,
|
||||
firmware_version=self.firmware_version,
|
||||
device_metadata=self.device_metadata,
|
||||
original_filename=self.original_filename,
|
||||
classifier_response=self.classifier_response,
|
||||
source_type=self.source_type,
|
||||
@@ -258,3 +265,17 @@ class Event(ClassifiedAudio):
|
||||
class Meta(ClassifiedAudio.Meta):
|
||||
verbose_name = _("Event")
|
||||
verbose_name_plural = _("Events")
|
||||
|
||||
|
||||
class SensorSubmission(models.Model):
|
||||
"""Durable idempotency receipt, retained after moderation."""
|
||||
|
||||
sensor = models.ForeignKey(Sensor, on_delete=models.CASCADE, related_name="submissions")
|
||||
event_id = models.CharField(max_length=100)
|
||||
audio_sha256 = models.CharField(max_length=64)
|
||||
submission_id = models.UUIDField(default=uuid.uuid4, unique=True, editable=False)
|
||||
pending_event = models.ForeignKey(PendingEvent, null=True, blank=True, on_delete=models.SET_NULL)
|
||||
created_at = models.DateTimeField(auto_now_add=True)
|
||||
|
||||
class Meta:
|
||||
constraints = [models.UniqueConstraint(fields=["sensor", "event_id"], name="unique_sensor_event_id")]
|
||||
|
||||
@@ -0,0 +1,91 @@
|
||||
import io
|
||||
import json
|
||||
import struct
|
||||
import wave
|
||||
from tempfile import TemporaryDirectory
|
||||
from unittest.mock import patch
|
||||
|
||||
from django.contrib.auth import get_user_model
|
||||
from django.core.files.uploadedfile import SimpleUploadedFile
|
||||
from django.test import TestCase, override_settings
|
||||
from django.urls import reverse
|
||||
|
||||
from .models import PendingEvent, Sensor, SensorSubmission
|
||||
|
||||
|
||||
def wav_bytes():
|
||||
stream = io.BytesIO()
|
||||
with wave.open(stream, "wb") as wav:
|
||||
wav.setnchannels(1)
|
||||
wav.setsampwidth(2)
|
||||
wav.setframerate(16000)
|
||||
wav.writeframes(struct.pack("<16000h", *([0] * 16000)))
|
||||
return stream.getvalue()
|
||||
|
||||
|
||||
class SensorSubmissionTests(TestCase):
|
||||
def setUp(self):
|
||||
self.owner = get_user_model().objects.create_user("sensor-owner", password="test")
|
||||
self.sensor = Sensor.objects.create(name="Waveshare V2", owner=self.owner)
|
||||
self.token = self.sensor.issue_token()
|
||||
self.url = reverse("sensor_pending")
|
||||
self.audio = wav_bytes()
|
||||
|
||||
def submit(self, token=None, **fields):
|
||||
data = {
|
||||
"sensor_id": str(self.sensor.pk), "event_id": "device-event-1",
|
||||
"captured_at": "2026-10-09T10:00:00Z", "duration_seconds": "1",
|
||||
"firmware_version": "0.1.0-concept",
|
||||
"file": SimpleUploadedFile("event.wav", self.audio, content_type="audio/wav"),
|
||||
}
|
||||
data.update(fields)
|
||||
return self.client.post(self.url, data, HTTP_AUTHORIZATION=f"Bearer {token or self.token}")
|
||||
|
||||
def test_authenticated_upload_is_classified_and_retry_is_idempotent(self):
|
||||
response_body = io.BytesIO(json.dumps({"predictions": [{"class": "Fireworks", "score": 0.8}], "duration_seconds": 1}).encode())
|
||||
with TemporaryDirectory() as media, override_settings(MEDIA_ROOT=media), patch("fireworks_detect.views.urlopen", return_value=response_body) as classify:
|
||||
first = self.submit(trigger_type="audio_spike", latitude="52.1")
|
||||
second = self.submit()
|
||||
self.assertEqual(first.status_code, 201)
|
||||
self.assertEqual(second.status_code, 200)
|
||||
self.assertEqual(first.json()["submission_id"], second.json()["submission_id"])
|
||||
self.assertEqual(PendingEvent.objects.count(), 1)
|
||||
self.assertEqual(SensorSubmission.objects.count(), 1)
|
||||
self.assertEqual(classify.call_count, 1)
|
||||
pending = PendingEvent.objects.get()
|
||||
self.assertEqual(pending.sensor, self.sensor)
|
||||
self.assertEqual(pending.source_type, "sensor")
|
||||
self.assertFalse(pending.latitude)
|
||||
self.assertEqual(pending.device_metadata["latitude"], "52.1")
|
||||
self.assertTrue(pending.audio_file.storage.exists(pending.audio_file.name))
|
||||
|
||||
def test_pending_admin_shows_sensor_details(self):
|
||||
staff = get_user_model().objects.create_superuser("reviewer-sensor", password="test")
|
||||
pending = PendingEvent.objects.create(sensor=self.sensor, source_type="sensor", original_filename="event.wav", classifier_response={"predictions": [{"class": "Fireworks", "score": 0.8}]}, firmware_version="0.1.0-concept", device_metadata={"trigger_type": "audio_spike"})
|
||||
self.client.force_login(staff)
|
||||
response = self.client.get(reverse("admin:fireworks_detect_pendingevent_change", args=[pending.pk]))
|
||||
self.assertEqual(response.status_code, 200)
|
||||
self.assertContains(response, "sensor-owner")
|
||||
self.assertContains(response, "0.1.0-concept")
|
||||
self.assertContains(response, "audio_spike")
|
||||
|
||||
def test_classifier_failure_keeps_event_retryable(self):
|
||||
from urllib.error import URLError
|
||||
with patch("fireworks_detect.views.urlopen", side_effect=URLError("offline")):
|
||||
response = self.submit()
|
||||
self.assertEqual(response.status_code, 502)
|
||||
self.assertEqual(response.json()["code"], "classifier_unavailable")
|
||||
self.assertFalse(PendingEvent.objects.exists())
|
||||
self.assertFalse(SensorSubmission.objects.exists())
|
||||
|
||||
def test_existing_event_id_with_different_audio_conflicts(self):
|
||||
SensorSubmission.objects.create(sensor=self.sensor, event_id="device-event-1", audio_sha256="0" * 64)
|
||||
response = self.submit()
|
||||
self.assertEqual(response.status_code, 409)
|
||||
self.assertEqual(response.json()["code"], "event_id_conflict")
|
||||
|
||||
def test_bad_token_sensor_mismatch_and_malformed_audio_are_rejected(self):
|
||||
self.assertEqual(self.submit(token="wrong").status_code, 401)
|
||||
self.assertEqual(self.submit(sensor_id="999").status_code, 403)
|
||||
self.assertEqual(self.submit(file=SimpleUploadedFile("bad.wav", b"not wav", content_type="audio/wav")).status_code, 400)
|
||||
self.assertFalse(PendingEvent.objects.exists())
|
||||
@@ -14,6 +14,7 @@ from .views import (
|
||||
submit_manual_pending_event,
|
||||
submit_pending_event,
|
||||
sensor_heartbeat,
|
||||
submit_sensor_pending,
|
||||
browser_processing_policy,
|
||||
)
|
||||
|
||||
|
||||
+120
-1
@@ -1,4 +1,11 @@
|
||||
import math
|
||||
import hashlib
|
||||
import re
|
||||
import wave
|
||||
from datetime import datetime, timezone as datetime_timezone
|
||||
from django.core.cache import cache
|
||||
from django.db import IntegrityError, transaction
|
||||
from django.utils.dateparse import parse_datetime
|
||||
from datetime import timedelta
|
||||
from decimal import Decimal, InvalidOperation
|
||||
import json
|
||||
@@ -22,7 +29,7 @@ from django.views.decorators.http import require_http_methods
|
||||
|
||||
from .h3_utils import cell_boundary, cell_center, cell_from_coordinates, h3_resolution
|
||||
from .browser_policy import advisory_browser_metadata, browser_config, browser_policy
|
||||
from .models import BrowserProcessingSettings, ClassificationRule, Event, PendingEvent, Sensor
|
||||
from .models import BrowserProcessingSettings, ClassificationRule, Event, PendingEvent, Sensor, SensorSubmission
|
||||
|
||||
|
||||
CLASSIFIER_URL = "http://192.168.1.122:5000/classify"
|
||||
@@ -500,6 +507,118 @@ def classify_audio(request):
|
||||
return JsonResponse({**payload, "pending_event_id": pending.pk, "sensor": sensor.name}, status=201)
|
||||
|
||||
|
||||
def _submission_error(code, detail, status=400):
|
||||
return JsonResponse({"code": code, "detail": detail}, status=status)
|
||||
|
||||
|
||||
@csrf_exempt
|
||||
@require_http_methods(["POST"])
|
||||
def submit_sensor_pending(request):
|
||||
sensor = _sensor_from_request(request)
|
||||
if sensor is None:
|
||||
return _submission_error("unauthorized", "A valid sensor API token is required.", 401)
|
||||
if not sensor.owner_id:
|
||||
return _submission_error("unowned_sensor", "Sensor has no registered owner.", 403)
|
||||
if request.POST.get("sensor_id") != str(sensor.pk):
|
||||
return _submission_error("sensor_mismatch", "sensor_id must match the authenticated sensor.", 403)
|
||||
event_id = request.POST.get("event_id", "")
|
||||
if not re.fullmatch(r"[A-Za-z0-9_-]{1,100}", event_id):
|
||||
return _submission_error("invalid_event_id", "Provide a valid event_id.")
|
||||
uploaded = request.FILES.get("file")
|
||||
if uploaded is None:
|
||||
return _submission_error("missing_file", "Attach PCM WAV as multipart field 'file'.")
|
||||
if uploaded.size > MAX_AUDIO_SIZE:
|
||||
return _submission_error("file_too_large", "Audio exceeds 25 MiB.", 413)
|
||||
if not uploaded.name.lower().endswith(".wav"):
|
||||
return _submission_error("invalid_audio", "Only PCM WAV is accepted.")
|
||||
try:
|
||||
with wave.open(uploaded, "rb") as wav:
|
||||
if wav.getcomptype() != "NONE" or wav.getnchannels() != 1 or wav.getsampwidth() != 2 or wav.getframerate() != 16000:
|
||||
raise ValueError("WAV must be 16-bit mono PCM at 16 kHz.")
|
||||
frames = wav.getnframes()
|
||||
if len(wav.readframes(frames)) != frames * 2:
|
||||
raise ValueError("WAV sample data is truncated.")
|
||||
actual_duration = frames / wav.getframerate()
|
||||
if not 0.1 <= actual_duration <= 30:
|
||||
raise ValueError("WAV duration must be between 0.1 and 30 seconds.")
|
||||
declared_duration = float(request.POST.get("duration_seconds", ""))
|
||||
if not math.isfinite(declared_duration) or abs(declared_duration - actual_duration) > 0.1:
|
||||
raise ValueError("duration_seconds does not match the WAV.")
|
||||
except (wave.Error, EOFError, ValueError, TypeError) as error:
|
||||
return _submission_error("invalid_audio", str(error))
|
||||
finally:
|
||||
uploaded.seek(0)
|
||||
raw_time = request.POST.get("captured_at", "")
|
||||
try:
|
||||
captured_at = datetime.fromtimestamp(float(raw_time), datetime_timezone.utc) if re.fullmatch(r"[0-9]{10}(?:\.[0-9]+)?", raw_time) else parse_datetime(raw_time)
|
||||
if captured_at is None or timezone.is_naive(captured_at):
|
||||
raise ValueError()
|
||||
if captured_at > timezone.now() + timedelta(minutes=5):
|
||||
raise ValueError()
|
||||
except (ValueError, OverflowError, OSError):
|
||||
return _submission_error("invalid_capture_time", "captured_at must be a valid past UTC time.")
|
||||
firmware = request.POST.get("firmware_version", "")
|
||||
if not 1 <= len(firmware) <= 64 or not firmware.isprintable():
|
||||
return _submission_error("invalid_firmware_version", "Provide a printable firmware_version of at most 64 characters.")
|
||||
metadata = {}
|
||||
for key in ("trigger_type", "signal_rms", "signal_peak", "latitude", "longitude"):
|
||||
value = request.POST.get(key)
|
||||
if value is None or value == "":
|
||||
continue
|
||||
if key == "trigger_type":
|
||||
if len(value) > 64 or not value.isprintable():
|
||||
return _submission_error("invalid_metadata", "Invalid trigger_type.")
|
||||
else:
|
||||
try:
|
||||
number = float(value)
|
||||
if not math.isfinite(number) or (key.startswith("signal_") and number < 0) or (key == "latitude" and abs(number) > 90) or (key == "longitude" and abs(number) > 180):
|
||||
raise ValueError()
|
||||
except ValueError:
|
||||
return _submission_error("invalid_metadata", f"Invalid {key}.")
|
||||
metadata[key] = value
|
||||
digest = hashlib.sha256()
|
||||
for chunk in uploaded.chunks():
|
||||
digest.update(chunk)
|
||||
audio_hash = digest.hexdigest()
|
||||
uploaded.seek(0)
|
||||
existing = SensorSubmission.objects.filter(sensor=sensor, event_id=event_id).first()
|
||||
if existing:
|
||||
if existing.audio_sha256 != audio_hash:
|
||||
return _submission_error("event_id_conflict", "event_id already belongs to different audio.", 409)
|
||||
return JsonResponse({"submission_id": str(existing.submission_id), "status": "pending" if existing.pending_event_id else "reviewed", "duplicate": True}, status=200)
|
||||
rate_key = f"sensor-submissions:{sensor.pk}"
|
||||
if cache.get(rate_key, 0) >= 30:
|
||||
response = _submission_error("rate_limited", "Sensor submission rate exceeded.", 429)
|
||||
response["Retry-After"] = "60"
|
||||
return response
|
||||
cache.add(rate_key, 0, 60)
|
||||
try:
|
||||
cache.incr(rate_key)
|
||||
except ValueError:
|
||||
cache.set(rate_key, 1, 60)
|
||||
body, content_type = _encode_audio_multipart(uploaded)
|
||||
classifier_request = Request(CLASSIFIER_URL, data=body, headers={"Content-Type": content_type, "Accept": "application/json"}, method="POST")
|
||||
try:
|
||||
with urlopen(classifier_request, timeout=60) as response:
|
||||
payload = json.loads(response.read().decode("utf-8"))
|
||||
if not isinstance(payload, dict):
|
||||
raise ValueError("Classifier response must be an object.")
|
||||
except (HTTPError, URLError, TimeoutError, OSError, ValueError, json.JSONDecodeError):
|
||||
return _submission_error("classifier_unavailable", "Classification failed; retain the queued recording.", 502)
|
||||
uploaded.seek(0)
|
||||
try:
|
||||
with transaction.atomic():
|
||||
pending = PendingEvent.objects.create(audio_file=uploaded, sensor=sensor, source_type=PendingEvent.SourceType.SENSOR, original_filename=Path(uploaded.name).name[:255], classifier_response=payload, captured_at=captured_at, firmware_version=firmware, device_metadata=metadata)
|
||||
receipt = SensorSubmission.objects.create(sensor=sensor, event_id=event_id, audio_sha256=audio_hash, pending_event=pending)
|
||||
except IntegrityError:
|
||||
existing = SensorSubmission.objects.get(sensor=sensor, event_id=event_id)
|
||||
if existing.audio_sha256 != audio_hash:
|
||||
return _submission_error("event_id_conflict", "event_id already belongs to different audio.", 409)
|
||||
return JsonResponse({"submission_id": str(existing.submission_id), "status": "pending" if existing.pending_event_id else "reviewed", "duplicate": True})
|
||||
sensor.record_heartbeat(submission=True)
|
||||
return JsonResponse({"submission_id": str(receipt.submission_id), "pending_event_id": pending.pk, "status": "pending", "classification": payload}, status=201)
|
||||
|
||||
|
||||
@csrf_exempt
|
||||
@require_http_methods(["POST"])
|
||||
def sensor_heartbeat(request):
|
||||
|
||||
Binary file not shown.
Binary file not shown.
+2
-1
@@ -6,7 +6,7 @@ from django.contrib.auth import views as auth_views
|
||||
from django.urls import include, path, re_path
|
||||
from django.views.static import serve
|
||||
|
||||
from fireworks_detect.views import dashboard_view
|
||||
from fireworks_detect.views import dashboard_view, submit_sensor_pending
|
||||
from hello.views import hello_view
|
||||
from members.language_views import set_anonymous_language
|
||||
from members.views import register
|
||||
@@ -20,6 +20,7 @@ urlpatterns = [
|
||||
path("classifications/", include("fireworks_detect.classification_urls")),
|
||||
path("settings/", include("members.settings_urls")),
|
||||
path("fireworks/", include("fireworks_detect.urls")),
|
||||
path("api/pending/", submit_sensor_pending, name="sensor_pending"),
|
||||
path("members/", include("members.urls")),
|
||||
path("old/", hello_view, name="old_home"),
|
||||
path("", dashboard_view, name="hello"),
|
||||
|
||||
Reference in New Issue
Block a user