Removed the default auto from input sampling period. Added descriptor to...

Removed the default auto from input sampling period. Added descriptor to swagger saying that  will generate correct sampling period needed to find the output_sampling_period.

geomagio/api/ws/DataApiQuery.py

@@ -41,15 +41,6 @@ class SamplingPeriod(float, enum.Enum):
     DAY = 86400.0
 
 
-class SamplingPeriodWithAuto(str, enum.Enum):
-    AUTO = "auto"
-    TEN_HERTZ = SamplingPeriod.TEN_HERTZ.value
-    SECOND = SamplingPeriod.SECOND.value
-    MINUTE = SamplingPeriod.MINUTE.value
-    HOUR = SamplingPeriod.HOUR.value
-    DAY = SamplingPeriod.DAY.value
-
-
 class DataHost(str, enum.Enum):
     # recognized public Edge data hosts, plus one user-specified
     DEFAULT = os.getenv("DATA_HOST", "edgecwb.usgs.gov")

geomagio/api/ws/FilterApiQuery.py

@@ -2,7 +2,6 @@ from .DataApiQuery import (
     DataApiQuery,
     SamplingPeriod,
     REQUEST_LIMIT,
-    SamplingPeriodWithAuto,
 )
 from pydantic import ConfigDict, model_validator, field_validator
 from typing import Optional, Union
@@ -14,36 +13,7 @@ the fields input_sampling_period and output_sampling_period."""
 class FilterApiQuery(DataApiQuery):
     model_config = ConfigDict(extra="forbid")
 
-    input_sampling_period: Union[SamplingPeriodWithAuto, float] = (
-        SamplingPeriodWithAuto.AUTO
-    )
-
-    @field_validator("input_sampling_period", mode="before")
-    def normalize_sampling_period(cls, value):
-        if isinstance(value, str) and value == SamplingPeriodWithAuto.AUTO:
-            return float("nan")  # Map 'auto' to NaN internally
-        if isinstance(value, str):
-            return float(value)  # Map string values to float
-        try:
-            value = float(value)  # Coerce numeric-like strings to float
-        except ValueError:
-            raise ValueError(
-                f"Invalid sampling period. Must be one of "
-                f"{[item.value for item in SamplingPeriodWithAuto]}"
-            )
-        # If the value is a float, find its matching enum based on the string value
-        if isinstance(value, float):
-            print("The sampling period is touching this logic downstream", type(value))
-            # Find matching enum value by checking if the float matches the string equivalent but skip the string "auto"
-            for period in list(SamplingPeriodWithAuto)[1:]:
-                if float(period.value) == value:
-
-                    return period
-
-            # If no match is found, return the float as-is
-            return value
-
-        return value  # Return the value if it's not a recognized string or float
+    input_sampling_period: Optional[Union[SamplingPeriod, float]] = None
 
     @model_validator(mode="after")
     def validate_sample_size(self):

geomagio/api/ws/algorithms.py

@@ -2,15 +2,14 @@ import json
 
 from fastapi import APIRouter, Depends, HTTPException, Query
 from starlette.responses import Response
-from obspy.core import Stream, Stats
-from typing import List, Union
 
-from ...algorithm import DbDtAlgorithm, FilterAlgorithm
+
+from ...algorithm import DbDtAlgorithm
 from ...residual import (
     calculate,
     Reading,
 )
-from .DataApiQuery import DataApiQuery, SamplingPeriod
+from .DataApiQuery import DataApiQuery
 from .FilterApiQuery import FilterApiQuery
 from .data import format_timeseries, get_data_factory, get_data_query, get_timeseries
 from .filter import get_filter_data_query

geomagio/api/ws/filter.py

@@ -11,7 +11,6 @@ from .DataApiQuery import (
     DataType,
     OutputFormat,
     SamplingPeriod,
-    SamplingPeriodWithAuto,
 )
 from .FilterApiQuery import FilterApiQuery
 from ...algorithm.FilterAlgorithm import STEPS
@@ -34,13 +33,13 @@ def get_filter_data_query(
     format: Union[OutputFormat, str] = Query(
         OutputFormat.IAGA2002, title="Output Format"
     ),
-    input_sampling_period: Union[SamplingPeriodWithAuto, float, int] = Query(
-        SamplingPeriodWithAuto.AUTO,  # Assign Default value as auto
+    input_sampling_period: Optional[Union[SamplingPeriod, float]] = Query(
+        None,
         title="Initial Sampling Period",
-        description="Auto will dynamically determine necessary input_sampling_period.",
+        description="`--` dynamically determines a necessary sampling period.",
     ),
     sampling_period: Union[SamplingPeriod, float] = Query(
-        SamplingPeriod, alias="output_sampling_period", title="Output sampling period"
+        SamplingPeriod.SECOND, alias="output_sampling_period", title="Output sampling period"
     ),
     data_host: Union[DataHost, str] = Query(
         DataHost.DEFAULT, title="Data Host", description="Edge host to pull data from."
@@ -66,7 +65,7 @@ def get_timeseries(query: FilterApiQuery) -> Stream:
 
     # Determine input sampling period if not provided
     # if query.input_sampling_period == SamplingPeriodWithAuto.AUTO or query.input_sampling_period is None:
-    if math.isnan(query.input_sampling_period) or query.input_sampling_period is None:
+    if query.input_sampling_period is None:
         # Dynamically determine the input sampling period
         input_sampling_period, data = determine_available_period(
             query.sampling_period, query, data_factory

test/FilterApiQuery_test.py

@@ -5,7 +5,6 @@ from obspy import UTCDateTime
 from geomagio.api.ws.FilterApiQuery import FilterApiQuery
 from geomagio.api.ws.DataApiQuery import (
     SamplingPeriod,
-    SamplingPeriodWithAuto,
     DataType,
     OutputFormat,
     DataHost,
@@ -23,7 +22,7 @@ def test_FilterApiQuery_defaults():
     assert_equal(query.starttime, expected_start_time)
     assert_equal(query.endtime, expected_endtime)
     assert_equal(query.elements, ["X", "Y", "Z", "F"])
-    assert_equal(query.input_sampling_period, SamplingPeriodWithAuto.AUTO)
+    assert_equal(query.input_sampling_period, None)
     assert_equal(query.sampling_period, SamplingPeriod.MINUTE)
     assert_equal(query.data_type, DataType.VARIATION)
     assert_equal(query.format, OutputFormat.IAGA2002)
@@ -47,7 +46,7 @@ def test_FilterApiQuery_valid():
     assert_equal(query.starttime, UTCDateTime("2024-09-01T00:00:01"))
     assert_equal(query.endtime, UTCDateTime("2024-09-01T01:00:01"))
     assert_equal(query.elements, ["Z"])
-    assert_equal(query.input_sampling_period, SamplingPeriodWithAuto.MINUTE)
+    assert_equal(query.input_sampling_period, SamplingPeriod.MINUTE)
     assert_equal(query.sampling_period, SamplingPeriod.HOUR)
     assert_equal(query.data_type, DataType.ADJUSTED)
     assert_equal(query.format, OutputFormat.JSON)