support full auto-generate

Author: Teque5

sigmf/generate.py

@@ -42,7 +42,7 @@ class SigMFGenerator:
     """
 
     def __init__(self, seed: Optional[int] = None):
-        # random state for reproducible generation
+        # random state for reproducible generation across arch / platforms
         self._rng = np.random.RandomState(seed)
         self._seed = seed
 
@@ -320,9 +320,18 @@ def _fill_random_parameters(self) -> None:
         if self._duration_s is None:
             self._duration_s = self._rng.uniform(0.1, 5.0)
 
-        # fill parameters for each signal component
-        max_freq = self._sample_rate_hz / 4
+        # if no components specified, randomly generate some
+        if len(self._signal_components) == 0:
+            while True:
+                if self._rng.random() < 0.5:
+                    self._signal_components.append({"type": "tone"})
+                else:
+                    self._signal_components.append({"type": "sweep"})
+                if self._rng.random() <= 0.2:
+                    # E[N] = 1 / threshold -> 5 components on average
+                    break
 
+        # fill parameters for each signal component
         for component in self._signal_components:
             # add random timing for each component
             if "start_time_s" not in component:
@@ -342,34 +351,29 @@ def _fill_random_parameters(self) -> None:
 
             if component["type"] == "tone":
                 if "frequency_hz" not in component:
-                    # random frequency between 100hz and 1/4 sample rate
-                    component["frequency_hz"] = round(self._rng.uniform(100.0, max_freq), 1)
+                    # random frequency across full baseband: -nyquist to +nyquist (excluding DC ±100 Hz)
+                    nyquist = self._sample_rate_hz / 2
+                    freq = self._rng.uniform(-nyquist + 100.0, nyquist - 100.0)
+                    component["frequency_hz"] = round(freq, 1)
 
             elif component["type"] == "sweep":
                 if "start_frequency_hz" not in component:
-                    component["start_frequency_hz"] = round(self._rng.uniform(100.0, max_freq * 0.8), 1)
+                    component["start_frequency_hz"] = round(self._rng.uniform(100.0, self._sample_rate_hz / 4 * 0.8), 1)
                 if "end_frequency_hz" not in component:
                     start_freq = component["start_frequency_hz"]
                     # ensure end freq is different from start
-                    if start_freq < max_freq * 0.5:
-                        component["end_frequency_hz"] = round(self._rng.uniform(start_freq * 1.5, max_freq), 1)
+                    if start_freq < self._sample_rate_hz / 4 * 0.5:
+                        component["end_frequency_hz"] = round(
+                            self._rng.uniform(start_freq * 1.5, self._sample_rate_hz / 4), 1
+                        )
                     else:
                         component["end_frequency_hz"] = round(self._rng.uniform(100.0, start_freq * 0.7), 1)
 
     def _validate_parameters(self) -> None:
         """Validate current parameters."""
-        if len(self._signal_components) == 0:
-            raise SigMFGeneratorError("no signal components specified - call tone() or sweep()")
-
-        if self._sample_rate_hz is None:
-            raise SigMFGeneratorError("sample rate not specified")
-
         if self._sample_rate_hz <= 0:
             raise SigMFGeneratorError(f"sample rate must be positive, got {self._sample_rate_hz}")
 
-        if self._duration_s is None:
-            raise SigMFGeneratorError("duration not specified")
-
         if self._duration_s <= 0:
             raise SigMFGeneratorError(f"duration must be positive, got {self._duration_s}")
 
@@ -388,7 +392,7 @@ def _validate_parameters(self) -> None:
                 ]
 
             for freq, freq_name in frequencies_to_check:
-                if freq >= nyquist:
+                if abs(freq) >= nyquist:
                     raise SigMFGeneratorError(f"{freq_name} {freq} hz exceeds nyquist limit {nyquist} hz")
 
     def _generate_samples(self) -> np.ndarray:
@@ -431,9 +435,6 @@ def _generate_samples(self) -> np.ndarray:
                 phase = 2 * np.pi * (start_freq * component_time + 0.5 * freq_slope * component_time**2)
                 component_signal = amplitude * np.exp(1j * phase)
 
-            else:
-                raise SigMFGeneratorError(f"unknown signal type: {component['type']}")
-
             # apply tapering to avoid clicks (5ms taper or 10% of component duration, whichever is smaller)
             taper_samples = min(int(0.005 * self._sample_rate_hz), component_samples // 10)
             if taper_samples > 1:

tests/test_generator.py

@@ -25,7 +25,7 @@ def setUp(self):
         self.test_seed = 0xDEADBEEF
         self.test_sample_rate = 48000
         self.test_duration = 1.0
-        self.test_freq = 1000.0
+        self.test_freq = -1000.0
 
     def test_deterministic_tone_generation(self):
         """test deterministic tone generation with specified parameters"""
@@ -38,7 +38,7 @@ def test_deterministic_tone_generation(self):
         # verify metadata
         self.assertEqual(signal.sample_rate, self.test_sample_rate)
         self.assertEqual(signal.get_global_info()[SigMFFile.DATATYPE_KEY], "cf32_le")
-        self.assertIn("1000.0 hz tone", signal.get_global_info()[SigMFFile.DESCRIPTION_KEY])
+        self.assertIn("-1000.0 hz tone", signal.get_global_info()[SigMFFile.DESCRIPTION_KEY])
 
         # verify signal characteristics
         samples = signal.read_samples()
@@ -52,8 +52,8 @@ def test_deterministic_tone_generation(self):
         fft_samples = np.fft.fft(samples)
         fft_freqs = np.fft.fftfreq(len(samples), 1 / self.test_sample_rate)
         dominant_freq_idx = np.argmax(np.abs(fft_samples))
-        dominant_freq = abs(fft_freqs[dominant_freq_idx])
-        self.assertAlmostEqual(dominant_freq, self.test_freq, delta=10)  # within 10 hz
+        dominant_freq = fft_freqs[dominant_freq_idx]
+        self.assertAlmostEqual(dominant_freq, self.test_freq, delta=10)  # within 10 hz, signed
 
     def test_random_tone_generation(self):
         """test random tone generation"""
@@ -92,7 +92,7 @@ def test_reproducible_random_generation(self):
 
     def test_sweep_generation(self):
         """test linear frequency sweep generation"""
-        start_freq = 500.0
+        start_freq = -500.0
         end_freq = 2000.0
 
         gen = SigMFGenerator(seed=self.test_seed)
@@ -101,7 +101,7 @@ def test_sweep_generation(self):
         )
 
         # verify metadata
-        self.assertIn("500.0-2000.0 hz sweep", signal.get_global_info()[SigMFFile.DESCRIPTION_KEY])
+        self.assertIn("-500.0-2000.0 hz sweep", signal.get_global_info()[SigMFFile.DESCRIPTION_KEY])
 
         # verify signal properties
         samples = signal.read_samples()
@@ -187,13 +187,15 @@ def test_parameter_validation(self):
         """test parameter validation and error handling"""
         gen = SigMFGenerator()
 
-        # should raise error if no signal type specified
-        with self.assertRaises(SigMFGeneratorError):
-            gen.generate()
+        # bare generate() should now work (auto-generates components)
+        signal = gen.generate()
+        self.assertIsInstance(signal, SigMFFile)
 
-        # should raise error for tone frequency exceeding nyquist
+        # should raise error for tone frequency exceeding nyquist (positive and negative)
         with self.assertRaises(SigMFGeneratorError):
             gen.tone(30000).sample_rate(48000).duration(1.0).generate()
+        with self.assertRaises(SigMFGeneratorError):
+            gen.tone(-30000).sample_rate(48000).duration(1.0).generate()
 
         # should raise error for negative duration
         with self.assertRaises(SigMFGeneratorError):
@@ -207,12 +209,15 @@ def test_sweep_parameter_validation(self):
         """test sweep-specific parameter validation"""
         gen = SigMFGenerator()
 
-        # sweep frequencies exceeding nyquist should raise error
+        # sweep frequencies exceeding nyquist should raise error (positive and negative)
         with self.assertRaises(SigMFGeneratorError):
             gen.sweep(1000, 30000).sample_rate(48000).duration(1.0).generate()
-
         with self.assertRaises(SigMFGeneratorError):
             gen.sweep(30000, 1000).sample_rate(48000).duration(1.0).generate()
+        with self.assertRaises(SigMFGeneratorError):
+            gen.sweep(1000, -30000).sample_rate(48000).duration(1.0).generate()
+        with self.assertRaises(SigMFGeneratorError):
+            gen.sweep(-30000, 1000).sample_rate(48000).duration(1.0).generate()
 
     def test_random_parameters_reasonable(self):
         """test that random parameters are within reasonable ranges"""
@@ -363,31 +368,31 @@ def test_automatic_annotations(self):
         self.assertIn("+200.0 Hz", offset_annotation[SigMFFile.LABEL_KEY])
 
     def test_sweep_annotations(self):
-        """test sweep annotations have correct frequency bounds"""
+        """test sweep annotations have correct frequency bounds including negative"""
         gen = SigMFGenerator(seed=42)
-        signal = gen.sweep(500, 2500).sample_rate(22050).duration(0.1).generate()
+        signal = gen.sweep(-2500, 2500).sample_rate(22050).duration(0.1).generate()
 
         annotations = signal.get_annotations()
         self.assertEqual(len(annotations), 1)  # just main sweep annotation
 
         sweep_annotation = annotations[0]
-        self.assertEqual(sweep_annotation[SigMFFile.FLO_KEY], 500.0)
+        self.assertEqual(sweep_annotation[SigMFFile.FLO_KEY], -2500.0)
         self.assertEqual(sweep_annotation[SigMFFile.FHI_KEY], 2500.0)
-        self.assertIn("500.0-2500.0 Hz sweep", sweep_annotation[SigMFFile.LABEL_KEY])
+        self.assertIn("-2500.0-2500.0 Hz sweep", sweep_annotation[SigMFFile.LABEL_KEY])
 
     def test_reverse_sweep_annotations(self):
-        """test reverse sweep (high to low freq) has correct bounds"""
+        """test reverse sweep crossing DC has correct bounds"""
         gen = SigMFGenerator(seed=42)
-        signal = gen.sweep(3000, 800).sample_rate(48000).duration(0.1).generate()
+        signal = gen.sweep(3000, -800).sample_rate(48000).duration(0.1).generate()
 
         annotations = signal.get_annotations()
         sweep_annotation = annotations[0]
 
         # frequency bounds should be min/max regardless of sweep direction
-        self.assertEqual(sweep_annotation[SigMFFile.FLO_KEY], 800.0)
+        self.assertEqual(sweep_annotation[SigMFFile.FLO_KEY], -800.0)
         self.assertEqual(sweep_annotation[SigMFFile.FHI_KEY], 3000.0)
         # but label should show original order
-        self.assertIn("3000.0-800.0 Hz sweep", sweep_annotation[SigMFFile.LABEL_KEY])
+        self.assertIn("3000.0--800.0 Hz sweep", sweep_annotation[SigMFFile.LABEL_KEY])
 
     def test_minimal_annotations(self):
         """test that simple signals get minimal but complete annotations"""