ents 2.3.4__py3-none-any.whl → 2.3.6__py3-none-any.whl

ents/__init__.py

@@ -3,10 +3,11 @@ from .proto.encode import (
     encode_power_measurement,
     encode_teros12_measurement,
     encode_phytos31_measurement,
+    encode_user_configuration,
     encode_bme280_measurement,
 )
 
-from .proto.decode import decode_response, decode_measurement
+from .proto.decode import decode_response, decode_measurement, decode_user_configuration
 
 from .proto.esp32 import encode_esp32command, decode_esp32command
 
@@ -20,4 +21,6 @@ __all__ = [
     "decode_measurement",
     "encode_esp32command",
     "decode_esp32command",
+    "encode_user_configuration",
+    "decode_user_configuration",
 ]

ents/calibrate/recorder.py

@@ -16,7 +16,7 @@ import socket
 import serial
 from typing import Tuple
 from tqdm import tqdm
-from ..proto import decode_measurement
+from ..proto.sensor import decode_repeated_sensor_measurements
 
 
 class SerialController:
@@ -116,10 +116,10 @@ class SoilPowerSensorController(SerialController):
 
         reply = self.ser.read(resp_len)  # read said measurment
 
-        meas_dict = decode_measurement(reply)  # decode using protobuf
+        meas_dict = decode_repeated_sensor_measurements(reply)  # decode using protobuf
 
-        voltage_value = meas_dict["data"]["voltage"]
-        current_value = meas_dict["data"]["current"]
+        voltage_value = meas_dict["measurements"][0]["decimal"]
+        current_value = meas_dict["measurements"][1]["decimal"]
 
         return float(voltage_value), float(current_value)
 

ents/cli.py

@@ -29,7 +29,14 @@ from .proto.encode import (
 from .proto.decode import decode_measurement, decode_response
 from .proto.esp32 import encode_esp32command, decode_esp32command
 
-from .simulator.node import NodeSimulator
+from .proto.sensor import (
+    encode_repeated_sensor_measurements,
+    decode_repeated_sensor_measurements,
+    encode_sensor_response,
+    decode_sensor_response,
+)
+
+from .simulator.node import NodeSimulator, NodeSimulatorGeneric
 
 
 def entry():
@@ -37,17 +44,81 @@ def entry():
 
     parser = argparse.ArgumentParser()
 
-    subparsers = parser.add_subparsers(help="Ents Utilities")
+    subparsers = parser.add_subparsers(help="Ents Utilities", required=True)
 
     create_encode_parser(subparsers)
+    create_encode_generic_parser(subparsers)
     create_decode_parser(subparsers)
+    create_decode_generic_parser(subparsers)
     create_calib_parser(subparsers)
     create_sim_parser(subparsers)
+    create_sim_generic_parser(subparsers)
 
     args = parser.parse_args()
     args.func(args)
 
 
+def create_sim_generic_parser(subparsers):
+    """Creates the generic simulation subparser
+
+    Args:
+        subparsers: Reference to subparser group
+    Returns:
+        Reference to new subparser
+    """
+
+    sim_p = subparsers.add_parser("sim_generic", help="Simluate generic sensor uploads")
+
+    sim_p.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="Print addiitional request information.",
+    )
+
+    sim_p.add_argument(
+        "--url",
+        default="http://localhost:8000/api/sensor",
+        type=str,
+        help="URL of the dirtviz instance (default: http://localhost:8000)",
+    )
+    sim_p.add_argument(
+        "mode",
+        choices=["batch", "stream"],
+        type=str,
+        help="Upload mode",
+    )
+    sim_p.add_argument(
+        "--sensor",
+        required=True,
+        type=str,
+        nargs="+",
+        help="Type of sensor to simulate",
+    )
+
+    sim_p.add_argument(
+        "--min", type=float, default=-1.0, help="Minimum sensor value (default: -1.0)"
+    )
+    sim_p.add_argument(
+        "--max", type=float, default=1.0, help="Maximum sensor value (default: 1.0)"
+    )
+    sim_p.add_argument("--cell", required=True, type=int, help="Cell Id")
+    sim_p.add_argument("--logger", required=True, type=int, help="Logger Id")
+
+    batch = sim_p.add_argument_group("Batch")
+    batch.add_argument("--start", type=str, help="Start date")
+    batch.add_argument("--end", type=str, help="End date")
+
+    stream = sim_p.add_argument_group("Stream")
+    stream.add_argument(
+        "--freq", default=10.0, type=float, help="Frequency of uploads (default: 10s)"
+    )
+
+    sim_p.set_defaults(func=simulate_generic)
+
+    return sim_p
+
+
 def create_sim_parser(subparsers):
     """Creates the simulation subparser
 
@@ -90,6 +161,63 @@ def create_sim_parser(subparsers):
     return sim_p
 
 
+def simulate_generic(args):
+    if args.verbose:
+        print("Arguments:")
+        print(args)
+        print()
+
+    simulation = NodeSimulatorGeneric(
+        cell=args.cell,
+        logger=args.logger,
+        sensors=args.sensor,
+        _min=args.min,
+        _max=args.max,
+    )
+
+    if args.mode == "batch":
+        if (args.start is None) or (args.end is None):
+            raise ValueError("Start and end date must be provided for batch mode.")
+
+        # format dates
+        curr_dt = datetime.fromisoformat(args.start)
+        end_dt = datetime.fromisoformat(args.end)
+
+        # create list of measurements
+        while curr_dt <= end_dt:
+            ts = int(curr_dt.timestamp())
+            simulation.measure(ts)
+            curr_dt += timedelta(seconds=args.freq)
+
+        # send measurements
+        while simulation.send_next(args.url):
+            print(simulation)
+
+        print("Done!")
+
+    elif args.mode == "stream":
+        print("Use CTRL+C to stop the simulation")
+        try:
+            while True:
+                dt = datetime.now()
+                ts = int(dt.timestamp())
+                simulation.measure(ts)
+
+                while simulation.send_next(args.url):
+                    print(simulation)
+
+                if args.verbose:
+                    print("Request")
+                    print(simulation.last_request())
+                    print("\nResponse")
+                    print(simulation.last_response())
+                    print()
+
+                time.sleep(args.freq)
+        except KeyboardInterrupt as _:
+            print("Stopping simulation")
+
+
 def simulate(args):
     simulation = NodeSimulator(
         cell=args.cell,
@@ -169,6 +297,133 @@ def create_calib_parser(subparsers):
     return calib_p
 
 
+def create_encode_generic_parser(subparsers):
+    """Create generic encode command subparser
+
+    Args:
+        subparsers: Reference to subparser group
+
+    Returns:
+        Reference to new subparser
+    """
+
+    encode_parser = subparsers.add_parser("encode_generic", help="Encode generic data")
+
+    print_format = encode_parser.add_mutually_exclusive_group()
+    print_format.add_argument(
+        "--hex", action="store_true", help="Print as hex values (default)"
+    )
+    print_format.add_argument(
+        "--raw", action="store_true", help="Print raw bytes object"
+    )
+    print_format.add_argument(
+        "--c", action="store_true", help="Print bytes for copying to c"
+    )
+
+    encode_subparsers = encode_parser.add_subparsers(
+        title="Message type", dest="type", required=True
+    )
+
+    # sensor measurement
+    measurement_parser = encode_subparsers.add_parser(
+        "meas", help='Proto "Measurement" message'
+    )
+    measurement_parser.add_argument("--ts", type=int, help="Unix epoch timestamp")
+    measurement_parser.add_argument("--cell", type=int, help="Cell Id")
+    measurement_parser.add_argument("--logger", type=int, help="Logger Id")
+    measurement_parser.add_argument("--idx", type=int, default=1, help="Upload index")
+    measurement_parser.add_argument(
+        "--sensor",
+        nargs=2,
+        metavar=("type", "value"),
+        action="append",
+        required=True,
+        help="Specify as: --sensor <type> <value>",
+    )
+    measurement_parser.set_defaults(func=handle_encode_generic_measurement)
+
+    # response
+    response_parser = encode_subparsers.add_parser(
+        "resp", help='Proto "Response" message'
+    )
+    response_parser.add_argument(
+        "--resp",
+        nargs=2,
+        metavar=("idx", "status"),
+        action="append",
+        required=True,
+        help="Specify as: --resp <idx> <status>",
+    )
+    response_parser.set_defaults(func=handle_encode_generic_response)
+
+    return encode_parser
+
+
+def parse_number(s: str) -> tuple:
+    try:
+        i = int(s)
+        if i >= 0:
+            return i, "unsignedInt"
+        return i, "signedInt"
+    except ValueError:
+        pass
+
+    try:
+        return float(s), "decimal"
+    except ValueError:
+        pass
+
+    raise ValueError(f"Invalid numeric value: {s}")
+
+
+def handle_encode_generic_measurement(args):
+    """Take arguments and encode a repeated senosr measurement message"""
+
+    meas = {
+        "meta": {
+            "ts": args.ts,
+            "cellId": args.cell,
+            "loggerId": args.logger,
+        },
+        "measurements": [],
+    }
+
+    for s in args.sensor:
+        val, val_type = parse_number(s[1])
+        meas["measurements"].append(
+            {
+                "type": s[0],
+                val_type: val,
+                "idx": args.idx,
+            }
+        )
+        args.idx += 1
+
+    data = encode_repeated_sensor_measurements(meas)
+    print_data(args, data)
+
+
+def handle_encode_generic_response(args):
+    """Takes arguments and encode a sensor response message"""
+
+    resp = {
+        "responses": [],
+    }
+
+    for r in args.resp:
+        idx = int(r[0])
+        status = r[1]
+        resp["responses"].append(
+            {
+                "uploadIndex": idx,
+                "status": status,
+            }
+        )
+
+    data = encode_sensor_response(resp)
+    print_data(args, data)
+
+
 def create_encode_parser(subparsers):
     """Create encode command subparser
 
@@ -192,14 +447,19 @@ def create_encode_parser(subparsers):
         "--c", action="store_true", help="Print bytes for copying to c"
     )
 
-    encode_subparsers = encode_parser.add_subparsers(title="Message type", dest="type")
+    encode_subparsers = encode_parser.add_subparsers(
+        title="Message type",
+        dest="type",
+        required=True,
+    )
 
     def create_measurement_parser(encode_subparsers):
         measurement_parser = encode_subparsers.add_parser(
             "measurement", help='Proto "Measurement" message'
         )
         measurement_subparser = measurement_parser.add_subparsers(
-            title="Measurement type"
+            title="Measurement type",
+            required=True,
         )
 
         # metadata
@@ -246,7 +506,9 @@ def create_encode_parser(subparsers):
             "esp32command", help='Proto "Esp32Command" message'
         )
         esp32command_subparser = esp32command_parser.add_subparsers(
-            title="type", help="PageCommand"
+            title="type",
+            help="PageCommand",
+            required=True,
         )
 
         test_parser = esp32command_subparser.add_parser("test", help="TestCommand")
@@ -383,6 +645,55 @@ def print_bytes_c(data: bytes) -> str:
     print(f"size_t data_len = {len(hex_str)};")
 
 
+def create_decode_generic_parser(subparsers):
+    """Create generic decode command parser
+
+    Args:
+        subparsers: Reference to subparser group
+
+    Returns:
+        Reference to new subparser
+    """
+
+    decode_parser = subparsers.add_parser("decode_generic", help="Decode generic data")
+
+    decode_subparsers = decode_parser.add_subparsers(
+        title="Message type",
+        dest="type",
+        required=True,
+    )
+
+    decode_parser.add_argument(
+        "data", type=str, help="Protobuf serialized data in hex format"
+    )
+
+    # sensor measurement
+    measurement_parser = decode_subparsers.add_parser(
+        "meas", help='Proto "Measurement" message'
+    )
+    measurement_parser.set_defaults(func=handle_decode_generic_measurement)
+
+    # response
+    response_parser = decode_subparsers.add_parser(
+        "resp", help='Proto "Response" message'
+    )
+    response_parser.set_defaults(func=handle_decode_generic_response)
+
+    return decode_parser
+
+
+def handle_decode_generic_measurement(args):
+    data = bytes.fromhex(args.data)
+    vals = decode_repeated_sensor_measurements(data)
+    print(vals)
+
+
+def handle_decode_generic_response(args):
+    data = bytes.fromhex(args.data)
+    vals = decode_sensor_response(data)
+    print(vals)
+
+
 def create_decode_parser(subparsers):
     """Create decode command parser
 
@@ -395,7 +706,11 @@ def create_decode_parser(subparsers):
 
     decode_parser = subparsers.add_parser("decode", help="Decode data")
 
-    decode_subparsers = decode_parser.add_subparsers(title="Message type", dest="type")
+    decode_subparsers = decode_parser.add_subparsers(
+        title="Message type",
+        dest="type",
+        required=True,
+    )
 
     # measurement
     measurement_parser = decode_subparsers.add_parser(

ents/config/user_config.py

@@ -24,10 +24,7 @@ import sys
 import serial
 import serial.tools.list_ports
 import re  # For validating URL input
-from ents.proto import (
-    encode_user_configuration,
-    decode_user_configuration,
-)
+from ..proto import encode_user_configuration, decode_user_configuration
 
 
 class Ui_MainWindow(object):

ents/dirtviz/__init__.py

@@ -0,0 +1,8 @@
+from .client import BackendClient
+
+from .plots import plot_data
+
+__all__ = [
+    "BackendClient",
+    "plot_data",
+]

ents/dirtviz/client.py

@@ -0,0 +1,223 @@
+"""Client interface with dirtviz.
+
+TODO:
+- Add caching of data
+"""
+
+from datetime import datetime
+
+import pandas as pd
+
+import requests
+
+
+class Cell:
+    """Class representing a cell in the Dirtviz API."""
+
+    def __init__(self, data: str):
+        """Initialize the Cell object from a cell ID.
+
+        Args:
+            data: json data from the Dirtviz API containing cell information.
+        """
+
+        self.id = data["id"]
+        self.name = data["name"]
+        self.location = data["location"]
+        self.latitude = data["latitude"]
+        self.longitude = data["longitude"]
+
+    def __repr__(self):
+        return f"Cell(id={self.cell_id}, name={self.name})"
+
+
+class BackendClient:
+    """Client for interacting with the Dirtviz API."""
+
+    def __init__(self, base_url: str = "https://dirtviz.jlab.ucsc.edu/api/"):
+        """Initialize the BackendClient.
+
+        Sets the base URL for the API. Defaults to the Dirtviz API.
+        """
+
+        self.base_url = base_url
+
+    def get(self, endpoint: str, params: dict = None) -> dict:
+        """Get request to the API.
+
+        Args:
+            endpoint: The API endpoint to request.
+            params: Optional parameters for the request.
+
+        Returns:
+            A dictionary containing the response data.
+        """
+
+        url = f"{self.base_url}{endpoint}"
+        response = requests.get(url, params=params)
+        response.raise_for_status()
+
+        return response.json()
+
+    @staticmethod
+    def time_to_params(start: datetime, end: datetime) -> dict:
+        """Puts start and end datetime into an API paramter dictionary
+
+        Args:
+            dt: The datetime object to format.
+
+        Returns:
+            A string representing the formatted datetime.
+        """
+
+        timestamp_format = "%a, %d %b %Y %H:%M:%S GMT"
+
+        start_str = start.strftime(timestamp_format)
+        end_str = end.strftime(timestamp_format)
+
+        params = {
+            "startTime": start_str,
+            "endTime": end_str,
+        }
+
+        return params
+
+    def power_data(self, cell: Cell, start: datetime, end: datetime) -> pd.DataFrame:
+        """Gets power data for a specific cell by name.
+
+        Args:
+            cell: The Cell object for which to get power data.
+            start: The start date of the data.
+            end: The end date of the data.
+
+        Returns:
+            A pandas DataFrame containing the power data.
+        """
+
+        endpoint = f"/power/{cell.id}"
+
+        params = self.time_to_params(start, end)
+
+        data = self.get(endpoint, params=params)
+
+        data_df = pd.DataFrame(data)
+        data_df["timestamp"] = pd.to_datetime(data_df["timestamp"])
+
+        return data_df
+
+    def teros_data(self, cell: Cell, start: datetime, end: datetime) -> pd.DataFrame:
+        """Gets teros data for a specific cell
+
+        Args:
+            cell: The Cell object for which to get teros data.
+            start: The start date of the data.
+            end: The end date of the data.
+
+        Returns:
+            A pandas DataFrame containing the teros data with columns vwc_raw,
+            vwc_adj, temp, ec.
+        """
+
+        endpoint = f"/teros/{cell.id}"
+
+        params = self.time_to_params(start, end)
+
+        data = self.get(endpoint, params=params)
+
+        data_df = pd.DataFrame(data)
+        data_df["timestamp"] = pd.to_datetime(data_df["timestamp"])
+
+        return data_df
+
+    def sensor_data(
+        self,
+        cell: Cell,
+        name: str,
+        meas: str,
+        start: datetime,
+        end: datetime,
+        resample: str = "none",
+    ) -> pd.DataFrame:
+        """Gets generic sensor data for a specific cell
+
+        Args:
+            cell: The Cell object for which to get sensor data.
+            name: Name of the sensor (e.g., "power", "teros").
+            meas: The measurement type (e.g., "v", "i", "vwc", "temp", "ec").
+            start: The start date of the data.
+            end: The end date of the data.
+
+        Returns:
+            A pandas DataFrame containing the sensor data.
+        """
+
+        endpoint = "/sensor/"
+
+        params = {
+            "cellId": cell.id,
+            "name": name,
+            "measurement": meas,
+        }
+
+        params = params | self.time_to_params(start, end)
+
+        data = self.get(endpoint, params=params)
+
+        data_df = pd.DataFrame(data)
+        data_df["timestamp"] = pd.to_datetime(data_df["timestamp"])
+
+        return data_df
+
+    def cell_from_id(self, cell_id: int) -> Cell | None:
+        """Get a Cell object from its ID.
+
+        Args:
+            cell_id: The ID of the cell.
+
+        Returns:
+            A Cell object. None if the cell does not exist.
+        """
+
+        cell_list = self.cells()
+
+        for cell in cell_list:
+            if cell.id == cell_id:
+                return cell
+
+        return None
+
+    def cell_from_name(self, name: str) -> Cell | None:
+        """Get a Cell object from its name.
+
+        Args:
+            name: The name of the cell.
+
+        Returns:
+            A Cell object. None if the cell does not exist.
+        """
+
+        cell_list = self.cells()
+
+        for cell in cell_list:
+            if cell.name == name:
+                return cell
+
+        return None
+
+    def cells(self) -> list[Cell]:
+        """Gets a list of all cells from the API.
+
+        Returns:
+            A list of Cell objects.
+        """
+
+        cell_list = []
+
+        endpoint = "/cell/id"
+        cell_data_list = self.get(endpoint)
+
+        for c in cell_data_list:
+            cell = Cell(c)
+            cell_list.append(cell)
+
+        return cell_list