telemetry-server 0.1.0__py3-none-any.whl

app.py

@@ -0,0 +1,6 @@
+from autoboat_telemetry_server import create_app
+
+app = create_app()
+
+if __name__ == "__main__":
+    app.run()

autoboat_telemetry_server/__init__.py

@@ -0,0 +1,44 @@
+"""Telemetry server for Autoboat at Virginia Tech."""
+
+import os
+from flask import Flask as _flask
+from autoboat_telemetry_server.routes import AutopilotParametersEndpoint, BoatStatusEndpoint, WaypointEndpoint
+
+__all__ = ["create_app"]
+
+
+def create_app() -> _flask:
+    """
+    Create and configure the Flask application instance.
+
+    Returns
+    -------
+    _flask
+        Configured Flask application instance.
+    """
+
+    app = _flask(__name__)
+
+    instance_dir = "/home/ubuntu/telemetry_server/src/instance"
+    config_path = os.path.join(instance_dir, "config.py")
+
+    app.config.from_pyfile(config_path)
+
+    app.register_blueprint(AutopilotParametersEndpoint().blueprint)
+    app.register_blueprint(BoatStatusEndpoint().blueprint)
+    app.register_blueprint(WaypointEndpoint().blueprint)
+
+    @app.route("/")
+    def index() -> str:
+        """
+        Root route for the telemetry server.
+
+        Returns
+        -------
+        str
+            Confirmation message indicating which server is running.
+        """
+
+        return "This is the production telemetry server. It is running!"
+
+    return app

autoboat_telemetry_server/routes/__init__.py

@@ -0,0 +1,29 @@
+"""
+Module containing the routes for the Autoboat telemetry server.
+
+Autopilot Routes:
+- `/autopilot_parameters/test`: Test route for autopilot parameters.
+- `/autopilot_parameters/get`: Get the current autopilot parameters.
+- `/autopilot_parameters/get_new`: Get the latest autopilot parameters if they haven't been seen yet.
+- `/autopilot_parameters/get_default`: Get the default autopilot parameters.
+- `/autopilot_parameters/set`: Set the autopilot parameters from the request data.
+- `/autopilot_parameters/set_default`: Set the default autopilot parameters from the request data.
+
+Boat Status Routes:
+- `/boat_status/test`: Test route for boat status.
+- `/boat_status/get`: Get the current boat status.
+- `/boat_status/get_new`: Get the latest boat status if it hasn't been seen yet.
+- `/boat_status/set`: Set the boat status from the request data.
+
+Waypoint Routes:
+- `/waypoints/test`: Test route for waypoints.
+- `/waypoints/get`: Get the current waypoints.
+- `/waypoints/get_new`: Get the latest waypoints if they haven't been seen yet.
+- `/waypoints/set`: Set the waypoints from the request data.
+"""
+
+__all__ = ["AutopilotParametersEndpoint", "BoatStatusEndpoint", "WaypointEndpoint"]
+
+from .autopilot_parameters import AutopilotParametersEndpoint
+from .boat_status import BoatStatusEndpoint
+from .waypoints import WaypointEndpoint

autoboat_telemetry_server/routes/autopilot_parameters.py

@@ -0,0 +1,176 @@
+from flask import Blueprint, Response, jsonify, request
+from typing import Literal, Any
+
+
+class AutopilotParametersEndpoint:
+    """Endpoint for handling autopilot parameters."""
+
+    def __init__(self) -> None:
+        self._blueprint = Blueprint("autopilot_parameters_page", __name__, url_prefix="/autopilot_parameters")
+        self.autopilot_parameters: dict[str, Any] = {}
+        self.default_autopilot_parameters: dict[str, Any] = {}
+        self.new_flag: bool = False
+        self._register_routes()
+
+    @property
+    def blueprint(self) -> Blueprint:
+        """Returns the Flask blueprint for autopilot parameters."""
+
+        return self._blueprint
+
+    def _register_routes(self) -> str:
+        """
+        Registers the routes for the autopilot parameters endpoint.
+
+        Returns
+        -------
+        str
+            Confirmation message indicating the routes have been registered successfully.
+        """
+
+        @self._blueprint.route("/test", methods=["GET"])
+        def test_route() -> Literal["autopilot_parameters route testing!"]:
+            """
+            Test route for autopilot parameters.
+
+            Method: GET
+
+            Returns
+            -------
+            Literal["autopilot_parameters route testing!"]
+                Confirmation message for testing the autopilot parameters route.
+            """
+
+            return "autopilot_parameters route testing!"
+
+        @self._blueprint.route("/get", methods=["GET"])
+        def get_route() -> tuple[Response, int]:
+            """
+            Get the current autopilot parameters.
+
+            Method: GET
+
+            Returns
+            -------
+            tuple[Response, int]
+                A tuple containing the JSON response of the autopilot parameters and the HTTP status code.
+            """
+
+            return jsonify(self.autopilot_parameters), 200
+
+        @self._blueprint.route("/get_new", methods=["GET"])
+        def get_new_route() -> tuple[Response, int]:
+            """
+            Get the latest autopilot parameters if they haven't been seen yet.
+
+            Method: GET
+
+            Returns
+            -------
+            tuple[Response, int]
+                A tuple containing the JSON response of the autopilot parameters if new,
+                otherwise an empty JSON object, along with the HTTP status code.
+            """
+
+            if self.new_flag:
+                self.new_flag = False
+                return jsonify(self.autopilot_parameters), 200
+
+            else:
+                return jsonify({}), 200
+
+        @self._blueprint.route("/get_default", methods=["GET"])
+        def get_default_route() -> tuple[Response, int]:
+            """
+            Get the default autopilot parameters.
+
+            Method: GET
+
+            Returns
+            -------
+            tuple[Response, int]
+                A tuple containing the JSON response of the default autopilot parameters and the HTTP status code.
+            """
+
+            return jsonify(self.default_autopilot_parameters), 200
+
+        @self._blueprint.route("/set", methods=["POST"])
+        def set_route() -> tuple[Response, int]:
+            """
+            Set the autopilot parameters from the request data.
+
+            Method: POST
+
+            Returns
+            -------
+            tuple[Response, int]
+                A tuple containing a success message or error message and the corresponding HTTP status code.
+            """
+
+            try:
+                new_parameters = request.json
+                if not isinstance(new_parameters, dict):
+                    raise TypeError("Invalid autopilot parameters format. Expected a dictionary.")
+
+                if self.default_autopilot_parameters != {}:
+                    new_parameters_keys = list(new_parameters.keys())
+                    if len(new_parameters_keys) == 1 and new_parameters_keys[0] in self.default_autopilot_parameters:
+                        self.autopilot_parameters[new_parameters_keys[0]] = new_parameters[new_parameters_keys[0]]
+
+                    elif new_parameters_keys == list(self.default_autopilot_parameters.keys()):
+                        self.autopilot_parameters = new_parameters
+
+                    else:
+                        raise ValueError("Invalid keys in autopilot parameters.")
+
+                else:
+                    self.autopilot_parameters = new_parameters
+
+                self.new_flag = True
+                return jsonify("Autopilot parameters updated successfully."), 200
+
+            except TypeError as e:
+                return jsonify(str(e)), 400
+
+            except ValueError as e:
+                return jsonify(str(e)), 400
+
+            except Exception as e:
+                return jsonify(str(e)), 500
+
+        @self._blueprint.route("/set_default", methods=["POST"])
+        def set_default_route() -> tuple[Response, int]:
+            """
+            Set the default autopilot parameters from the request data.
+
+            Method: POST
+
+            Returns
+            -------
+            tuple[Response, int]
+                A tuple containing a success message or error message and the corresponding HTTP status code.
+            """
+
+            try:
+                new_default_parameters = request.json
+                if not isinstance(new_default_parameters, dict):
+                    raise TypeError("Invalid default autopilot parameters format. Expected a dictionary.")
+
+                if new_default_parameters != {}:
+                    filtered_autopilot_parameters = {}
+                    for key in new_default_parameters:
+                        if key in self.default_autopilot_parameters:
+                            filtered_autopilot_parameters[key] = new_default_parameters[key]
+
+                    self.autopilot_parameters = filtered_autopilot_parameters
+
+                self.default_autopilot_parameters = new_default_parameters
+                return jsonify("Default autopilot parameters updated successfully."), 200
+
+            except TypeError as e:
+                return jsonify(str(e)), 400
+
+            except Exception as e:
+                return jsonify(str(e)), 500
+
+        return f"autopilot_parameters paths registered successfully: {self._blueprint.url_prefix}"

autoboat_telemetry_server/routes/boat_status.py

@@ -0,0 +1,108 @@
+from flask import Blueprint, Response, jsonify, request
+from typing import Literal, Any
+
+
+class BoatStatusEndpoint:
+    """Endpoint for handling boat status."""
+
+    def __init__(self) -> None:
+        self._blueprint = Blueprint("boat_status_page", __name__, url_prefix="/boat_status")
+        self.boat_status: dict[str, Any] = {}
+        self.new_flag: bool = False
+        self._register_routes()
+
+    @property
+    def blueprint(self) -> Blueprint:
+        """Returns the Flask blueprint for autopilot parameters."""
+        return self._blueprint
+
+    def _register_routes(self) -> str:
+        """
+        Registers the routes for the boat status endpoint.
+
+        Returns
+        -------
+        str
+            Confirmation message indicating the routes have been registered successfully.
+        """
+
+        @self._blueprint.route("/test", methods=["GET"])
+        def test_route() -> Literal["boat_status route testing!"]:
+            """
+            Test route for boat status.
+
+            Method: GET
+
+            Returns
+            -------
+            Literal["boat_status route testing!"]
+                Confirmation message for testing the boat status route.
+            """
+
+            return "boat_status route testing!"
+
+        @self._blueprint.route("/get", methods=["GET"])
+        def get_route() -> tuple[Response, int]:
+            """
+            Get the current boat status.
+
+            Method: GET
+
+            Returns
+            -------
+            tuple[Response, int]
+                A tuple containing the JSON response of the boat status and the HTTP status code.
+            """
+
+            return jsonify(self.boat_status)
+
+        @self._blueprint.route("/get_new", methods=["GET"])
+        def get_new_route() -> tuple[Response, int]:
+            """
+            Get the latest boat status if it hasn't been seen yet.
+
+            Method: GET
+
+            Returns
+            -------
+            tuple[Response, int]
+                A tuple containing the JSON response of the new boat status (or empty if none) and the HTTP status code.
+            """
+
+            if self.new_flag:
+                self.new_flag = False
+                return jsonify(self.boat_status), 200
+
+            else:
+                return jsonify({}), 200
+
+        @self._blueprint.route("/set", methods=["POST"])
+        def set_route() -> tuple[Response, int]:
+            """
+            Set the boat status from the request data.
+
+            Method: POST
+
+            Returns
+            -------
+            tuple[Response, int]
+                A tuple containing a confirmation message and the HTTP status code.
+            """
+
+            try:
+                new_status = request.json
+                if not isinstance(new_status, dict):
+                    raise TypeError("Invalid boat status format. Expected a dictionary.")
+
+                self.boat_status = new_status
+                self.new_flag = True
+
+                return jsonify("Boat status updated successfully."), 200
+
+            except TypeError as e:
+                return jsonify(str(e)), 400
+
+            except Exception as e:
+                return jsonify(str(e)), 500
+
+        return f"boat_status paths registered successfully: {self._blueprint.url_prefix}"

autoboat_telemetry_server/routes/waypoints.py

@@ -0,0 +1,108 @@
+from flask import Blueprint, Response, jsonify, request
+from typing import Literal
+
+
+class WaypointEndpoint:
+    """Endpoint for handling waypoints."""
+
+    def __init__(self) -> None:
+        self._blueprint = Blueprint("waypoints_page", __name__, url_prefix="/waypoints")
+        self.waypoints: list[list[float]] = []
+        self.new_flag: bool = False
+        self._register_routes()
+
+    @property
+    def blueprint(self) -> Blueprint:
+        """Returns the Flask blueprint for autopilot parameters."""
+        return self._blueprint
+
+    def _register_routes(self) -> str:
+        """
+        Registers the routes for the waypoints endpoint.
+
+        Returns
+        -------
+        str
+            Confirmation message indicating the routes have been registered successfully.
+        """
+
+        @self._blueprint.route("/test", methods=["GET"])
+        def test_route() -> Literal["waypoints route testing!"]:
+            """
+            Test route for waypoints.
+
+            Method: GET
+
+            Returns
+            -------
+            Literal["waypoints route testing!"]
+                Confirmation message for testing the waypoints route.
+            """
+
+            return "waypoints route testing!"
+
+        @self._blueprint.route("/get", methods=["GET"])
+        def get_route() -> tuple[Response, int]:
+            """
+            Get the current waypoints.
+
+            Method: GET
+
+            Returns
+            -------
+            tuple[Response, int]
+                A tuple containing the JSON response of the waypoints and the HTTP status code.
+            """
+
+            return jsonify(self.waypoints), 200
+
+        @self._blueprint.route("/get_new", methods=["GET"])
+        def get_new_route() -> tuple[Response, int]:
+            """
+            Get the latest waypoints if they haven't been seen yet.
+
+            Method: GET
+
+            Returns
+            -------
+            tuple[Response, int]
+                A tuple containing the JSON response of the new waypoints (or empty if none) and the HTTP status code.
+            """
+
+            if self.new_flag:
+                self.new_flag = False
+                return jsonify(self.waypoints), 200
+
+            else:
+                return jsonify({}), 200
+
+        @self._blueprint.route("/set", methods=["POST"])
+        def set_route() -> tuple[Response, int]:
+            """
+            Set the waypoints from the request data.
+
+            Method: POST
+
+            Returns
+            -------
+            tuple[Response, int]
+                A tuple containing a confirmation message and the HTTP status code.
+            """
+
+            try:
+                new_waypoints = request.json
+                if not isinstance(new_waypoints, list):
+                    raise TypeError("Invalid waypoints format. Expected a list of lists of floats.")
+
+                self.waypoints = new_waypoints
+                self.new_flag = True
+
+                return jsonify("Waypoints updated successfully."), 200
+
+            except TypeError as e:
+                return jsonify(str(e)), 400
+
+            except Exception as e:
+                return jsonify(str(e)), 500
+
+        return f"waypoints paths registered successfully: {self._blueprint.url_prefix}"

instance/config.py

@@ -0,0 +1,5 @@
+import os
+
+BASE_DIR = os.path.abspath(os.path.dirname(__file__))
+SQLALCHEMY_DATABASE_URI = f"sqlite:///{os.path.join(BASE_DIR, 'app.db')}"
+SQLALCHEMY_TRACK_MODIFICATIONS = False

telemetry_server-0.1.0.dist-info/METADATA

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: telemetry_server
+Version: 0.1.0
+Project-URL: repository, https://github.com/autoboat-vt/telemetry_server
+Description-Content-Type: text/markdown
+Requires-Dist: flask
+Requires-Dist: gunicorn
+
+# Autoboat Telemetry Server
+
+A lightweight Flask-based web server to collect, display, and manage telemetry data from the Virginia Tech Autoboat project.
+
+## 📦 Project Structure
+
+```txt
+autoboat_telemetry_server/
+├── __init__.py                   # App factory
+├── routes
+    ├── __init__.py               # Routes initialization
+    ├── autopilot_parameters.py   # Autopilot parameters routes
+    ├── boat_status.py            # Boat status routes
+    ├── waypoints.py              # Waypoints management routes
+
+instance/
+    ├── config.py                 # Configuration file
+```
+
+## 🚀 Quick Start
+
+### Installation
+
+```bash
+pip install -e .
+```
+
+### Running the server
+
+1. Production ([Gunicorn](https://gunicorn.org/)):
+
+    ```bash
+    gunicorn "autoboat_telemetry_server:create_app()"
+    ```
+
+2. Development (Flask):
+
+    ```bash
+    flask run
+    ```
+
+## Server (Long term)
+
+### Installation
+
+```bash
+git clone https://github.com/autoboat-vt/telemetry_server
+cd telemetry_server
+./server_files/install.sh
+```

telemetry_server-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+app.py,sha256=bia5RTM3ljRs6u2ANIwTsahzu48CmUzqNmMGxJTASpI,111
+autoboat_telemetry_server/__init__.py,sha256=La0KoBk2RGZVNq-MoJCF0YOx7ocbvsx8c9yrz-gTev0,1117
+autoboat_telemetry_server/routes/__init__.py,sha256=ru7YCQu4qAVnJDHA4M8fN3FkkiMEFpHc4RKFE3hXnvk,1344
+autoboat_telemetry_server/routes/autopilot_parameters.py,sha256=WQ5pjKABPP0c-BUM8BReTUrtUGY1AUwWA4wSybremzg,6258
+autoboat_telemetry_server/routes/boat_status.py,sha256=XgbrsB4niUDTCMa_0x3mANpOLROH2hKMiEE0X5D23F0,3272
+autoboat_telemetry_server/routes/waypoints.py,sha256=_qpy3DNLlLh0bEUXjYQbr6cv3DAhEbWLPzys0qeWmw8,3256
+instance/config.py,sha256=Ll7E0tPZ91v5XNLmEkhbSa793-ugFRCDF7olhXyvEdU,178
+telemetry_server-0.1.0.dist-info/METADATA,sha256=sHTd7-tn0_D36rhLLOR03HwBjzDuN2Y_GC2vevRV_bA,1285
+telemetry_server-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+telemetry_server-0.1.0.dist-info/top_level.txt,sha256=GK0z6liXhI5z6-OmWt5pjq3CaxQ98wguiMhFHonnKvM,39
+telemetry_server-0.1.0.dist-info/RECORD,,

telemetry_server-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

telemetry_server-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+app
+autoboat_telemetry_server
+instance