[P] Add second agent in docker-compose.yaml

MapView/datasource.py

@@ -9,7 +9,6 @@ from config import STORE_HOST, STORE_PORT
 
 # Pydantic models
 class ProcessedAgentData(BaseModel):
-    id: int
     road_state: str
     user_id: int
     x: float
@@ -33,12 +32,11 @@ class ProcessedAgentData(BaseModel):
 
 
 class Datasource:
-    def __init__(self):
-        self.websocket: Connection | None = None
+    def __init__(self, user_id: int):
         self.index = 0
+        self.user_id = user_id
         self.connection_status = None
         self._new_points = []
-        self._active_markers = []
         asyncio.ensure_future(self.connect_to_server())
 
     def get_new_points(self):
@@ -48,12 +46,11 @@ class Datasource:
         return points
 
     async def connect_to_server(self):
-        uri = f"ws://{STORE_HOST}:{STORE_PORT}/ws"
+        uri = f"ws://{STORE_HOST}:{STORE_PORT}/ws/{self.user_id}"
         while True:
             Logger.debug("CONNECT TO SERVER")
             async with websockets.connect(uri) as websocket:
                 self.connection_status = "Connected"
-                self.websocket = websocket
                 try:
                     while True:
                         data = await websocket.recv()
@@ -63,26 +60,6 @@ class Datasource:
                     self.connection_status = "Disconnected"
                     Logger.debug("SERVER DISCONNECT")
 
-    def update_db_record_visibility(self, record_id):
-        if self.websocket:
-            data = json.dumps({"id": record_id})
-            asyncio.ensure_future(self.websocket.send(data))
-
-    def map_lat_lon_to_processed_agent_data(self, lat: float, lon: float) -> ProcessedAgentData | None:
-        distances = tuple((abs(lon - marker.latitude) ** 2 + abs(lat - marker.longitude) ** 2) ** 0.5 for marker in
-                          self._active_markers)
-
-        if len(distances) == 0:
-            return None
-
-        min_distance = min(distances)
-        marker = self._active_markers[distances.index(min_distance)]
-
-        if min_distance < 0.005:
-            return marker
-        else:
-            return None
-
     def handle_received_data(self, data):
         # Update your UI or perform actions with received data here
         Logger.debug(f"Received data: {data}")
@@ -93,9 +70,6 @@ class Datasource:
             ],
             key=lambda v: v.timestamp,
         )
-
-        self._active_markers += [i for i in processed_agent_data_list if i.road_state != 'normal']
-
         new_points = [
             (
                 processed_agent_data.longitude,

MapView/main.py

@@ -15,31 +15,18 @@ line_layer_colors = [
     [1, 0, 1, 1],
 ]
 
-
-def get_lat_lon(point: dict[str, float] | list[float] | tuple[float, float]) -> tuple[float, float] | None:
-    if isinstance(point, dict):
-        lat = point.get("lat")
-        lon = point.get("lon")
-    else:
-        lat, lon = point
-
-    if lat is None or lon is None:
-        return None
-    return lat, lon
-
-
 class MapViewApp(App):
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
 
-        self.mapview: MapView | None = None
-        self.datasource = Datasource()
+        self.mapview = None
+        self.datasource = Datasource(user_id=1)
         self.line_layers = dict()
         self.car_markers = dict()
 
         # додати необхідні змінні
-        self.bump_markers: list[MapMarker] = []
-        self.pothole_markers: list[MapMarker] = []
+        self.bump_markers = []
+        self.pothole_markers = []
 
     def on_start(self):
         """
@@ -104,16 +91,13 @@ class MapViewApp(App):
         if user_id == config.TRACK_ID:
             self.mapview.center_on(lat, lon)
 
-    def map_lat_lon_to_marker(self, lat: float, lon: float) -> MapMarker | None:
-        flt = filter(lambda marker: lon == marker.lat and lat == marker.lon, self.pothole_markers + self.bump_markers)
-
-        try:
-            return next(flt)
-        except StopIteration:
-            return None
-
     def set_pothole_marker(self, point):
-        lat, lon = get_lat_lon(point)
+        if isinstance(point, dict):
+            lat = point.get("lat")
+            lon = point.get("lon")
+        else:
+            lat, lon = point
+
         if lat is None or lon is None:
             return
 
@@ -127,7 +111,12 @@ class MapViewApp(App):
         self.pothole_markers.append(marker)
 
     def set_bump_marker(self, point):
-        lat, lon = get_lat_lon(point)
+        if isinstance(point, dict):
+            lat = point.get("lat")
+            lon = point.get("lon")
+        else:
+            lat, lon = point
+
         if lat is None or lon is None:
             return
         
@@ -140,35 +129,6 @@ class MapViewApp(App):
         self.mapview.add_marker(marker)
         self.bump_markers.append(marker)
 
-    def delete_pothole_marker(self, point):
-        lat, lon = get_lat_lon(point)
-        if lat is None or lon is None:
-            return
-
-        clicked_marker_data = self.datasource.map_lat_lon_to_processed_agent_data(lat, lon)
-
-        if not clicked_marker_data:
-            return
-
-        clicked_marker = self.map_lat_lon_to_marker(clicked_marker_data.latitude, clicked_marker_data.longitude)
-
-        if clicked_marker is None:
-            return
-
-        self.mapview.remove_marker(clicked_marker)
-
-        if clicked_marker in self.pothole_markers:
-            self.pothole_markers.pop(self.pothole_markers.index(clicked_marker))
-        elif clicked_marker in self.bump_markers:
-            self.bump_markers.pop(self.bump_markers.index(clicked_marker))
-
-        self.datasource.update_db_record_visibility(clicked_marker_data.id)
-
-    def on_touch_down(self, widget, touch):
-        if touch.button == "right":
-            coordinate = self.mapview.get_latlon_at(touch.x, touch.y, self.mapview.zoom)
-            self.delete_pothole_marker(coordinate)
-            return True
 
     def build(self):
         """
@@ -181,8 +141,6 @@ class MapViewApp(App):
             lon=30.5234
         )
 
-        self.mapview.bind(on_touch_down=self.on_touch_down)
-
         return self.mapview
 
 

agent/src/data/gpx-to-csv.py

@@ -1,13 +0,0 @@
-print('lat,lon')
-
-try:
-    while True:
-        i = input()
-
-        if '<trkpt' not in i:
-            continue
-
-        si = i.split('"')[1::2]
-        print(f"{si[0]},{si[1]}")
-except EOFError:
-    pass

docker-compose.yaml

@@ -148,7 +148,7 @@ services:
       MQTT_BROKER_HOST: "mqtt"
       MQTT_BROKER_PORT: 1883
       MQTT_TOPIC: "processed_data_topic"
-      BATCH_SIZE: 4
+      BATCH_SIZE: 20
     ports:
       - "9000:8000"
     networks:

store/docker/db/structure.sql

@@ -7,6 +7,5 @@ CREATE TABLE processed_agent_data (
     z FLOAT,
     latitude FLOAT,
     longitude FLOAT,
-    timestamp TIMESTAMP,
-    visible BOOLEAN
+    timestamp TIMESTAMP
 );

store/main.py

@@ -8,13 +8,12 @@ from sqlalchemy import (
     Integer,
     String,
     Float,
-    Boolean,
     DateTime,
 )
 from sqlalchemy.sql import select
 
 from database import metadata, SessionLocal
-from schemas import ProcessedAgentData, ProcessedAgentDataInDB, WebSocketData
+from schemas import ProcessedAgentData, ProcessedAgentDataInDB
 
 # FastAPI app setup
 app = FastAPI()
@@ -31,7 +30,6 @@ processed_agent_data = Table(
     Column("latitude", Float),
     Column("longitude", Float),
     Column("timestamp", DateTime),
-    Column("visible", Boolean),
 )
 
 # WebSocket subscriptions
@@ -39,21 +37,16 @@ subscriptions: Set[WebSocket] = set()
 
 
 # FastAPI WebSocket endpoint
-@app.websocket("/ws")
-async def websocket_endpoint(websocket: WebSocket):
+@app.websocket("/ws/{user_id}")
+async def websocket_endpoint(websocket: WebSocket, user_id: int):
     await websocket.accept()
 
     subscriptions.add(websocket)
 
     try:
         # send already available data
-        r = processed_agent_data.select() \
-                                .where(processed_agent_data.c.visible == True) \
-                                .order_by(processed_agent_data.c.timestamp)
-
-        session = SessionLocal()
-        stored_data = session.execute(r).fetchall()
-        session.close() 
+        r = processed_agent_data.select()
+        stored_data = SessionLocal().execute(r).fetchall()
 
         jsonable_data = [{c.name: getattr(i, c.name) for c in processed_agent_data.columns} for i in stored_data]
         for i in jsonable_data:
@@ -64,24 +57,7 @@ async def websocket_endpoint(websocket: WebSocket):
 
         # receive forever
         while True:
-            data = await websocket.receive_text()
-            try:
-                if (data):
-                    ws_data = WebSocketData.model_validate(json.loads(data))
-                    session = SessionLocal()
-                    update_query = (
-                        processed_agent_data.update()
-                        .where(processed_agent_data.c.id == ws_data.id)
-                        .values(visible=False)
-                    ).returning(processed_agent_data)
-                    res = session.execute(update_query).fetchone()
-                    if (not res):
-                        session.rollback()
-                        raise Exception("Error while websocket PUT")
-                    session.commit()
-            finally:
-                session.close()                  
-         
+            await websocket.receive_text()
     except WebSocketDisconnect:
         subscriptions.remove(websocket)
 
@@ -105,7 +81,6 @@ def ProcessedAgentData_to_td(data: List[ProcessedAgentData]):
                 "latitude": item.agent_data.gps.latitude,
                 "longitude": item.agent_data.gps.longitude,
                 "timestamp": item.agent_data.timestamp,
-                "visible": True,
             }
             for item in data
         ]
@@ -203,12 +178,8 @@ def update_processed_agent_data(processed_agent_data_id: int, data: ProcessedAge
         session.commit()
 
         updated_result = session.execute(query).fetchone()
-        return ProcessedAgentDataInDB(**updated_result._mapping)
 
-    except Exception as err:
-        session.rollback()
-        print(f"Database error: {err}")
-        raise HTTPException(status_code=500, detail="Internal Server Error")
+        return ProcessedAgentDataInDB(**updated_result._mapping)
 
     finally:
         session.close()
@@ -240,11 +211,6 @@ def delete_processed_agent_data(processed_agent_data_id: int):
 
         return ProcessedAgentDataInDB(**result._mapping)
 
-    except Exception as err:
-        session.rollback()
-        print(f"Database error: {err}")
-        raise HTTPException(status_code=500, detail="Internal Server Error")
-        
     finally:
         session.close()
 

store/schemas.py

@@ -49,7 +49,3 @@ class AgentData(BaseModel):
 class ProcessedAgentData(BaseModel):
     road_state: str
     agent_data: AgentData
-    
-class WebSocketData(BaseModel):
-    id: int
-

store/test_db.py

@@ -1,45 +0,0 @@
-from fastapi.testclient import TestClient
-from main import app, processed_agent_data
-from database import SessionLocal
-from sqlalchemy import select
-from datetime import datetime
-
-client = TestClient(app)
-
-
-def test_create_processed_agent_data():
-    db = SessionLocal()
-    before = db.execute(select(processed_agent_data)).fetchall()
-    before_count = len(before)
-    payload = {
-        "user_id": 123,
-        "data": [
-            {
-                "road_state": "normal",
-                "agent_data": {
-                    "user_id": 999, 
-                    "accelerometer": {
-                        "x": 1.1,
-                        "y": 2.2,
-                        "z": 3.3
-                    },
-                    "gps": {
-                        "latitude": 50.45,
-                        "longitude": 30.52
-                    },
-                    "timestamp": datetime.now().isoformat()
-                }
-            }
-        ]
-    }
-    
-    response = client.post("/processed_agent_data/", json=payload)
-
-    assert response.status_code == 200
-
-    after = db.execute(select(processed_agent_data)).fetchall()
-    after_count = len(after)
-
-    assert after_count == before_count + 1
-
-    db.close()