205 lines
8 KiB
Zig
205 lines
8 KiB
Zig
const std = @import("std");
|
|
const zfin = @import("zfin");
|
|
const cli = @import("../common.zig");
|
|
|
|
/// CLI `enrich` command: bootstrap a metadata.srf file from Alpha Vantage OVERVIEW data.
|
|
/// Reads the portfolio, extracts stock symbols, fetches sector/industry/country for each,
|
|
/// and outputs a metadata SRF file to stdout.
|
|
/// If the argument looks like a symbol (no path separators, no .srf extension), enrich just that symbol.
|
|
pub fn run(allocator: std.mem.Allocator, config: zfin.Config, arg: []const u8, out: *std.Io.Writer) !void {
|
|
// Check for Alpha Vantage API key
|
|
const av_key = config.alphavantage_key orelse {
|
|
try cli.stderrPrint("Error: ALPHAVANTAGE_API_KEY not set. Add it to .env\n");
|
|
return;
|
|
};
|
|
|
|
// Determine if arg is a symbol or a file path
|
|
const is_file = std.mem.endsWith(u8, arg, ".srf") or
|
|
std.mem.indexOfScalar(u8, arg, '/') != null or
|
|
std.mem.indexOfScalar(u8, arg, '.') != null;
|
|
|
|
if (!is_file) {
|
|
// Single symbol mode: enrich one symbol, output appendable SRF (no header)
|
|
try enrichSymbol(allocator, av_key, arg, out);
|
|
return;
|
|
}
|
|
|
|
// Portfolio file mode: enrich all symbols
|
|
try enrichPortfolio(allocator, av_key, arg, out);
|
|
}
|
|
|
|
/// Enrich a single symbol and output appendable SRF lines to stdout.
|
|
fn enrichSymbol(allocator: std.mem.Allocator, av_key: []const u8, sym: []const u8, out: *std.Io.Writer) !void {
|
|
const AV = zfin.AlphaVantage;
|
|
var av = AV.init(allocator, av_key);
|
|
defer av.deinit();
|
|
|
|
{
|
|
var msg_buf: [128]u8 = undefined;
|
|
const msg = std.fmt.bufPrint(&msg_buf, " Fetching {s}...\n", .{sym}) catch " ...\n";
|
|
try cli.stderrPrint(msg);
|
|
}
|
|
|
|
const overview = av.fetchCompanyOverview(allocator, sym) catch {
|
|
try cli.stderrPrint("Error: Failed to fetch data for symbol\n");
|
|
try out.print("# {s} -- fetch failed\n", .{sym});
|
|
try out.print("# symbol::{s},sector::TODO,geo::TODO,asset_class::TODO\n", .{sym});
|
|
return;
|
|
};
|
|
defer {
|
|
if (overview.name) |n| allocator.free(n);
|
|
if (overview.sector) |s| allocator.free(s);
|
|
if (overview.industry) |ind| allocator.free(ind);
|
|
if (overview.country) |c| allocator.free(c);
|
|
if (overview.market_cap) |mc| allocator.free(mc);
|
|
if (overview.asset_type) |at| allocator.free(at);
|
|
}
|
|
|
|
const sector_str = overview.sector orelse "Unknown";
|
|
const country_str = overview.country orelse "US";
|
|
const geo_str = if (std.mem.eql(u8, country_str, "USA")) "US" else country_str;
|
|
|
|
const asset_class_str = blk: {
|
|
if (overview.asset_type) |at| {
|
|
if (std.mem.eql(u8, at, "ETF")) break :blk "ETF";
|
|
if (std.mem.eql(u8, at, "Mutual Fund")) break :blk "Mutual Fund";
|
|
}
|
|
if (overview.market_cap) |mc_str| {
|
|
const mc = std.fmt.parseInt(u64, mc_str, 10) catch 0;
|
|
if (mc >= 10_000_000_000) break :blk "US Large Cap";
|
|
if (mc >= 2_000_000_000) break :blk "US Mid Cap";
|
|
break :blk "US Small Cap";
|
|
}
|
|
break :blk "US Large Cap";
|
|
};
|
|
|
|
if (overview.name) |name| {
|
|
try out.print("# {s}\n", .{name});
|
|
}
|
|
try out.print("symbol::{s},sector::{s},geo::{s},asset_class::{s}\n", .{
|
|
sym, sector_str, geo_str, asset_class_str,
|
|
});
|
|
}
|
|
|
|
/// Enrich all symbols from a portfolio file.
|
|
fn enrichPortfolio(allocator: std.mem.Allocator, av_key: []const u8, file_path: []const u8, out: *std.Io.Writer) !void {
|
|
const AV = zfin.AlphaVantage;
|
|
|
|
// Load portfolio
|
|
const file_data = std.fs.cwd().readFileAlloc(allocator, file_path, 10 * 1024 * 1024) catch {
|
|
try cli.stderrPrint("Error: Cannot read portfolio file\n");
|
|
return;
|
|
};
|
|
defer allocator.free(file_data);
|
|
|
|
var portfolio = zfin.cache.deserializePortfolio(allocator, file_data) catch {
|
|
try cli.stderrPrint("Error: Cannot parse portfolio file\n");
|
|
return;
|
|
};
|
|
defer portfolio.deinit();
|
|
|
|
// Get unique stock symbols (using display-oriented names)
|
|
const positions = try portfolio.positions(allocator);
|
|
defer allocator.free(positions);
|
|
|
|
// Get unique price symbols (raw API symbols)
|
|
const syms = try portfolio.stockSymbols(allocator);
|
|
defer allocator.free(syms);
|
|
|
|
var av = AV.init(allocator, av_key);
|
|
defer av.deinit();
|
|
|
|
try out.print("#!srfv1\n", .{});
|
|
try out.print("# Portfolio classification metadata\n", .{});
|
|
try out.print("# Generated from Alpha Vantage OVERVIEW data\n", .{});
|
|
try out.print("# Edit as needed: sector, geo, asset_class, pct:num:N\n", .{});
|
|
try out.print("#\n", .{});
|
|
try out.print("# For ETFs/funds with multi-class exposure, add multiple lines\n", .{});
|
|
try out.print("# with pct:num: values that sum to ~100\n\n", .{});
|
|
|
|
var success: usize = 0;
|
|
var skipped: usize = 0;
|
|
var failed: usize = 0;
|
|
|
|
for (syms, 0..) |sym, i| {
|
|
// Skip CUSIPs and known non-stock symbols
|
|
if (zfin.OpenFigi.isCusipLike(sym)) {
|
|
// Find the display name for this CUSIP
|
|
const display: []const u8 = sym;
|
|
var note: ?[]const u8 = null;
|
|
for (positions) |pos| {
|
|
if (std.mem.eql(u8, pos.symbol, sym)) {
|
|
if (pos.note) |n| {
|
|
note = n;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
try out.print("# CUSIP {s}", .{sym});
|
|
if (note) |n| try out.print(" ({s})", .{n});
|
|
try out.print(" -- fill in manually\n", .{});
|
|
try out.print("# symbol::{s},asset_class::TODO,geo::TODO\n\n", .{display});
|
|
skipped += 1;
|
|
continue;
|
|
}
|
|
|
|
// Progress to stderr
|
|
{
|
|
var msg_buf: [128]u8 = undefined;
|
|
const msg = std.fmt.bufPrint(&msg_buf, " [{d}/{d}] {s}...\n", .{ i + 1, syms.len, sym }) catch " ...\n";
|
|
try cli.stderrPrint(msg);
|
|
}
|
|
|
|
const overview = av.fetchCompanyOverview(allocator, sym) catch {
|
|
try out.print("# {s} -- fetch failed\n", .{sym});
|
|
try out.print("# symbol::{s},sector::TODO,geo::TODO,asset_class::TODO\n\n", .{sym});
|
|
failed += 1;
|
|
continue;
|
|
};
|
|
// Free allocated strings from overview when done
|
|
defer {
|
|
if (overview.name) |n| allocator.free(n);
|
|
if (overview.sector) |s| allocator.free(s);
|
|
if (overview.industry) |ind| allocator.free(ind);
|
|
if (overview.country) |c| allocator.free(c);
|
|
if (overview.market_cap) |mc| allocator.free(mc);
|
|
if (overview.asset_type) |at| allocator.free(at);
|
|
}
|
|
|
|
const sector_str = overview.sector orelse "Unknown";
|
|
const country_str = overview.country orelse "US";
|
|
const geo_str = if (std.mem.eql(u8, country_str, "USA")) "US" else country_str;
|
|
|
|
// Determine asset_class from asset type + market cap
|
|
const asset_class_str = blk: {
|
|
if (overview.asset_type) |at| {
|
|
if (std.mem.eql(u8, at, "ETF")) break :blk "ETF";
|
|
if (std.mem.eql(u8, at, "Mutual Fund")) break :blk "Mutual Fund";
|
|
}
|
|
// For common stocks, infer from market cap
|
|
if (overview.market_cap) |mc_str| {
|
|
const mc = std.fmt.parseInt(u64, mc_str, 10) catch 0;
|
|
if (mc >= 10_000_000_000) break :blk "US Large Cap";
|
|
if (mc >= 2_000_000_000) break :blk "US Mid Cap";
|
|
break :blk "US Small Cap";
|
|
}
|
|
break :blk "US Large Cap";
|
|
};
|
|
|
|
// Comment with the name for readability
|
|
if (overview.name) |name| {
|
|
try out.print("# {s}\n", .{name});
|
|
}
|
|
try out.print("symbol::{s},sector::{s},geo::{s},asset_class::{s}\n\n", .{
|
|
sym, sector_str, geo_str, asset_class_str,
|
|
});
|
|
success += 1;
|
|
}
|
|
|
|
// Summary comment
|
|
try out.print("# ---\n", .{});
|
|
try out.print("# Enriched {d} symbols ({d} success, {d} skipped, {d} failed)\n", .{
|
|
syms.len, success, skipped, failed,
|
|
});
|
|
try out.print("# Review and edit this file, then save as metadata.srf\n", .{});
|
|
}
|