chia-blockchain 2.5.0rc1__py3-none-any.whl → 2.5.1__py3-none-any.whl

chia/cmds/gh.py

@@ -0,0 +1,275 @@
+from __future__ import annotations
+
+import json
+import os
+import shlex
+import urllib
+import uuid
+import webbrowser
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Callable, ClassVar, Literal, Optional, Union, overload
+
+import anyio
+import click
+import yaml
+
+from chia.cmds.cmd_classes import chia_command, option
+
+
+class UnexpectedFormError(Exception):
+    pass
+
+
+Oses = Union[Literal["linux"], Literal["macos-arm"], Literal["macos-intel"], Literal["windows"]]
+Method = Union[Literal["GET"], Literal["POST"]]
+Per = Union[Literal["directory"], Literal["file"]]
+
+all_oses: Sequence[Oses] = ("linux", "macos-arm", "macos-intel", "windows")
+
+
+def report(*args: str) -> None:
+    print("    ====", *args)
+
+
+async def get_gh_token() -> str:
+    command = ["gh", "auth", "token"]
+    report(f"running command: {shlex.join(command)}")
+    process = await anyio.run_process(command=command, check=False, stderr=None)
+
+    if process.returncode != 0:
+        raise click.ClickException("failed to get gh cli personal access token")
+
+    return process.stdout.decode("utf-8").strip()
+
+
+@overload
+async def run_gh_api(method: Method, args: list[str], error: str) -> None: ...
+@overload
+async def run_gh_api(method: Method, args: list[str], error: str, capture_stdout: Literal[False]) -> None: ...
+@overload
+async def run_gh_api(method: Method, args: list[str], error: str, capture_stdout: Literal[True]) -> str: ...
+
+
+async def run_gh_api(method: Method, args: list[str], error: str, capture_stdout: bool = False) -> Optional[str]:
+    command = [
+        "gh",
+        "api",
+        f"--method={method}",
+        "-H=Accept: application/vnd.github+json",
+        "-H=X-GitHub-Api-Version: 2022-11-28",
+        *args,
+    ]
+    report(f"running command: {shlex.join(command)}")
+
+    if capture_stdout:
+        process = await anyio.run_process(command=command, check=False, stderr=None)
+    else:
+        process = await anyio.run_process(command=command, check=False, stderr=None, stdout=None)
+
+    if process.returncode != 0:
+        raise click.ClickException(error)
+
+    if capture_stdout:
+        return process.stdout.decode("utf-8")
+
+    return None
+
+
+def input_arg(name: str, value: object, cond: bool = True) -> list[str]:
+    if not cond:
+        return []
+
+    assert value is not None
+
+    if isinstance(value, os.PathLike):
+        value = os.fspath(value)
+    dumped = yaml.safe_dump(value).partition("\n")[0]
+    return [f"-f=inputs[{name}]={dumped}"]
+
+
+@click.group("gh", help="For working with GitHub")
+def gh_group() -> None:
+    pass
+
+
+@chia_command(
+    group=gh_group,
+    name="test",
+    short_help="launch a test run in CI from HEAD or existing remote ref",
+    help="""Allows easy triggering and viewing of test workflow runs in CI including
+    configuration of parameters.  If a ref is specified then it must exist on the
+    remote and a run will be launched for it.  If ref is not specified then the local
+    HEAD will be pushed to a temporary remote branch and a run will be launched for
+    that.  There is no need to push the local commit first.  The temporary remote
+    branch will automatically be deleted in most cases.
+
+    After launching the workflow run GitHub will be queried for the run and the URL
+    will be opened in the default browser.
+    """,
+)
+class TestCMD:
+    workflow_id: ClassVar[str] = "test.yml"
+    owner: str = option("-o", "--owner", help="Owner of the repo", type=str, default="Chia-Network")
+    repository: str = option("-r", "--repository", help="Repository name", type=str, default="chia-blockchain")
+    ref: Optional[str] = option(
+        "-f",
+        "--ref",
+        help="Branch or tag name (commit SHA not supported), if not specified will push HEAD to a temporary branch",
+        type=str,
+        default=None,
+    )
+    per: Per = option("-p", "--per", help="Per", type=click.Choice(["directory", "file"]), default="directory")
+    only: Optional[Path] = option(
+        "-o", "--only", help="Only run this item, a file or directory depending on --per", type=Path
+    )
+    duplicates: int = option("-d", "--duplicates", help="Number of duplicates", type=int, default=1)
+    oses: Sequence[Oses] = option(
+        "--os",
+        help="Operating systems to run on",
+        type=click.Choice(all_oses),
+        multiple=True,
+        default=all_oses,
+    )
+    full_python_matrix: bool = option(
+        "--full-python-matrix/--default-python-matrix", help="Run on all Python versions", default=False
+    )
+    remote: str = option("-r", "--remote", help="Name of git remote", type=str, default="origin")
+    open_browser: bool = option("--open-browser/--no-open-browser", help="Open browser", default=True)
+
+    async def run(self) -> None:
+        await self.check_only()
+
+        username = await self.get_username()
+
+        if self.ref is not None:
+            await self.trigger_workflow(self.ref)
+            query = "+".join(
+                [
+                    "event=workflow_dispatch",
+                    f"branch={self.ref}",
+                    f"actor={username}",
+                ]
+            )
+            run_url = f"https://github.com/Chia-Network/chia-blockchain/actions/workflows/test.yml?query={urllib.parse.quote(query)}"
+            report(f"waiting a few seconds to load: {run_url}")
+            await anyio.sleep(10)
+        else:
+            process = await anyio.run_process(command=["git", "rev-parse", "HEAD"], check=True, stderr=None)
+            if process.returncode != 0:
+                raise click.ClickException("Failed to get current commit SHA")
+
+            commit_sha = process.stdout.decode("utf-8").strip()
+
+            temp_branch_name = f"tmp/{username}/{commit_sha}/{uuid.uuid4()}"
+
+            process = await anyio.run_process(
+                command=["git", "push", self.remote, f"HEAD:{temp_branch_name}"], check=False, stdout=None, stderr=None
+            )
+            if process.returncode != 0:
+                raise click.ClickException("Failed to push temporary branch")
+
+            try:
+                await self.trigger_workflow(temp_branch_name)
+                for _ in range(10):
+                    await anyio.sleep(1)
+
+                    try:
+                        report("looking for run")
+                        html_url, api_url = await self.find_run(temp_branch_name)
+                        report(f"run found at: {html_url}")
+                        report(f"run found at: {api_url}")
+                    except UnexpectedFormError:
+                        report("run not found")
+                        continue
+
+                    break
+                else:
+                    raise click.ClickException("Failed to find run url")
+            finally:
+                report(f"deleting temporary branch: {temp_branch_name}")
+                process = await anyio.run_process(
+                    command=["git", "push", self.remote, "-d", temp_branch_name], check=False, stdout=None, stderr=None
+                )
+                if process.returncode != 0:
+                    raise click.ClickException("Failed to dispatch workflow")
+                report(f"temporary branch deleted: {temp_branch_name}")
+
+        report(f"run html url: {html_url}")
+        report(f"run api url: {api_url}")
+        if self.open_browser:
+            webbrowser.open(html_url)
+
+    async def check_only(self) -> None:
+        if self.only is not None:
+            import chia._tests
+
+            test_path = Path(chia._tests.__file__).parent
+            effective_path = test_path.joinpath(self.only)
+            checks: dict[Per, Callable[[], bool]] = {"directory": effective_path.is_dir, "file": effective_path.is_file}
+            check = checks[self.per]
+            if not check():
+                if effective_path.exists():
+                    explanation = "wrong type"
+                else:
+                    explanation = "does not exist"
+                message = f"expected requested --only to be a {self.per}, {explanation} at: {effective_path.as_posix()}"
+                raise click.ClickException(message)
+
+    async def trigger_workflow(self, ref: str) -> None:
+        # https://docs.github.com/en/rest/actions/workflows?apiVersion=2022-11-28#create-a-workflow-dispatch-event
+        await run_gh_api(
+            method="POST",
+            args=[
+                f"/repos/{self.owner}/{self.repository}/actions/workflows/{self.workflow_id}/dispatches",
+                f"-f=ref={ref}",
+                *input_arg("per", self.per),
+                *input_arg("only", self.only, self.only is not None),
+                *input_arg("duplicates", self.duplicates),
+                *(arg for os_name in all_oses for arg in input_arg(f"run-{os_name}", os_name in self.oses)),
+                *input_arg("full-python-matrix", self.full_python_matrix),
+            ],
+            error="Failed to dispatch workflow",
+        )
+        report(f"workflow triggered on branch: {ref}")
+
+    async def find_run(self, ref: str) -> tuple[str, str]:
+        # https://docs.github.com/en/rest/actions/workflow-runs?apiVersion=2022-11-28#list-workflow-runs-for-a-workflow
+        stdout = await run_gh_api(
+            method="GET",
+            args=[
+                f"-f=branch={ref}",
+                f"/repos/{self.owner}/{self.repository}/actions/workflows/{self.workflow_id}/runs",
+            ],
+            error="Failed to query workflow runs",
+            capture_stdout=True,
+        )
+
+        response = json.loads(stdout)
+        runs = response["workflow_runs"]
+        try:
+            [run] = runs
+        except ValueError:
+            raise UnexpectedFormError(f"expected 1 run, got: {len(runs)}")
+
+        html_url = run["html_url"]
+        assert isinstance(html_url, str), f"expected html url to be a string, got: {html_url!r}"
+
+        api_url = run["url"]
+        assert isinstance(api_url, str), f"expected url to be a string, got: {api_url!r}"
+
+        return html_url, api_url
+
+    async def get_username(self) -> str:
+        # https://docs.github.com/en/rest/users/users?apiVersion=2022-11-28#get-the-authenticated-user
+        stdout = await run_gh_api(
+            method="GET",
+            args=["/user"],
+            error="Failed to get username",
+            capture_stdout=True,
+        )
+
+        response = json.loads(stdout)
+        username = response["login"]
+        assert isinstance(username, str), f"expected username to be a string, got: {username!r}"
+        return username

chia/cmds/init.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 import click
 
+from chia.cmds.cmd_classes import ChiaCliContext
+
 
 @click.command("init", help="Create or migrate the configuration")
 @click.option(
@@ -46,25 +48,16 @@ def init_cmd(
     """
     from pathlib import Path
 
+    from chia.cmds.init_funcs import init
     from chia.cmds.passphrase_funcs import initialize_passphrase
 
-    from .init_funcs import init
-
     if set_passphrase:
         initialize_passphrase()
 
     init(
         Path(create_certs) if create_certs is not None else None,
-        ctx.obj["root_path"],
+        ChiaCliContext.set_default(ctx).root_path,
         fix_ssl_permissions,
         testnet,
         v1_db,
     )
-
-
-if __name__ == "__main__":
-    from chia.util.default_root import DEFAULT_ROOT_PATH
-
-    from .init_funcs import chia_init
-
-    chia_init(DEFAULT_ROOT_PATH)

chia/cmds/init_funcs.py

@@ -4,7 +4,7 @@ import os
 import shutil
 import sqlite3
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
 import yaml
 
@@ -40,9 +40,9 @@ from chia.wallet.derive_keys import (
 )
 
 
-def dict_add_new_default(updated: Dict[str, Any], default: Dict[str, Any], do_not_migrate_keys: Dict[str, Any]) -> None:
-    for k in do_not_migrate_keys:
-        if k in updated and do_not_migrate_keys[k] == "":
+def dict_add_new_default(updated: dict[str, Any], default: dict[str, Any], do_not_migrate_keys: dict[str, Any]) -> None:
+    for k, v in do_not_migrate_keys.items():
+        if k in updated and v == "":
             updated.pop(k)
     for k, v in default.items():
         ignore = False
@@ -56,7 +56,7 @@ def dict_add_new_default(updated: Dict[str, Any], default: Dict[str, Any], do_no
             # If there is an intermediate key with empty string value, do not migrate all descendants
             if do_not_migrate_keys.get(k, None) == "":
                 do_not_migrate_keys[k] = v
-            dict_add_new_default(updated[k], default[k], do_not_migrate_keys.get(k, {}))
+            dict_add_new_default(updated[k], v, do_not_migrate_keys.get(k, {}))
         elif k not in updated or ignore is True:
             updated[k] = v
 
@@ -168,8 +168,8 @@ def copy_files_rec(old_path: Path, new_path: Path) -> None:
 def migrate_from(
     old_root: Path,
     new_root: Path,
-    manifest: List[str],
-    do_not_migrate_settings: List[str],
+    manifest: list[str],
+    do_not_migrate_settings: list[str],
 ) -> int:
     """
     Copy all the files in "manifest" to the new config directory.
@@ -192,7 +192,7 @@ def migrate_from(
 
     with lock_and_load_config(new_root, "config.yaml") as config:
         config_str: str = initial_config_file("config.yaml")
-        default_config: Dict[str, Any] = yaml.safe_load(config_str)
+        default_config: dict[str, Any] = yaml.safe_load(config_str)
         flattened_keys = unflatten_properties({k: "" for k in do_not_migrate_settings})
         dict_add_new_default(config, default_config, flattened_keys)
 
@@ -331,7 +331,7 @@ def chia_init(
     if should_check_keys:
         check_keys(root_path)
 
-    config: Dict[str, Any]
+    config: dict[str, Any]
 
     db_path_replaced: str
     if v1_db:

chia/cmds/installers.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import json
 import subprocess
 import tempfile
-from typing import Dict, List, Optional
+from typing import Optional
 
 import click
 import packaging.version
@@ -12,7 +12,7 @@ from chia.daemon.server import executable_for_service
 from chia.util.timing import adjusted_timeout
 
 
-def check_plotter(plotter: List[str], expected_output: bytes, specify_tmp: bool = True) -> None:
+def check_plotter(plotter: list[str], expected_output: bytes, specify_tmp: bool = True) -> None:
     with tempfile.TemporaryDirectory() as path:
         tmp_dir = []
         if specify_tmp:
@@ -61,6 +61,7 @@ def test_command(expected_chia_version_str: str, require_madmax: bool) -> None:
         capture_output=True,
         encoding="utf-8",
         timeout=adjusted_timeout(30),
+        check=False,
     )
     assert chia_version_process.returncode == 0
     assert chia_version_process.stderr == ""
@@ -76,6 +77,7 @@ def test_command(expected_chia_version_str: str, require_madmax: bool) -> None:
         capture_output=True,
         encoding="utf-8",
         timeout=adjusted_timeout(30),
+        check=False,
     )
 
     print()
@@ -88,7 +90,7 @@ def test_command(expected_chia_version_str: str, require_madmax: bool) -> None:
     assert plotter_version_process.stderr == ""
 
     found_start = False
-    plotter_versions: Dict[str, packaging.version.Version] = {}
+    plotter_versions: dict[str, packaging.version.Version] = {}
     for line in plotter_version_process.stdout.splitlines():
         if line.startswith("chiapos:"):
             found_start = True

chia/cmds/keys.py

@@ -1,20 +1,19 @@
 from __future__ import annotations
 
-from typing import Optional, Tuple
+from typing import Optional
 
 import click
 from chia_rs import PrivateKey
 
 from chia.cmds import options
+from chia.cmds.cmd_classes import ChiaCliContext
 
 
 @click.group("keys", help="Manage your keys")
 @click.pass_context
 def keys_cmd(ctx: click.Context) -> None:
     """Create, delete, view and use your key pairs"""
-    from pathlib import Path
-
-    root_path: Path = ctx.obj["root_path"]
+    root_path = ChiaCliContext.set_default(ctx).root_path
     if not root_path.is_dir():
         raise RuntimeError("Please initialize (or migrate) your config directory with chia init")
 
@@ -30,11 +29,11 @@ def keys_cmd(ctx: click.Context) -> None:
 )
 @click.pass_context
 def generate_cmd(ctx: click.Context, label: Optional[str]) -> None:
-    from .init_funcs import check_keys
-    from .keys_funcs import generate_and_add
+    from chia.cmds.init_funcs import check_keys
+    from chia.cmds.keys_funcs import generate_and_add
 
     generate_and_add(label)
-    check_keys(ctx.obj["root_path"])
+    check_keys(ChiaCliContext.set_default(ctx).root_path)
 
 
 @keys_cmd.command("show", help="Displays all the keys in keychain or the key with the given fingerprint")
@@ -75,9 +74,16 @@ def show_cmd(
     fingerprint: Optional[int],
     bech32m_prefix: Optional[str],
 ) -> None:
-    from .keys_funcs import show_keys
+    from chia.cmds.keys_funcs import show_keys
 
-    show_keys(ctx.obj["root_path"], show_mnemonic_seed, non_observer_derivation, json, fingerprint, bech32m_prefix)
+    show_keys(
+        ChiaCliContext.set_default(ctx).root_path,
+        show_mnemonic_seed,
+        non_observer_derivation,
+        json,
+        fingerprint,
+        bech32m_prefix,
+    )
 
 
 @keys_cmd.command("add", help="Add a private key by mnemonic or public key as hex")
@@ -99,8 +105,8 @@ def show_cmd(
 )
 @click.pass_context
 def add_cmd(ctx: click.Context, filename: str, label: Optional[str]) -> None:
-    from .init_funcs import check_keys
-    from .keys_funcs import query_and_add_key_info
+    from chia.cmds.init_funcs import check_keys
+    from chia.cmds.keys_funcs import query_and_add_key_info
 
     mnemonic_or_pk = None
     if filename:
@@ -109,7 +115,7 @@ def add_cmd(ctx: click.Context, filename: str, label: Optional[str]) -> None:
         mnemonic_or_pk = Path(filename).read_text().rstrip()
 
     query_and_add_key_info(mnemonic_or_pk, label)
-    check_keys(ctx.obj["root_path"])
+    check_keys(ChiaCliContext.set_default(ctx).root_path)
 
 
 @keys_cmd.group("label", help="Manage your key labels")
@@ -119,7 +125,7 @@ def label_cmd() -> None:
 
 @label_cmd.command("show", help="Show the labels of all available keys")
 def show_label_cmd() -> None:
-    from .keys_funcs import show_all_key_labels
+    from chia.cmds.keys_funcs import show_all_key_labels
 
     show_all_key_labels()
 
@@ -134,7 +140,7 @@ def show_label_cmd() -> None:
     required=True,
 )
 def set_label_cmd(fingerprint: int, label: str) -> None:
-    from .keys_funcs import set_key_label
+    from chia.cmds.keys_funcs import set_key_label
 
     set_key_label(fingerprint, label)
 
@@ -142,7 +148,7 @@ def set_label_cmd(fingerprint: int, label: str) -> None:
 @label_cmd.command("delete", help="Delete the label of a key")
 @options.create_fingerprint(required=True)
 def delete_label_cmd(fingerprint: int) -> None:
-    from .keys_funcs import delete_key_label
+    from chia.cmds.keys_funcs import delete_key_label
 
     delete_key_label(fingerprint)
 
@@ -151,11 +157,11 @@ def delete_label_cmd(fingerprint: int) -> None:
 @options.create_fingerprint(required=True)
 @click.pass_context
 def delete_cmd(ctx: click.Context, fingerprint: int) -> None:
-    from .init_funcs import check_keys
-    from .keys_funcs import delete
+    from chia.cmds.init_funcs import check_keys
+    from chia.cmds.keys_funcs import delete
 
     delete(fingerprint)
-    check_keys(ctx.obj["root_path"])
+    check_keys(ChiaCliContext.set_default(ctx).root_path)
 
 
 @keys_cmd.command("delete_all", help="Delete all private keys in keychain")
@@ -167,7 +173,7 @@ def delete_all_cmd() -> None:
 
 @keys_cmd.command("generate_and_print", help="Generates but does NOT add to keychain")
 def generate_and_print_cmd() -> None:
-    from .keys_funcs import generate_and_print
+    from chia.cmds.keys_funcs import generate_and_print
 
     generate_and_print()
 
@@ -203,7 +209,7 @@ def generate_and_print_cmd() -> None:
 def sign_cmd(
     message: str, fingerprint: Optional[int], filename: Optional[str], hd_path: str, as_bytes: bool, json: bool
 ) -> None:
-    from .keys_funcs import resolve_derivation_master_key, sign
+    from chia.cmds.keys_funcs import resolve_derivation_master_key, sign
 
     _, resolved_sk = resolve_derivation_master_key(filename if filename is not None else fingerprint)
 
@@ -214,7 +220,7 @@ def sign_cmd(
     sign(message, resolved_sk, hd_path, as_bytes, json)
 
 
-def parse_signature_json(json_str: str) -> Tuple[str, str, str, str]:
+def parse_signature_json(json_str: str) -> tuple[str, str, str, str]:
     import json
 
     try:
@@ -253,7 +259,7 @@ def parse_signature_json(json_str: str) -> Tuple[str, str, str, str]:
     type=str,
 )
 def verify_cmd(message: str, public_key: str, signature: str, as_bytes: bool, json: str) -> None:
-    from .keys_funcs import as_bytes_from_signing_mode, verify
+    from chia.cmds.keys_funcs import as_bytes_from_signing_mode, verify
 
     if json is not None:
         parsed_message, parsed_pubkey, parsed_sig, parsed_signing_mode_str = parse_signature_json(json)
@@ -275,8 +281,9 @@ def verify_cmd(message: str, public_key: str, signature: str, as_bytes: bool, js
 )
 @click.pass_context
 def derive_cmd(ctx: click.Context, fingerprint: Optional[int], filename: Optional[str]) -> None:
-    ctx.obj["fingerprint"] = fingerprint
-    ctx.obj["filename"] = filename
+    context = ChiaCliContext.set_default(ctx)
+    context.keys_fingerprint = fingerprint
+    context.keys_filename = filename
 
 
 @derive_cmd.command("search", help="Search the keyring for one or more matching derived keys or wallet addresses")
@@ -320,20 +327,21 @@ def derive_cmd(ctx: click.Context, fingerprint: Optional[int], filename: Optiona
 @click.pass_context
 def search_cmd(
     ctx: click.Context,
-    search_terms: Tuple[str, ...],
+    search_terms: tuple[str, ...],
     limit: int,
     non_observer_derivation: bool,
     show_progress: bool,
-    search_type: Tuple[str, ...],
+    search_type: tuple[str, ...],
     derive_from_hd_path: Optional[str],
     prefix: Optional[str],
 ) -> None:
     import sys
 
-    from .keys_funcs import resolve_derivation_master_key, search_derive
+    from chia.cmds.keys_funcs import resolve_derivation_master_key, search_derive
 
-    fingerprint: Optional[int] = ctx.obj.get("fingerprint", None)
-    filename: Optional[str] = ctx.obj.get("filename", None)
+    context = ChiaCliContext.set_default(ctx)
+    fingerprint: Optional[int] = context.keys_fingerprint
+    filename: Optional[str] = context.keys_filename
 
     # Specifying the master key is optional for the search command. If not specified, we'll search all keys.
     resolved_sk = None
@@ -343,7 +351,7 @@ def search_cmd(
             print("Could not resolve private key from fingerprint/mnemonic file")
 
     found: bool = search_derive(
-        ctx.obj["root_path"],
+        context.root_path,
         fingerprint,
         search_terms,
         limit,
@@ -364,8 +372,8 @@ class ResolutionError(Exception):
 
 def _resolve_fingerprint_and_sk(
     filename: Optional[str], fingerprint: Optional[int], non_observer_derivation: bool
-) -> Tuple[Optional[int], Optional[PrivateKey]]:
-    from .keys_funcs import resolve_derivation_master_key
+) -> tuple[Optional[int], Optional[PrivateKey]]:
+    from chia.cmds.keys_funcs import resolve_derivation_master_key
 
     reolved_fp, resolved_sk = resolve_derivation_master_key(filename if filename is not None else fingerprint)
 
@@ -408,10 +416,11 @@ def _resolve_fingerprint_and_sk(
 def wallet_address_cmd(
     ctx: click.Context, index: int, count: int, prefix: Optional[str], non_observer_derivation: bool, show_hd_path: bool
 ) -> None:
-    from .keys_funcs import derive_wallet_address
+    from chia.cmds.keys_funcs import derive_wallet_address
 
-    fingerprint: Optional[int] = ctx.obj.get("fingerprint", None)
-    filename: Optional[str] = ctx.obj.get("filename", None)
+    context = ChiaCliContext.set_default(ctx)
+    fingerprint = context.keys_fingerprint
+    filename = context.keys_filename
 
     try:
         fingerprint, sk = _resolve_fingerprint_and_sk(filename, fingerprint, non_observer_derivation)
@@ -419,7 +428,14 @@ def wallet_address_cmd(
         return
 
     derive_wallet_address(
-        ctx.obj["root_path"], fingerprint, index, count, prefix, non_observer_derivation, show_hd_path, sk
+        context.root_path,
+        fingerprint,
+        index,
+        count,
+        prefix,
+        non_observer_derivation,
+        show_hd_path,
+        sk,
     )
 
 
@@ -483,13 +499,14 @@ def child_key_cmd(
     show_hd_path: bool,
     bech32m_prefix: Optional[str],
 ) -> None:
-    from .keys_funcs import derive_child_key
+    from chia.cmds.keys_funcs import derive_child_key
 
     if key_type is None and derive_from_hd_path is None:
         ctx.fail("--type or --derive-from-hd-path is required")
 
-    fingerprint: Optional[int] = ctx.obj.get("fingerprint", None)
-    filename: Optional[str] = ctx.obj.get("filename", None)
+    context = ChiaCliContext.set_default(ctx)
+    fingerprint = context.keys_fingerprint
+    filename = context.keys_filename
 
     try:
         fingerprint, sk = _resolve_fingerprint_and_sk(filename, fingerprint, non_observer_derivation)