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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sift_stack_py
-Version: 0.16.0
+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.
@@ -45,6 +45,7 @@ Requires-Dist: typing-extensions~=4.6
 Requires-Dist: types-requests~=2.25
 Requires-Dist: googleapis-common-protos>=1.60
 Requires-Dist: protoc-gen-openapiv2>=0.0.1
+Requires-Dist: filelock~=3.13
 Provides-Extra: all
 Requires-Dist: cffi~=1.14; extra == "all"
 Requires-Dist: h5py~=3.11; extra == "all"

{sift_stack_py-0.16.0 → sift_stack_py-0.16.2}/lib/sift_client/_internal/low_level_wrappers/_test_results_log.py

@@ -1,11 +1,15 @@
 """Internal log-format primitives for test-result simulation logs.
 
-Two files per run:
+Three files per run:
 
 * **Log file** (e.g. ``foo.jsonl``) - append-only record of each logged API call,
   one line per call. Written by :func:`log_request_to_file` in the test process
   and read by :func:`iter_log_data_lines` / the replay subprocess. Has no header:
   every line is a data line.
+* **Lock sidecar** (``foo.jsonl.lock``) - empty file used by :class:`filelock.FileLock`
+  to coordinate appends and snapshot reads across processes. Created on demand;
+  ``filelock`` unlinks it on release on Unix, and on Windows it may linger but is
+  harmless to leave or delete after the run.
 * **Tracking sidecar** (``foo.jsonl.tracking``) - small JSON file holding the
   incremental replay cursor (``lastUploadedLine``) and the simulated-to-real ID
   map. Written only by the replay subprocess via :meth:`LogTracking.save` using
@@ -15,26 +19,26 @@ Two files per run:
 
 # Concurrency
 
-With tracking moved out of the main log, the log file becomes strictly
-append-only and has exactly one in-place mutator (the writer) and one scanner
-(the replay subprocess). POSIX guarantees that an ``O_APPEND`` write atomically
-bumps the EOF, so parallel writers can't lose data. To keep a concurrent reader
-from observing a mid-append partial final line we still take ``LOCK_EX`` on the
-writer's single append and ``LOCK_SH`` on the reader's ``readlines()``; there
-is never any exclusive-vs-exclusive contention because nothing rewrites the
-file any more.
-
-The sidecar has a single writer (the replay subprocess) and no live reader, so
-it needs no locking. Atomic rename is still used to keep the on-disk contents
-valid across crashes.
-
-``flock`` is advisory, so this contract only holds for processes that use these
-helpers; ad-hoc writers are not protected.
+With tracking moved out of the main log, the log file is strictly append-only
+and has exactly one in-place mutator (the writer) and one scanner (the replay
+subprocess). Both serialize through a cross-platform exclusive ``FileLock`` on
+the lock sidecar: the writer holds it across a single append, the reader holds
+it across the snapshot ``readlines()``. That keeps a concurrent reader from
+observing a mid-append partial final line on any OS, including Windows where
+POSIX advisory ``flock`` is unavailable. The exclusive-only lock means a hot
+reader briefly blocks the writer (and vice versa), which is acceptable because
+writes are tiny and we only have one reader.
+
+The tracking sidecar has a single writer (the replay subprocess) and no live
+reader, so it needs no locking. Atomic rename is still used to keep the on-disk
+contents valid across crashes.
+
+The lock is advisory: it only protects callers that go through these helpers.
+Ad-hoc writers to the same path are not protected.
 """
 
 from __future__ import annotations
 
-import fcntl
 import json
 import os
 import re
@@ -42,6 +46,7 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Generator
 
+from filelock import FileLock
 from google.protobuf import json_format
 
 if TYPE_CHECKING:
@@ -153,9 +158,10 @@ def log_request_to_file(
 ) -> None:
     """Append a request as a JSON-encoded line to ``log_file``.
 
-    Takes ``LOCK_EX`` across the append so a concurrent reader holding
-    ``LOCK_SH`` in :func:`iter_log_data_lines` can't see a mid-write partial
-    final line. See the module docstring for the full concurrency model.
+    Holds an exclusive :class:`filelock.FileLock` on the sidecar across the
+    append so a concurrent reader in :func:`iter_log_data_lines` can't see a
+    mid-write partial final line. See the module docstring for the full
+    concurrency model.
 
     Args:
         log_file: Path to the log file.
@@ -171,15 +177,15 @@ def log_request_to_file(
     request_dict = json_format.MessageToDict(request)
     request_json = json.dumps(request_dict, separators=(",", ":"))
     line = f"[{tag}] {request_json}\n"
-    with open(log_path, "a") as f:
-        fcntl.flock(f, fcntl.LOCK_EX)
-        # Closing the file flushes and releases the flock atomically; no
-        # explicit unlock needed here.
-        f.write(line)
+    with FileLock(str(log_path.with_name(log_path.name + ".lock"))):
+        with open(log_path, "a") as f:
+            # The inner ``with`` flushes and closes the file before the
+            # FileLock is released, so no reader sees a partial line.
+            f.write(line)
 
 
 def iter_log_data_lines(
-    log_path: Path,
+    log_path: str | Path,
     start_line: int = 0,
 ) -> Generator[tuple[str, str | None, str], None, None]:
     """Parse data lines from a log file.
@@ -191,15 +197,16 @@ def iter_log_data_lines(
     iterator skips the first ``start_line`` lines and yields the rest. Pass 0
     to read all data lines.
 
-    Acquires ``LOCK_SH`` only while snapshotting the file into memory, then
-    releases before yielding. Lines appended by a concurrent
-    :func:`log_request_to_file` after the snapshot are not visible this call --
-    they will be picked up on the next invocation.
+    Holds the sidecar :class:`filelock.FileLock` only while snapshotting the
+    file into memory, then releases before yielding. Lines appended by a
+    concurrent :func:`log_request_to_file` after the snapshot are not visible
+    this call -- they will be picked up on the next invocation.
     """
     line_pattern = re.compile(r"^\[(\w+)(?::([^\]]+))?\]\s*(.+)$")
-    with open(log_path) as f:
-        fcntl.flock(f, fcntl.LOCK_SH)
-        raw_lines = f.readlines()
+    log_path = Path(log_path)
+    with FileLock(str(log_path.with_name(log_path.name + ".lock"))):
+        with open(log_path) as f:
+            raw_lines = f.readlines()
 
     data_line_count = 0
     for raw_line in raw_lines:

{sift_stack_py-0.16.0 → 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.0 → 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.0 → 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.0 → 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.0 → 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.0 → 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.0 → 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()}