jeremylongshore/tons-of-skills-marketplace / plugins/crypto/crypto-portfolio-tracker/skills/tracking-crypto-portfolio
tracking-crypto-portfolio
VerifiedTrack cryptocurrency portfolio with real-time valuations, allocation analysis, and P&L tracking. Use when checking portfolio value, viewing holdings breakdown, analyzing allocations, or exporting portfolio data. Trigger with phrases like "show my portfolio", "check crypto holdings", "portfolio allocation", "track my crypto", or "export portfolio".
| File | Kind | Size |
|---|---|---|
| ARD.md | markdown | 13.5 KB |
| PRD.md | markdown | 8.2 KB |
| SKILL.md | skill md | 4.9 KB |
| config/settings.yaml | config | 4.4 KB |
| references/errors.md | markdown | 5.8 KB |
| references/examples.md | markdown | 7.6 KB |
| references/implementation.md | markdown | 2.6 KB |
| scripts/formatters.py | script | 10.5 KB |
| scripts/portfolio_loader.py | script | 7.4 KB |
| scripts/portfolio_tracker.py | script | 5.1 KB |
| scripts/price_fetcher.py | script | 7.7 KB |
| scripts/valuation_engine.py | script | 8.2 KB |
scripts/portfolio_loader.py
View on GitHub#!/usr/bin/env python3
"""
Portfolio Loader
Loads and validates portfolio JSON files.
Supports multiple portfolio formats with graceful handling.
Author: Jeremy Longshore <jeremy@intentsolutions.io>
Version: 2.0.0
License: MIT
"""
import json
import sys
from pathlib import Path
from typing import Optional, Dict, Any, List
class PortfolioLoader:
"""Loads and validates portfolio files."""
def __init__(self, verbose: bool = False):
"""Initialize loader.
Args:
verbose: Enable verbose output
"""
self.verbose = verbose
def load(self, path: str) -> Optional[Dict[str, Any]]:
"""Load portfolio from JSON file.
Args:
path: Path to portfolio JSON file
Returns:
Validated portfolio dict or None on error
"""
file_path = Path(path).expanduser()
# Check file exists
if not file_path.exists():
print(f"Error: Portfolio file not found: {file_path}", file=sys.stderr)
return None
# Load JSON
try:
with open(file_path, "r") as f:
data = json.load(f)
except json.JSONDecodeError as e:
print(f"Error: Invalid JSON in portfolio file: {e}", file=sys.stderr)
return None
except Exception as e:
print(f"Error: Failed to read portfolio file: {e}", file=sys.stderr)
return None
# Validate and normalize
return self._validate_portfolio(data)
def _validate_portfolio(self, data: Any) -> Optional[Dict[str, Any]]:
"""Validate and normalize portfolio data."""
# Handle list format (just holdings array)
if isinstance(data, list):
data = {"holdings": data}
if not isinstance(data, dict):
print("Error: Portfolio must be a JSON object or array", file=sys.stderr)
return None
# Check for holdings
holdings = data.get("holdings", [])
if not holdings:
print("Error: Portfolio has no holdings", file=sys.stderr)
return None
# Validate each holding
valid_holdings = []
for i, holding in enumerate(holdings):
validated = self._validate_holding(holding, i)
if validated:
valid_holdings.append(validated)
if not valid_holdings:
print("Error: No valid holdings found in portfolio", file=sys.stderr)
return None
# Aggregate duplicate coins
aggregated = self._aggregate_holdings(valid_holdings)
return {
"name": data.get("name", "My Portfolio"),
"holdings": aggregated,
"categories": data.get("categories", {}),
"currency": data.get("currency", "USD"),
}
def _validate_holding(self, holding: Any, index: int) -> Optional[Dict[str, Any]]:
"""Validate a single holding entry."""
if not isinstance(holding, dict):
if self.verbose:
print(f"Warning: Holding {index} is not an object, skipping", file=sys.stderr)
return None
# Required: coin symbol
coin = holding.get("coin") or holding.get("symbol") or holding.get("ticker")
if not coin:
if self.verbose:
print(f"Warning: Holding {index} missing coin symbol, skipping", file=sys.stderr)
return None
coin = str(coin).upper().strip()
# Required: quantity
quantity = holding.get("quantity") or holding.get("amount") or holding.get("qty")
if quantity is None:
if self.verbose:
print(f"Warning: Holding {index} ({coin}) missing quantity, skipping", file=sys.stderr)
return None
try:
quantity = float(quantity)
except (TypeError, ValueError):
if self.verbose:
print(f"Warning: Holding {index} ({coin}) has invalid quantity, skipping", file=sys.stderr)
return None
if quantity <= 0:
if self.verbose:
print(f"Warning: Holding {index} ({coin}) has non-positive quantity, skipping", file=sys.stderr)
return None
# Optional: cost basis
cost_basis = holding.get("cost_basis") or holding.get("cost") or holding.get("avg_cost")
if cost_basis is not None:
try:
cost_basis = float(cost_basis)
if cost_basis < 0:
cost_basis = None
except (TypeError, ValueError):
cost_basis = None
# Optional: acquired date
acquired = holding.get("acquired") or holding.get("date") or holding.get("purchase_date")
# Optional: wallet/location
wallet = holding.get("wallet") or holding.get("location") or holding.get("exchange")
# Optional: notes
notes = holding.get("notes") or holding.get("memo")
return {
"coin": coin,
"quantity": quantity,
"cost_basis": cost_basis,
"acquired": acquired,
"wallet": wallet,
"notes": notes,
}
def _aggregate_holdings(self, holdings: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
"""Aggregate holdings for the same coin."""
aggregated = {}
for holding in holdings:
coin = holding["coin"]
if coin not in aggregated:
aggregated[coin] = {
"coin": coin,
"quantity": 0,
"total_cost": 0,
"has_cost_basis": False,
"wallets": [],
"notes": [],
}
aggregated[coin]["quantity"] += holding["quantity"]
# Track cost basis if available
if holding.get("cost_basis") is not None:
cost = holding["quantity"] * holding["cost_basis"]
aggregated[coin]["total_cost"] += cost
aggregated[coin]["has_cost_basis"] = True
# Track wallets
if holding.get("wallet"):
aggregated[coin]["wallets"].append(holding["wallet"])
# Track notes
if holding.get("notes"):
aggregated[coin]["notes"].append(holding["notes"])
# Convert to list with calculated average cost basis
result = []
for coin, data in aggregated.items():
entry = {"coin": coin, "quantity": data["quantity"]}
# Calculate average cost basis
if data["has_cost_basis"] and data["quantity"] > 0:
entry["cost_basis"] = data["total_cost"] / data["quantity"]
# Include wallets if tracked
if data["wallets"]:
entry["wallets"] = list(set(data["wallets"]))
# Include notes
if data["notes"]:
entry["notes"] = "; ".join(data["notes"])
result.append(entry)
return result
def main():
"""CLI entry point for testing."""
import argparse
parser = argparse.ArgumentParser(description="Load and validate portfolio file")
parser.add_argument("portfolio", type=str, help="Path to portfolio JSON")
parser.add_argument("--verbose", "-v", action="store_true", help="Verbose output")
args = parser.parse_args()
loader = PortfolioLoader(verbose=args.verbose)
portfolio = loader.load(args.portfolio)
if portfolio:
print(json.dumps(portfolio, indent=2))
else:
sys.exit(1)
if __name__ == "__main__":
main()
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 |