1211 lines
50 KiB
Zig
1211 lines
50 KiB
Zig
const std = @import("std");
|
|
const srf = @import("srf");
|
|
const Date = @import("../models/date.zig").Date;
|
|
const Candle = @import("../models/candle.zig").Candle;
|
|
const Dividend = @import("../models/dividend.zig").Dividend;
|
|
const DividendType = @import("../models/dividend.zig").DividendType;
|
|
const Split = @import("../models/split.zig").Split;
|
|
const EarningsEvent = @import("../models/earnings.zig").EarningsEvent;
|
|
const ReportTime = @import("../models/earnings.zig").ReportTime;
|
|
const EtfProfile = @import("../models/etf_profile.zig").EtfProfile;
|
|
const Holding = @import("../models/etf_profile.zig").Holding;
|
|
const SectorWeight = @import("../models/etf_profile.zig").SectorWeight;
|
|
const Lot = @import("../models/portfolio.zig").Lot;
|
|
const Portfolio = @import("../models/portfolio.zig").Portfolio;
|
|
const OptionsChain = @import("../models/option.zig").OptionsChain;
|
|
const OptionContract = @import("../models/option.zig").OptionContract;
|
|
|
|
/// TTL durations in seconds for cache expiry.
|
|
pub const Ttl = struct {
|
|
/// Historical candles older than 1 day never expire
|
|
pub const candles_historical: i64 = -1; // infinite
|
|
/// Latest day's candle refreshes every 24h
|
|
pub const candles_latest: i64 = 24 * 3600;
|
|
/// Dividend data refreshes weekly
|
|
pub const dividends: i64 = 7 * 24 * 3600;
|
|
/// Split data refreshes weekly
|
|
pub const splits: i64 = 7 * 24 * 3600;
|
|
/// Options chains refresh hourly
|
|
pub const options: i64 = 3600;
|
|
/// Earnings refresh daily
|
|
pub const earnings: i64 = 24 * 3600;
|
|
/// ETF profiles refresh monthly
|
|
pub const etf_profile: i64 = 30 * 24 * 3600;
|
|
};
|
|
|
|
pub const DataType = enum {
|
|
candles_daily,
|
|
dividends,
|
|
splits,
|
|
options,
|
|
earnings,
|
|
etf_profile,
|
|
meta,
|
|
|
|
pub fn fileName(self: DataType) []const u8 {
|
|
return switch (self) {
|
|
.candles_daily => "candles_daily.srf",
|
|
.dividends => "dividends.srf",
|
|
.splits => "splits.srf",
|
|
.options => "options.srf",
|
|
.earnings => "earnings.srf",
|
|
.etf_profile => "etf_profile.srf",
|
|
.meta => "meta.srf",
|
|
};
|
|
}
|
|
};
|
|
|
|
/// Persistent SRF-backed cache with per-symbol, per-data-type files.
|
|
///
|
|
/// Layout:
|
|
/// {cache_dir}/{SYMBOL}/candles_daily.srf
|
|
/// {cache_dir}/{SYMBOL}/dividends.srf
|
|
/// {cache_dir}/{SYMBOL}/meta.srf
|
|
/// ...
|
|
pub const Store = struct {
|
|
cache_dir: []const u8,
|
|
allocator: std.mem.Allocator,
|
|
|
|
pub fn init(allocator: std.mem.Allocator, cache_dir: []const u8) Store {
|
|
return .{
|
|
.cache_dir = cache_dir,
|
|
.allocator = allocator,
|
|
};
|
|
}
|
|
|
|
/// Ensure the cache directory for a symbol exists.
|
|
pub fn ensureSymbolDir(self: *Store, symbol: []const u8) !void {
|
|
const path = try self.symbolPath(symbol, "");
|
|
defer self.allocator.free(path);
|
|
std.fs.cwd().makePath(path) catch |err| switch (err) {
|
|
error.PathAlreadyExists => {},
|
|
else => return err,
|
|
};
|
|
}
|
|
|
|
/// Read raw SRF file contents for a symbol and data type.
|
|
/// Returns null if the file does not exist.
|
|
pub fn readRaw(self: *Store, symbol: []const u8, data_type: DataType) !?[]const u8 {
|
|
const path = try self.symbolPath(symbol, data_type.fileName());
|
|
defer self.allocator.free(path);
|
|
|
|
return std.fs.cwd().readFileAlloc(self.allocator, path, 50 * 1024 * 1024) catch |err| switch (err) {
|
|
error.FileNotFound => return null,
|
|
else => return err,
|
|
};
|
|
}
|
|
|
|
/// Write raw SRF data for a symbol and data type with an embedded expiry timestamp.
|
|
/// Inserts a `# good_until::{unix_seconds}` comment after the `#!srfv1` header so
|
|
/// freshness can be determined from the file content rather than filesystem mtime.
|
|
pub fn writeWithExpiry(self: *Store, symbol: []const u8, data_type: DataType, data: []const u8, ttl_seconds: i64) !void {
|
|
try self.ensureSymbolDir(symbol);
|
|
const path = try self.symbolPath(symbol, data_type.fileName());
|
|
defer self.allocator.free(path);
|
|
|
|
const file = try std.fs.cwd().createFile(path, .{});
|
|
defer file.close();
|
|
|
|
const header = "#!srfv1\n";
|
|
if (std.mem.startsWith(u8, data, header)) {
|
|
try file.writeAll(header);
|
|
var expiry_buf: [48]u8 = undefined;
|
|
const expiry = std.time.timestamp() + ttl_seconds;
|
|
const expiry_line = std.fmt.bufPrint(&expiry_buf, "# good_until::{d}\n", .{expiry}) catch return;
|
|
try file.writeAll(expiry_line);
|
|
try file.writeAll(data[header.len..]);
|
|
} else {
|
|
// Unexpected format -- write as-is to avoid data loss
|
|
try file.writeAll(data);
|
|
}
|
|
}
|
|
|
|
/// Write raw SRF data for a symbol and data type (no expiry metadata).
|
|
pub fn writeRaw(self: *Store, symbol: []const u8, data_type: DataType, data: []const u8) !void {
|
|
try self.ensureSymbolDir(symbol);
|
|
const path = try self.symbolPath(symbol, data_type.fileName());
|
|
defer self.allocator.free(path);
|
|
|
|
const file = try std.fs.cwd().createFile(path, .{});
|
|
defer file.close();
|
|
try file.writeAll(data);
|
|
}
|
|
|
|
/// Check if a cached data file is fresh by reading the embedded expiry timestamp.
|
|
/// - Negative cache entries (# fetch_failed) are always fresh.
|
|
/// - Files with `# good_until::{timestamp}` are fresh if now < timestamp.
|
|
/// - Files without expiry metadata are considered stale (triggers re-fetch + rewrite).
|
|
pub fn isFresh(self: *Store, symbol: []const u8, data_type: DataType) !bool {
|
|
const path = try self.symbolPath(symbol, data_type.fileName());
|
|
defer self.allocator.free(path);
|
|
|
|
const file = std.fs.cwd().openFile(path, .{}) catch return false;
|
|
defer file.close();
|
|
|
|
// Read enough to find the good_until or fetch_failed comment lines
|
|
var buf: [128]u8 = undefined;
|
|
const n = file.readAll(&buf) catch return false;
|
|
const content = buf[0..n];
|
|
|
|
// Negative cache entry -- always fresh
|
|
if (std.mem.indexOf(u8, content, "# fetch_failed")) |_| return true;
|
|
|
|
// Look for embedded expiry
|
|
if (std.mem.indexOf(u8, content, "# good_until::")) |idx| {
|
|
const after = content[idx + "# good_until::".len ..];
|
|
const end = std.mem.indexOfScalar(u8, after, '\n') orelse after.len;
|
|
const expiry = std.fmt.parseInt(i64, after[0..end], 10) catch return false;
|
|
return std.time.timestamp() < expiry;
|
|
}
|
|
|
|
// No expiry info (legacy file or missing metadata) -- stale
|
|
return false;
|
|
}
|
|
|
|
/// Get the modification time (unix seconds) of a cached data file.
|
|
/// Returns null if the file does not exist.
|
|
pub fn getMtime(self: *Store, symbol: []const u8, data_type: DataType) ?i64 {
|
|
const path = self.symbolPath(symbol, data_type.fileName()) catch return null;
|
|
defer self.allocator.free(path);
|
|
|
|
const file = std.fs.cwd().openFile(path, .{}) catch return null;
|
|
defer file.close();
|
|
|
|
const stat = file.stat() catch return null;
|
|
return @intCast(@divFloor(stat.mtime, std.time.ns_per_s));
|
|
}
|
|
|
|
/// Clear all cached data for a symbol.
|
|
pub fn clearSymbol(self: *Store, symbol: []const u8) !void {
|
|
const path = try self.symbolPath(symbol, "");
|
|
defer self.allocator.free(path);
|
|
std.fs.cwd().deleteTree(path) catch {};
|
|
}
|
|
|
|
/// Content of a negative cache entry (fetch failed, don't retry until --refresh).
|
|
pub const negative_cache_content = "#!srfv1\n# fetch_failed\n";
|
|
|
|
/// Write a negative cache entry for a symbol + data type.
|
|
/// This records that a fetch was attempted and failed, preventing repeated
|
|
/// network requests for symbols that will never resolve.
|
|
/// Cleared by --refresh (which calls clearData/invalidate).
|
|
pub fn writeNegative(self: *Store, symbol: []const u8, data_type: DataType) void {
|
|
self.writeRaw(symbol, data_type, negative_cache_content) catch {};
|
|
}
|
|
|
|
/// Check if a cached data file is a negative entry (fetch_failed marker).
|
|
/// Negative entries are always considered "fresh" -- they never expire.
|
|
pub fn isNegative(self: *Store, symbol: []const u8, data_type: DataType) bool {
|
|
const path = self.symbolPath(symbol, data_type.fileName()) catch return false;
|
|
defer self.allocator.free(path);
|
|
|
|
const file = std.fs.cwd().openFile(path, .{}) catch return false;
|
|
defer file.close();
|
|
|
|
var buf: [negative_cache_content.len]u8 = undefined;
|
|
const n = file.readAll(&buf) catch return false;
|
|
return n == negative_cache_content.len and
|
|
std.mem.eql(u8, buf[0..n], negative_cache_content);
|
|
}
|
|
|
|
/// Clear a specific data type for a symbol.
|
|
pub fn clearData(self: *Store, symbol: []const u8, data_type: DataType) void {
|
|
const path = self.symbolPath(symbol, data_type.fileName()) catch return;
|
|
defer self.allocator.free(path);
|
|
std.fs.cwd().deleteFile(path) catch {};
|
|
}
|
|
|
|
/// Clear all cached data.
|
|
pub fn clearAll(self: *Store) !void {
|
|
std.fs.cwd().deleteTree(self.cache_dir) catch {};
|
|
}
|
|
|
|
// -- Serialization helpers --
|
|
|
|
/// Serialize candles to SRF compact format.
|
|
pub fn serializeCandles(allocator: std.mem.Allocator, candles: []const Candle) ![]const u8 {
|
|
var buf: std.ArrayList(u8) = .empty;
|
|
errdefer buf.deinit(allocator);
|
|
const writer = buf.writer(allocator);
|
|
|
|
try writer.writeAll("#!srfv1\n");
|
|
for (candles) |c| {
|
|
var date_buf: [10]u8 = undefined;
|
|
const date_str = c.date.format(&date_buf);
|
|
try writer.print(
|
|
"date::{s},open:num:{d},high:num:{d},low:num:{d},close:num:{d},adj_close:num:{d},volume:num:{d}\n",
|
|
.{ date_str, c.open, c.high, c.low, c.close, c.adj_close, c.volume },
|
|
);
|
|
}
|
|
|
|
return buf.toOwnedSlice(allocator);
|
|
}
|
|
|
|
/// Deserialize candles from SRF data.
|
|
pub fn deserializeCandles(allocator: std.mem.Allocator, data: []const u8) ![]Candle {
|
|
var candles: std.ArrayList(Candle) = .empty;
|
|
errdefer candles.deinit(allocator);
|
|
|
|
var reader = std.Io.Reader.fixed(data);
|
|
const parsed = srf.parse(&reader, allocator, .{ .alloc_strings = false }) catch return error.InvalidData;
|
|
defer parsed.deinit();
|
|
|
|
for (parsed.records.items) |record| {
|
|
var candle = Candle{
|
|
.date = Date.epoch,
|
|
.open = 0,
|
|
.high = 0,
|
|
.low = 0,
|
|
.close = 0,
|
|
.adj_close = 0,
|
|
.volume = 0,
|
|
};
|
|
for (record.fields) |field| {
|
|
if (std.mem.eql(u8, field.key, "date")) {
|
|
if (field.value) |v| {
|
|
const str = switch (v) {
|
|
.string => |s| s,
|
|
else => continue,
|
|
};
|
|
candle.date = Date.parse(str) catch continue;
|
|
}
|
|
} else if (std.mem.eql(u8, field.key, "open")) {
|
|
if (field.value) |v| candle.open = numVal(v);
|
|
} else if (std.mem.eql(u8, field.key, "high")) {
|
|
if (field.value) |v| candle.high = numVal(v);
|
|
} else if (std.mem.eql(u8, field.key, "low")) {
|
|
if (field.value) |v| candle.low = numVal(v);
|
|
} else if (std.mem.eql(u8, field.key, "close")) {
|
|
if (field.value) |v| candle.close = numVal(v);
|
|
} else if (std.mem.eql(u8, field.key, "adj_close")) {
|
|
if (field.value) |v| candle.adj_close = numVal(v);
|
|
} else if (std.mem.eql(u8, field.key, "volume")) {
|
|
if (field.value) |v| candle.volume = @intFromFloat(numVal(v));
|
|
}
|
|
}
|
|
try candles.append(allocator, candle);
|
|
}
|
|
|
|
return candles.toOwnedSlice(allocator);
|
|
}
|
|
|
|
/// Serialize dividends to SRF compact format.
|
|
pub fn serializeDividends(allocator: std.mem.Allocator, dividends: []const Dividend) ![]const u8 {
|
|
var buf: std.ArrayList(u8) = .empty;
|
|
errdefer buf.deinit(allocator);
|
|
const writer = buf.writer(allocator);
|
|
|
|
try writer.writeAll("#!srfv1\n");
|
|
for (dividends) |d| {
|
|
var ex_buf: [10]u8 = undefined;
|
|
const ex_str = d.ex_date.format(&ex_buf);
|
|
try writer.print("ex_date::{s},amount:num:{d}", .{ ex_str, d.amount });
|
|
if (d.pay_date) |pd| {
|
|
var pay_buf: [10]u8 = undefined;
|
|
try writer.print(",pay_date::{s}", .{pd.format(&pay_buf)});
|
|
}
|
|
if (d.frequency) |f| {
|
|
try writer.print(",frequency:num:{d}", .{f});
|
|
}
|
|
try writer.print(",type::{s}\n", .{@tagName(d.distribution_type)});
|
|
}
|
|
|
|
return buf.toOwnedSlice(allocator);
|
|
}
|
|
|
|
/// Serialize splits to SRF compact format.
|
|
pub fn serializeSplits(allocator: std.mem.Allocator, splits: []const Split) ![]const u8 {
|
|
var buf: std.ArrayList(u8) = .empty;
|
|
errdefer buf.deinit(allocator);
|
|
const writer = buf.writer(allocator);
|
|
|
|
try writer.writeAll("#!srfv1\n");
|
|
for (splits) |s| {
|
|
var date_buf: [10]u8 = undefined;
|
|
const date_str = s.date.format(&date_buf);
|
|
try writer.print("date::{s},numerator:num:{d},denominator:num:{d}\n", .{
|
|
date_str, s.numerator, s.denominator,
|
|
});
|
|
}
|
|
|
|
return buf.toOwnedSlice(allocator);
|
|
}
|
|
|
|
/// Deserialize dividends from SRF data.
|
|
pub fn deserializeDividends(allocator: std.mem.Allocator, data: []const u8) ![]Dividend {
|
|
var dividends: std.ArrayList(Dividend) = .empty;
|
|
errdefer dividends.deinit(allocator);
|
|
|
|
var reader = std.Io.Reader.fixed(data);
|
|
const parsed = srf.parse(&reader, allocator, .{ .alloc_strings = false }) catch return error.InvalidData;
|
|
defer parsed.deinit();
|
|
|
|
for (parsed.records.items) |record| {
|
|
var div = Dividend{
|
|
.ex_date = Date.epoch,
|
|
.amount = 0,
|
|
};
|
|
for (record.fields) |field| {
|
|
if (std.mem.eql(u8, field.key, "ex_date")) {
|
|
if (field.value) |v| {
|
|
const str = switch (v) {
|
|
.string => |s| s,
|
|
else => continue,
|
|
};
|
|
div.ex_date = Date.parse(str) catch continue;
|
|
}
|
|
} else if (std.mem.eql(u8, field.key, "amount")) {
|
|
if (field.value) |v| div.amount = numVal(v);
|
|
} else if (std.mem.eql(u8, field.key, "pay_date")) {
|
|
if (field.value) |v| {
|
|
const str = switch (v) {
|
|
.string => |s| s,
|
|
else => continue,
|
|
};
|
|
div.pay_date = Date.parse(str) catch null;
|
|
}
|
|
} else if (std.mem.eql(u8, field.key, "frequency")) {
|
|
if (field.value) |v| {
|
|
const n = numVal(v);
|
|
if (n > 0 and n <= 255) div.frequency = @intFromFloat(n);
|
|
}
|
|
} else if (std.mem.eql(u8, field.key, "type")) {
|
|
if (field.value) |v| {
|
|
const str = switch (v) {
|
|
.string => |s| s,
|
|
else => continue,
|
|
};
|
|
div.distribution_type = parseDividendTypeTag(str);
|
|
}
|
|
}
|
|
}
|
|
try dividends.append(allocator, div);
|
|
}
|
|
|
|
return dividends.toOwnedSlice(allocator);
|
|
}
|
|
|
|
/// Deserialize splits from SRF data.
|
|
pub fn deserializeSplits(allocator: std.mem.Allocator, data: []const u8) ![]Split {
|
|
var splits: std.ArrayList(Split) = .empty;
|
|
errdefer splits.deinit(allocator);
|
|
|
|
var reader = std.Io.Reader.fixed(data);
|
|
const parsed = srf.parse(&reader, allocator, .{ .alloc_strings = false }) catch return error.InvalidData;
|
|
defer parsed.deinit();
|
|
|
|
for (parsed.records.items) |record| {
|
|
var split = Split{
|
|
.date = Date.epoch,
|
|
.numerator = 0,
|
|
.denominator = 0,
|
|
};
|
|
for (record.fields) |field| {
|
|
if (std.mem.eql(u8, field.key, "date")) {
|
|
if (field.value) |v| {
|
|
const str = switch (v) {
|
|
.string => |s| s,
|
|
else => continue,
|
|
};
|
|
split.date = Date.parse(str) catch continue;
|
|
}
|
|
} else if (std.mem.eql(u8, field.key, "numerator")) {
|
|
if (field.value) |v| split.numerator = numVal(v);
|
|
} else if (std.mem.eql(u8, field.key, "denominator")) {
|
|
if (field.value) |v| split.denominator = numVal(v);
|
|
}
|
|
}
|
|
try splits.append(allocator, split);
|
|
}
|
|
|
|
return splits.toOwnedSlice(allocator);
|
|
}
|
|
|
|
/// Serialize earnings events to SRF compact format.
|
|
pub fn serializeEarnings(allocator: std.mem.Allocator, events: []const EarningsEvent) ![]const u8 {
|
|
var buf: std.ArrayList(u8) = .empty;
|
|
errdefer buf.deinit(allocator);
|
|
const writer = buf.writer(allocator);
|
|
|
|
try writer.writeAll("#!srfv1\n");
|
|
for (events) |e| {
|
|
var date_buf: [10]u8 = undefined;
|
|
const date_str = e.date.format(&date_buf);
|
|
try writer.print("date::{s}", .{date_str});
|
|
if (e.estimate) |est| try writer.print(",estimate:num:{d}", .{est});
|
|
if (e.actual) |act| try writer.print(",actual:num:{d}", .{act});
|
|
if (e.quarter) |q| try writer.print(",quarter:num:{d}", .{q});
|
|
if (e.fiscal_year) |fy| try writer.print(",fiscal_year:num:{d}", .{fy});
|
|
if (e.revenue_actual) |ra| try writer.print(",revenue_actual:num:{d}", .{ra});
|
|
if (e.revenue_estimate) |re| try writer.print(",revenue_estimate:num:{d}", .{re});
|
|
try writer.print(",report_time::{s}\n", .{@tagName(e.report_time)});
|
|
}
|
|
|
|
return buf.toOwnedSlice(allocator);
|
|
}
|
|
|
|
/// Deserialize earnings events from SRF data.
|
|
pub fn deserializeEarnings(allocator: std.mem.Allocator, data: []const u8) ![]EarningsEvent {
|
|
var events: std.ArrayList(EarningsEvent) = .empty;
|
|
errdefer events.deinit(allocator);
|
|
|
|
var reader = std.Io.Reader.fixed(data);
|
|
const parsed = srf.parse(&reader, allocator, .{ .alloc_strings = false }) catch return error.InvalidData;
|
|
defer parsed.deinit();
|
|
|
|
for (parsed.records.items) |record| {
|
|
var ev = EarningsEvent{
|
|
.symbol = "",
|
|
.date = Date.epoch,
|
|
};
|
|
for (record.fields) |field| {
|
|
if (std.mem.eql(u8, field.key, "date")) {
|
|
if (field.value) |v| {
|
|
const str = switch (v) {
|
|
.string => |s| s,
|
|
else => continue,
|
|
};
|
|
ev.date = Date.parse(str) catch continue;
|
|
}
|
|
} else if (std.mem.eql(u8, field.key, "estimate")) {
|
|
if (field.value) |v| ev.estimate = numVal(v);
|
|
} else if (std.mem.eql(u8, field.key, "actual")) {
|
|
if (field.value) |v| ev.actual = numVal(v);
|
|
} else if (std.mem.eql(u8, field.key, "quarter")) {
|
|
if (field.value) |v| {
|
|
const n = numVal(v);
|
|
if (n >= 1 and n <= 4) ev.quarter = @intFromFloat(n);
|
|
}
|
|
} else if (std.mem.eql(u8, field.key, "fiscal_year")) {
|
|
if (field.value) |v| {
|
|
const n = numVal(v);
|
|
if (n > 1900 and n < 2200) ev.fiscal_year = @intFromFloat(n);
|
|
}
|
|
} else if (std.mem.eql(u8, field.key, "revenue_actual")) {
|
|
if (field.value) |v| ev.revenue_actual = numVal(v);
|
|
} else if (std.mem.eql(u8, field.key, "revenue_estimate")) {
|
|
if (field.value) |v| ev.revenue_estimate = numVal(v);
|
|
} else if (std.mem.eql(u8, field.key, "report_time")) {
|
|
if (field.value) |v| {
|
|
const str = switch (v) {
|
|
.string => |s| s,
|
|
else => continue,
|
|
};
|
|
ev.report_time = parseReportTimeTag(str);
|
|
}
|
|
}
|
|
}
|
|
// Recompute surprise from actual/estimate
|
|
if (ev.actual != null and ev.estimate != null) {
|
|
ev.surprise = ev.actual.? - ev.estimate.?;
|
|
if (ev.estimate.? != 0) {
|
|
ev.surprise_percent = (ev.surprise.? / @abs(ev.estimate.?)) * 100.0;
|
|
}
|
|
}
|
|
try events.append(allocator, ev);
|
|
}
|
|
|
|
return events.toOwnedSlice(allocator);
|
|
}
|
|
|
|
/// Serialize ETF profile to SRF compact format.
|
|
/// Uses multiple record types: meta fields, then sector:: and holding:: prefixed records.
|
|
pub fn serializeEtfProfile(allocator: std.mem.Allocator, profile: EtfProfile) ![]const u8 {
|
|
var buf: std.ArrayList(u8) = .empty;
|
|
errdefer buf.deinit(allocator);
|
|
const writer = buf.writer(allocator);
|
|
|
|
try writer.writeAll("#!srfv1\n");
|
|
|
|
// Meta record
|
|
try writer.writeAll("type::meta");
|
|
if (profile.expense_ratio) |er| try writer.print(",expense_ratio:num:{d}", .{er});
|
|
if (profile.net_assets) |na| try writer.print(",net_assets:num:{d}", .{na});
|
|
if (profile.dividend_yield) |dy| try writer.print(",dividend_yield:num:{d}", .{dy});
|
|
if (profile.portfolio_turnover) |pt| try writer.print(",portfolio_turnover:num:{d}", .{pt});
|
|
if (profile.total_holdings) |th| try writer.print(",total_holdings:num:{d}", .{th});
|
|
if (profile.inception_date) |d| {
|
|
var db: [10]u8 = undefined;
|
|
try writer.print(",inception_date::{s}", .{d.format(&db)});
|
|
}
|
|
if (profile.leveraged) try writer.writeAll(",leveraged::yes");
|
|
try writer.writeAll("\n");
|
|
|
|
// Sector records
|
|
if (profile.sectors) |sectors| {
|
|
for (sectors) |sec| {
|
|
try writer.print("type::sector,name::{s},weight:num:{d}\n", .{ sec.sector, sec.weight });
|
|
}
|
|
}
|
|
|
|
// Holding records
|
|
if (profile.holdings) |holdings| {
|
|
for (holdings) |h| {
|
|
try writer.writeAll("type::holding");
|
|
if (h.symbol) |s| try writer.print(",symbol::{s}", .{s});
|
|
try writer.print(",name::{s},weight:num:{d}\n", .{ h.name, h.weight });
|
|
}
|
|
}
|
|
|
|
return buf.toOwnedSlice(allocator);
|
|
}
|
|
|
|
/// Deserialize ETF profile from SRF data.
|
|
pub fn deserializeEtfProfile(allocator: std.mem.Allocator, data: []const u8) !EtfProfile {
|
|
var reader = std.Io.Reader.fixed(data);
|
|
const parsed = srf.parse(&reader, allocator, .{ .alloc_strings = false }) catch return error.InvalidData;
|
|
defer parsed.deinit();
|
|
|
|
var profile = EtfProfile{ .symbol = "" };
|
|
var sectors: std.ArrayList(SectorWeight) = .empty;
|
|
errdefer sectors.deinit(allocator);
|
|
var holdings: std.ArrayList(Holding) = .empty;
|
|
errdefer holdings.deinit(allocator);
|
|
|
|
for (parsed.records.items) |record| {
|
|
var record_type: []const u8 = "";
|
|
for (record.fields) |field| {
|
|
if (std.mem.eql(u8, field.key, "type")) {
|
|
if (field.value) |v| {
|
|
record_type = switch (v) {
|
|
.string => |s| s,
|
|
else => "",
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
if (std.mem.eql(u8, record_type, "meta")) {
|
|
for (record.fields) |field| {
|
|
if (std.mem.eql(u8, field.key, "expense_ratio")) {
|
|
if (field.value) |v| profile.expense_ratio = numVal(v);
|
|
} else if (std.mem.eql(u8, field.key, "net_assets")) {
|
|
if (field.value) |v| profile.net_assets = numVal(v);
|
|
} else if (std.mem.eql(u8, field.key, "dividend_yield")) {
|
|
if (field.value) |v| profile.dividend_yield = numVal(v);
|
|
} else if (std.mem.eql(u8, field.key, "portfolio_turnover")) {
|
|
if (field.value) |v| profile.portfolio_turnover = numVal(v);
|
|
} else if (std.mem.eql(u8, field.key, "total_holdings")) {
|
|
if (field.value) |v| {
|
|
const n = numVal(v);
|
|
if (n > 0) profile.total_holdings = @intFromFloat(n);
|
|
}
|
|
} else if (std.mem.eql(u8, field.key, "inception_date")) {
|
|
if (field.value) |v| {
|
|
const str = switch (v) {
|
|
.string => |s| s,
|
|
else => continue,
|
|
};
|
|
profile.inception_date = Date.parse(str) catch null;
|
|
}
|
|
} else if (std.mem.eql(u8, field.key, "leveraged")) {
|
|
if (field.value) |v| {
|
|
const str = switch (v) {
|
|
.string => |s| s,
|
|
else => continue,
|
|
};
|
|
profile.leveraged = std.mem.eql(u8, str, "yes");
|
|
}
|
|
}
|
|
}
|
|
} else if (std.mem.eql(u8, record_type, "sector")) {
|
|
var name: ?[]const u8 = null;
|
|
var weight: f64 = 0;
|
|
for (record.fields) |field| {
|
|
if (std.mem.eql(u8, field.key, "name")) {
|
|
if (field.value) |v| name = switch (v) {
|
|
.string => |s| s,
|
|
else => null,
|
|
};
|
|
} else if (std.mem.eql(u8, field.key, "weight")) {
|
|
if (field.value) |v| weight = numVal(v);
|
|
}
|
|
}
|
|
if (name) |n| {
|
|
const duped = try allocator.dupe(u8, n);
|
|
try sectors.append(allocator, .{ .sector = duped, .weight = weight });
|
|
}
|
|
} else if (std.mem.eql(u8, record_type, "holding")) {
|
|
var sym: ?[]const u8 = null;
|
|
var hname: ?[]const u8 = null;
|
|
var weight: f64 = 0;
|
|
for (record.fields) |field| {
|
|
if (std.mem.eql(u8, field.key, "symbol")) {
|
|
if (field.value) |v| sym = switch (v) {
|
|
.string => |s| s,
|
|
else => null,
|
|
};
|
|
} else if (std.mem.eql(u8, field.key, "name")) {
|
|
if (field.value) |v| hname = switch (v) {
|
|
.string => |s| s,
|
|
else => null,
|
|
};
|
|
} else if (std.mem.eql(u8, field.key, "weight")) {
|
|
if (field.value) |v| weight = numVal(v);
|
|
}
|
|
}
|
|
if (hname) |hn| {
|
|
const duped_sym = if (sym) |s| try allocator.dupe(u8, s) else null;
|
|
const duped_name = try allocator.dupe(u8, hn);
|
|
try holdings.append(allocator, .{ .symbol = duped_sym, .name = duped_name, .weight = weight });
|
|
}
|
|
}
|
|
}
|
|
|
|
if (sectors.items.len > 0) {
|
|
profile.sectors = try sectors.toOwnedSlice(allocator);
|
|
} else {
|
|
sectors.deinit(allocator);
|
|
}
|
|
if (holdings.items.len > 0) {
|
|
profile.holdings = try holdings.toOwnedSlice(allocator);
|
|
} else {
|
|
holdings.deinit(allocator);
|
|
}
|
|
|
|
return profile;
|
|
}
|
|
|
|
/// Serialize options chains to SRF compact format.
|
|
pub fn serializeOptions(allocator: std.mem.Allocator, chains: []const OptionsChain) ![]const u8 {
|
|
var buf: std.ArrayList(u8) = .empty;
|
|
errdefer buf.deinit(allocator);
|
|
const w = buf.writer(allocator);
|
|
|
|
try w.writeAll("#!srfv1\n");
|
|
for (chains) |chain| {
|
|
var exp_buf: [10]u8 = undefined;
|
|
try w.print("type::chain,expiration::{s},symbol::{s}", .{
|
|
chain.expiration.format(&exp_buf), chain.underlying_symbol,
|
|
});
|
|
if (chain.underlying_price) |p| try w.print(",price:num:{d}", .{p});
|
|
try w.writeAll("\n");
|
|
|
|
for (chain.calls) |c| {
|
|
var eb: [10]u8 = undefined;
|
|
try w.print("type::call,expiration::{s},strike:num:{d}", .{ chain.expiration.format(&eb), c.strike });
|
|
if (c.bid) |v| try w.print(",bid:num:{d}", .{v});
|
|
if (c.ask) |v| try w.print(",ask:num:{d}", .{v});
|
|
if (c.last_price) |v| try w.print(",last:num:{d}", .{v});
|
|
if (c.volume) |v| try w.print(",volume:num:{d}", .{v});
|
|
if (c.open_interest) |v| try w.print(",oi:num:{d}", .{v});
|
|
if (c.implied_volatility) |v| try w.print(",iv:num:{d}", .{v});
|
|
if (c.delta) |v| try w.print(",delta:num:{d}", .{v});
|
|
if (c.gamma) |v| try w.print(",gamma:num:{d}", .{v});
|
|
if (c.theta) |v| try w.print(",theta:num:{d}", .{v});
|
|
if (c.vega) |v| try w.print(",vega:num:{d}", .{v});
|
|
try w.writeAll("\n");
|
|
}
|
|
|
|
for (chain.puts) |p| {
|
|
var eb: [10]u8 = undefined;
|
|
try w.print("type::put,expiration::{s},strike:num:{d}", .{ chain.expiration.format(&eb), p.strike });
|
|
if (p.bid) |v| try w.print(",bid:num:{d}", .{v});
|
|
if (p.ask) |v| try w.print(",ask:num:{d}", .{v});
|
|
if (p.last_price) |v| try w.print(",last:num:{d}", .{v});
|
|
if (p.volume) |v| try w.print(",volume:num:{d}", .{v});
|
|
if (p.open_interest) |v| try w.print(",oi:num:{d}", .{v});
|
|
if (p.implied_volatility) |v| try w.print(",iv:num:{d}", .{v});
|
|
if (p.delta) |v| try w.print(",delta:num:{d}", .{v});
|
|
if (p.gamma) |v| try w.print(",gamma:num:{d}", .{v});
|
|
if (p.theta) |v| try w.print(",theta:num:{d}", .{v});
|
|
if (p.vega) |v| try w.print(",vega:num:{d}", .{v});
|
|
try w.writeAll("\n");
|
|
}
|
|
}
|
|
|
|
return buf.toOwnedSlice(allocator);
|
|
}
|
|
|
|
/// Deserialize options chains from SRF data.
|
|
pub fn deserializeOptions(allocator: std.mem.Allocator, data: []const u8) ![]OptionsChain {
|
|
var reader = std.Io.Reader.fixed(data);
|
|
const parsed = srf.parse(&reader, allocator, .{ .alloc_strings = false }) catch return error.InvalidData;
|
|
defer parsed.deinit();
|
|
|
|
var chains: std.ArrayList(OptionsChain) = .empty;
|
|
errdefer {
|
|
for (chains.items) |*ch| {
|
|
allocator.free(ch.calls);
|
|
allocator.free(ch.puts);
|
|
}
|
|
chains.deinit(allocator);
|
|
}
|
|
|
|
// First pass: collect chain headers (expirations)
|
|
// Second: collect calls/puts per expiration
|
|
var exp_map = std.StringHashMap(usize).init(allocator);
|
|
defer exp_map.deinit();
|
|
|
|
// Collect all chain records first
|
|
for (parsed.records.items) |record| {
|
|
var rec_type: []const u8 = "";
|
|
var expiration: ?Date = null;
|
|
var exp_str: []const u8 = "";
|
|
var symbol: []const u8 = "";
|
|
var price: ?f64 = null;
|
|
|
|
for (record.fields) |field| {
|
|
if (std.mem.eql(u8, field.key, "type")) {
|
|
if (field.value) |v| rec_type = switch (v) {
|
|
.string => |s| s,
|
|
else => "",
|
|
};
|
|
} else if (std.mem.eql(u8, field.key, "expiration")) {
|
|
if (field.value) |v| {
|
|
exp_str = switch (v) {
|
|
.string => |s| s,
|
|
else => continue,
|
|
};
|
|
expiration = Date.parse(exp_str) catch null;
|
|
}
|
|
} else if (std.mem.eql(u8, field.key, "symbol")) {
|
|
if (field.value) |v| symbol = switch (v) {
|
|
.string => |s| s,
|
|
else => "",
|
|
};
|
|
} else if (std.mem.eql(u8, field.key, "price")) {
|
|
if (field.value) |v| price = numVal(v);
|
|
}
|
|
}
|
|
|
|
if (std.mem.eql(u8, rec_type, "chain")) {
|
|
if (expiration) |exp| {
|
|
const idx = chains.items.len;
|
|
try chains.append(allocator, .{
|
|
.underlying_symbol = try allocator.dupe(u8, symbol),
|
|
.underlying_price = price,
|
|
.expiration = exp,
|
|
.calls = &.{},
|
|
.puts = &.{},
|
|
});
|
|
try exp_map.put(exp_str, idx);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Second pass: collect contracts
|
|
var calls_map = std.AutoHashMap(usize, std.ArrayList(OptionContract)).init(allocator);
|
|
defer {
|
|
var iter = calls_map.valueIterator();
|
|
while (iter.next()) |v| v.deinit(allocator);
|
|
calls_map.deinit();
|
|
}
|
|
var puts_map = std.AutoHashMap(usize, std.ArrayList(OptionContract)).init(allocator);
|
|
defer {
|
|
var iter = puts_map.valueIterator();
|
|
while (iter.next()) |v| v.deinit(allocator);
|
|
puts_map.deinit();
|
|
}
|
|
|
|
for (parsed.records.items) |record| {
|
|
var rec_type: []const u8 = "";
|
|
var exp_str: []const u8 = "";
|
|
var contract = OptionContract{
|
|
.contract_type = .call,
|
|
.strike = 0,
|
|
.expiration = Date.epoch,
|
|
};
|
|
|
|
for (record.fields) |field| {
|
|
if (std.mem.eql(u8, field.key, "type")) {
|
|
if (field.value) |v| rec_type = switch (v) {
|
|
.string => |s| s,
|
|
else => "",
|
|
};
|
|
} else if (std.mem.eql(u8, field.key, "expiration")) {
|
|
if (field.value) |v| {
|
|
exp_str = switch (v) {
|
|
.string => |s| s,
|
|
else => continue,
|
|
};
|
|
contract.expiration = Date.parse(exp_str) catch Date.epoch;
|
|
}
|
|
} else if (std.mem.eql(u8, field.key, "strike")) {
|
|
if (field.value) |v| contract.strike = numVal(v);
|
|
} else if (std.mem.eql(u8, field.key, "bid")) {
|
|
if (field.value) |v| contract.bid = numVal(v);
|
|
} else if (std.mem.eql(u8, field.key, "ask")) {
|
|
if (field.value) |v| contract.ask = numVal(v);
|
|
} else if (std.mem.eql(u8, field.key, "last")) {
|
|
if (field.value) |v| contract.last_price = numVal(v);
|
|
} else if (std.mem.eql(u8, field.key, "volume")) {
|
|
if (field.value) |v| contract.volume = @intFromFloat(numVal(v));
|
|
} else if (std.mem.eql(u8, field.key, "oi")) {
|
|
if (field.value) |v| contract.open_interest = @intFromFloat(numVal(v));
|
|
} else if (std.mem.eql(u8, field.key, "iv")) {
|
|
if (field.value) |v| contract.implied_volatility = numVal(v);
|
|
} else if (std.mem.eql(u8, field.key, "delta")) {
|
|
if (field.value) |v| contract.delta = numVal(v);
|
|
} else if (std.mem.eql(u8, field.key, "gamma")) {
|
|
if (field.value) |v| contract.gamma = numVal(v);
|
|
} else if (std.mem.eql(u8, field.key, "theta")) {
|
|
if (field.value) |v| contract.theta = numVal(v);
|
|
} else if (std.mem.eql(u8, field.key, "vega")) {
|
|
if (field.value) |v| contract.vega = numVal(v);
|
|
}
|
|
}
|
|
|
|
if (std.mem.eql(u8, rec_type, "call")) {
|
|
contract.contract_type = .call;
|
|
if (exp_map.get(exp_str)) |idx| {
|
|
const entry = try calls_map.getOrPut(idx);
|
|
if (!entry.found_existing) entry.value_ptr.* = .empty;
|
|
try entry.value_ptr.append(allocator, contract);
|
|
}
|
|
} else if (std.mem.eql(u8, rec_type, "put")) {
|
|
contract.contract_type = .put;
|
|
if (exp_map.get(exp_str)) |idx| {
|
|
const entry = try puts_map.getOrPut(idx);
|
|
if (!entry.found_existing) entry.value_ptr.* = .empty;
|
|
try entry.value_ptr.append(allocator, contract);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Assign calls/puts to chains
|
|
for (chains.items, 0..) |*chain, idx| {
|
|
if (calls_map.getPtr(idx)) |cl| {
|
|
chain.calls = try cl.toOwnedSlice(allocator);
|
|
}
|
|
if (puts_map.getPtr(idx)) |pl| {
|
|
chain.puts = try pl.toOwnedSlice(allocator);
|
|
}
|
|
}
|
|
|
|
return chains.toOwnedSlice(allocator);
|
|
}
|
|
|
|
fn parseDividendTypeTag(s: []const u8) DividendType {
|
|
if (std.mem.eql(u8, s, "regular")) return .regular;
|
|
if (std.mem.eql(u8, s, "special")) return .special;
|
|
if (std.mem.eql(u8, s, "supplemental")) return .supplemental;
|
|
if (std.mem.eql(u8, s, "irregular")) return .irregular;
|
|
return .unknown;
|
|
}
|
|
|
|
fn parseReportTimeTag(s: []const u8) ReportTime {
|
|
if (std.mem.eql(u8, s, "bmo")) return .bmo;
|
|
if (std.mem.eql(u8, s, "amc")) return .amc;
|
|
if (std.mem.eql(u8, s, "dmh")) return .dmh;
|
|
return .unknown;
|
|
}
|
|
|
|
fn symbolPath(self: *Store, symbol: []const u8, file_name: []const u8) ![]const u8 {
|
|
if (file_name.len == 0) {
|
|
return std.fs.path.join(self.allocator, &.{ self.cache_dir, symbol });
|
|
}
|
|
return std.fs.path.join(self.allocator, &.{ self.cache_dir, symbol, file_name });
|
|
}
|
|
|
|
fn numVal(v: srf.Value) f64 {
|
|
return switch (v) {
|
|
.number => |n| n,
|
|
else => 0,
|
|
};
|
|
}
|
|
};
|
|
|
|
const InvalidData = error{InvalidData};
|
|
|
|
/// Serialize a portfolio (list of lots) to SRF format.
|
|
pub fn serializePortfolio(allocator: std.mem.Allocator, lots: []const Lot) ![]const u8 {
|
|
var buf: std.ArrayList(u8) = .empty;
|
|
errdefer buf.deinit(allocator);
|
|
const writer = buf.writer(allocator);
|
|
|
|
try writer.writeAll("#!srfv1\n");
|
|
for (lots) |lot| {
|
|
var od_buf: [10]u8 = undefined;
|
|
// Write security_type if not stock (stock is the default)
|
|
if (lot.lot_type != .stock) {
|
|
const type_str: []const u8 = switch (lot.lot_type) {
|
|
.option => "option",
|
|
.cd => "cd",
|
|
.cash => "cash",
|
|
.illiquid => "illiquid",
|
|
.watch => "watch",
|
|
.stock => unreachable,
|
|
};
|
|
try writer.print("security_type::{s},", .{type_str});
|
|
}
|
|
// Watch lots only need a symbol
|
|
if (lot.lot_type == .watch) {
|
|
try writer.print("symbol::{s}\n", .{lot.symbol});
|
|
continue;
|
|
}
|
|
try writer.print("symbol::{s}", .{lot.symbol});
|
|
if (lot.ticker) |t| {
|
|
try writer.print(",ticker::{s}", .{t});
|
|
}
|
|
try writer.print(",shares:num:{d},open_date::{s},open_price:num:{d}", .{
|
|
lot.shares, lot.open_date.format(&od_buf), lot.open_price,
|
|
});
|
|
if (lot.close_date) |cd| {
|
|
var cd_buf: [10]u8 = undefined;
|
|
try writer.print(",close_date::{s}", .{cd.format(&cd_buf)});
|
|
}
|
|
if (lot.close_price) |cp| {
|
|
try writer.print(",close_price:num:{d}", .{cp});
|
|
}
|
|
if (lot.note) |n| {
|
|
try writer.print(",note::{s}", .{n});
|
|
}
|
|
if (lot.account) |a| {
|
|
try writer.print(",account::{s}", .{a});
|
|
}
|
|
if (lot.maturity_date) |md| {
|
|
var md_buf: [10]u8 = undefined;
|
|
try writer.print(",maturity_date::{s}", .{md.format(&md_buf)});
|
|
}
|
|
if (lot.rate) |r| {
|
|
try writer.print(",rate:num:{d}", .{r});
|
|
}
|
|
if (lot.drip) {
|
|
try writer.writeAll(",drip::true");
|
|
}
|
|
if (lot.price) |p| {
|
|
try writer.print(",price:num:{d}", .{p});
|
|
}
|
|
if (lot.price_date) |pd| {
|
|
var pd_buf: [10]u8 = undefined;
|
|
try writer.print(",price_date::{s}", .{pd.format(&pd_buf)});
|
|
}
|
|
try writer.writeAll("\n");
|
|
}
|
|
|
|
return buf.toOwnedSlice(allocator);
|
|
}
|
|
|
|
/// Deserialize a portfolio from SRF data. Caller owns the returned Portfolio.
|
|
pub fn deserializePortfolio(allocator: std.mem.Allocator, data: []const u8) !Portfolio {
|
|
const LotType = @import("../models/portfolio.zig").LotType;
|
|
var lots: std.ArrayList(Lot) = .empty;
|
|
errdefer {
|
|
for (lots.items) |lot| {
|
|
allocator.free(lot.symbol);
|
|
if (lot.note) |n| allocator.free(n);
|
|
if (lot.account) |a| allocator.free(a);
|
|
if (lot.ticker) |t| allocator.free(t);
|
|
}
|
|
lots.deinit(allocator);
|
|
}
|
|
|
|
var reader = std.Io.Reader.fixed(data);
|
|
const parsed = srf.parse(&reader, allocator, .{ .alloc_strings = false }) catch return error.InvalidData;
|
|
defer parsed.deinit();
|
|
|
|
for (parsed.records.items) |record| {
|
|
var lot = Lot{
|
|
.symbol = "",
|
|
.shares = 0,
|
|
.open_date = Date.epoch,
|
|
.open_price = 0,
|
|
};
|
|
var sym_raw: ?[]const u8 = null;
|
|
var note_raw: ?[]const u8 = null;
|
|
var account_raw: ?[]const u8 = null;
|
|
var sec_type_raw: ?[]const u8 = null;
|
|
var ticker_raw: ?[]const u8 = null;
|
|
|
|
for (record.fields) |field| {
|
|
if (std.mem.eql(u8, field.key, "symbol")) {
|
|
if (field.value) |v| sym_raw = switch (v) {
|
|
.string => |s| s,
|
|
else => null,
|
|
};
|
|
} else if (std.mem.eql(u8, field.key, "shares")) {
|
|
if (field.value) |v| lot.shares = Store.numVal(v);
|
|
} else if (std.mem.eql(u8, field.key, "open_date")) {
|
|
if (field.value) |v| {
|
|
const str = switch (v) {
|
|
.string => |s| s,
|
|
else => continue,
|
|
};
|
|
lot.open_date = Date.parse(str) catch continue;
|
|
}
|
|
} else if (std.mem.eql(u8, field.key, "open_price")) {
|
|
if (field.value) |v| lot.open_price = Store.numVal(v);
|
|
} else if (std.mem.eql(u8, field.key, "close_date")) {
|
|
if (field.value) |v| {
|
|
const str = switch (v) {
|
|
.string => |s| s,
|
|
else => continue,
|
|
};
|
|
lot.close_date = Date.parse(str) catch null;
|
|
}
|
|
} else if (std.mem.eql(u8, field.key, "close_price")) {
|
|
if (field.value) |v| lot.close_price = Store.numVal(v);
|
|
} else if (std.mem.eql(u8, field.key, "note")) {
|
|
if (field.value) |v| note_raw = switch (v) {
|
|
.string => |s| s,
|
|
else => null,
|
|
};
|
|
} else if (std.mem.eql(u8, field.key, "account")) {
|
|
if (field.value) |v| account_raw = switch (v) {
|
|
.string => |s| s,
|
|
else => null,
|
|
};
|
|
} else if (std.mem.eql(u8, field.key, "security_type")) {
|
|
if (field.value) |v| sec_type_raw = switch (v) {
|
|
.string => |s| s,
|
|
else => null,
|
|
};
|
|
} else if (std.mem.eql(u8, field.key, "maturity_date")) {
|
|
if (field.value) |v| {
|
|
const str = switch (v) {
|
|
.string => |s| s,
|
|
else => continue,
|
|
};
|
|
lot.maturity_date = Date.parse(str) catch null;
|
|
}
|
|
} else if (std.mem.eql(u8, field.key, "rate")) {
|
|
if (field.value) |v| {
|
|
const r = Store.numVal(v);
|
|
if (r > 0) lot.rate = r;
|
|
}
|
|
} else if (std.mem.eql(u8, field.key, "drip")) {
|
|
if (field.value) |v| {
|
|
switch (v) {
|
|
.string => |s| lot.drip = std.mem.eql(u8, s, "true") or std.mem.eql(u8, s, "1"),
|
|
.number => |n| lot.drip = n > 0,
|
|
else => {},
|
|
}
|
|
}
|
|
} else if (std.mem.eql(u8, field.key, "ticker")) {
|
|
if (field.value) |v| ticker_raw = switch (v) {
|
|
.string => |s| s,
|
|
else => null,
|
|
};
|
|
} else if (std.mem.eql(u8, field.key, "price")) {
|
|
if (field.value) |v| {
|
|
const p = Store.numVal(v);
|
|
if (p > 0) lot.price = p;
|
|
}
|
|
} else if (std.mem.eql(u8, field.key, "price_date")) {
|
|
if (field.value) |v| {
|
|
const str = switch (v) {
|
|
.string => |s| s,
|
|
else => continue,
|
|
};
|
|
lot.price_date = Date.parse(str) catch null;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Determine lot type
|
|
if (sec_type_raw) |st| {
|
|
lot.lot_type = LotType.fromString(st);
|
|
}
|
|
|
|
// Cash lots don't require a symbol -- generate a placeholder
|
|
if (lot.lot_type == .cash) {
|
|
if (sym_raw == null) {
|
|
lot.symbol = try allocator.dupe(u8, "CASH");
|
|
} else {
|
|
lot.symbol = try allocator.dupe(u8, sym_raw.?);
|
|
}
|
|
} else if (sym_raw) |s| {
|
|
lot.symbol = try allocator.dupe(u8, s);
|
|
} else continue;
|
|
|
|
if (note_raw) |n| {
|
|
lot.note = try allocator.dupe(u8, n);
|
|
}
|
|
|
|
if (account_raw) |a| {
|
|
lot.account = try allocator.dupe(u8, a);
|
|
}
|
|
|
|
if (ticker_raw) |t| {
|
|
lot.ticker = try allocator.dupe(u8, t);
|
|
}
|
|
|
|
try lots.append(allocator, lot);
|
|
}
|
|
|
|
return .{
|
|
.lots = try lots.toOwnedSlice(allocator),
|
|
.allocator = allocator,
|
|
};
|
|
}
|
|
|
|
test "dividend serialize/deserialize round-trip" {
|
|
const allocator = std.testing.allocator;
|
|
const divs = [_]Dividend{
|
|
.{ .ex_date = Date.fromYmd(2024, 3, 15), .amount = 0.8325, .pay_date = Date.fromYmd(2024, 3, 28), .frequency = 4, .distribution_type = .regular },
|
|
.{ .ex_date = Date.fromYmd(2024, 6, 14), .amount = 0.9148, .distribution_type = .special },
|
|
};
|
|
|
|
const data = try Store.serializeDividends(allocator, &divs);
|
|
defer allocator.free(data);
|
|
|
|
const parsed = try Store.deserializeDividends(allocator, data);
|
|
defer allocator.free(parsed);
|
|
|
|
try std.testing.expectEqual(@as(usize, 2), parsed.len);
|
|
|
|
try std.testing.expect(parsed[0].ex_date.eql(Date.fromYmd(2024, 3, 15)));
|
|
try std.testing.expectApproxEqAbs(@as(f64, 0.8325), parsed[0].amount, 0.0001);
|
|
try std.testing.expect(parsed[0].pay_date != null);
|
|
try std.testing.expect(parsed[0].pay_date.?.eql(Date.fromYmd(2024, 3, 28)));
|
|
try std.testing.expectEqual(@as(?u8, 4), parsed[0].frequency);
|
|
try std.testing.expectEqual(DividendType.regular, parsed[0].distribution_type);
|
|
|
|
try std.testing.expect(parsed[1].ex_date.eql(Date.fromYmd(2024, 6, 14)));
|
|
try std.testing.expectApproxEqAbs(@as(f64, 0.9148), parsed[1].amount, 0.0001);
|
|
try std.testing.expect(parsed[1].pay_date == null);
|
|
try std.testing.expectEqual(DividendType.special, parsed[1].distribution_type);
|
|
}
|
|
|
|
test "split serialize/deserialize round-trip" {
|
|
const allocator = std.testing.allocator;
|
|
const splits = [_]Split{
|
|
.{ .date = Date.fromYmd(2020, 8, 31), .numerator = 4, .denominator = 1 },
|
|
.{ .date = Date.fromYmd(2014, 6, 9), .numerator = 7, .denominator = 1 },
|
|
};
|
|
|
|
const data = try Store.serializeSplits(allocator, &splits);
|
|
defer allocator.free(data);
|
|
|
|
const parsed = try Store.deserializeSplits(allocator, data);
|
|
defer allocator.free(parsed);
|
|
|
|
try std.testing.expectEqual(@as(usize, 2), parsed.len);
|
|
|
|
try std.testing.expect(parsed[0].date.eql(Date.fromYmd(2020, 8, 31)));
|
|
try std.testing.expectApproxEqAbs(@as(f64, 4), parsed[0].numerator, 0.001);
|
|
try std.testing.expectApproxEqAbs(@as(f64, 1), parsed[0].denominator, 0.001);
|
|
|
|
try std.testing.expect(parsed[1].date.eql(Date.fromYmd(2014, 6, 9)));
|
|
try std.testing.expectApproxEqAbs(@as(f64, 7), parsed[1].numerator, 0.001);
|
|
}
|
|
|
|
test "portfolio serialize/deserialize round-trip" {
|
|
const allocator = std.testing.allocator;
|
|
const lots = [_]Lot{
|
|
.{ .symbol = "AMZN", .shares = 10, .open_date = Date.fromYmd(2022, 3, 15), .open_price = 150.25 },
|
|
.{ .symbol = "AMZN", .shares = 5, .open_date = Date.fromYmd(2023, 6, 1), .open_price = 125.00, .close_date = Date.fromYmd(2024, 1, 15), .close_price = 185.50 },
|
|
.{ .symbol = "VTI", .shares = 100, .open_date = Date.fromYmd(2022, 1, 10), .open_price = 220.00 },
|
|
};
|
|
|
|
const data = try serializePortfolio(allocator, &lots);
|
|
defer allocator.free(data);
|
|
|
|
var portfolio = try deserializePortfolio(allocator, data);
|
|
defer portfolio.deinit();
|
|
|
|
try std.testing.expectEqual(@as(usize, 3), portfolio.lots.len);
|
|
|
|
try std.testing.expectEqualStrings("AMZN", portfolio.lots[0].symbol);
|
|
try std.testing.expectApproxEqAbs(@as(f64, 10), portfolio.lots[0].shares, 0.01);
|
|
try std.testing.expect(portfolio.lots[0].isOpen());
|
|
|
|
try std.testing.expectEqualStrings("AMZN", portfolio.lots[1].symbol);
|
|
try std.testing.expectApproxEqAbs(@as(f64, 5), portfolio.lots[1].shares, 0.01);
|
|
try std.testing.expect(!portfolio.lots[1].isOpen());
|
|
try std.testing.expect(portfolio.lots[1].close_date.?.eql(Date.fromYmd(2024, 1, 15)));
|
|
try std.testing.expectApproxEqAbs(@as(f64, 185.50), portfolio.lots[1].close_price.?, 0.01);
|
|
|
|
try std.testing.expectEqualStrings("VTI", portfolio.lots[2].symbol);
|
|
}
|