sift-stack-py 0.16.1__tar.gz → 0.16.2__tar.gz

{sift_stack_py-0.16.1 → sift_stack_py-0.16.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sift_stack_py
-Version: 0.16.1
+Version: 0.16.2
 Summary: Python client library for the Sift API
 Maintainer-email: Sift Software Engineers <engineering@siftstack.com>
 License: Copyright (c) 2024 Azimuth Industries Inc.

{sift_stack_py-0.16.1 → sift_stack_py-0.16.2}/lib/sift_client/_internal/low_level_wrappers/exports.py

@@ -26,10 +26,25 @@ from sift_client.transport import WithGrpcClient
 if TYPE_CHECKING:
     from datetime import datetime
 
+    from sift_client.sift_types.channel import ChannelReference
     from sift_client.sift_types.export import ExportOutputFormat
     from sift_client.transport.grpc_transport import GrpcClient
 
 
+def _abstract_ref_to_proto(ref: ChannelReference) -> CalculatedChannelAbstractChannelReference:
+    # After ChannelReference validation, calculated_channel is always a version_id string.
+    if ref.calculated_channel:
+        assert isinstance(ref.calculated_channel, str)
+        return CalculatedChannelAbstractChannelReference(
+            channel_reference=ref.channel_reference,
+            calculated_channel_version_id=ref.calculated_channel,
+        )
+    return CalculatedChannelAbstractChannelReference(
+        channel_reference=ref.channel_reference,
+        channel_identifier=ref.channel_identifier or "",
+    )
+
+
 def _build_calc_channel_configs(
     calculated_channels: list[CalculatedChannel | CalculatedChannelCreate] | None,
 ) -> list[CalculatedChannelConfig]:
@@ -46,13 +61,7 @@ def _build_calc_channel_configs(
             CalculatedChannelConfig(
                 name=cc.name,
                 expression=cc.expression or "",
-                channel_references=[
-                    CalculatedChannelAbstractChannelReference(
-                        channel_reference=ref.channel_reference,
-                        channel_identifier=ref.channel_identifier,
-                    )
-                    for ref in refs
-                ],
+                channel_references=[_abstract_ref_to_proto(ref) for ref in refs],
                 units=cc.units,
             )
         )

{sift_stack_py-0.16.1 → sift_stack_py-0.16.2}/lib/sift_client/_internal/low_level_wrappers/rules.py

@@ -75,6 +75,16 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
+def _channel_reference_to_proto(ref: ChannelReference) -> ChannelReferenceProto:
+    # ChannelReference's validator normalizes calculated_channel to a version_id str
+    # and guarantees exactly one of calculated_channel / channel_identifier is set.
+    if ref.calculated_channel:
+        return ChannelReferenceProto(
+            calculated_channel_version_id=cast("str", ref.calculated_channel)
+        )
+    return ChannelReferenceProto(name=cast("str", ref.channel_identifier))
+
+
 class RulesLowLevelClient(LowLevelClientBase, WithGrpcClient):
     """Low-level client for the RulesAPI.
 
@@ -126,7 +136,7 @@ class RulesLowLevelClient(LowLevelClientBase, WithGrpcClient):
             calculated_channel=CalculatedChannelConfig(
                 expression=create.expression,
                 channel_references={
-                    c.channel_reference: ChannelReferenceProto(name=c.channel_identifier)
+                    c.channel_reference: _channel_reference_to_proto(c)
                     for c in create.channel_references
                 },
             )
@@ -259,7 +269,7 @@ class RulesLowLevelClient(LowLevelClientBase, WithGrpcClient):
                 CalculatedChannelConfig(
                     expression=expression,
                     channel_references={
-                        c.channel_reference: ChannelReferenceProto(name=c.channel_identifier)
+                        c.channel_reference: _channel_reference_to_proto(c)
                         for c in channel_references
                     },
                 )

{sift_stack_py-0.16.1 → sift_stack_py-0.16.2}/lib/sift_client/_internal/util/channels.py

@@ -32,6 +32,9 @@ async def resolve_calculated_channels(
 
         resolved_refs: list[ChannelReference] = []
         for ref in refs:
+            if ref.calculated_channel:
+                resolved_refs.append(ref)
+                continue
             channel = await channels_api.find(
                 name=ref.channel_identifier,
                 assets=cc.asset_ids,

{sift_stack_py-0.16.1 → sift_stack_py-0.16.2}/lib/sift_client/_tests/_internal/test_channels.py

@@ -41,6 +41,25 @@ class TestResolveCalculatedChannels:
         assert refs is not None
         assert refs[0].channel_identifier == "resolved-uuid"
 
+    @pytest.mark.asyncio
+    async def test_skips_lookup_for_calculated_channel_version_id(self):
+        api = MagicMock()
+        api.find = AsyncMock()
+        cc = CalculatedChannelCreate(
+            name="nested",
+            expression="$1 + 1",
+            expression_channel_references=[
+                ChannelReference(channel_reference="$1", calculated_channel="v-nested")
+            ],
+        )
+        result = await resolve_calculated_channels([cc], channels_api=api)
+        api.find.assert_not_awaited()
+        assert result is not None
+        refs = result[0].expression_channel_references
+        assert refs is not None
+        assert refs[0].calculated_channel == "v-nested"
+        assert refs[0].channel_identifier is None
+
     @pytest.mark.asyncio
     async def test_keeps_identifier_when_not_found(self):
         api = MagicMock()

{sift_stack_py-0.16.1 → sift_stack_py-0.16.2}/lib/sift_client/_tests/resources/test_data_imports.py

@@ -1,11 +1,31 @@
 """Unit tests for data import config models and helpers."""
 
+from __future__ import annotations
+
 from datetime import datetime, timezone
+from typing import TYPE_CHECKING, cast
 
 import pytest
+from sift.common.type.v1.channel_config_pb2 import ChannelConfig as ChannelConfigProto
+from sift.data_imports.v2.data_imports_pb2 import (
+    ParquetColumn,
+    ParquetConfig,
+    ParquetFlatDatasetConfig,
+    ParquetSingleChannelPerRowConfig,
+)
+from sift.data_imports.v2.data_imports_pb2 import (
+    ParquetDataColumn as ParquetDataColumnProto,
+)
+from sift.data_imports.v2.data_imports_pb2 import (
+    ParquetTimeColumn as ParquetTimeColumnProto,
+)
 
 from sift_client.resources import DataImportAPI, DataImportAPIAsync
-from sift_client.resources.data_imports import _resolve_data_type_key
+from sift_client.resources.data_imports import (
+    _infer_time_column,
+    _parse_parquet_detect_response,
+    _resolve_data_type_key,
+)
 from sift_client.sift_types.channel import ChannelDataType
 from sift_client.sift_types.data_import import (
     CsvDataColumn,
@@ -22,6 +42,11 @@ from sift_client.sift_types.data_import import (
     TimeFormat,
 )
 
+if TYPE_CHECKING:
+    from sift.common.type.v1.channel_data_type_pb2 import (
+        ChannelDataType as ChannelDataTypeProto,
+    )
+
 
 @pytest.mark.integration
 def test_client_binding(sift_client):
@@ -362,3 +387,130 @@ class TestResolveDataTypeKey:
     def test_unknown_extension_raises(self):
         with pytest.raises(ValueError, match="Unsupported file extension"):
             _resolve_data_type_key(".xyz", None)
+
+
+class TestInferTimeColumn:
+    def test_picks_canonical_skips_other_columns(self):
+        path = _infer_time_column(
+            [
+                ("delta_time", ChannelDataType.INT_64, "delta_time"),
+                ("voltage", ChannelDataType.DOUBLE, "voltage"),
+                ("timestamp", ChannelDataType.INT_64, "timestamp"),
+            ]
+        )
+        assert path == "timestamp"
+
+    def test_accepts_uint64(self):
+        path = _infer_time_column([("time", ChannelDataType.UINT_64, "time")])
+        assert path == "time"
+
+    def test_case_insensitive(self):
+        path = _infer_time_column([("TimeStamp", ChannelDataType.INT_64, "TimeStamp")])
+        assert path == "TimeStamp"
+
+    def test_multiple_candidates_sorted_alphabetically(self):
+        path = _infer_time_column(
+            [
+                ("timestamp", ChannelDataType.INT_64, "timestamp"),
+                ("time", ChannelDataType.INT_64, "time"),
+                ("ts", ChannelDataType.INT_64, "ts"),
+            ]
+        )
+        assert path == "time"
+
+    def test_returns_none_when_no_canonical_int_column(self):
+        path = _infer_time_column(
+            [
+                ("timestamp", ChannelDataType.DOUBLE, "timestamp"),
+                ("event_time", ChannelDataType.INT_64, "event_time"),
+            ]
+        )
+        assert path is None
+
+
+def _make_flat_dataset_response(
+    time_path: str, data_columns: list[tuple[str, int]]
+) -> ParquetConfig:
+    return ParquetConfig(
+        flat_dataset=ParquetFlatDatasetConfig(
+            time_column=ParquetTimeColumnProto(path=time_path),
+            data_columns=[
+                ParquetDataColumnProto(
+                    path=path,
+                    channel_config=ChannelConfigProto(
+                        name=path,
+                        data_type=cast("ChannelDataTypeProto.ValueType", data_type),
+                    ),
+                )
+                for path, data_type in data_columns
+            ],
+        )
+    )
+
+
+def _make_scpr_response(time_path: str, columns: list[tuple[str, int]]) -> ParquetConfig:
+    return ParquetConfig(
+        single_channel_per_row=ParquetSingleChannelPerRowConfig(
+            time_column=ParquetTimeColumnProto(path=time_path),
+            columns=[
+                ParquetColumn(
+                    path=path,
+                    column_config=ChannelConfigProto(
+                        name=path,
+                        data_type=cast("ChannelDataTypeProto.ValueType", data_type),
+                    ),
+                )
+                for path, data_type in columns
+            ],
+        )
+    )
+
+
+class TestParseParquetDetectResponseTimeFallback:
+    def test_flat_dataset_infers_int64_time_column(self):
+        proto = _make_flat_dataset_response(
+            time_path="",
+            data_columns=[
+                ("voltage", ChannelDataType.DOUBLE.value),
+                ("timestamp", ChannelDataType.INT_64.value),
+                ("status", ChannelDataType.INT_32.value),
+            ],
+        )
+        config = _parse_parquet_detect_response(proto, "file.parquet", 0, 0)
+        assert isinstance(config, ParquetFlatDatasetImportConfig)
+        assert config.time_column.path == "timestamp"
+        assert [dc.path for dc in config.data_columns] == ["voltage", "status"]
+
+    def test_flat_dataset_keeps_server_time_column_when_set(self):
+        proto = _make_flat_dataset_response(
+            time_path="server_ts",
+            data_columns=[
+                ("server_ts", ChannelDataType.INT_64.value),
+                ("timestamp", ChannelDataType.INT_64.value),
+                ("voltage", ChannelDataType.DOUBLE.value),
+            ],
+        )
+        config = _parse_parquet_detect_response(proto, "file.parquet", 0, 0)
+        assert config.time_column.path == "server_ts"
+        assert [dc.path for dc in config.data_columns] == ["timestamp", "voltage"]
+
+    def test_flat_dataset_no_int64_match_leaves_time_empty(self):
+        proto = _make_flat_dataset_response(
+            time_path="",
+            data_columns=[("voltage", ChannelDataType.DOUBLE.value)],
+        )
+        config = _parse_parquet_detect_response(proto, "file.parquet", 0, 0)
+        assert config.time_column.path == ""
+        assert [dc.path for dc in config.data_columns] == ["voltage"]
+
+    def test_scpr_infers_int64_time_column(self):
+        proto = _make_scpr_response(
+            time_path="",
+            columns=[
+                ("voltage", ChannelDataType.DOUBLE.value),
+                ("timestamp", ChannelDataType.INT_64.value),
+            ],
+        )
+        config = _parse_parquet_detect_response(proto, "file.parquet", 0, 0)
+        assert isinstance(config, ParquetSingleChannelPerRowImportConfig)
+        assert config.time_column.path == "timestamp"

{sift_stack_py-0.16.1 → sift_stack_py-0.16.2}/lib/sift_client/_tests/sift_types/test_calculated_channel.py

@@ -7,6 +7,7 @@ import pytest
 
 from sift_client.sift_types import CalculatedChannel
 from sift_client.sift_types.calculated_channel import (
+    CalculatedChannelCreate,
     CalculatedChannelUpdate,
 )
 from sift_client.sift_types.channel import ChannelReference
@@ -151,6 +152,68 @@ class TestCalculatedChannelBase:
                 ],
             )
 
+    def test_nested_calculated_channel_reference_serialized_to_version_id_oneof(self):
+        """A ChannelReference with calculated_channel set routes to the proto oneof."""
+        update = CalculatedChannelUpdate(
+            expression="$1 + $2",
+            expression_channel_references=[
+                ChannelReference(channel_reference="$1", channel_identifier="channel1"),
+                ChannelReference(channel_reference="$2", calculated_channel="v-nested"),
+            ],
+        )
+        update.resource_id = "test_calc_channel_id"
+
+        proto, _ = update.to_proto_with_mask()
+
+        refs = proto.calculated_channel_configuration.query_configuration.sel.expression_channel_references
+        assert len(refs) == 2
+        assert refs[0].channel_identifier == "channel1"
+        assert refs[0].WhichOneof("calculated_channel_reference") is None
+        assert refs[1].WhichOneof("calculated_channel_reference") == "calculated_channel_version_id"
+        assert refs[1].calculated_channel_version_id == "v-nested"
+        assert refs[1].channel_identifier == ""
+
+    def test_create_serializes_nested_calculated_channel_reference(self):
+        """CalculatedChannelCreate.to_proto routes the version_id into the proto oneof."""
+        create = CalculatedChannelCreate(
+            name="nested-cc",
+            expression="$1 * 2",
+            expression_channel_references=[
+                ChannelReference(channel_reference="$1", calculated_channel="v-nested"),
+            ],
+            all_assets=True,
+        )
+
+        proto = create.to_proto()
+
+        refs = proto.calculated_channel_configuration.query_configuration.sel.expression_channel_references
+        assert len(refs) == 1
+        assert refs[0].WhichOneof("calculated_channel_reference") == "calculated_channel_version_id"
+        assert refs[0].calculated_channel_version_id == "v-nested"
+
+    def test_create_serializes_nested_reference_from_calculated_channel_object(
+        self, mock_calculated_channel
+    ):
+        """Passing a CalculatedChannel object to ChannelReference also serializes correctly."""
+        create = CalculatedChannelCreate(
+            name="nested-cc",
+            expression="$1 * 2",
+            expression_channel_references=[
+                ChannelReference(
+                    channel_reference="$1", calculated_channel=mock_calculated_channel
+                ),
+            ],
+            all_assets=True,
+        )
+
+        proto = create.to_proto()
+
+        refs = proto.calculated_channel_configuration.query_configuration.sel.expression_channel_references
+        assert len(refs) == 1
+        assert refs[0].WhichOneof("calculated_channel_reference") == "calculated_channel_version_id"
+        # mock_calculated_channel fixture has version_id="v1"
+        assert refs[0].calculated_channel_version_id == "v1"
+
     def test_expression_validator_accepts_both_set(self):
         """Test validator accepts expression and channel references together."""
         # Should not raise

{sift_stack_py-0.16.1 → sift_stack_py-0.16.2}/lib/sift_client/_tests/sift_types/test_channel.py

@@ -6,7 +6,7 @@ from unittest.mock import MagicMock
 import pytest
 
 from sift_client.sift_types import Channel
-from sift_client.sift_types.channel import ChannelDataType
+from sift_client.sift_types.channel import ChannelDataType, ChannelReference
 
 
 @pytest.fixture
@@ -104,6 +104,100 @@ class TestChannel:
         mock_client.channels.get_data.assert_not_called()
         assert result == mock_data
 
+    def test_channel_reference_requires_one_target(self):
+        """ChannelReference must specify exactly one of identifier or calculated_channel."""
+        with pytest.raises(ValueError, match="exactly one"):
+            ChannelReference(channel_reference="$1")
+        with pytest.raises(ValueError, match="exactly one"):
+            ChannelReference(
+                channel_reference="$1",
+                channel_identifier="ch",
+                calculated_channel="v-id",
+            )
+
+    def test_channel_reference_accepts_version_id_string(self):
+        """A plain version_id string is stored as-is."""
+        ref = ChannelReference(channel_reference="$1", calculated_channel="v-abc")
+        assert ref.calculated_channel == "v-abc"
+        assert ref.channel_identifier is None
+
+    def test_channel_reference_accepts_calculated_channel_object(self):
+        """Passing a CalculatedChannel normalizes to its version_id string."""
+        from sift_client.sift_types.calculated_channel import CalculatedChannel
+
+        cc = CalculatedChannel(
+            proto=MagicMock(),
+            id_="cc-id",
+            name="parent",
+            description="",
+            expression="$1",
+            channel_references=[],
+            is_archived=False,
+            units=None,
+            asset_ids=["asset-1"],
+            tag_ids=None,
+            all_assets=False,
+            organization_id=None,
+            client_key=None,
+            archived_date=None,
+            version_id="v-abc",
+            version=1,
+            change_message=None,
+            user_notes=None,
+            created_date=datetime.now(timezone.utc),
+            modified_date=datetime.now(timezone.utc),
+            created_by_user_id="u",
+            modified_by_user_id="u",
+        )
+
+        ref = ChannelReference(channel_reference="$1", calculated_channel=cc)
+        assert ref.calculated_channel == "v-abc"
+
+    def test_channel_reference_rejects_calculated_channel_without_version_id(self):
+        """A CalculatedChannel missing version_id is unusable as a reference."""
+        from sift_client.sift_types.calculated_channel import CalculatedChannel
+
+        cc = CalculatedChannel(
+            proto=MagicMock(),
+            id_="cc-id",
+            name="parent",
+            description="",
+            expression="$1",
+            channel_references=[],
+            is_archived=False,
+            units=None,
+            asset_ids=["asset-1"],
+            tag_ids=None,
+            all_assets=False,
+            organization_id=None,
+            client_key=None,
+            archived_date=None,
+            version_id=None,
+            version=None,
+            change_message=None,
+            user_notes=None,
+            created_date=datetime.now(timezone.utc),
+            modified_date=datetime.now(timezone.utc),
+            created_by_user_id="u",
+            modified_by_user_id="u",
+        )
+
+        with pytest.raises(ValueError, match="no version_id"):
+            ChannelReference(channel_reference="$1", calculated_channel=cc)
+
+    def test_channel_reference_from_proto_reads_version_id_oneof(self):
+        """_from_proto picks calculated_channel when the proto oneof selects it."""
+        from sift.calculated_channels.v2.calculated_channels_pb2 import (
+            CalculatedChannelAbstractChannelReference,
+        )
+
+        proto = CalculatedChannelAbstractChannelReference(
+            channel_reference="$1", calculated_channel_version_id="v-abc"
+        )
+        ref = ChannelReference._from_proto(proto)
+        assert ref.calculated_channel == "v-abc"
+        assert ref.channel_identifier is None
+
     def test_data_method_with_minimal_params(self, mock_channel, mock_client):
         """Test that data() method works with minimal parameters."""
         mock_data = {"test_channel": MagicMock()}

{sift_stack_py-0.16.1 → sift_stack_py-0.16.2}/lib/sift_client/_tests/sift_types/test_rule.py

@@ -147,3 +147,76 @@ class TestRule:
             mock_update.assert_called_once_with(unarchived_rule)
             # Verify it returns self
             assert result is mock_rule
+
+
+class TestRuleChannelReferenceSerialization:
+    """Nested CC references flow through the low-level wrapper and back."""
+
+    def test_helper_routes_version_id_into_proto(self):
+        from sift_client._internal.low_level_wrappers.rules import (
+            _channel_reference_to_proto,
+        )
+
+        proto = _channel_reference_to_proto(
+            ChannelReference(channel_reference="$1", calculated_channel="v-abc")
+        )
+        assert proto.HasField("calculated_channel_version_id")
+        assert proto.calculated_channel_version_id == "v-abc"
+        assert proto.name == ""
+
+    def test_helper_routes_identifier_into_name(self):
+        from sift_client._internal.low_level_wrappers.rules import (
+            _channel_reference_to_proto,
+        )
+
+        proto = _channel_reference_to_proto(
+            ChannelReference(channel_reference="$1", channel_identifier="my-channel")
+        )
+        assert not proto.HasField("calculated_channel_version_id")
+        assert proto.name == "my-channel"
+
+    def test_from_proto_reads_version_id_when_present(self):
+        from google.protobuf.timestamp_pb2 import Timestamp
+        from sift.rules.v1.rules_pb2 import (
+            CalculatedChannelConfig,
+            RuleCondition,
+            RuleConditionExpression,
+        )
+        from sift.rules.v1.rules_pb2 import (
+            ChannelReference as ChannelReferenceProto,
+        )
+        from sift.rules.v1.rules_pb2 import (
+            Rule as RuleProto,
+        )
+        from sift.rules.v1.rules_pb2 import (
+            RuleAction as RuleActionProto,
+        )
+
+        ts = Timestamp()
+        ts.GetCurrentTime()
+        proto = RuleProto(
+            rule_id="r1",
+            name="r",
+            description="",
+            created_date=ts,
+            modified_date=ts,
+            conditions=[
+                RuleCondition(
+                    expression=RuleConditionExpression(
+                        calculated_channel=CalculatedChannelConfig(
+                            expression="$1 > 0",
+                            channel_references={
+                                "$1": ChannelReferenceProto(calculated_channel_version_id="v-xyz"),
+                            },
+                        )
+                    ),
+                    actions=[RuleActionProto(created_date=ts, modified_date=ts)],
+                )
+            ],
+        )
+        rule = Rule._from_proto(proto)
+        assert rule.channel_references is not None
+        assert len(rule.channel_references) == 1
+        ref = rule.channel_references[0]
+        assert ref.calculated_channel == "v-xyz"
+        assert ref.channel_identifier is None

{sift_stack_py-0.16.1 → sift_stack_py-0.16.2}/lib/sift_client/resources/data_imports.py

@@ -8,6 +8,7 @@ from sift_client._internal.util.executor import run_sync_function
 from sift_client._internal.util.file import extract_parquet_footer, upload_file
 from sift_client.resources._base import ResourceBase
 from sift_client.sift_types.asset import Asset
+from sift_client.sift_types.channel import ChannelDataType
 from sift_client.sift_types.data_import import (
     EXTENSION_TO_DATA_TYPE_KEY,
     CsvImportConfig,
@@ -15,10 +16,13 @@ from sift_client.sift_types.data_import import (
     ImportConfig,
     ParquetFlatDatasetImportConfig,
     ParquetSingleChannelPerRowImportConfig,
+    ParquetTimeColumn,
 )
 from sift_client.sift_types.run import Run
 
 if TYPE_CHECKING:
+    from collections.abc import Iterable
+
     from sift_client.client import SiftClient
     from sift_client.sift_types.job import Job
 
@@ -320,6 +324,28 @@ def _parse_csv_detect_response(proto) -> CsvImportConfig:
     return csv_config
 
 
+_TIME_COLUMN_NAMES: frozenset[str] = frozenset({"ts", "timestamp", "time"})
+_TIME_COLUMN_TYPES: frozenset[ChannelDataType] = frozenset(
+    {ChannelDataType.INT_64, ChannelDataType.UINT_64}
+)
+
+
+def _infer_time_column(
+    columns: Iterable[tuple[str, ChannelDataType, str]],
+) -> str | None:
+    """Pick a likely time column when the server couldn't identify one.
+
+    Returns the path of an INT64 or UINT64 column whose name
+    (case-insensitive) matches one of ``ts``, ``timestamp``, or ``time``.
+    Returns None otherwise.
+    """
+    data_columns = sorted(columns, key=lambda c: c[0].lower())
+    for name, data_type, path in data_columns:
+        if data_type in _TIME_COLUMN_TYPES and name.lower() in _TIME_COLUMN_NAMES:
+            return path
+    return None
+
+
 def _parse_parquet_detect_response(
     proto, filename: str, footer_offset: int, footer_length: int
 ) -> ParquetFlatDatasetImportConfig | ParquetSingleChannelPerRowImportConfig:
@@ -328,16 +354,30 @@ def _parse_parquet_detect_response(
         parquet_config = ParquetFlatDatasetImportConfig._from_proto(
             proto, footer_offset=footer_offset, footer_length=footer_length
         )
-        time_path = parquet_config.time_column.path
+        time_path: str | None = parquet_config.time_column.path
+        if not time_path:
+            time_path = _infer_time_column(
+                (dc.name, dc.data_type, dc.path) for dc in parquet_config.data_columns
+            )
+            if time_path:
+                parquet_config.time_column = ParquetTimeColumn(path=time_path)
         if time_path:
             parquet_config.data_columns = [
                 dc for dc in parquet_config.data_columns if dc.path != time_path
             ]
         return parquet_config
     elif proto.HasField("single_channel_per_row"):
-        return ParquetSingleChannelPerRowImportConfig._from_proto(
+        scpr_config = ParquetSingleChannelPerRowImportConfig._from_proto(
             proto, footer_offset=footer_offset, footer_length=footer_length
         )
+        if not scpr_config.time_column.path:
+            time_path = _infer_time_column(
+                (col.column_config.name, ChannelDataType(col.column_config.data_type), col.path)
+                for col in proto.single_channel_per_row.columns
+            )
+            if time_path is not None:
+                scpr_config.time_column = ParquetTimeColumn(path=time_path)
+        return scpr_config
     raise ValueError(f"Unsupported parquet layout in DetectConfig response for '{filename}'.")