Merge branch 'test' into fix/cli-help-bittensor-argparse-hijack

Author: plind-junior

gittensor/classes.py

@@ -305,12 +305,8 @@ def from_graphql_response(cls, pr_data: dict, uid: int, hotkey: str, github_id:
         last_edited_at = parse_github_timestamp_to_cst(raw_edited_at) if isinstance(raw_edited_at, str) else None
         merged_at = parse_github_timestamp_to_cst(pr_data['mergedAt']) if is_merged else None
 
-        changes_requested_count = 0
-        if is_merged:
-            cr_reviews = pr_data.get('changesRequestedReviews', {}).get('nodes', [])
-            changes_requested_count = sum(
-                1 for r in cr_reviews if r.get('authorAssociation') in MAINTAINER_ASSOCIATIONS
-            )
+        cr_reviews = (pr_data.get('changesRequestedReviews') or {}).get('nodes') or []
+        changes_requested_count = sum(1 for r in cr_reviews if r.get('authorAssociation') in MAINTAINER_ASSOCIATIONS)
 
         current = {(n.get('name') or '').lower() for n in (pr_data.get('labels') or {}).get('nodes') or [] if n}
         label: Optional[str] = None
@@ -370,10 +366,15 @@ class MinerEvaluation:
     total_leaf_score: float = 0.0
     failed_reason: Optional[str] = None
     github_pr_fetch_failed: bool = False
+    # Mirror-source-specific fetch flag set by mirror.combine.combine alongside
+    # the OR into github_pr_fetch_failed. Lets the validator tell a complete
+    # mirror outage apart from a legacy partial-pagination failure.
+    mirror_pr_fetch_failed: bool = False
     evaluation_timestamp: Optional[datetime] = None
     merged_pull_requests: List[PullRequest] = field(default_factory=list)
     open_pull_requests: List[PullRequest] = field(default_factory=list)
     closed_pull_requests: List[PullRequest] = field(default_factory=list)
+    stale_closed_pull_requests: List[PullRequest] = field(default_factory=list)
 
     # Populated by gittensor.validator.oss_contributions.mirror.combine.combine
     # when the mirror scoring path runs. Empty for legacy-only evaluations.
@@ -485,6 +486,13 @@ def add_closed_pull_request(self, raw_pr: Dict):
             PullRequest.from_graphql_response(raw_pr, self.uid, self.hotkey, self.github_id)
         )
 
+    def add_stale_closed_pull_request(self, raw_pr: Dict):
+        """Track a stale CLOSED PR so storage can refresh its pull_requests row."""
+        bt.logging.info(f'Stale CLOSED PR #{raw_pr["number"]} in {parse_repo_name(raw_pr["repository"])}')
+        self.stale_closed_pull_requests.append(
+            PullRequest.from_graphql_response(raw_pr, self.uid, self.hotkey, self.github_id)
+        )
+
 
 @dataclass
 class ScoreBreakdown:
@@ -708,6 +716,9 @@ def _build_cache_entry(evaluation: 'MinerEvaluation') -> 'MinerEvaluation':
         cached.merged_pull_requests = [_pr_for_cache(pr) for pr in evaluation.merged_pull_requests]
         cached.open_pull_requests = [_pr_for_cache(pr) for pr in evaluation.open_pull_requests]
         cached.closed_pull_requests = [_pr_for_cache(pr) for pr in evaluation.closed_pull_requests]
+        cached.mirror_merged_prs = [_scored_mirror_pr_for_cache(pr) for pr in evaluation.mirror_merged_prs]
+        cached.mirror_open_prs = [_scored_mirror_pr_for_cache(pr) for pr in evaluation.mirror_open_prs]
+        cached.mirror_closed_prs = [_scored_mirror_pr_for_cache(pr) for pr in evaluation.mirror_closed_prs]
         return cached
 
     @staticmethod
@@ -735,3 +746,9 @@ def _pr_with_fresh_issues(pr: 'PullRequest') -> 'PullRequest':
     if pr.issues is not None:
         pr_copy.issues = [copy.copy(issue) for issue in pr.issues]
     return pr_copy
+
+
+def _scored_mirror_pr_for_cache(scored: 'ScoredMirrorPR') -> 'ScoredMirrorPR':
+    scored_copy = copy.copy(scored)
+    scored_copy.files = None
+    return scored_copy

gittensor/cli/issue_commands/help.py

@@ -16,11 +16,6 @@
 from rich.table import Table
 
 
-def _single_paragraph(text: str) -> str:
-    """Collapse multiline help text into a single paragraph."""
-    return ' '.join(text.split())
-
-
 def _collect_help_rows(params: list[click.Parameter], ctx: click.Context) -> list[tuple[str, str]]:
     """Collect Click help records for parameters."""
     rows: list[tuple[str, str]] = []
@@ -192,7 +187,7 @@ def get_help(self, ctx: click.Context) -> str:
             if help_text:
                 console.print(
                     Padding(
-                        f'[bright_white]{escape(_single_paragraph(help_text))}[/bright_white]',
+                        f'[bright_white]{escape(" ".join(help_text.split()))}[/bright_white]',
                         (0, 0, 0, 1),
                     )
                 )

gittensor/cli/issue_commands/helpers.py

@@ -281,7 +281,7 @@ def fetch_open_issue_pull_requests(
     """Fetch open PR submissions for a GitHub issue."""
     token = get_github_pat() or ''
     if not token and not as_json:
-        print_warning('No GitHub token (GITTENSOR_MINER_PAT) found; using unauthenticated requests (lower rate limits)')
+        print_warning('No GitHub token found; set GITTENSOR_MINER_PAT to fetch GitHub issue submissions')
 
     try:
         from gittensor.utils.github_api_tools import find_prs_for_issue

gittensor/cli/issue_commands/vote.py

@@ -246,7 +246,7 @@ def vote_list_validators(network: str, rpc_url: str, contract: str, as_json: boo
             validators = client.get_validators()
 
         n = len(validators)
-        required = (n // 2) + 1
+        required = (n // 2) + 1 if n > 0 else 0
 
         if as_json:
             emit_json(

gittensor/cli/miner_commands/check.py

@@ -11,13 +11,16 @@
 from rich.table import Table
 
 from .helpers import (
+    DEFAULT_MIN_VALIDATOR_STAKE,
+    DEFAULT_MIN_VALIDATOR_VTRUST,
     NETUID_DEFAULT,
     _connect_bittensor,
     _error,
     _load_config_value,
     _pat_check_aggregate_counts,
     _pat_check_row_category,
     _print,
+    _render_skipped_validators,
     _require_registered,
     _require_validator_axons,
     _resolve_endpoint,
@@ -40,8 +43,22 @@
 @click.option('--netuid', type=int, default=NETUID_DEFAULT, help='Subnet UID.', show_default=True)
 @click.option('--network', default=None, help='Network name (local, test, finney).')
 @click.option('--rpc-url', default=None, help='Subtensor RPC endpoint URL (overrides --network).')
+@click.option(
+    '--min-vtrust',
+    type=float,
+    default=DEFAULT_MIN_VALIDATOR_VTRUST,
+    show_default=True,
+    help='Minimum validator_trust to probe.',
+)
+@click.option(
+    '--min-stake',
+    type=float,
+    default=DEFAULT_MIN_VALIDATOR_STAKE,
+    show_default=True,
+    help='Minimum validator stake (α) to probe.',
+)
 @click.option('--json-output', 'json_mode', is_flag=True, default=False, help='Output results as JSON.')
-def miner_check(wallet_name, wallet_hotkey, netuid, network, rpc_url, json_mode):
+def miner_check(wallet_name, wallet_hotkey, netuid, network, rpc_url, min_vtrust, min_stake, json_mode):
     """Check how many validators have your PAT stored.
 
     Sends a lightweight probe to each validator — no PAT is transmitted.
@@ -71,8 +88,10 @@ def miner_check(wallet_name, wallet_hotkey, netuid, network, rpc_url, json_mode)
     # Verify miner is registered
     _require_registered(wallet, metagraph, netuid, json_mode)
 
-    # 3. Find active validator axons (vtrust > 0.1 = actively participating in consensus)
-    validator_axons, validator_uids = _require_validator_axons(metagraph, json_mode)
+    # 3. Find active validator axons (vtrust + serving + stake threshold)
+    validator_axons, validator_uids, excluded = _require_validator_axons(
+        metagraph, json_mode, min_vtrust=min_vtrust, min_stake=min_stake
+    )
 
     # 4. Send check probes
     synapse = PatCheckSynapse()
@@ -115,6 +134,7 @@ async def _check():
                     'success': valid_count > 0,
                     'total_validators': len(results),
                     **counts,
+                    'skipped': excluded,
                     'results': results,
                 },
                 indent=2,
@@ -134,3 +154,4 @@ async def _check():
 
         console.print(table)
         console.print(f'\n[bold]{valid_count}/{len(results)} validators have a valid PAT stored.[/bold]')
+        _render_skipped_validators(excluded, json_mode)

gittensor/cli/miner_commands/helpers.py

@@ -13,23 +13,51 @@
 
 import click
 from rich.console import Console
+from rich.table import Table
 
 from gittensor.constants import NETWORK_MAP
 
 console = Console()
 
 NETUID_DEFAULT = 74
-
-
-def _get_validator_axons(metagraph) -> tuple[list, list]:
-    """Return (axons, uids) for all active validators (vtrust > 0.1, serving)."""
-    axons = []
-    uids = []
+DEFAULT_MIN_VALIDATOR_VTRUST = 0.25
+DEFAULT_MIN_VALIDATOR_STAKE = 15_000.0
+
+
+def _get_validator_axons(
+    metagraph,
+    *,
+    min_vtrust: float = DEFAULT_MIN_VALIDATOR_VTRUST,
+    min_stake: float = DEFAULT_MIN_VALIDATOR_STAKE,
+) -> tuple[list, list, list[dict]]:
+    """Return (axons, uids, excluded) for active validators.
+
+    A validator is broadcast to when vtrust > min_vtrust AND axon.is_serving
+    AND stake >= min_stake. UIDs failing only the latter two checks are
+    surfaced in `excluded` so miners can see why a high-vtrust validator
+    was skipped. Sub-vtrust UIDs are dropped silently — they are not
+    validators.
+    """
+    axons: list = []
+    uids: list[int] = []
+    excluded: list[dict] = []
     for uid in range(metagraph.n):
-        if metagraph.validator_trust[uid] > 0.1 and metagraph.axons[uid].is_serving:
-            axons.append(metagraph.axons[uid])
-            uids.append(uid)
-    return axons, uids
+        vt = float(metagraph.validator_trust[uid])
+        if vt <= min_vtrust:
+            continue
+        serving = bool(metagraph.axons[uid].is_serving)
+        stake = float(metagraph.S[uid])
+        reasons: list[str] = []
+        if not serving:
+            reasons.append('not serving an axon')
+        if stake < min_stake:
+            reasons.append(f'stake {stake:,.0f} α below {min_stake:,.0f} α threshold')
+        if reasons:
+            excluded.append({'uid': uid, 'vtrust': vt, 'stake': stake, 'reasons': reasons})
+            continue
+        axons.append(metagraph.axons[uid])
+        uids.append(uid)
+    return axons, uids, excluded
 
 
 def _load_config_value(key: str):
@@ -96,13 +124,40 @@ def _require_registered(wallet, metagraph, netuid: int, json_mode: bool) -> None
         sys.exit(1)
 
 
-def _require_validator_axons(metagraph, json_mode: bool) -> tuple[list, list]:
-    """Return validator (axons, uids), or exit with error if none found."""
-    validator_axons, validator_uids = _get_validator_axons(metagraph)
+def _require_validator_axons(
+    metagraph,
+    json_mode: bool,
+    *,
+    min_vtrust: float = DEFAULT_MIN_VALIDATOR_VTRUST,
+    min_stake: float = DEFAULT_MIN_VALIDATOR_STAKE,
+) -> tuple[list, list, list[dict]]:
+    """Return validator (axons, uids, excluded), or exit with error if no axons match."""
+    validator_axons, validator_uids, excluded = _get_validator_axons(
+        metagraph, min_vtrust=min_vtrust, min_stake=min_stake
+    )
     if not validator_axons:
         _error('No reachable validator axons found on the network.', json_mode)
         sys.exit(1)
-    return validator_axons, validator_uids
+    return validator_axons, validator_uids, excluded
+
+
+def _render_skipped_validators(excluded: list[dict], json_mode: bool) -> None:
+    """Print a 'Skipped Validators' table when any high-vtrust UIDs were filtered."""
+    if json_mode or not excluded:
+        return
+    table = Table(title='Skipped Validators')
+    table.add_column('UID', style='cyan', justify='right')
+    table.add_column('vtrust', justify='right')
+    table.add_column('stake (α)', justify='right')
+    table.add_column('Reason', style='dim')
+    for e in excluded:
+        table.add_row(
+            str(e['uid']),
+            f'{e["vtrust"]:.4f}',
+            f'{e["stake"]:,.0f}',
+            '; '.join(e['reasons']),
+        )
+    console.print(table)
 
 
 def _pat_check_row_category(row: dict[str, Any]) -> str:
@@ -125,3 +180,22 @@ def _pat_check_aggregate_counts(results: list[dict[str, Any]]) -> dict[str, int]
         'invalid_pat': counts['invalid_pat'],
         'no_response': counts['no_response'],
     }
+
+
+def _pat_post_row_category(row: dict[str, Any]) -> str:
+    """Classify a PAT broadcast row; must match `miner post` table rendering order."""
+    if row.get('accepted') is True:
+        return 'accepted'
+    if row.get('accepted') is False:
+        return 'rejected'
+    return 'no_response'
+
+
+def _pat_post_aggregate_counts(results: list[dict[str, Any]]) -> dict[str, int]:
+    """Count PAT broadcast rows by status for JSON summaries."""
+    counts = Counter(_pat_post_row_category(r) for r in results)
+    return {
+        'accepted': counts['accepted'],
+        'rejected': counts['rejected'],
+        'no_response': counts['no_response'],
+    }