Merge remote-tracking branch 'upstream/test' into fix/mirror-outage-cache-fallback-mixed-source

# Conflicts:
#	tests/validator/test_validator_cache_fallback.py

Author: MKDev11

gittensor/classes.py

@@ -1,5 +1,5 @@
+import copy
 import re
-from copy import deepcopy
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from enum import Enum
@@ -80,6 +80,9 @@ def is_test_file(self) -> bool:
         test_dir_patterns = [
             r'(^|/)tests?/',
             r'(^|/)__tests?__/',
+            r'(^|/)androidtest[a-z]*/',
+            r'(^|/)integrationtest/',
+            r'(^|/)spec/',
         ]
         if any(re.search(pattern, filename_lower) for pattern in test_dir_patterns):
             return True
@@ -89,6 +92,7 @@ def is_test_file(self) -> bool:
             r'^spec_',
             r'_test\.[^.]+$',
             r'_tests\.[^.]+$',
+            r'_spec\.[^.]+$',
             r'\.test\.[^.]+$',
             r'\.tests\.[^.]+$',
             r'\.spec\.[^.]+$',
@@ -659,7 +663,7 @@ def store(self, evaluation: 'MinerEvaluation') -> None:
         if not evaluation.hotkey or not evaluation.github_id or evaluation.github_id == '0':
             return
 
-        cached_eval = self.create_lightweight_copy(evaluation)
+        cached_eval = self._build_cache_entry(evaluation)
 
         self._cache[evaluation.uid] = CachedEvaluation(
             hotkey=evaluation.hotkey,
@@ -694,17 +698,44 @@ def get(self, uid: int, hotkey: str, github_id: str) -> Optional['MinerEvaluatio
 
         bt.logging.debug(f'Cache hit for UID {uid} (cached at {cached.cached_at.isoformat()})')
 
-        return deepcopy(cached.evaluation)
-
-    def create_lightweight_copy(self, evaluation: 'MinerEvaluation') -> 'MinerEvaluation':
-        """Create a memory-efficient copy, stripping file patches."""
-        light_eval = deepcopy(evaluation)
-
-        for pr in light_eval.merged_pull_requests + light_eval.open_pull_requests + light_eval.closed_pull_requests:
-            if pr.file_changes:
-                for fc in pr.file_changes:
-                    fc.patch = None
-
-        light_eval.github_pat = None
-
-        return light_eval
+        return self._isolate_for_downstream(cached.evaluation)
+
+    @staticmethod
+    def _build_cache_entry(evaluation: 'MinerEvaluation') -> 'MinerEvaluation':
+        # Cached evaluations feed only the GitHub-fetch-failure fallback path
+        # (issue_competitions + issue discovery scoring), which never reads
+        # file_changes. Drop them at store time to save memory and avoid
+        # copying thousands of FileChange objects per miner.
+        cached = copy.copy(evaluation)
+        cached.github_pat = None
+        cached.unique_repos_contributed_to = set(evaluation.unique_repos_contributed_to)
+        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]
+        return cached
+
+    @staticmethod
+    def _isolate_for_downstream(cached_eval: 'MinerEvaluation') -> 'MinerEvaluation':
+        # Downstream scoring mutates top-level scalar fields on MinerEvaluation
+        # and discovery_* fields on Issue. Everything else (PR metadata) is
+        # read-only on the cache-fallback path, so we can share it.
+        copy_eval = copy.copy(cached_eval)
+        copy_eval.unique_repos_contributed_to = set(cached_eval.unique_repos_contributed_to)
+        copy_eval.merged_pull_requests = [_pr_with_fresh_issues(pr) for pr in cached_eval.merged_pull_requests]
+        copy_eval.open_pull_requests = [_pr_with_fresh_issues(pr) for pr in cached_eval.open_pull_requests]
+        copy_eval.closed_pull_requests = [_pr_with_fresh_issues(pr) for pr in cached_eval.closed_pull_requests]
+        return copy_eval
+
+
+def _pr_for_cache(pr: 'PullRequest') -> 'PullRequest':
+    pr_copy = copy.copy(pr)
+    pr_copy.file_changes = None
+    pr_copy.issues = [copy.copy(issue) for issue in pr.issues] if pr.issues else None
+    return pr_copy
+
+
+def _pr_with_fresh_issues(pr: 'PullRequest') -> 'PullRequest':
+    pr_copy = copy.copy(pr)
+    if pr.issues is not None:
+        pr_copy.issues = [copy.copy(issue) for issue in pr.issues]
+    return pr_copy

gittensor/cli/issue_commands/helpers.py

@@ -696,31 +696,6 @@ def _resolve_contract_and_network(
 # ============================================================================
 
 
-def _get_contract_child_storage_key(substrate, contract_addr: str, verbose: bool = False) -> Optional[str]:
-    """
-    Get the child storage key for a contract's trie.
-
-    Args:
-        substrate: SubstrateInterface instance
-        contract_addr: Contract address
-        verbose: If True, print debug output
-
-    Returns:
-        Hex-encoded child storage key or None if contract doesn't exist
-    """
-    try:
-        child_key = get_contract_child_storage_key(substrate, contract_addr)
-        if not child_key:
-            if verbose:
-                console.print(f'[dim]Debug: Contract not found at {contract_addr}[/dim]')
-            return None
-        return child_key
-    except Exception as e:
-        if verbose:
-            console.print(f'[dim]Debug: Contract info query failed: {e}[/dim]')
-        return None
-
-
 def _read_contract_packed_storage(substrate, contract_addr: str, verbose: bool = False) -> Optional[Dict[str, Any]]:
     """
     Read the packed root storage from a contract using childstate RPC
@@ -785,10 +760,16 @@ def _read_issues_from_child_storage(substrate, contract_addr: str, verbose: bool
     Returns:
         List of issue dictionaries
     """
-    child_key = _get_contract_child_storage_key(substrate, contract_addr, verbose)
+    try:
+        child_key = get_contract_child_storage_key(substrate, contract_addr)
+    except Exception as e:
+        if verbose:
+            console.print(f'[dim]Debug: Contract info query failed: {e}[/dim]')
+        child_key = None
+
     if not child_key:
         if verbose:
-            console.print('[dim]Debug: Cannot read issues - no child storage key[/dim]')
+            console.print(f'[dim]Debug: Cannot read issues - no child storage key for {contract_addr}[/dim]')
         return []
 
     # First, read packed storage to get next_issue_id

gittensor/cli/main.py

@@ -92,15 +92,21 @@ def show_config():
         console.print(f'[red]Error reading config: {e}[/red]')
 
 
+CONFIG_KEYS = ('wallet', 'hotkey', 'network', 'contract_address', 'ws_endpoint')
+
+
 @config_group.command('set')
-@click.argument('key', type=str)
+@click.argument('key', type=click.Choice(CONFIG_KEYS, case_sensitive=False))
 @click.argument('value', type=str)
 def config_set(key: str, value: str):
     """Set a configuration value.
 
-    [dim]Use this command to override values stored in `~/.gittensor/config.json`.[/dim]
+    [dim]Use this command to override values stored in `~/.gittensor/config.json`.
+    KEY must be one of the recognised settings — unknown keys are rejected so a
+    typo (for example `wallet_name`) cannot silently write a dead entry that
+    downstream commands will ignore.[/dim]
 
-    [dim]Common keys:
+    [dim]Recognised keys:
         wallet              Wallet name
         hotkey              Hotkey name
         contract_address    Contract address
@@ -114,6 +120,7 @@ def config_set(key: str, value: str):
         $ gitt config set network local
     [/dim]
     """
+    key = key.lower()
     # Ensure config directory exists
     GITTENSOR_DIR.mkdir(parents=True, exist_ok=True)
 

gittensor/utils/github_api_tools.py

@@ -3,10 +3,11 @@
 import fnmatch
 import os
 import time
+from contextlib import contextmanager
 from dataclasses import dataclass
 from datetime import datetime, timedelta, timezone
 from math import ceil
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, Dict, Iterator, List, Optional
 
 from gittensor.utils.utils import parse_repo_name
 
@@ -174,7 +175,51 @@ def make_headers(token: str) -> Dict[str, str]:
 
 def make_graphql_headers(token: str) -> Dict[str, str]:
     """Build GitHub GraphQL headers for a PAT."""
-    return {'Authorization': f'Bearer {token}', 'Content-Type': 'application/json'}
+    return {
+        'Authorization': f'Bearer {token}',
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+    }
+
+
+def make_anonymous_headers() -> Dict[str, str]:
+    """Build GitHub HTTP headers for unauthenticated calls."""
+    return {'Accept': 'application/vnd.github.v3+json', 'User-Agent': 'gittensor-cli'}
+
+
+_session_cache: Optional[Dict[str, requests.Session]] = None
+
+
+@contextmanager
+def session_scope() -> Iterator[None]:
+    """Share requests.Session per PAT within the scope; close all on exit. Not re-entrant."""
+    global _session_cache
+    if _session_cache is not None:
+        raise RuntimeError('session_scope is not re-entrant')
+    _session_cache = {}
+    try:
+        yield
+    finally:
+        cache = _session_cache
+        _session_cache = None
+        for s in cache.values():
+            s.close()
+
+
+def _build_session(token: str) -> requests.Session:
+    session = requests.Session()
+    session.headers.update(make_headers(token) if token else make_anonymous_headers())
+    return session
+
+
+def get_session(token: str) -> requests.Session:
+    """Return a requests.Session for the given PAT, reusing one within a session_scope() and allocating fresh otherwise."""
+    if _session_cache is None:
+        return _build_session(token)
+    key = token or ''
+    if key not in _session_cache:
+        _session_cache[key] = _build_session(token)
+    return _session_cache[key]
 
 
 def get_github_id(token: str) -> Optional[str]:
@@ -189,12 +234,12 @@ def get_github_id(token: str) -> Optional[str]:
     if not token:
         return None
 
-    headers = make_headers(token)
+    session = get_session(token)
 
     # Retry logic for timeout issues
     for attempt in range(6):
         try:
-            response = requests.get(f'{BASE_GITHUB_API_URL}/user', headers=headers, timeout=GITHUB_HTTP_TIMEOUT_SECONDS)
+            response = session.get(f'{BASE_GITHUB_API_URL}/user', timeout=GITHUB_HTTP_TIMEOUT_SECONDS)
             if response.status_code == 200:
                 try:
                     user_data: Dict[str, Any] = response.json()
@@ -235,14 +280,13 @@ def get_merge_base_sha(repository: str, base_sha: str, head_sha: str, token: str
     Returns:
         Merge-base commit SHA, or None if the request fails
     """
-    headers = make_headers(token)
+    session = get_session(token)
     max_attempts = 3
 
     for attempt in range(max_attempts):
         try:
-            response = requests.get(
+            response = session.get(
                 f'{BASE_GITHUB_API_URL}/repos/{repository}/compare/{base_sha}...{head_sha}',
-                headers=headers,
                 timeout=15,
             )
 
@@ -293,7 +337,7 @@ def get_pull_request_file_changes(repository: str, pr_number: int, token: str) -
     """
     max_attempts = 3
     per_page = 100
-    headers = make_headers(token)
+    session = get_session(token)
 
     all_file_diffs: list = []
     page = 1
@@ -302,9 +346,8 @@ def get_pull_request_file_changes(repository: str, pr_number: int, token: str) -
 
     while attempt < max_attempts:
         try:
-            response = requests.get(
+            response = session.get(
                 f'{BASE_GITHUB_API_URL}/repos/{repository}/pulls/{pr_number}/files',
-                headers=headers,
                 params={'per_page': per_page, 'page': page},
                 timeout=15,
             )
@@ -485,20 +528,15 @@ def _search_issue_referencing_prs_rest(
     if issue_number < 1:
         return []
 
-    if token:
-        headers = make_headers(token)
-    else:
-        headers = {'Accept': 'application/vnd.github.v3+json'}
-    headers.setdefault('User-Agent', 'gittensor-cli')
+    session = get_session(token or '')
 
     state_clause = f' state:{state}' if state != 'all' else ''
     max_attempts = 3
     for attempt in range(max_attempts):
         try:
-            resp = requests.get(
+            resp = session.get(
                 f'{BASE_GITHUB_API_URL}/search/issues',
                 params={'q': f'repo:{repo} type:pr{state_clause} {issue_number} in:title,body', 'per_page': '50'},
-                headers=headers,
                 timeout=10,
             )
             resp.raise_for_status()
@@ -593,11 +631,12 @@ def execute_graphql_query(
     Returns:
         Parsed JSON response data, or None if all attempts failed
     """
+    session = get_session(token)
     headers = make_graphql_headers(token)
 
     for attempt in range(max_attempts):
         try:
-            response = requests.post(
+            response = session.post(
                 f'{BASE_GITHUB_API_URL}/graphql',
                 headers=headers,
                 json={'query': query, 'variables': variables},
@@ -670,6 +709,7 @@ def get_github_graphql_query(
     """
 
     max_attempts = 8
+    session = get_session(token)
     headers = make_graphql_headers(token)
     limit = page_size if page_size is not None else min(100, max_prs - merged_pr_count)
 
@@ -681,7 +721,7 @@ def get_github_graphql_query(
             'maxChangesRequestedReviews': _MAX_CHANGES_REQUESTED_REVIEWS,
         }
         try:
-            response = requests.post(
+            response = session.post(
                 f'{BASE_GITHUB_API_URL}/graphql',
                 headers=headers,
                 json={'query': QUERY, 'variables': variables},
@@ -1068,12 +1108,11 @@ def check_github_issue_closed(repo: str, issue_number: int, token: str) -> Optio
     Returns:
         Dict with 'is_closed', 'solver_github_id', 'pr_number', 'solver_lookup_failed' or None on error
     """
-    headers = make_headers(token)
+    session = get_session(token)
 
     try:
-        response = requests.get(
+        response = session.get(
             f'{BASE_GITHUB_API_URL}/repos/{repo}/issues/{issue_number}',
-            headers=headers,
             timeout=15,
         )
 

gittensor/utils/mirror/client.py

@@ -43,6 +43,15 @@ def __init__(
         self.max_attempts = max_attempts
         self.session = session or requests.Session()
 
+    def close(self) -> None:
+        self.session.close()
+
+    def __enter__(self) -> 'MirrorClient':
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> None:
+        self.close()
+
     def get_miner_pulls(
         self,
         github_id: str,

gittensor/validator/issue_competitions/forward.py

@@ -9,12 +9,10 @@
 
 from gittensor.classes import MinerEvaluation
 from gittensor.utils.github_api_tools import check_github_issue_closed
+from gittensor.utils.utils import get_contract_address
 from gittensor.validator.issue_competitions.contract_client import IssueCompetitionContractClient, IssueStatus
 from gittensor.validator.utils.config import GITTENSOR_VALIDATOR_PAT
-from gittensor.validator.utils.issue_competitions import (
-    get_contract_address,
-    get_miner_coldkey,
-)
+from gittensor.validator.utils.issue_competitions import get_miner_coldkey
 
 if TYPE_CHECKING:
     from neurons.base.validator import BaseValidatorNeuron