Fixes by format action

welcome_aboard/battery_testing/main.py → docs_tofupilot/api_v1/assembly_test_with_voltage_sampling.py

@@ -136,6 +136,43 @@ def voltage_value():
     return passed, value_measured, "V", 10.0, 12.0
 
 
+def voltage_sampling_test():
+    """
+    Multi-dimensional voltage sampling test.
+    Samples 100 voltage measurements over time.
+    Returns: (passed, measurements, units, limit_low, limit_high)
+    where measurements is a list of (timestamp, voltage) tuples
+    """
+    passed_prob = 0.98
+    num_samples = 100
+    limit_low = 10.0
+    limit_high = 12.0
+
+    measurements = []
+    all_passed = True
+
+    # Simulate voltage measurements over time
+    for i in range(num_samples):
+        timestamp = i / num_samples  # Time in seconds (0 to 0.99)
+
+        # Determine if this sample should pass
+        sample_passed = simulate_test_result(passed_prob)
+
+        if sample_passed:
+            voltage = round(random.uniform(limit_low, limit_high), 2)
+        else:
+            voltage = round(random.uniform(8.0, 9.5), 2)
+            all_passed = False
+
+        measurements.append((timestamp, voltage))
+
+    # Return multi-dimensional measurement
+    # Format: (passed, value_measured, unit, limit_low, limit_high)
+    # For multi-dimensional, value_measured is the list of tuples
+    # and unit should be a list of units for each dimension
+    return all_passed, measurements, ["s", "V"], limit_low, limit_high
+
+
 def internal_resistance():
     passed = simulate_test_result(0.98)
     value_measured = (
@@ -349,10 +386,13 @@ def execute_procedures(end):
         if not passed_cell:
             continue
 
-        # Execute Assembly Tests
+        # Execute Assembly Tests with voltage sampling
         tests_assembly = [
             (battery_connection, timedelta(seconds=0.1)),
-            (voltage_value, timedelta(seconds=1)),
+            (
+                voltage_sampling_test,
+                timedelta(seconds=10),
+            ),  # New multi-dimensional test
             (internal_resistance, timedelta(seconds=1)),
             (thermal_runaway_detection, timedelta(seconds=2)),
             (state_of_health, timedelta(seconds=2)),

docs_tofupilot/attachments/client/main.py → docs_tofupilot/api_v1/attachments/client/main.py

@@ -12,7 +12,7 @@ def main():
     attachments = phase_file_attachment()
 
     client.create_run(
-        procedure_id="FVT1",
+        procedure_id="FVT1",  # Create the procedure first in the Application
         unit_under_test={"serial_number": "PCB1A001", "part_number": "PCB1"},
         run_passed=True,
         attachments=attachments,

docs_tofupilot/attachments/openhtf/main.py → docs_tofupilot/api_v1/attachments/openhtf/main.py

@@ -11,8 +11,9 @@ def phase_file_attachment(test):
 def main():
     test = htf.Test(
         phase_file_attachment,
-        procedure_id="FVT1",
-        part_number="PCB1")
+        procedure_id="FVT1",  # Create the procedure first in the Application
+        part_number="PCB1",
+    )
 
     with TofuPilot(test):
         test.execute(lambda: "PCB1A001")

docs_tofupilot/integrations/client/main.py → docs_tofupilot/api_v1/integrations/client/main.py

@@ -5,7 +5,7 @@ def main():
     client = TofuPilotClient()
 
     client.create_run(
-        procedure_id="FVT1",  # Define the TofuPilot's procedure ID
+        procedure_id="FVT1",  # Create the procedure first in the Application
         unit_under_test={
             "serial_number": "PCB1A001",
             "part_number": "PCB1",

docs_tofupilot/integrations/openhtf/main.py → docs_tofupilot/api_v1/integrations/openhtf/main.py

@@ -2,12 +2,14 @@
 from tofupilot.openhtf import TofuPilot  # Import OpenHTF for TofuPilot
 
 
-def phase_one(test):
+def phase_one():
     return htf.PhaseResult.CONTINUE
 
 
 def main():
-    test = htf.Test(phase_one)
+    test = htf.Test(
+        phase_one, procedure_id="FVT1", part_number="PCB01"
+    )  # Specify procedure and part_number
 
     with TofuPilot(test):  # One-line integration
         test.execute(lambda: "PCB1A001")

docs_tofupilot/api_v1/logger/client/main.py

@@ -0,0 +1,61 @@
+import logging
+import sys
+from datetime import datetime
+
+from tofupilot import TofuPilotClient
+
+
+class TofuPilotLogHandler(logging.Handler):
+    """Handler that captures logs in a format compatible with TofuPilot API."""
+
+    def __init__(self):
+        super().__init__()
+        self.logs = []
+
+    def emit(self, record):
+        # Format log with ISO-8601 timestamp (UTC, ms) for TofuPilot API
+        log_entry = {
+            "level": record.levelname,
+            "timestamp": datetime.utcfromtimestamp(record.created).isoformat(
+                timespec="milliseconds"
+            )
+            + "Z",
+            "message": record.getMessage(),
+            "source_file": record.filename,
+            "line_number": record.lineno,
+        }
+        self.logs.append(log_entry)
+
+
+# Initialize the TofuPilot client to report test results
+client = TofuPilotClient()
+
+# Set up local logger with custom name and prevent propagation to parent
+# loggers
+local_logger = logging.getLogger("test_logger")
+local_logger.setLevel(logging.DEBUG)
+local_logger.propagate = False
+
+# Add handlers: one for TofuPilot API capture and one for console output
+capture_handler = TofuPilotLogHandler()
+local_logger.addHandler(capture_handler)
+local_logger.addHandler(logging.StreamHandler(sys.stdout))
+
+
+# Log examples at different severity levels
+local_logger.debug("Debug message: Detailed information for troubleshooting")
+local_logger.info("Info message: Normal operation information")
+local_logger.warning("Warning: Something unexpected but not critical")
+local_logger.error("Error: A significant problem that needs attention")
+local_logger.critical("Critical: System unstable, immediate action required")
+
+# Create a run and send captured logs to TofuPilot
+try:
+    client.create_run(
+        procedure_id="FVT1",
+        unit_under_test={"serial_number": "00007035", "part_number": "LOGS01"},
+        run_passed=True,
+        logs=capture_handler.logs,
+    )
+finally:
+    local_logger.removeHandler(capture_handler)