aiden-shared-calculations-unified 1.0.71 → 1.0.73

package/calculations/behavioural/historical/asset_crowd_flow.js

@@ -102,8 +102,8 @@ class AssetCrowdFlow {
             const yP = yPosMap.get(instrumentId);
             const tP = tPosMap.get(instrumentId);
 
-            const yInvested = yP?.InvestedAmount || yP?.Amount || 0;
-            const tInvested = tP?.InvestedAmount || tP?.Amount || 0;
+            const yInvested = yP?.Invested || 0;
+            const tInvested = tP?.Invested || 0;
 
             if (yInvested > 0) {
                 asset.total_invested_yesterday += yInvested;

package/calculations/behavioural/historical/dumb-cohort-flow.js

@@ -61,7 +61,7 @@ class DumbCohortFlow {
      * Statically declare dependencies.
      */
     static getDependencies() {
-        return ['user_profitability_tracker'];
+        return ['user_profitability_tracker']; 
     }
 
     _getPortfolioPositions(portfolio) {

package/calculations/behavioural/historical/gem_cohort-skill-definition.js

@@ -0,0 +1,109 @@
+/**
+ * @fileoverview Calculation (Pass 1) for defining skill-based cohorts.
+ *
+ * This metric calculates a long-term "Skill Score" for each user based on
+ * their closed trade history (win rate, profit/loss ratio, and trade count).
+ *
+ * To remain compact, it processes all users, ranks them, and returns
+ * only the list of user IDs for the top and bottom 20% cohorts.
+ */
+class CohortSkillDefinition {
+    constructor() {
+        // { userId: { skill_score: 12.3 } }
+        this.userScores = new Map();
+    }
+
+    /**
+     * Defines the output schema for this calculation.
+     * @returns {object} JSON Schema object
+     */
+    static getSchema() {
+        return {
+            "type": "object",
+            "description": "Provides the user ID lists for the 'Skilled' (top 20%) and 'Unskilled' (bottom 20%) cohorts based on historical trade performance.",
+            "properties": {
+                "skilled_user_ids": {
+                    "type": "array",
+                    "description": "List of user IDs in the top 20% 'Skilled' cohort.",
+                    "items": { "type": "string" }
+                },
+                "unskilled_user_ids": {
+                    "type": "array",
+                    "description": "List of user IDs in the bottom 20% 'Unskilled' cohort.",
+                    "items": { "type": "string" }
+                },
+                "skilled_cohort_size": { "type": "number" },
+                "unskilled_cohort_size": { "type": "number" }
+            },
+            "required": ["skilled_user_ids", "unskilled_user_ids", "skilled_cohort_size", "unskilled_cohort_size"]
+        };
+    }
+
+    /**
+     * This is a Pass 1 calculation and has no dependencies.
+     */
+    static getDependencies() {
+        return [];
+    }
+
+    /**
+     * Process data from the 'history' root data source.
+     * @param {object} rootData - The root data object from the runner.
+     * @param {string} userId - The user ID.
+     */
+    process(rootData, userId) {
+        const history = rootData?.history?.all;
+        if (!history) {
+            return; // Skip user if they have no history data
+        }
+
+        const { winRatio, avgProfitPct, avgLossPct, totalTrades } = history;
+
+        if (!totalTrades || totalTrades < 10) {
+            return; // Skip users with too few trades for a reliable score
+        }
+
+        // Calculate Expectancy: (Win % * Avg Win %) - (Loss % * Avg Loss %)
+        const winRate = winRatio / 100.0;
+        const lossRate = 1.0 - winRate;
+        const avgWin = avgProfitPct; // Already in %
+        const avgLoss = Math.abs(avgLossPct); // Already in %
+        
+        // This score is "percentage points gained per trade"
+        const expectancy = (winRate * avgWin) - (lossRate * avgLoss);
+        
+        // Weight by log(trades) to value experience, clamped to avoid log(0)
+        const skillScore = expectancy * Math.log10(Math.max(1, totalTrades));
+
+        if (isFinite(skillScore)) {
+            this.userScores.set(userId, skillScore);
+        }
+    }
+
+    getResult() {
+        const sortedUsers = Array.from(this.userScores.entries())
+            // Sort descending by skill score
+            .sort((a, b) => b[1] - a[1]);
+
+        const cohortSize = Math.floor(sortedUsers.length * 0.20);
+        if (cohortSize === 0) {
+            return { skilled_user_ids: [], unskilled_user_ids: [], skilled_cohort_size: 0, unskilled_cohort_size: 0 };
+        }
+
+        const skilled_user_ids = sortedUsers.slice(0, cohortSize).map(u => u[0]);
+        const unskilled_user_ids = sortedUsers.slice(-cohortSize).map(u => u[0]);
+
+        return {
+            skilled_user_ids: skilled_user_ids,
+            unskilled_user_ids: unskilled_user_ids,
+            skilled_cohort_size: skilled_user_ids.length,
+            unskilled_cohort_size: unskilled_user_ids.length
+        };
+    }
+
+    reset() {
+        this.userScores.clear();
+    }
+}
+
+module.exports = CohortSkillDefinition;

package/calculations/behavioural/historical/gem_skilled-cohort-flow.js

@@ -0,0 +1,226 @@
+/**
+ * @fileoverview Calculation (Pass 2) for "Skilled Cohort" flow.
+ *
+ * This metric calculates the "Net Crowd Flow Percentage" for the
+ * "Skilled Cohort" (top 20% by long-term skill score).
+ *
+ * This calculation *depends* on 'cohort-skill-definition'
+ * to identify the cohort.
+ */
+const { loadInstrumentMappings } = require('../../../utils/sector_mapping_provider');
+
+class SkilledCohortFlow {
+    constructor() {
+        this.assetData = new Map();
+        this.sectorData = new Map();
+        this.mappings = null;
+        this.skilledCohortUserIds = null;
+    }
+
+    /**
+     * Defines the output schema for this calculation.
+     * @returns {object} JSON Schema object
+     */
+    static getSchema() {
+        const flowSchema = {
+            "type": "object",
+            "properties": {
+                "net_flow_percentage": { "type": "number" },
+                "total_invested_today": { "type": "number" },
+                "total_invested_yesterday": { "type": "number" }
+            },
+            "required": ["net_flow_percentage", "total_invested_today", "total_invested_yesterday"]
+        };
+
+        return {
+            "type": "object",
+            "description": "Calculates net capital flow % (price-adjusted) for the 'Skilled Cohort' (top 20% by skill score), aggregated by asset and sector.",
+            "properties": {
+                "cohort_size": {
+                    "type": "number",
+                    "description": "The number of users identified as being in the Skilled Cohort."
+                },
+                "assets": {
+                    "type": "object",
+                    "description": "Price-adjusted net flow per asset.",
+                    "patternProperties": { "^.*$": flowSchema }, // Ticker
+                    "additionalProperties": flowSchema
+                },
+                "sectors": {
+                    "type": "object",
+                    "description": "Price-adjusted net flow per sector.",
+                    "patternProperties": { "^.*$": flowSchema }, // Sector
+                    "additionalProperties": flowSchema
+                }
+            },
+            "required": ["cohort_size", "assets", "sectors"]
+        };
+    }
+
+    /**
+     * Statically declare dependencies.
+     */
+    static getDependencies() {
+        return ['gem_cohort-skill-definition']; // Pass 1
+    }
+
+    _getPortfolioPositions(portfolio) {
+        return portfolio?.PublicPositions || portfolio?.AggregatedPositions;
+    }
+
+    _initAsset(instrumentId) {
+        if (!this.assetData.has(instrumentId)) {
+            this.assetData.set(instrumentId, {
+                total_invested_yesterday: 0,
+                total_invested_today: 0,
+                price_change_yesterday: 0,
+            });
+        }
+    }
+    
+    _initSector(sector) {
+        if (!this.sectorData.has(sector)) {
+            this.sectorData.set(sector, {
+                total_invested_yesterday: 0,
+                total_invested_today: 0,
+                price_change_yesterday: 0,
+            });
+        }
+    }
+
+    _getSkilledCohort(fetchedDependencies) {
+        if (this.skilledCohortUserIds) {
+            return this.skilledCohortUserIds;
+        }
+        
+        const cohortData = fetchedDependencies['cohort-skill-definition'];
+        if (!cohortData || !cohortData.skilled_user_ids) {
+            return new Set();
+        }
+
+        this.skilledCohortUserIds = new Set(cohortData.skilled_user_ids);
+        return this.skilledCohortUserIds;
+    }
+
+    process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, fetchedDependencies) {
+        const skilledCohort = this._getSkilledCohort(fetchedDependencies);
+        
+        if (!skilledCohort.has(userId)) {
+            return; // This user is not in the "skilled cohort", skip.
+        }
+
+        if (!todayPortfolio || !yesterdayPortfolio) {
+            return;
+        }
+
+        // Logic from here is identical to smart-cohort-flow.js
+        const yPos = this._getPortfolioPositions(yesterdayPortfolio);
+        const tPos = this._getPortfolioPositions(todayPortfolio);
+        const yPosMap = new Map(yPos?.map(p => [p.InstrumentID, p]) || []);
+        const tPosMap = new Map(tPos?.map(p => [p.InstrumentID, p]) || []);
+        const allInstrumentIds = new Set([...yPosMap.keys(), ...tPosMap.keys()]);
+        
+        if (!this.mappings) {
+            this.mappings = context.mappings;
+        }
+
+        for (const instrumentId of allInstrumentIds) {
+            if (!instrumentId) continue;
+            
+            this._initAsset(instrumentId);
+            const asset = this.assetData.get(instrumentId);
+            const yP = yPosMap.get(instrumentId);
+            const tP = tPosMap.get(instrumentId);
+            
+            // Use 'Invested' for % portfolio, not 'Amount'
+            const yInvested = yP?.Invested || 0; 
+            const tInvested = tP?.Invested || 0;
+            
+            const sector = this.mappings.instrumentToSector[instrumentId] || 'Other';
+            this._initSector(sector);
+            const sectorAsset = this.sectorData.get(sector);
+
+            if (yInvested > 0) {
+                // Use P&L % from portfolio 'NetProfit'
+                const yPriceChange = (yP?.NetProfit || 0) / (yP?.Invested || 1); 
+                
+                asset.total_invested_yesterday += yInvested;
+                asset.price_change_yesterday += yPriceChange * yInvested;
+                
+                sectorAsset.total_invested_yesterday += yInvested;
+                sectorAsset.price_change_yesterday += yPriceChange * yInvested;
+            }
+            if (tInvested > 0) {
+                asset.total_invested_today += tInvested;
+                sectorAsset.total_invested_today += tInvested;
+            }
+        }
+    }
+    
+    _calculateFlow(dataMap) {
+        const result = {};
+        for (const [key, data] of dataMap.entries()) {
+            const { total_invested_yesterday, total_invested_today, price_change_yesterday } = data;
+            
+            if (total_invested_yesterday > 0) {
+                const avg_price_change_pct = price_change_yesterday / total_invested_yesterday;
+                const price_contribution = total_invested_yesterday * avg_price_change_pct;
+                const flow_contribution = total_invested_today - (total_invested_yesterday + price_contribution);
+                const net_flow_percentage = (flow_contribution / total_invested_yesterday) * 100;
+                
+                result[key] = {
+                    net_flow_percentage: net_flow_percentage,
+                    total_invested_today: total_invested_today,
+                    total_invested_yesterday: total_invested_yesterday
+                };
+            }
+        }
+        return result;
+    }
+
+    async getResult(fetchedDependencies) {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+        
+        const skilledCohort = this._getSkilledCohort(fetchedDependencies);
+
+        // 1. Calculate Asset Flow
+        const assetResult = {};
+        for (const [instrumentId, data] of this.assetData.entries()) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || `id_${instrumentId}`;
+            const { total_invested_yesterday, total_invested_today, price_change_yesterday } = data;
+            
+            if (total_invested_yesterday > 0) {
+                const avg_price_change_pct = price_change_yesterday / total_invested_yesterday;
+                const price_contribution = total_invested_yesterday * avg_price_change_pct;
+                const flow_contribution = total_invested_today - (total_invested_yesterday + price_contribution);
+                const net_flow_percentage = (flow_contribution / total_invested_yesterday) * 100;
+                
+                assetResult[ticker] = {
+                    net_flow_percentage: net_flow_percentage,
+                    total_invested_today: total_invested_today,
+                    total_invested_yesterday: total_invested_yesterday
+                };
+            }
+        }
+        
+        // 2. Calculate Sector Flow
+        const sectorResult = this._calculateFlow(this.sectorData);
+
+        return {
+            cohort_size: skilledCohort.size,
+            assets: assetResult,
+            sectors: sectorResult
+        };
+    }
+
+    reset() {
+        this.assetData.clear();
+        this.sectorData.clear();
+        this.mappings = null;
+        this.skilledCohortUserIds = null;
+    }
+}
+
+module.exports = SkilledCohortFlow;

package/calculations/behavioural/historical/gem_unskilled-cohort-flow.js

@@ -0,0 +1,225 @@
+/**
+ * @fileoverview Calculation (Pass 2) for "Unskilled Cohort" flow.
+ *
+ * This metric calculates the "Net Crowd Flow Percentage" for the
+ * "Unskilled Cohort" (bottom 20% by long-term skill score).
+ *
+ * This calculation *depends* on 'cohort-skill-definition'
+ * to identify the cohort.
+ */
+const { loadInstrumentMappings } = require('../../../utils/sector_mapping_provider');
+
+class UnskilledCohortFlow {
+    constructor() {
+        this.assetData = new Map();
+        this.sectorData = new Map();
+        this.mappings = null;
+        this.unskilledCohortUserIds = null;
+    }
+
+    /**
+     * Defines the output schema for this calculation.
+     * @returns {object} JSON Schema object
+     */
+    static getSchema() {
+        const flowSchema = {
+            "type": "object",
+            "properties": {
+                "net_flow_percentage": { "type": "number" },
+                "total_invested_today": { "type": "number" },
+                "total_invested_yesterday": { "type": "number" }
+            },
+            "required": ["net_flow_percentage", "total_invested_today", "total_invested_yesterday"]
+        };
+
+        return {
+            "type": "object",
+            "description": "Calculates net capital flow % (price-adjusted) for the 'Unskilled Cohort' (bottom 20% by skill score), aggregated by asset and sector.",
+            "properties": {
+                "cohort_size": {
+                    "type": "number",
+                    "description": "The number of users identified as being in the Unskilled Cohort."
+                },
+                "assets": {
+                    "type": "object",
+                    "description": "Price-adjusted net flow per asset.",
+                    "patternProperties": { "^.*$": flowSchema }, // Ticker
+                    "additionalProperties": flowSchema
+                },
+                "sectors": {
+                    "type": "object",
+                    "description": "Price-adjusted net flow per sector.",
+                    "patternProperties": { "^.*$": flowSchema }, // Sector
+                    "additionalProperties": flowSchema
+                }
+            },
+            "required": ["cohort_size", "assets", "sectors"]
+        };
+    }
+
+    /**
+     * Statically declare dependencies.
+     */
+    static getDependencies() {
+        return ['gem_cohort-skill-definition']; // Pass 1
+    }
+
+    _getPortfolioPositions(portfolio) {
+        return portfolio?.PublicPositions || portfolio?.AggregatedPositions;
+    }
+
+    _initAsset(instrumentId) {
+        if (!this.assetData.has(instrumentId)) {
+            this.assetData.set(instrumentId, {
+                total_invested_yesterday: 0,
+                total_invested_today: 0,
+                price_change_yesterday: 0,
+            });
+        }
+    }
+    
+    _initSector(sector) {
+        if (!this.sectorData.has(sector)) {
+            this.sectorData.set(sector, {
+                total_invested_yesterday: 0,
+                total_invested_today: 0,
+                price_change_yesterday: 0,
+            });
+        }
+    }
+
+    _getUnskilledCohort(fetchedDependencies) {
+        if (this.unskilledCohortUserIds) {
+            return this.unskilledCohortUserIds;
+        }
+        
+        const cohortData = fetchedDependencies['cohort-skill-definition'];
+        if (!cohortData || !cohortData.unskilled_user_ids) {
+            return new Set();
+        }
+
+        this.unskilledCohortUserIds = new Set(cohortData.unskilled_user_ids);
+        return this.unskilledCohortUserIds;
+    }
+
+    process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, fetchedDependencies) {
+        const unskilledCohort = this._getUnskilledCohort(fetchedDependencies);
+        
+        if (!unskilledCohort.has(userId)) {
+            return; // This user is not in the "unskilled cohort", skip.
+        }
+
+        if (!todayPortfolio || !yesterdayPortfolio) {
+            return;
+        }
+
+        // Logic from here is identical to smart-cohort-flow.js
+        const yPos = this._getPortfolioPositions(yesterdayPortfolio);
+        const tPos = this._getPortfolioPositions(todayPortfolio);
+        const yPosMap = new Map(yPos?.map(p => [p.InstrumentID, p]) || []);
+        const tPosMap = new Map(tPos?.map(p => [p.InstrumentID, p]) || []);
+        const allInstrumentIds = new Set([...yPosMap.keys(), ...tPosMap.keys()]);
+        
+        if (!this.mappings) {
+            this.mappings = context.mappings;
+        }
+
+        for (const instrumentId of allInstrumentIds) {
+            if (!instrumentId) continue;
+            
+            this._initAsset(instrumentId);
+            const asset = this.assetData.get(instrumentId);
+            const yP = yPosMap.get(instrumentId);
+            const tP = tPosMap.get(instrumentId);
+            
+            const yInvested = yP?.Invested || 0; 
+            const tInvested = tP?.Invested || 0;
+            
+            const sector = this.mappings.instrumentToSector[instrumentId] || 'Other';
+            this._initSector(sector);
+            const sectorAsset = this.sectorData.get(sector);
+
+            if (yInvested > 0) {
+                const yPriceChange = (yP?.NetProfit || 0) / (yP?.Invested || 1); 
+                
+                asset.total_invested_yesterday += yInvested;
+                asset.price_change_yesterday += yPriceChange * yInvested;
+                
+                sectorAsset.total_invested_yesterday += yInvested;
+                sectorAsset.price_change_yesterday += yPriceChange * yInvested;
+            }
+            if (tInvested > 0) {
+                asset.total_invested_today += tInvested;
+                sectorAsset.total_invested_today += tInvested;
+            }
+        }
+    }
+    
+    _calculateFlow(dataMap) {
+        // This helper is identical to the one in skilled-cohort-flow
+        const result = {};
+        for (const [key, data] of dataMap.entries()) {
+            const { total_invested_yesterday, total_invested_today, price_change_yesterday } = data;
+            
+            if (total_invested_yesterday > 0) {
+                const avg_price_change_pct = price_change_yesterday / total_invested_yesterday;
+                const price_contribution = total_invested_yesterday * avg_price_change_pct;
+                const flow_contribution = total_invested_today - (total_invested_yesterday + price_contribution);
+                const net_flow_percentage = (flow_contribution / total_invested_yesterday) * 100;
+                
+                result[key] = {
+                    net_flow_percentage: net_flow_percentage,
+                    total_invested_today: total_invested_today,
+                    total_invested_yesterday: total_invested_yesterday
+                };
+            }
+        }
+        return result;
+    }
+
+    async getResult(fetchedDependencies) {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+        
+        const unskilledCohort = this._getUnskilledCohort(fetchedDependencies);
+
+        // 1. Calculate Asset Flow
+        const assetResult = {};
+        for (const [instrumentId, data] of this.assetData.entries()) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || `id_${instrumentId}`;
+            const { total_invested_yesterday, total_invested_today, price_change_yesterday } = data;
+            
+            if (total_invested_yesterday > 0) {
+                const avg_price_change_pct = price_change_yesterday / total_invested_yesterday;
+                const price_contribution = total_invested_yesterday * avg_price_change_pct;
+                const flow_contribution = total_invested_today - (total_invested_yesterday + price_contribution);
+                const net_flow_percentage = (flow_contribution / total_invested_yesterday) * 100;
+                
+                assetResult[ticker] = {
+                    net_flow_percentage: net_flow_percentage,
+                    total_invested_today: total_invested_today,
+                    total_invested_yesterday: total_invested_yesterday
+                };
+            }
+        }
+        
+        // 2. Calculate Sector Flow
+        const sectorResult = this._calculateFlow(this.sectorData);
+
+        return {
+            cohort_size: unskilledCohort.size,
+            assets: assetResult,
+            sectors: sectorResult
+        };
+    }
+
+    reset() {
+        this.assetData.clear();
+        this.sectorData.clear();
+        this.mappings = null;
+        this.unskilledCohortUserIds = null;
+    }
+}
+
+module.exports = UnskilledCohortFlow;

package/calculations/insights/daily_ownership_per_sector.js

@@ -54,7 +54,7 @@ class DailyOwnershipPerSector {
         // 2. Get the insights document
         const insightsDoc = rootData.insights;
         if (!insightsDoc || !Array.isArray(insightsDoc.insights)) {
-            dependencies.logger.log('WARN', `[daily-ownership-per-sector] No 'insights' data found for ${dateStr}.`);
+            // dependencies.logger.log('WARN', `[daily-ownership-per-sector] No 'insights' data found for ${dateStr}.`); TODO : This is broken, returns log undefined 
             return {};
         }
 

package/calculations/meta/crowd_sharpe_ratio_proxy.js

@@ -6,14 +6,19 @@
  *
  * It uses the distribution of P&L from 'pnl_distribution_per_stock'
  * to calculate variance (risk).
+ *
+ * --- FIX: 2025-11-12 ---
+ * Refactored this file to be a "meta" calculation.
+ * 1. Removed constructor, getResult, reset, and the no-op 'process'.
+ * 2. Added the required `async process(dStr, deps, config, fetchedDeps)` method.
+ * 3. Moved all logic into `process`.
+ * 4. Updated logic to read from `fetchedDeps['pnl_distribution_per_stock']`.
+ * 5. Updated data access to read from the new `data.stats` object
+ * provided by the fixed dependency.
  */
 const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
 
 class CrowdSharpeRatioProxy {
-    constructor() {
-        this.mappings = null;
-    }
-
     /**
      * Defines the output schema for this calculation.
      * @returns {object} JSON Schema object
@@ -54,25 +59,36 @@ class CrowdSharpeRatioProxy {
         ];
     }
 
-    process() {
-        // No-op
-    }
-
-    async getResult(fetchedDependencies) {
+    /**
+     * --- FIX: This is the new main execution method for meta-calcs ---
+     * It receives all dependencies from the orchestrator.
+     */
+    async process(dateStr, dependencies, config, fetchedDependencies) {
+        // --- FIX: Load dependency data from the argument ---
         const pnlDistData = fetchedDependencies['pnl_distribution_per_stock'];
         
         if (!pnlDistData) {
+            dependencies.logger.log('WARN', `[crowd_sharpe_ratio_proxy] Missing dependency 'pnl_distribution_per_stock' for ${dateStr}. Skipping.`);
             return {};
         }
         
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
+        // --- FIX: Load mappings inside the process method ---
+        const mappings = await loadInstrumentMappings();
+        if (!mappings || !mappings.instrumentToTicker) {
+            dependencies.logger.log('ERROR', `[crowd_sharpe_ratio_proxy] Failed to load instrument mappings.`);
+            return {};
         }
 
         const result = {};
 
-        for (const [instrumentId, data] of Object.entries(pnlDistData)) {
-            const { sum, sumSq, count } = data;
+        for (const [ticker, data] of Object.entries(pnlDistData)) {
+            
+            // --- FIX: Read from the new 'stats' sub-object ---
+            if (!data.stats) {
+                continue; // Skip if data is malformed
+            }
+            
+            const { sum, sumSq, count } = data.stats;
             
             if (count < 2) {
                 continue; // Need at least 2 data points for variance
@@ -102,7 +118,8 @@ class CrowdSharpeRatioProxy {
             // Sharpe = Mean(Return) / StdDev(Return)
             const sharpeProxy = mean / stdDev;
             
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || `id_${instrumentId}`;
+            // --- FIX: Data is already keyed by ticker, no mapping needed ---
+            // const ticker = this.mappings.instrumentToTicker[instrumentId] || `id_${instrumentId}`;
 
             result[ticker] = {
                 sharpe_ratio_proxy: sharpeProxy,
@@ -115,10 +132,6 @@ class CrowdSharpeRatioProxy {
         
         return result;
     }
-
-    reset() {
-        this.mappings = null;
-    }
 }
 
 module.exports = CrowdSharpeRatioProxy;