Merge branch 'main' into codex/fix-authentication-for-ape-foundry

Author: fubuloubu

src/ape/api/providers.py

@@ -21,7 +21,7 @@
 from ethpm_types import MethodABI
 from pydantic import Field, computed_field, field_serializer, model_validator
 
-from ape.api.networks import NetworkAPI
+from ape.api.networks import NetworkAPI, ProviderContextManager
 from ape.api.query import BlockTransactionQuery
 from ape.api.transactions import ReceiptAPI, TransactionAPI
 from ape.exceptions import (
@@ -311,6 +311,38 @@ def disconnect(self):
         Disconnect from a provider, such as tear-down a process or quit an HTTP session.
         """
 
+    def connection(
+        self,
+        disconnect_after: bool = False,
+        disconnect_on_exit: bool = True,
+    ) -> ProviderContextManager:
+        """
+        Use this provider in a temporary context. Connects on enter and disconnects
+        on exit. Equivalent to :meth:`~ape.managers.networks.NetworkManager.parse_network_choice`
+        but for a provider instance that has already been resolved.
+
+        Usage example::
+
+            provider = networks.ethereum.mainnet.get_provider("infura")
+            with provider.connection():
+                ...
+
+        Args:
+            disconnect_after (bool): Set to ``True`` to force a disconnect after ending
+              the context. Defaults to ``False`` so the connection can be reused, such
+              as in a multi-chain scenario.
+            disconnect_on_exit (bool): Whether to disconnect on the exit of the python
+              session. Defaults to ``True``.
+
+        Returns:
+            :class:`~ape.api.networks.ProviderContextManager`
+        """
+        return ProviderContextManager(
+            provider=self,
+            disconnect_after=disconnect_after,
+            disconnect_on_exit=disconnect_on_exit,
+        )
+
     @property
     def ipc_path(self) -> Path | None:
         """

src/ape/cli/commands.py

@@ -28,10 +28,19 @@ def get_param_from_ctx(ctx: "Context", param: str) -> Any | None:
 
 def parse_network(ctx: "Context") -> "ProviderContextManager | None":
     from ape.api.providers import ProviderAPI
+    from ape.cli.options import NETWORK_META_KEY
     from ape.utils.basemodel import ManagerAccessMixin as access
 
     interactive = get_param_from_ctx(ctx, "interactive")
 
+    # Handle if already parsed by the network_option callback. Preferred
+    # location is ``ctx.meta`` so we don't collide with user-owned ``ctx.obj``
+    # (e.g. when a command chains ``click.make_pass_decorator(...)`` that
+    # replaces ``ctx.obj`` with a typed container).
+    network_meta = ctx.meta.get(NETWORK_META_KEY)
+    if network_meta and (provider := network_meta.get("provider")) is not None:
+        return provider.network.use_provider(provider, disconnect_on_exit=not interactive)
+
     # Handle if already parsed (as when using network-option)
     if ctx.obj and "provider" in ctx.obj:
         provider = ctx.obj["provider"]

src/ape/cli/options.py

@@ -322,6 +322,9 @@ def _get_requested_networks(function, network_object_names):
     return [x for x in command_kwargs if x in network_object_names]
 
 
+NETWORK_META_KEY = "__ape_network__"
+
+
 def _update_context_with_network(ctx, provider, requested_network_objects):
     choice_classes = {
         "ecosystem": provider.network.ecosystem,
@@ -336,22 +339,12 @@ def _update_context_with_network(ctx, provider, requested_network_objects):
         ctx.params[item] = instance
 
     if isinstance(ctx.command, ConnectedProviderCommand):
-        # Place all values, regardless of request in
-        # the context. This helps the Ape CLI backend.
-        if ctx.obj is None:
-            # Happens when using commands that don't use the
-            # Ape context or any context.
-            ctx.obj = {}
-
-        for choice, obj in choice_classes.items():
-            try:
-                ctx.obj[choice] = obj
-            except Exception:
-                # This would only happen if using an unusual context object.
-                raise Abort(
-                    "Cannot use connected-provider command type(s) "
-                    "with non key-settable context object."
-                )
+        # Place all values, regardless of request, in ``ctx.meta`` so that
+        # ``parse_network`` (and ``ctx.obj`` consumers that use
+        # :meth:`click.Context.ensure_object`) can all coexist. ``ctx.obj`` is
+        # owned by the caller's code; ``ctx.meta`` is Click's cross-cutting
+        # scratch space and is safe for us to write to.
+        ctx.meta.setdefault(NETWORK_META_KEY, {}).update(choice_classes)
 
 
 def _get_provider(value, default, keep_as_choice_str):

tests/functional/test_accounts.py

@@ -330,9 +330,9 @@ def test_deploy(owner, contract_container, clean_contract_caches):
 
 @explorer_test
 @pytest.mark.timeout(360)
-def test_deploy_and_publish_local_network(owner, contract_container):
+def test_deploy_and_publish_local_network(owner, minimal_proxy_container):
     with pytest.raises(ProjectError, match="Can only publish deployments on a live network"):
-        owner.deploy(contract_container, 0, publish=True)
+        owner.deploy(minimal_proxy_container, publish=True)
 
 
 @explorer_test

tests/functional/test_cli.py

@@ -873,6 +873,7 @@ def test_get_param_from_ctx(mocker):
 
 def test_parse_network_when_interactive_and_no_param(mocker):
     ctx = mocker.MagicMock()
+    ctx.meta = {}
     ctx.params = {"interactive": True}
     ctx.parent = None
     network_ctx = parse_network(ctx)
@@ -883,6 +884,7 @@ def test_parse_network_when_interactive_and_no_param(mocker):
 
 def test_parse_network_when_interactive_and_str_param(mocker):
     ctx = mocker.MagicMock()
+    ctx.meta = {}
     ctx.params = {"interactive": True, "network": "ethereum:local:test"}
     network_ctx = parse_network(ctx)
     assert network_ctx is not None
@@ -892,6 +894,7 @@ def test_parse_network_when_interactive_and_str_param(mocker):
 
 def test_parse_network_when_interactive_and_class_param(mocker, eth_tester_provider):
     ctx = mocker.MagicMock()
+    ctx.meta = {}
     ctx.params = {"interactive": True, "network": eth_tester_provider}
     network_ctx = parse_network(ctx)
     assert network_ctx is not None
@@ -901,6 +904,7 @@ def test_parse_network_when_interactive_and_class_param(mocker, eth_tester_provi
 
 def test_parse_network_when_explicit_none(mocker):
     ctx = mocker.MagicMock()
+    ctx.meta = {}
     ctx.params = {"network": _NONE_NETWORK}
     network_ctx = parse_network(ctx)
     assert network_ctx is None

tests/functional/test_contract_container.py

@@ -45,9 +45,9 @@ def test_deploy_wrong_number_of_arguments(
         contract_container.deploy(sender=not_owner)
 
 
-def test_deploy_and_publish_local_network(owner, contract_container):
+def test_deploy_and_publish_local_network(owner, minimal_proxy_container):
     with pytest.raises(ProjectError, match="Can only publish deployments on a live network"):
-        contract_container.deploy(0, sender=owner, publish=True)
+        minimal_proxy_container.deploy(sender=owner, publish=True)
 
 
 def test_deploy_and_publish_live_network_no_explorer(owner, contract_container, dummy_live_network):

tests/functional/test_provider.py

@@ -146,6 +146,7 @@ def test_chain_id_when_disconnected(eth_tester_provider):
     assert actual == expected
 
 
+@pytest.mark.skip("Use stable rpc")
 def test_chain_id_adhoc_http(networks):
     with networks.parse_network_choice("https://www.shibrpc.com") as bor:
         assert bor.chain_id == 109