update tests

Author: alexluck-sift

python/lib/sift_client/.ruff.toml

@@ -49,6 +49,7 @@ ignore = ["W191", "D206", "D300", # https://docs.astral.sh/ruff/formatter/#confl
     "D105", # Missing docstring in magic method
     "D205", # 1 blank line required between summary line and description
     "D100", # Missing docstring in public module
+    "C408", # Allow dict()
 ]
 
 

python/lib/sift_client/_internal/gen_pyi.py

@@ -143,7 +143,9 @@ def generate_stubs_for_module(path_arg: str | pathlib.Path) -> dict[pathlib.Path
             raw_doc = inspect.getdoc(cls) or ""
             if raw_doc:
                 doc = (
-                    '    """\n' + "\n".join(f"    {l.strip()}" for l in raw_doc.splitlines()) + '\n    """'
+                    '    """\n'
+                    + "\n".join(f"    {l.strip()}" for l in raw_doc.splitlines())
+                    + '\n    """'
                 )
             else:
                 doc = "    ..."

python/lib/sift_client/_tests/integrated/calculated_channels.py

@@ -9,6 +9,7 @@
     CalculatedChannelUpdate,
     ChannelReference,
 )
+from sift_client.sift_types.calculated_channel import CalculatedChannelCreate
 
 """
 Comprehensive test script for calculated channels with extensive update field exercises.
@@ -55,18 +56,17 @@ async def main():
 
     created_channels = []
     for i in range(num_channels):
-        calculated_channel = client.calculated_channels.create(
-            name=f"test_channel_{unique_name_suffix}_{i}",
-            description=f"Test calculated channel {i} - initial description",
-            expression="$1 / $2",  # $1 = mainmotor.velocity, $2 = voltage
-            channel_references=[
-                ChannelReference(channel_reference="$1", channel_identifier="mainmotor.velocity"),
-                ChannelReference(channel_reference="$2", channel_identifier="voltage"),
-            ],
-            units="velocity/voltage",
-            asset_ids=[asset_id],
-            user_notes=f"Created for testing update fields - channel {i}",
-        )
+        new_chan = CalculatedChannelCreate(name=f"test_channel_{unique_name_suffix}_{i}",
+                                           description=f"Test calculated channel {i} - initial description",
+                                           expression="$1 / $2",  # $1 = mainmotor.velocity, $2 = voltage
+                                           expression_channel_references=[
+                                               ChannelReference(channel_reference="$1", channel_identifier="mainmotor.velocity"),
+                                               ChannelReference(channel_reference="$2", channel_identifier="voltage"),
+                                           ],
+                                           units="velocity/voltage",
+                                           asset_ids=[asset_id],
+                                           user_notes=f"Created for testing update fields - channel {i}",)
+        calculated_channel = client.calculated_channels.create(new_chan)
         created_channels.append(calculated_channel)
         print(
             f"Created calculated channel: {calculated_channel.name} (ID: {calculated_channel.id_})"
@@ -236,7 +236,7 @@ async def main():
     assert updated_channel_7.tag_ids == [], f"Tag IDs update failed: {updated_channel_7.tag_ids}"
 
     versions = client.calculated_channels.list_versions(
-        calculated_channel_id=channel_1.id_,
+        calculated_channel=channel_1.id_,
         limit=10,
     )
     print(f"Found {len(versions)} versions for {created_channels[0].name}")

python/lib/sift_client/_tests/integrated/channels.py

@@ -41,7 +41,7 @@ async def main():
     # List channels for this asset (find a run w/ data)
     channels = []
     for run in runs:
-        asset_channels = asset.channels(run_id=run.id_, limit=10)
+        asset_channels = asset.channels(run=run.id_, limit=10)
         other_channels = []
         for c in asset_channels:
             if c.name in {"voltage", "gpio", "temperature", "mainmotor.velocity"}:
@@ -68,7 +68,7 @@ async def main():
     print("Getting data for multiple channels:")
     perf_start = time.perf_counter()
     channel_data = client.channels.get_data(
-        run_id="1d5f5c93-eaaa-48f2-94ff-7ec4337faec7", channels=channels, limit=100
+        run="1d5f5c93-eaaa-48f2-94ff-7ec4337faec7", channels=channels, limit=100
     )
     first_time = time.perf_counter() - perf_start
     start_time = None

python/lib/sift_client/_tests/integrated/ingestion.py

@@ -35,19 +35,19 @@ async def main():
     asset = "ian-test-asset"
 
     # TODO:Get user id from current user
-    previously_created_runs = client.runs.list(
-        name_regex="test-run-.*", created_by_user_id="1eba461b-fa36-4e98-8fe8-ff32d3e43a6e"
+    previously_created_runs = client.runs.list_(
+        name_regex="test-run-.*", created_by="1eba461b-fa36-4e98-8fe8-ff32d3e43a6e"
     )
     if previously_created_runs:
         print(f"   Deleting previously created runs: {previously_created_runs}")
         for run in previously_created_runs:
             print(f"   Deleting run: {run.name}")
             client.runs.archive(run=run)
 
-    run = client.runs.create(
+    run = client.runs.create(dict(
         name=f"test-run-{datetime.now(tz=timezone.utc).timestamp()}",
-        description="A test run created via the API",
-        tags=["api-created", "test"],
+       description="A test run created via the API",
+        tags=["api-created", "test"],)
     )
 
     regular_flow = Flow(

python/lib/sift_client/_tests/integrated/runs.py

@@ -11,6 +11,8 @@
 import os
 from datetime import datetime, timedelta, timezone
 
+import dotenv
+
 from sift_client import SiftClient
 
 
@@ -52,7 +54,7 @@ async def main():
 
     # Example 1: List all runs
     print("\n1. Listing all runs...")
-    runs = client.runs.list(limit=5)
+    runs = client.runs.list_(limit=5)
     print(f"   Found {len(runs)} runs:")
     for run in runs:
         print(f"   - {run.name} (ID: {run.id_}), Organization ID: {run.organization_id}")
@@ -61,7 +63,7 @@ async def main():
     print("\n2. Testing different filter options...")
 
     # Get a sample run for testing filters
-    sample_runs = client.runs.list(limit=3)
+    sample_runs = client.runs.list_(limit=3)
     if not sample_runs:
         print("   No runs available for filter testing")
         return
@@ -71,38 +73,38 @@ async def main():
     # 2a: Filter by exact name
     print("\n   2a. Filter by exact name...")
     run_name = sample_run.name
-    runs = client.runs.list(name=run_name, limit=5)
+    runs = client.runs.list_(name=run_name, limit=5)
     print(f"   Found {len(runs)} runs with exact name '{run_name}':")
     for run in runs:
         print(f"   - {run.name} (ID: {run.id_})")
 
     # 2b: Filter by name containing text
     print("\n   2b. Filter by name containing text...")
-    runs = client.runs.list(name_contains="test", limit=5)
+    runs = client.runs.list_(name_contains="test", limit=5)
     print(f"   Found {len(runs)} runs with 'test' in name:")
     for run in runs:
         print(f"   - {run.name}")
 
     # 2c: Filter by name using regex
     print("\n   2c. Filter by name using regex...")
-    runs = client.runs.list(name_regex=".*test.*", limit=5)
+    runs = client.runs.list_(name_regex=".*test.*", limit=5)
     print(f"   Found {len(runs)} runs with 'test' in name (regex):")
     for run in runs:
         print(f"   - {run.name}")
 
     # 2d: Filter by exact description
-    print("\n   2d. Filter by exact description...")
+    print("\n   2d. Filter by description contains...")
     if sample_run.description:
-        runs = client.runs.list(description=sample_run.description, limit=5)
-        print(f"   Found {len(runs)} runs with exact description '{sample_run.description}':")
+        runs = client.runs.list_(description_contains=sample_run.description, limit=5)
+        print(f"   Found {len(runs)} runs with description contains '{sample_run.description}':")
         for run in runs:
             print(f"   - {run.name}: {run.description}")
     else:
         print("   No description available for testing")
 
     # 2e: Filter by description containing text
     print("\n   2e. Filter by description containing text...")
-    runs = client.runs.list(description_contains="test", limit=5)
+    runs = client.runs.list_(description_contains="test", limit=5)
     print(f"   Found {len(runs)} runs with 'test' in description:")
     for run in runs:
         print(f"   - {run.name}: {run.description}")
@@ -112,8 +114,8 @@ async def main():
     # Calculate duration for sample run if it has start and stop times
     if sample_run.start_time and sample_run.stop_time:
         duration_seconds = int((sample_run.stop_time - sample_run.start_time).total_seconds())
-        runs = client.runs.list(duration_seconds=duration_seconds, limit=5)
-        print(f"   Found {len(runs)} runs with duration {duration_seconds} seconds:")
+        runs = client.runs.list_(duration_greater_than=timedelta(seconds=duration_seconds), limit=5)
+        print(f"   Found {len(runs)} runs with duration greater than {duration_seconds} seconds:")
         for run in runs:
             if run.start_time and run.stop_time:
                 run_duration = int((run.stop_time - run.start_time).total_seconds())
@@ -124,18 +126,16 @@ async def main():
     # 2g: Filter by client key
     print("\n   2g. Filter by client key...")
     if sample_run.client_key:
-        runs = client.runs.list(client_key=sample_run.client_key, limit=5)
-        print(f"   Found {len(runs)} runs with client key '{sample_run.client_key}':")
-        for run in runs:
-            print(f"   - {run.name} (client_key: {run.client_key})")
+        run = client.runs.get(client_key=sample_run.client_key)
+        print(f"   Found run with client key '{run.name}'")
     else:
         print("   No client key available for testing")
 
     # 2h: Filter by asset ID
     print("\n   2h. Filter by asset ID...")
     if sample_run.asset_ids:
         asset_id = sample_run.asset_ids[0]
-        runs = client.runs.list(asset_id=asset_id, limit=5)
+        runs = client.runs.list_(assets=[asset_id], limit=5)
         print(f"   Found {len(runs)} runs associated with asset {asset_id}:")
         for run in runs:
             print(f"   - {run.name} (asset_ids: {list(run.asset_ids)})")
@@ -144,42 +144,42 @@ async def main():
 
     # 2i: Filter by asset name
     print("\n   2i. Filter by asset name...")
-    runs = client.runs.list(asset_name="NostromoLV426", limit=5)
+    runs = client.runs.list_(assets=[client.assets.find(name="NostromoLV426")], limit=5)
     print(f"   Found {len(runs)} runs associated with asset 'NostromoLV426':")
     for run in runs:
         print(f"   - {run.name}")
 
     # 2j: Filter by created by user ID
     print("\n   2j. Filter by created by user ID...")
-    created_by_user_id = sample_run.created_by_user_id
-    runs = client.runs.list(created_by_user_id=created_by_user_id, limit=5)
-    print(f"   Found {len(runs)} runs created by user {created_by_user_id}:")
+    created_by = sample_run.created_by_user_id
+    runs = client.runs.list_(created_by=created_by, limit=5)
+    print(f"   Found {len(runs)} runs created by user {created_by}:")
     for run in runs:
-        print(f"   - {run.name} (created by: {run.created_by_user_id})")
+        print(f"   - {run.name} (created by: {run.created_by})")
 
     # 2l: Test ordering options
     print("\n   2l. Testing ordering options...")
 
     # Order by name ascending
-    runs = client.runs.list(order_by="name", limit=3)
+    runs = client.runs.list_(order_by="name", limit=3)
     print("   First 3 runs ordered by name (ascending):")
     for run in runs:
         print(f"   - {run.name}")
 
     # Order by name descending
-    runs = client.runs.list(order_by="name desc", limit=3)
+    runs = client.runs.list_(order_by="name desc", limit=3)
     print("   First 3 runs ordered by name (descending):")
     for run in runs:
         print(f"   - {run.name}")
 
     # Order by creation date (newest first - default)
-    runs = client.runs.list(order_by="created_date desc", limit=3)
+    runs = client.runs.list_(order_by="created_date desc", limit=3)
     print("   First 3 runs ordered by creation date (newest first):")
     for run in runs:
         print(f"   - {run.name} (created: {run.created_date})")
 
     # Order by creation date (oldest first)
-    runs = client.runs.list(order_by="created_date", limit=3)
+    runs = client.runs.list_(order_by="created_date", limit=3)
     print("   First 3 runs ordered by creation date (oldest first):")
     for run in runs:
         print(f"   - {run.name} (created: {run.created_date})")
@@ -206,22 +206,22 @@ async def main():
     start_time = datetime.now(timezone.utc)
     stop_time = start_time + timedelta(minutes=2)
 
-    previously_created_runs = client.runs.list(name_regex="Example Test Run.*")
+    previously_created_runs = client.runs.list_(name_regex="Example Test Run.*")
     if previously_created_runs:
         print(f"   Deleting previously created runs: {previously_created_runs}")
         for run in previously_created_runs:
             print(f"   Deleting run: {run.name}")
             client.runs.archive(run=run)
 
-    new_run = client.runs.create(
+    new_run = client.runs.create(dict(
         name=f"Example Test Run {datetime.now(tz=timezone.utc).strftime('%Y-%m-%d %H:%M:%S')}",
         description="A test run created via the API",
         tags=["api-created", "test"],
         start_time=start_time,
         stop_time=stop_time,
         # Use a unique client key for each run
         client_key=f"example-run-key-{datetime.now(tz=timezone.utc).timestamp()}",
-        metadata=metadata,
+        metadata=metadata,)
     )
     print(f"   Created run: {new_run.name} (ID: {new_run.id_})")
     print(f"   Client key: {new_run.client_key}")
@@ -257,7 +257,7 @@ async def main():
 
     # Example 6: Associate assets with a run
     print("\n6. Associating assets with a run...")
-    ongoing_runs = client.runs.list(
+    ongoing_runs = client.runs.list_(
         name_regex="Example Test Run.*", include_archived=True, is_stopped=False
     )
     if ongoing_runs:
@@ -283,4 +283,5 @@ async def main():
 
 
 if __name__ == "__main__":
+    dotenv.load_dotenv()
     asyncio.run(main())

python/lib/sift_client/examples/generic_workflow_example.py

@@ -48,7 +48,7 @@ async def main():
     else:
         # Create a calculated channel that divides mainmotor.velocity by voltage
         print("\nCreating calculated channel...")
-        calculated_channel = client.calculated_channels.create(
+        calculated_channel = client.calculated_channels.create(dict(
             name="velocity_per_voltage",
             description="Ratio of mainmotor velocity to voltage",
             expression="$1 / $2",  # $1 = mainmotor.velocity, $2 = voltage
@@ -58,7 +58,7 @@ async def main():
             ],
             units="velocity/voltage",
             asset_ids=[asset_id],
-            user_notes="Created to monitor velocity-to-voltage ratio",
+            user_notes="Created to monitor velocity-to-voltage ratio",)
         )
         print(
             f"Created calculated channel: {calculated_channel.name} (ID: {calculated_channel.calculated_channel_id})"

python/lib/sift_client/resources/assets.py

@@ -48,6 +48,7 @@ async def get(
         Returns:
             The Asset.
         """
+        asset: Asset | None
         if asset_id is not None:
             asset = await self._low_level_client.get_asset(asset_id)
         elif name is not None:
@@ -78,6 +79,7 @@ async def list_(
         modified_by: Any | str | None = None,
         # tags
         tags: list[Any] | list[str] | None = None,
+        _tag_ids: list[str] | None = None,
         # metadata
         metadata: list[Any] | None = None,
         # common filters
@@ -101,6 +103,7 @@ async def list_(
             created_by: Filter assets created by this User or user ID.
             modified_by: Filter assets last modified by this User or user ID.
             tags: Filter assets with any of these Tags or tag names.
+            _tag_ids: Filter assets with any of these Tag IDs.
             metadata: Filter assets by metadata criteria.
             description_contains: Partial description of the asset.
             include_archived: If True, include archived assets in results.
@@ -132,6 +135,8 @@ async def list_(
         ]
         if asset_ids:
             filter_parts.append(cel.in_("asset_id", asset_ids))
+        if _tag_ids:
+            filter_parts.append(cel.in_("tag_id", _tag_ids))
         filter_query = cel.and_(*filter_parts)
 
         assets = await self._low_level_client.list_all_assets(
@@ -169,7 +174,7 @@ async def update(self, asset: str | Asset, update: AssetUpdate | dict) -> Asset:
             The updated Asset.
 
         """
-        asset_id = asset.id_ or "" if isinstance(asset, Asset) else asset
+        asset_id = asset._id_or_error if isinstance(asset, Asset) else asset
         if isinstance(update, dict):
             update = AssetUpdate.model_validate(update)
         update.resource_id = asset_id
@@ -186,9 +191,9 @@ async def archive(self, asset: str | Asset, *, archive_runs: bool = False) -> As
         Returns:
              The archived Asset.
         """
-        asset_id = asset.id_ or "" if isinstance(asset, Asset) else asset
+        asset_id = asset._id_or_error if isinstance(asset, Asset) else asset
 
-        await self._low_level_client.delete_asset(asset_id or "", archive_runs=archive_runs)
+        await self._low_level_client.delete_asset(asset_id, archive_runs=archive_runs)
 
         return await self.get(asset_id=asset_id)
 

python/lib/sift_client/resources/calculated_channels.py

@@ -152,10 +152,10 @@ async def list_(
         if client_keys:
             filter_parts.append(cel.in_("client_key", client_keys))
         if asset:
-            asset_id = asset.id_ if isinstance(asset, Asset) else asset
+            asset_id = asset._id_or_error if isinstance(asset, Asset) else asset
             filter_parts.append(cel.equals("asset_id", asset_id))
         if run:
-            run_id = run.id_ if isinstance(run, Run) else run
+            run_id = run._id_or_error if isinstance(run, Run) else run
             filter_parts.append(cel.equals("run_id", run_id))
         if version:
             filter_parts.append(cel.equals("version", version))