jeremylongshore/tons-of-skills-marketplace / plugins/crypto/market-movers-scanner/skills/scanning-market-movers
scanning-market-movers
VerifiedDetect significant price movements and unusual volume across crypto markets. Calculates significance scores combining price change, volume ratio, and market cap. Use when tracking market movers, finding gainers/losers, or detecting volume spikes. Trigger with phrases like "scan market movers", "top gainers", "biggest losers", "volume spikes", "what's moving", "find pumps", or "market scan".
| File | Kind | Size |
|---|---|---|
| ARD.md | markdown | 20.6 KB |
| PRD.md | markdown | 11.3 KB |
| SKILL.md | skill md | 5.3 KB |
| config/settings.yaml | config | 3.0 KB |
| references/errors.md | markdown | 5.2 KB |
| references/examples.md | markdown | 7.9 KB |
| references/implementation.md | markdown | 3.1 KB |
| scripts/analyzer.py | script | 6.8 KB |
| scripts/filters.py | script | 4.2 KB |
| scripts/formatters.py | script | 7.3 KB |
| scripts/scanner.py | script | 9.5 KB |
| scripts/scorers.py | script | 6.0 KB |
scripts/scorers.py
View on GitHub#!/usr/bin/env python3
"""
Significance Scorers - Composite Scoring for Market Movers
Calculate significance scores combining price change, volume ratio, and market cap.
Author: Jeremy Longshore <jeremy@intentsolutions.io>
Version: 2.0.0
License: MIT
"""
import math
from typing import Dict, Optional
def calculate_significance(
change_pct: float, volume_ratio: float, market_cap: float, weights: Optional[Dict[str, float]] = None
) -> float:
"""
Calculate composite significance score for ranking movers.
The score combines:
- Price change % (normalized, capped at 100)
- Volume ratio (normalized, capped at 100)
- Market cap (log scale, capped at 100)
Args:
change_pct: Percentage price change
volume_ratio: Current volume / average volume
market_cap: Market cap in USD
weights: Optional custom weights (change, volume, cap)
Returns:
Significance score from 0-100
"""
weights = weights or {"change_weight": 0.40, "volume_weight": 0.40, "cap_weight": 0.20}
# Normalize change score (cap at 100)
# 50% change = 100 score
change_score = min(100, abs(change_pct) * 2)
# Normalize volume ratio score (cap at 100)
# 5x volume = 100 score
volume_score = min(100, volume_ratio * 20)
# Normalize market cap score (log scale, cap at 100)
# $10B cap = 100 score (log10(10B) = 10, * 10 = 100)
if market_cap > 0:
cap_score = min(100, math.log10(market_cap) * 10)
else:
cap_score = 0
# Calculate weighted sum
score = (
weights.get("change_weight", 0.4) * change_score
+ weights.get("volume_weight", 0.4) * volume_score
+ weights.get("cap_weight", 0.2) * cap_score
)
return round(score, 1)
def calculate_momentum_score(
change_1h: Optional[float], change_24h: Optional[float], change_7d: Optional[float]
) -> float:
"""
Calculate momentum score based on multi-timeframe changes.
Higher scores indicate consistent directional movement.
Args:
change_1h: 1-hour change %
change_24h: 24-hour change %
change_7d: 7-day change %
Returns:
Momentum score from 0-100
"""
changes = []
if change_1h is not None:
changes.append(change_1h)
if change_24h is not None:
changes.append(change_24h)
if change_7d is not None:
changes.append(change_7d)
if not changes:
return 0
# Check if all changes are in same direction
positive = sum(1 for c in changes if c > 0)
negative = sum(1 for c in changes if c < 0)
# Alignment score (0-1): all same direction = 1
total = len(changes)
alignment = max(positive, negative) / total
# Magnitude score (average absolute change, capped)
avg_change = sum(abs(c) for c in changes) / total
magnitude = min(100, avg_change * 2)
# Combine alignment and magnitude
score = alignment * magnitude
return round(score, 1)
def calculate_volatility_score(high_24h: Optional[float], low_24h: Optional[float], current_price: float) -> float:
"""
Calculate volatility score based on 24h range.
Args:
high_24h: 24-hour high price
low_24h: 24-hour low price
current_price: Current price
Returns:
Volatility score from 0-100
"""
if not all([high_24h, low_24h, current_price]) or current_price <= 0:
return 0
# Calculate range as percentage of current price
range_pct = ((high_24h - low_24h) / current_price) * 100
# Normalize (20% range = 100 score)
score = min(100, range_pct * 5)
return round(score, 1)
def calculate_relative_strength(change: float, market_avg_change: float) -> float:
"""
Calculate relative strength vs market average.
Args:
change: Asset's change %
market_avg_change: Market average change %
Returns:
Relative strength score (can be negative)
"""
if market_avg_change == 0:
return change * 10 # Simple scaling if no market avg
# Relative outperformance
relative = change - market_avg_change
# Normalize to score
score = relative * 5
return round(score, 1)
def explain_score(
change_pct: float,
volume_ratio: float,
market_cap: float,
final_score: float,
weights: Optional[Dict[str, float]] = None,
) -> Dict[str, str]:
"""
Generate human-readable explanation of score components.
Args:
change_pct: Percentage price change
volume_ratio: Volume ratio
market_cap: Market cap
final_score: Final significance score
weights: Scoring weights
Returns:
Dictionary with explanation strings
"""
weights = weights or {"change_weight": 0.40, "volume_weight": 0.40, "cap_weight": 0.20}
explanations = {}
# Change component
change_score = min(100, abs(change_pct) * 2)
change_contribution = weights.get("change_weight", 0.4) * change_score
explanations["change"] = (
f"{change_pct:+.1f}% change → {change_score:.0f} points (contributes {change_contribution:.1f} to score)"
)
# Volume component
volume_score = min(100, volume_ratio * 20)
volume_contribution = weights.get("volume_weight", 0.4) * volume_score
explanations["volume"] = (
f"{volume_ratio:.1f}x volume → {volume_score:.0f} points (contributes {volume_contribution:.1f} to score)"
)
# Cap component
if market_cap > 0:
cap_score = min(100, math.log10(market_cap) * 10)
else:
cap_score = 0
cap_contribution = weights.get("cap_weight", 0.2) * cap_score
cap_str = f"${market_cap / 1e9:.1f}B" if market_cap >= 1e9 else f"${market_cap / 1e6:.1f}M"
explanations["market_cap"] = f"{cap_str} cap → {cap_score:.0f} points (contributes {cap_contribution:.1f} to score)"
# Summary
explanations["summary"] = (
f"Final Score: {final_score:.1f}/100 "
f"(Change: {change_contribution:.1f} + "
f"Volume: {volume_contribution:.1f} + "
f"Cap: {cap_contribution:.1f})"
)
return explanations
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack." | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read. | Stars: 196k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report. | Stars: 196k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt. | Stars: 196k | Updated | Claude CodeCodex | Verified | Install |