madsci.node_module 0.7.1__tar.gz → 0.8.0__tar.gz

madsci_node_module-0.7.1/README.md → madsci_node_module-0.8.0/PKG-INFO

@@ -1,3 +1,16 @@
+Metadata-Version: 2.1
+Name: madsci.node_module
+Version: 0.8.0
+Summary: The Modular Autonomous Discovery for Science (MADSci) Node Module Helper Classes.
+Author-Email: Tobias Ginsburg <tginsburg@anl.gov>, "Ryan D. Lewis" <ryan.lewis@anl.gov>, Casey Stone <cstone@anl.gov>, Doga Ozgulbas <dozgulbas@anl.gov>
+License: MIT
+Project-URL: Homepage, https://github.com/AD-SDL/MADSci
+Requires-Python: >=3.10.0
+Requires-Dist: madsci.common
+Requires-Dist: madsci.client
+Requires-Dist: regex
+Description-Content-Type: text/markdown
+
 # MADSci Node Module
 
 Framework for creating laboratory instrument nodes that integrate with MADSci workcells via REST APIs.
@@ -105,8 +118,8 @@ module_version: 1.0.0
 # Run directly
 python my_instrument_node.py
 
-# Or with a pre-defined node
-python my_instrument_node.py --node_definition my_instrument.node.yaml
+# Configuration is provided via environment variables (NODE_NAME, NODE_URL, etc.)
+# or settings files (settings.yaml, .env)
 
 # Node will be available at http://localhost:2000/docs
 ```
@@ -1266,3 +1279,11 @@ def get_multiple_files(self) -> list[Path]:
 ```
 
 **Working examples**: See [example_lab/](../../examples/example_lab/) for a complete working laboratory with multiple integrated nodes.
+
+
+## Development Steps
+In order to ensure a MADSci module is up to standard and will run reliably, developers should:
+1. Document expected behavior for each action exposed by the Node, and then test it on the device to ensure it behaves as documented
+2. Ensure that the module folder contains no extraneous files unused by the code.
+3. Ensure that the code passes automated linting and code quality checks (we use [pre-commit](https://pre-commit.com/) and [ruff](https://astral.sh/ruff), for instance. See [our pre-commit config](../../.pre-commit-config.yaml) and [ruff config](../../ruff.toml).
+4. Where appropriate, write a Docker image for the module and ensure that it builds and runs.

madsci_node_module-0.7.1/PKG-INFO → madsci_node_module-0.8.0/README.md

@@ -1,16 +1,3 @@
-Metadata-Version: 2.1
-Name: madsci.node_module
-Version: 0.7.1
-Summary: The Modular Autonomous Discovery for Science (MADSci) Node Module Helper Classes.
-Author-Email: Tobias Ginsburg <tginsburg@anl.gov>, "Ryan D. Lewis" <ryan.lewis@anl.gov>, Casey Stone <cstone@anl.gov>, Doga Ozgulbas <dozgulbas@anl.gov>
-License: MIT
-Project-URL: Homepage, https://github.com/AD-SDL/MADSci
-Requires-Python: >=3.10.0
-Requires-Dist: madsci.common
-Requires-Dist: madsci.client
-Requires-Dist: regex
-Description-Content-Type: text/markdown
-
 # MADSci Node Module
 
 Framework for creating laboratory instrument nodes that integrate with MADSci workcells via REST APIs.
@@ -118,8 +105,8 @@ module_version: 1.0.0
 # Run directly
 python my_instrument_node.py
 
-# Or with a pre-defined node
-python my_instrument_node.py --node_definition my_instrument.node.yaml
+# Configuration is provided via environment variables (NODE_NAME, NODE_URL, etc.)
+# or settings files (settings.yaml, .env)
 
 # Node will be available at http://localhost:2000/docs
 ```
@@ -1279,3 +1266,11 @@ def get_multiple_files(self) -> list[Path]:
 ```
 
 **Working examples**: See [example_lab/](../../examples/example_lab/) for a complete working laboratory with multiple integrated nodes.
+
+
+## Development Steps
+In order to ensure a MADSci module is up to standard and will run reliably, developers should:
+1. Document expected behavior for each action exposed by the Node, and then test it on the device to ensure it behaves as documented
+2. Ensure that the module folder contains no extraneous files unused by the code.
+3. Ensure that the code passes automated linting and code quality checks (we use [pre-commit](https://pre-commit.com/) and [ruff](https://astral.sh/ruff), for instance. See [our pre-commit config](../../.pre-commit-config.yaml) and [ruff config](../../ruff.toml).
+4. Where appropriate, write a Docker image for the module and ensure that it builds and runs.

{madsci_node_module-0.7.1 → madsci_node_module-0.8.0}/madsci/node_module/abstract_node_module.py

@@ -42,15 +42,20 @@ from madsci.common.types.action_types import (
     LocationArgumentDefinition,
 )
 from madsci.common.types.admin_command_types import AdminCommandResponse
+from madsci.common.types.auth_types import OwnershipInfo
 from madsci.common.types.base_types import Error
 from madsci.common.types.datapoint_types import DataPoint, FileDataPoint, ValueDataPoint
 from madsci.common.types.event_types import Event, EventType
+from madsci.common.types.location_types import LocationManagement
 from madsci.common.types.node_types import (
     AdminCommands,
     NodeCapabilities,
     NodeClientCapabilities,
     NodeConfig,
     NodeInfo,
+    NodeIntrinsicLocationDefinition,
+    NodeRepresentationTemplateDefinition,
+    NodeResourceTemplateDefinition,
     NodeSetConfigResponse,
     NodeStatus,
 )
@@ -99,6 +104,17 @@ class AbstractNode(MadsciClientMixin):
     _action_lock: ClassVar[threading.Lock] = threading.Lock()
     """Ensures only one blocking action can run at a time."""
 
+    resource_templates: ClassVar[list[NodeResourceTemplateDefinition]] = []
+    """Declarative resource template definitions to register on startup."""
+
+    location_representation_templates: ClassVar[
+        list[NodeRepresentationTemplateDefinition]
+    ] = []
+    """Declarative location representation template definitions to register on startup."""
+
+    intrinsic_locations: ClassVar[list[NodeIntrinsicLocationDefinition]] = []
+    """Intrinsic location definitions to register on startup."""
+
     def __init__(
         self,
         node_config: Optional[NodeConfig] = None,
@@ -118,6 +134,12 @@ class AbstractNode(MadsciClientMixin):
             module_name=module_name,
         )
 
+        # * Populate intrinsic location definitions from class variables
+        self.node_info.intrinsic_locations = list(self.__class__.intrinsic_locations)
+        self.node_info.location_representation_templates = list(
+            self.__class__.location_representation_templates
+        )
+
         # Resolve stable identity from registry if enabled
         self._resolver = None
         self._atexit_registered = False
@@ -190,6 +212,109 @@ class AbstractNode(MadsciClientMixin):
     def state_handler(self) -> None:
         """Called periodically to update the node state. Should set `self.node_state`"""
 
+    def template_handler(self) -> None:
+        """Register declarative templates with the resource and location managers.
+
+        Iterates over ``resource_templates`` and ``location_representation_templates``
+        class members. Each template is registered via the appropriate client API.
+        Errors are caught and logged per-template (with the template name and type
+        clearly identified) so that a single failed registration does not prevent the
+        node from starting.
+        """
+        # 1. Resource templates (via resource_client.init_template)
+        for defn in self.resource_templates:
+            try:
+                self.resource_client.init_template(
+                    resource=defn.resource,
+                    template_name=defn.template_name,
+                    description=defn.description,
+                    required_overrides=defn.required_overrides,
+                    tags=defn.tags,
+                    created_by=self.node_info.node_id,
+                    version=defn.version,
+                )
+                self.logger.info(
+                    "Registered resource template",
+                    event_type=EventType.LOG_INFO,
+                    template_name=defn.template_name,
+                    template_type="resource",
+                )
+            except Exception as e:
+                self.logger.warning(
+                    "Failed to register resource template",
+                    event_type=EventType.LOG_WARNING,
+                    template_name=defn.template_name,
+                    template_type="resource",
+                    error=str(e),
+                )
+
+        # 2. Location representation templates (via location_client.init_representation_template)
+        for defn in self.location_representation_templates:
+            try:
+                self.location_client.init_representation_template(
+                    template_name=defn.template_name,
+                    default_values=defn.default_values,
+                    schema_def=defn.schema_def,
+                    required_overrides=defn.required_overrides,
+                    tags=defn.tags,
+                    created_by=self.node_info.node_id,
+                    version=defn.version,
+                    description=defn.description,
+                )
+                self.logger.info(
+                    "Registered location representation template",
+                    event_type=EventType.LOG_INFO,
+                    template_name=defn.template_name,
+                    template_type="location_representation",
+                )
+            except Exception as e:
+                self.logger.warning(
+                    "Failed to register location representation template",
+                    event_type=EventType.LOG_WARNING,
+                    template_name=defn.template_name,
+                    template_type="location_representation",
+                    error=str(e),
+                )
+
+    def intrinsic_location_handler(self) -> None:
+        """Register intrinsic locations with the Location Manager.
+
+        Iterates over ``intrinsic_locations`` class variable. Each location is
+        registered via location_client.init_location() with automatic
+        '{node_name}.' prefix. Errors are caught per-location so a single
+        failure does not prevent the node from starting.
+        """
+        for defn in self.intrinsic_locations:
+            try:
+                location_name = f"{self.node_info.node_name}.{defn.location_name}"
+                representations = {
+                    self.node_info.node_name: defn.representation_overrides
+                }
+                owner = OwnershipInfo(node_id=self.node_info.node_id)
+
+                self.location_client.init_location(
+                    location_name=location_name,
+                    representations=representations,
+                    resource_template_name=defn.resource_template_name,
+                    resource_template_overrides=defn.resource_template_overrides,
+                    description=defn.description,
+                    allow_transfers=defn.allow_transfers,
+                    managed_by=LocationManagement.NODE,
+                    owner=owner,
+                )
+                self.logger.info(
+                    "Registered intrinsic location",
+                    event_type=EventType.LOG_INFO,
+                    location_name=location_name,
+                )
+            except Exception as e:
+                self.logger.warning(
+                    "Failed to register intrinsic location",
+                    event_type=EventType.LOG_WARNING,
+                    location_name=defn.location_name,
+                    error=str(e),
+                )
+
     def startup_handler(self) -> None:
         """Called to (re)initialize the node. Should be used to open connections to devices or initialize any other resources."""
 
@@ -1348,6 +1473,8 @@ class AbstractNode(MadsciClientMixin):
             self.node_status.locked = False
             self.node_status.paused = False
             self.node_status.stopped = False
+            self.template_handler()
+            self.intrinsic_location_handler()
             self.startup_handler()
             # * Start status and state update loops
             repeat_on_interval(

{madsci_node_module-0.7.1 → madsci_node_module-0.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "madsci.node_module"
-version = "0.7.1"
+version = "0.8.0"
 description = "The Modular Autonomous Discovery for Science (MADSci) Node Module Helper Classes."
 authors = [
     { name = "Tobias Ginsburg", email = "tginsburg@anl.gov" },

madsci_node_module-0.8.0/tests/test_intrinsic_location_handler.py

@@ -0,0 +1,344 @@
+"""Tests for the intrinsic_location_handler lifecycle on AbstractNode."""
+
+from typing import ClassVar
+from unittest.mock import MagicMock, patch
+
+import pytest
+from madsci.common.types.location_types import LocationManagement
+from madsci.common.types.node_types import (
+    NodeInfo,
+    NodeIntrinsicLocationDefinition,
+    RestNodeConfig,
+)
+from madsci.node_module.rest_node_module import RestNode
+
+
+class IntrinsicLocationTestConfig(RestNodeConfig):
+    """Configuration for the intrinsic location test node."""
+
+    __test__ = False
+
+
+class IntrinsicLocationTestNode(RestNode):
+    """A node subclass with intrinsic locations for testing."""
+
+    __test__ = False
+
+    config: IntrinsicLocationTestConfig = IntrinsicLocationTestConfig(
+        node_name="intrinsic_loc_test_node",
+        module_name="intrinsic_loc_test_node",
+        enable_registry_resolution=False,
+    )
+    config_model = IntrinsicLocationTestConfig
+
+    intrinsic_locations: ClassVar[list[NodeIntrinsicLocationDefinition]] = [
+        NodeIntrinsicLocationDefinition(
+            location_name="deck_1",
+            description="First deck slot",
+            representation_template_name="deck_repr",
+            representation_overrides={"rows": 8, "cols": 12},
+            resource_template_name="plate_resource",
+            resource_template_overrides={"capacity": 96},
+            allow_transfers=True,
+        ),
+        NodeIntrinsicLocationDefinition(
+            location_name="deck_2",
+            description="Second deck slot",
+            representation_template_name="deck_repr",
+            representation_overrides={"rows": 4, "cols": 6},
+            allow_transfers=False,
+        ),
+    ]
+
+    def startup_handler(self) -> None:
+        """Minimal startup handler."""
+        self.startup_has_run = True
+
+
+class EmptyIntrinsicLocationTestNode(RestNode):
+    """A node subclass with no intrinsic locations (default behavior)."""
+
+    __test__ = False
+
+    config: IntrinsicLocationTestConfig = IntrinsicLocationTestConfig(
+        node_name="empty_intrinsic_loc_node",
+        module_name="empty_intrinsic_loc_node",
+        enable_registry_resolution=False,
+    )
+    config_model = IntrinsicLocationTestConfig
+
+    def startup_handler(self) -> None:
+        """Minimal startup handler."""
+        self.startup_has_run = True
+
+
+@pytest.fixture
+def mock_location_client():
+    """Create a mock location client."""
+    client = MagicMock()
+    client.init_location.return_value = MagicMock()
+    return client
+
+
+@pytest.fixture
+def intrinsic_node(mock_location_client):
+    """Create an IntrinsicLocationTestNode with mocked clients."""
+    node = IntrinsicLocationTestNode(
+        node_config=IntrinsicLocationTestConfig(
+            node_name="intrinsic_loc_test_node",
+            module_name="intrinsic_loc_test_node",
+            enable_registry_resolution=False,
+        ),
+    )
+    node.location_client = mock_location_client
+    return node
+
+
+@pytest.fixture
+def empty_intrinsic_node(mock_location_client):
+    """Create an EmptyIntrinsicLocationTestNode with mocked clients."""
+    node = EmptyIntrinsicLocationTestNode(
+        node_config=IntrinsicLocationTestConfig(
+            node_name="empty_intrinsic_loc_node",
+            module_name="empty_intrinsic_loc_node",
+            enable_registry_resolution=False,
+        ),
+    )
+    node.location_client = mock_location_client
+    return node
+
+
+def _find_call_by_location(call_args_list, location_name):
+    """Helper: find the call whose location_name kwarg matches."""
+    return next(c for c in call_args_list if c.kwargs["location_name"] == location_name)
+
+
+class TestIntrinsicLocationHandlerRegistration:
+    """Test that intrinsic locations are registered on intrinsic_location_handler() call."""
+
+    def test_init_location_called_for_each_intrinsic_location(
+        self, intrinsic_node, mock_location_client
+    ):
+        """init_location is called once per intrinsic location definition."""
+        intrinsic_node.intrinsic_location_handler()
+
+        assert mock_location_client.init_location.call_count == 2
+
+    def test_location_name_auto_prefixed_with_node_name(
+        self, intrinsic_node, mock_location_client
+    ):
+        """Each location name is prefixed with '{node_name}.'."""
+        intrinsic_node.intrinsic_location_handler()
+
+        call_args_list = mock_location_client.init_location.call_args_list
+        location_names = [call.kwargs["location_name"] for call in call_args_list]
+        assert "intrinsic_loc_test_node.deck_1" in location_names
+        assert "intrinsic_loc_test_node.deck_2" in location_names
+
+    def test_managed_by_set_to_node(self, intrinsic_node, mock_location_client):
+        """managed_by is set to LocationManagement.NODE for each location."""
+        intrinsic_node.intrinsic_location_handler()
+
+        for call in mock_location_client.init_location.call_args_list:
+            assert call.kwargs["managed_by"] == LocationManagement.NODE
+
+    def test_owner_has_node_id(self, intrinsic_node, mock_location_client):
+        """owner.node_id is set to the node's node_id."""
+        intrinsic_node.intrinsic_location_handler()
+
+        for call in mock_location_client.init_location.call_args_list:
+            owner = call.kwargs["owner"]
+            assert owner.node_id == intrinsic_node.node_info.node_id
+
+    def test_representations_include_node_name_key(
+        self, intrinsic_node, mock_location_client
+    ):
+        """representations dict uses node_name as key with overrides as value."""
+        intrinsic_node.intrinsic_location_handler()
+
+        deck_1_call = _find_call_by_location(
+            mock_location_client.init_location.call_args_list,
+            "intrinsic_loc_test_node.deck_1",
+        )
+        assert deck_1_call.kwargs["representations"] == {
+            "intrinsic_loc_test_node": {"rows": 8, "cols": 12}
+        }
+
+    def test_resource_template_fields_passed(
+        self, intrinsic_node, mock_location_client
+    ):
+        """Resource template name and overrides are passed correctly."""
+        intrinsic_node.intrinsic_location_handler()
+
+        deck_1_call = _find_call_by_location(
+            mock_location_client.init_location.call_args_list,
+            "intrinsic_loc_test_node.deck_1",
+        )
+        assert deck_1_call.kwargs["resource_template_name"] == "plate_resource"
+        assert deck_1_call.kwargs["resource_template_overrides"] == {"capacity": 96}
+
+    def test_description_passed(self, intrinsic_node, mock_location_client):
+        """Description is forwarded from the definition."""
+        intrinsic_node.intrinsic_location_handler()
+
+        deck_1_call = _find_call_by_location(
+            mock_location_client.init_location.call_args_list,
+            "intrinsic_loc_test_node.deck_1",
+        )
+        assert deck_1_call.kwargs["description"] == "First deck slot"
+
+    def test_allow_transfers_passed(self, intrinsic_node, mock_location_client):
+        """allow_transfers is forwarded from the definition."""
+        intrinsic_node.intrinsic_location_handler()
+
+        deck_2_call = _find_call_by_location(
+            mock_location_client.init_location.call_args_list,
+            "intrinsic_loc_test_node.deck_2",
+        )
+        assert deck_2_call.kwargs["allow_transfers"] is False
+
+
+class TestIntrinsicLocationHandlerErrorIsolation:
+    """Test that per-location errors do not prevent other locations from registering."""
+
+    def test_first_failure_does_not_prevent_second(
+        self, intrinsic_node, mock_location_client
+    ):
+        """If first location registration fails, second still registers."""
+        call_count = 0
+
+        def side_effect(**_kwargs):
+            nonlocal call_count
+            call_count += 1
+            if call_count == 1:
+                raise ConnectionError("server unavailable")
+            return MagicMock()
+
+        mock_location_client.init_location.side_effect = side_effect
+
+        # Should not raise
+        intrinsic_node.intrinsic_location_handler()
+
+        assert mock_location_client.init_location.call_count == 2
+
+    def test_handler_never_raises_even_if_all_fail(
+        self, intrinsic_node, mock_location_client
+    ):
+        """intrinsic_location_handler() never raises, even if all registrations fail."""
+        mock_location_client.init_location.side_effect = Exception("boom")
+
+        # Should not raise
+        intrinsic_node.intrinsic_location_handler()
+
+    def test_failure_logged_with_location_name(
+        self, intrinsic_node, mock_location_client
+    ):
+        """Failed registration logs a warning with the location name."""
+        mock_location_client.init_location.side_effect = ConnectionError("down")
+
+        with patch.object(intrinsic_node.logger, "warning") as mock_warning:
+            intrinsic_node.intrinsic_location_handler()
+
+            assert mock_warning.call_count == 2
+            for call in mock_warning.call_args_list:
+                assert "location_name" in call.kwargs
+                assert "error" in call.kwargs
+
+
+class TestIntrinsicLocationHandlerEmptyList:
+    """Test backward compatibility when no intrinsic locations are declared."""
+
+    def test_empty_intrinsic_locations_no_calls(
+        self, empty_intrinsic_node, mock_location_client
+    ):
+        """intrinsic_location_handler() runs cleanly when list is empty (default)."""
+        empty_intrinsic_node.intrinsic_location_handler()
+
+        mock_location_client.init_location.assert_not_called()
+
+
+class TestIntrinsicLocationHandlerCallOrder:
+    """Test that intrinsic_location_handler runs between template_handler and startup_handler."""
+
+    def test_intrinsic_location_handler_called_between_template_and_startup(
+        self, intrinsic_node
+    ):
+        """Verify intrinsic_location_handler is called between template_handler and startup_handler."""
+        call_order = []
+
+        original_template_handler = intrinsic_node.template_handler
+        original_intrinsic_location_handler = intrinsic_node.intrinsic_location_handler
+        original_startup_handler = intrinsic_node.startup_handler
+
+        def tracked_template():
+            call_order.append("template_handler")
+            original_template_handler()
+
+        def tracked_intrinsic():
+            call_order.append("intrinsic_location_handler")
+            original_intrinsic_location_handler()
+
+        def tracked_startup():
+            call_order.append("startup_handler")
+            original_startup_handler()
+
+        intrinsic_node.template_handler = tracked_template
+        intrinsic_node.intrinsic_location_handler = tracked_intrinsic
+        intrinsic_node.startup_handler = tracked_startup
+
+        # Simulate _startup sequence
+        intrinsic_node.node_status.initializing = True
+        intrinsic_node.node_status.errored = False
+        intrinsic_node.node_status.locked = False
+        intrinsic_node.node_status.paused = False
+        intrinsic_node.node_status.stopped = False
+        intrinsic_node.template_handler()
+        intrinsic_node.intrinsic_location_handler()
+        intrinsic_node.startup_handler()
+
+        assert call_order == [
+            "template_handler",
+            "intrinsic_location_handler",
+            "startup_handler",
+        ]
+
+
+class TestNodeInfoIntrinsicLocationPopulation:
+    """Test that NodeInfo is populated with intrinsic location definitions."""
+
+    def test_node_info_has_intrinsic_locations(self, intrinsic_node):
+        """NodeInfo.intrinsic_locations is populated from the class variable."""
+        assert len(intrinsic_node.node_info.intrinsic_locations) == 2
+        names = [
+            loc.location_name for loc in intrinsic_node.node_info.intrinsic_locations
+        ]
+        assert "deck_1" in names
+        assert "deck_2" in names
+
+    def test_empty_node_has_empty_intrinsic_locations(self, empty_intrinsic_node):
+        """NodeInfo has empty list when node declares no intrinsic locations."""
+        assert empty_intrinsic_node.node_info.intrinsic_locations == []
+
+    def test_node_info_intrinsic_locations_are_copies(self, intrinsic_node):
+        """NodeInfo intrinsic_locations list is a copy, not a reference to the class variable."""
+        intrinsic_node.node_info.intrinsic_locations.append(
+            NodeIntrinsicLocationDefinition(
+                location_name="extra",
+                representation_template_name="extra_repr",
+            )
+        )
+        # Class variable should not be affected
+        assert len(IntrinsicLocationTestNode.intrinsic_locations) == 2
+
+    def test_node_info_intrinsic_location_serialization_roundtrip(self, intrinsic_node):
+        """NodeInfo with intrinsic_locations can be serialized and deserialized."""
+        dumped = intrinsic_node.node_info.model_dump(mode="json")
+        assert "intrinsic_locations" in dumped
+        assert len(dumped["intrinsic_locations"]) == 2
+
+        # Round-trip
+        restored = NodeInfo.model_validate(dumped)
+        assert len(restored.intrinsic_locations) == 2
+        names = [loc.location_name for loc in restored.intrinsic_locations]
+        assert "deck_1" in names
+        assert "deck_2" in names

{madsci_node_module-0.7.1 → madsci_node_module-0.8.0}/tests/test_location_argument_serialization.py

@@ -91,7 +91,7 @@ class TestLocationArgumentSerialization:
         )
         assert serialized_var_kwargs["regular_kwarg"] == "value"
 
-    @patch("madsci.client.node.rest_node_client.create_http_session")
+    @patch("madsci.client.node.rest_node_client.create_httpx_client")
     def test_rest_client_serializes_location_arguments(self, mock_create_session):
         """Test that RestNodeClient properly serializes LocationArguments."""
         # Mock the response
@@ -101,7 +101,7 @@ class TestLocationArgumentSerialization:
         mock_response.raise_for_status.return_value = None
 
         mock_session = MagicMock()
-        mock_session.post.return_value = mock_response
+        mock_session.request.return_value = mock_response
         mock_create_session.return_value = mock_session
 
         # Create client and LocationArgument
@@ -125,8 +125,8 @@ class TestLocationArgumentSerialization:
         assert result == "test_action_id"
 
         # Verify the call was made correctly
-        assert mock_session.post.called
-        call_args = mock_session.post.call_args
+        assert mock_session.request.called
+        call_args = mock_session.request.call_args
 
         # Check the JSON payload structure
         json_payload = call_args[1]["json"]
@@ -147,7 +147,7 @@ class TestLocationArgumentSerialization:
         # Other args should be preserved
         assert args["speed"] == 75
 
-    @patch("madsci.client.node.rest_node_client.create_http_session")
+    @patch("madsci.client.node.rest_node_client.create_httpx_client")
     def test_rest_client_serializes_location_arguments_in_var_args_kwargs(
         self, mock_create_session
     ):
@@ -159,7 +159,7 @@ class TestLocationArgumentSerialization:
         mock_response.raise_for_status.return_value = None
 
         mock_session = MagicMock()
-        mock_session.post.return_value = mock_response
+        mock_session.request.return_value = mock_response
         mock_create_session.return_value = mock_session
 
         client = RestNodeClient(url="http://localhost:8000")
@@ -179,7 +179,7 @@ class TestLocationArgumentSerialization:
         client._create_action(action_request)
 
         # Verify the call
-        call_args = mock_session.post.call_args
+        call_args = mock_session.request.call_args
         json_payload = call_args[1]["json"]
 
         # Check var_args serialization