bulltrackers-module 1.0.766 → 1.0.769

package/functions/computation-system-v2/legacy/PiSimilarityVector.js

@@ -0,0 +1,71 @@
+/**
+ * @fileoverview Similarity Vector for Popular Investors.
+ * Generates a normalized asset allocation vector.
+ */
+
+class PiSimilarityVector {
+    constructor() {
+        this.results = {}; 
+    }
+
+    static getMetadata() {
+        return {
+            type: 'standard', // MUST be 'standard'
+            category: 'popular_investor',
+            rootDataDependencies: ['portfolio'],
+            userType: 'POPULAR_INVESTOR'
+        };
+    }
+
+    static getDependencies() { return []; } 
+
+    static getSchema() {
+        return {
+            type: 'object',
+            patternProperties: {
+                "^[0-9]+$": { type: 'number' } // InstrumentID -> Weight
+            },
+            description: 'Normalized Asset Allocation Vector'
+        };
+    }
+
+    process(context) {
+        const { DataExtractor } = context.math;
+        const userId = context.user.id;
+        const portfolio = context.user.portfolio.today;
+
+        if (!portfolio) {
+            this.results[userId] = {};
+            return;
+        }
+
+        const positions = DataExtractor.getPositions(portfolio, 'POPULAR_INVESTOR');
+        const vector = {};
+        let totalValue = 0;
+        
+        for (const pos of positions) {
+            const id = DataExtractor.getInstrumentId(pos);
+            const weight = DataExtractor.getPositionWeight(pos);
+            
+            if (id && weight > 0) {
+                vector[id] = (vector[id] || 0) + weight;
+                totalValue += weight;
+            }
+        }
+
+        // Normalize
+        if (totalValue > 0) {
+            for (const key in vector) {
+                vector[key] = Number((vector[key] / totalValue).toFixed(6));
+            }
+        }
+
+        this.results[userId] = vector;
+    }
+
+    async getResult() {
+        return this.results;
+    }
+}
+
+module.exports = PiSimilarityVector;

package/functions/computation-system-v2/scripts/debug_aggregation.js

@@ -0,0 +1,25 @@
+const { BigQuery } = require('@google-cloud/bigquery');
+const config = require('../config/bulltrackers.config');
+
+async function checkAggregation() {
+    const bq = new BigQuery({ projectId: config.bigquery.projectId });
+    const date = '2026-01-30';
+
+    console.log(`Checking Aggregation on ${date}`);
+
+    const query = `
+        SELECT user_type, COUNT(*) as count 
+        FROM \`${config.bigquery.projectId}.${config.bigquery.dataset}.portfolio_snapshots\` 
+        WHERE date = @date 
+        GROUP BY 1
+    `;
+
+    const [rows] = await bq.query({
+        query,
+        params: { date }
+    });
+
+    console.log('Result:', rows);
+}
+
+checkAggregation().catch(console.error);

package/functions/computation-system-v2/scripts/test-computation-dag.js

@@ -0,0 +1,109 @@
+/**
+ * @fileoverview Test Computation DAG CLI
+ * Usage: node scripts/test-computation-dag.js <ComputationName> [Date]
+ * Example: node scripts/test-computation-dag.js UserPortfolioSummary
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { IntegrationTester } = require('../framework/testing/ComputationTester');
+const config = require('../config/bulltrackers.config');
+
+// Setup logging
+const logger = {
+    log: (level, msg) => console.log(`[${new Date().toISOString()}] ${level}: ${msg}`),
+    error: (msg) => console.error(`[ERROR] ${msg}`)
+};
+
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.length < 1) {
+        console.log('Usage: node scripts/test-computation-dag.js <ComputationName> [YYYY-MM-DD]');
+        process.exit(1);
+    }
+
+    const targetName = args[0];
+    let dateStr = args[1]; // Optional
+
+    try {
+        console.log('┌────────────────────────────────────────────────────────┐');
+        console.log('│             COMPUTATION INTEGRATION TEST               │');
+        console.log('└────────────────────────────────────────────────────────┘');
+        console.log(`Target: ${targetName}`);
+        console.log(`Mode:   DAG Integration (Production Read / Test Write)`);
+        
+        const tester = new IntegrationTester(config, logger);
+
+        // 1. Setup & Resolve Chain
+        await tester.setupForComputation(targetName);
+
+        // 2. Find Date if not provided
+        if (!dateStr) {
+            console.log('\n🔍 Auto-detecting latest runnable date...');
+            dateStr = await tester.findLatestRunnableDate(targetName);
+        }
+
+        // 3. Execute
+        console.log(`\n🚀 Executing chain on ${dateStr}...`);
+        const output = await tester.run(targetName, dateStr);
+
+        // 4. Report
+        const { summary, result } = output;
+        
+        console.log('\n┌────────────────────────────────────────────────────────┐');
+        console.log('│                     TEST RESULTS                       │');
+        console.log('└────────────────────────────────────────────────────────┘');
+        
+        if (summary.summary.errors > 0) {
+            console.log('❌ Execution FAILED');
+            summary.errors.forEach(e => console.log(`   - ${e.name}: ${e.error}`));
+        } else {
+            console.log('✅ Execution SUCCESS');
+
+            // SQL computations: result is { _sqlOutput, outputTable, rowCount, rows }
+            if (result && result._sqlOutput) {
+                console.log(`\n📊 SQL output table: \`${config.bigquery.dataset}.${result.outputTable}\``);
+                console.log(`   - Rows for ${dateStr}: ${result.rowCount}`);
+                if (result._error) {
+                    console.log(`   - ⚠️ Read error: ${result._error}`);
+                } else if (result.rowCount > 0) {
+                    const sample = result.rows[0];
+                    console.log(`   - Sample row: ${JSON.stringify(sample).substring(0, 120)}...`);
+                    const filename = `test-results-${targetName}-${dateStr}.json`;
+                    const outputPath = path.join(__dirname, '..', filename);
+                    fs.writeFileSync(outputPath, JSON.stringify(result.rows, null, 2));
+                    console.log(`\n💾 Full rows saved to: ${outputPath}`);
+                } else {
+                    console.log('   - No rows for this date. Check source table has data: portfolio_snapshots for this date.');
+                }
+                console.log(`\nQuery in BQ: SELECT * FROM \`${config.bigquery.projectId}.${config.bigquery.dataset}.${result.outputTable}\` WHERE date = '${dateStr}'`);
+            } else if (result) {
+                // Non-SQL: result from computation_results_test
+                const resultKeys = Object.keys(result);
+                const sampleKey = resultKeys[0];
+                const sampleData = resultKeys.length > 0 ? result[sampleKey] : null;
+
+                console.log(`\n📊 Result Summary for ${targetName}:`);
+                console.log(`   - Count: ${resultKeys.length} entities/records`);
+                console.log(`   - Sample ID: ${sampleKey || 'N/A'}`);
+                if (sampleData) {
+                    console.log(`   - Sample Data Preview: ${JSON.stringify(sampleData).substring(0, 100)}...`);
+                }
+                const filename = `test-results-${targetName}-${dateStr}.json`;
+                const outputPath = path.join(__dirname, '..', filename);
+                fs.writeFileSync(outputPath, JSON.stringify(result, null, 2));
+                console.log(`\n💾 Full results saved to: ${outputPath}`);
+                console.log(`Query results in BQ: SELECT * FROM \`${config.bigquery.dataset}.computation_results_test\` WHERE computation_name = '${targetName}' AND date = '${dateStr}'`);
+            } else {
+                console.log('⚠️  No results produced (Computation returned empty set).');
+            }
+        }
+
+    } catch (e) {
+        console.error('\n❌ FATAL ERROR:');
+        console.error(e);
+        process.exit(1);
+    }
+}
+
+main();

package/functions/computation-system-v2/scripts/test-invalidation-scenarios.js

@@ -0,0 +1,234 @@
+/**
+ * @fileoverview Real-World Invalidation Simulator
+ * Dynamically loads ALL computation AND rule code to verify:
+ * 1. Code Hash Generation (using real files).
+ * 2. Invalidation logic (Simulated DB vs Real Disk Hash).
+ * 3. Dependency chains (Dynamic discovery of chains).
+ * * Usage: node scripts/test-real-scenarios.js
+ */
+
+const fs = require('fs');
+const path = require('path');
+const assert = require('assert');
+
+// Framework Components
+const { RunAnalyzer } = require('../framework/core/RunAnalyzer');
+const { Orchestrator } = require('../framework/execution/Orchestrator');
+const { ManifestBuilder } = require('../framework/core/Manifest');
+
+// -----------------------------------------------------------------------------
+// 1. MOCKS (Virtual Environment)
+// -----------------------------------------------------------------------------
+
+class MockDataFetcher {
+    async checkAvailability() { return { canRun: true, missing: [] }; }
+}
+
+class MockStateRepository {
+    constructor() {
+        this.statusMap = new Map();
+        this.results = new Map();
+    }
+
+    setDailyStatus(date, compName, status) {
+        if (!this.statusMap.has(date)) this.statusMap.set(date, new Map());
+        this.statusMap.get(date).set(compName.toLowerCase(), status);
+    }
+
+    async getDailyStatus(date) {
+        return this.statusMap.get(date) || new Map();
+    }
+    
+    // Simulate finding history for backfills
+    async getRunDates(compName) { return ['2024-01-01', '2024-01-02']; }
+
+    // Mock Result fetching
+    async getResult(date, compName) { return this.results.get(`${date}:${compName}`); }
+}
+
+class TestOrchestrator extends Orchestrator {
+    constructor(config, stateRepo) {
+        super(config);
+        this.stateRepository = stateRepo;
+        this.scheduledTasks = [];
+    }
+    async _scheduleCloudTask(name, date, source, delay) {
+        this.scheduledTasks.push({ name, date, source });
+    }
+    _log(level, msg) { /* console.log(`[${level}] ${msg}`); */ }
+}
+
+// -----------------------------------------------------------------------------
+// 2. HELPER: Dynamic Loader
+// -----------------------------------------------------------------------------
+function loadModulesFromDir(directory, label) {
+    let modules = [];
+    try {
+        if (fs.existsSync(directory)) {
+            const files = fs.readdirSync(directory).filter(f => f.endsWith('.js') && f !== 'index.js');
+            console.log(`INFO: Found ${files.length} ${label} files in ${directory}`);
+            
+            modules = files.map(file => {
+                try {
+                    return require(path.join(directory, file));
+                } catch (e) {
+                    console.warn(`WARN: Failed to load ${file}: ${e.message}`);
+                    return null;
+                }
+            }).filter(c => c !== null);
+        } else {
+            console.warn(`WARN: ${label} directory not found at ${directory}`);
+        }
+    } catch (e) {
+        console.error(`ERROR: Could not load ${label}: ${e.message}`);
+    }
+    return modules;
+}
+
+// -----------------------------------------------------------------------------
+// 3. TEST SUITE
+// -----------------------------------------------------------------------------
+
+async function runRealWorldTests() {
+    console.log('┌────────────────────────────────────────────────────────┐');
+    console.log('│           REAL CODE SIMULATION SUITE                   │');
+    console.log('└────────────────────────────────────────────────────────┘');
+
+    // 1. LOAD ARTIFACTS
+    const computationsDir = path.join(__dirname, '../computations');
+    const rulesDir = path.join(__dirname, '../rules');
+
+    const computationClasses = loadModulesFromDir(computationsDir, 'computation');
+    const ruleModules = loadModulesFromDir(rulesDir, 'rule'); // <--- NEW: Load Rules
+
+    if (computationClasses.length === 0) {
+        console.error("❌ ABORT: No valid computations found to test.");
+        return;
+    }
+
+    // 2. BUILD REAL MANIFEST
+    const config = {
+        computations: computationClasses,
+        rules: ruleModules // <--- NEW: Pass Rules to Config
+    };
+    
+    // Initialize ManifestBuilder (this internally initializes RulesRegistry too)
+    const builder = new ManifestBuilder(config, console);
+    const realManifest = builder.build(config.computations);
+    
+    console.log(`INFO: Successfully built manifest with ${realManifest.length} entries.`);
+
+    // 3. RUN TESTS
+    await test_RealCodeInvalidation(realManifest);
+    await test_DynamicDependencyCascading(realManifest, config);
+}
+
+/**
+ * SCENARIO 1: Simulate a Deployment (Code Change)
+ */
+async function test_RealCodeInvalidation(manifest) {
+    // Pick 'RiskScoreIncrease' if available, otherwise the first one
+    let target = manifest.find(c => c.name === 'riskscoreincrease');
+    if (!target) target = manifest[0];
+
+    console.log(`\n🧪 Test 1: Real Code Hash Mismatch (${target.originalName})`);
+
+    const analyzer = new RunAnalyzer(manifest, new MockDataFetcher());
+    const date = '2024-06-01';
+    
+    // CONDITION: The DB has an old/different hash
+    const dailyStatus = new Map();
+    dailyStatus.set(target.name, { 
+        hash: 'OLD_DEPLOYMENT_HASH_123', 
+        resultHash: 'res_v1', 
+        updatedAt: new Date().toISOString() 
+    });
+
+    // ANALYZE
+    const result = await analyzer._evaluateEntry(target, date, true, dailyStatus, new Map());
+
+    // ASSERT
+    try {
+        assert.strictEqual(result.type, 'reRuns', 'Should trigger re-run');
+        assert.strictEqual(result.payload.reason, 'Code changed', 'Reason must be code change');
+        
+        console.log(`   [Current Disk Hash]: ${target.hash.substring(0, 16)}...`);
+        console.log(`   [Simulated DB Hash]: OLD_DEPLOYMENT_HASH_123`);
+        console.log('✅ PASS: System correctly detected the code mismatch.');
+    } catch (e) {
+        console.error('❌ FAIL:', e.message);
+        console.log('   Decision:', result);
+    }
+}
+
+/**
+ * SCENARIO 2: Dynamic Dependency Propagation
+ */
+async function test_DynamicDependencyCascading(manifest, config) {
+    console.log('\n🧪 Test 2: Dependency Propagation (Dynamic Chain Detection)');
+
+    // 1. Find a valid dependency chain (Parent -> Child)
+    let upstream = null;
+    let downstream = null;
+
+    for (const child of manifest) {
+        if (child.dependencies && child.dependencies.length > 0) {
+            // Find the parent object
+            const parentName = child.dependencies[0]; // normalized name usually
+            const parent = manifest.find(c => c.name === parentName); // match normalized names
+            
+            if (parent) {
+                upstream = parent;
+                downstream = child;
+                break; // Found a pair!
+            }
+        }
+    }
+
+    // 2. Handle Case: No Chains Found
+    if (!upstream || !downstream) {
+        console.log('⚠️  SKIPPED: No valid dependency chains found in the loaded computations.');
+        console.log('   (This is NOT a failure. It simply means all loaded computations are independent)');
+        console.log('✅ PASS: Skipped due to lack of testable chains.');
+        return;
+    }
+
+    console.log(`   Found chain: ${upstream.originalName} -> ${downstream.originalName}`);
+
+    // 3. Setup Orchestrator
+    const mockState = new MockStateRepository();
+    const orch = new TestOrchestrator({ ...config, bigquery: {}, tables: {} }, mockState);
+    orch.manifest = manifest;
+    orch._buildDependentsIndex();
+
+    const date = '2024-06-01';
+
+    // 4. Simulate Upstream Finishing
+    mockState.setDailyStatus(date, upstream.name, {
+        hash: upstream.hash,
+        resultHash: 'NEW_RESULT_HASH_XYZ',
+        updatedAt: new Date().toISOString()
+    });
+
+    // 5. Trigger Cascading Logic
+    await orch._scheduleDependents(upstream, date);
+
+    // 6. Assert
+    try {
+        const task = orch.scheduledTasks.find(t => t.name === downstream.originalName);
+        if (task) {
+             console.log(`   [Triggered]: ${task.name} due to update in ${upstream.name}`);
+             console.log('✅ PASS: Dependency chain resolved and task scheduled.');
+        } else {
+             console.error(`❌ FAIL: Downstream task (${downstream.name}) was NOT scheduled.`);
+             console.log('   Dependents Map keys:', Array.from(orch.dependentsByName.keys()));
+        }
+    } catch (e) {
+        console.error('❌ FAIL:', e.message);
+    }
+}
+
+// EXECUTE
+runRealWorldTests().catch(e => {
+    console.error('FATAL:', e);
+});

package/functions/task-engine/helpers/data_storage_helpers.js

@@ -43,7 +43,7 @@ async function storeSignedInUserPortfolio({ db, logger, collectionRegistry, cid,
                 date: date,
                 user_id: Number(cid),
                 user_type: 'SIGNED_IN_USER',
-                portfolio_data: JSON.stringify(portfolioData), // BigQuery JSON type requires a string
+                portfolio_data: portfolioData,
                 fetched_at: new Date().toISOString()
             };
             
@@ -103,7 +103,7 @@ async function storeSignedInUserTradeHistory({ db, logger, collectionRegistry, c
                 date: date,
                 user_id: Number(cid),
                 user_type: 'SIGNED_IN_USER',
-                history_data: JSON.stringify(historyData), // BigQuery JSON type requires a string
+                history_data: historyData,
                 fetched_at: new Date().toISOString()
             };
             
@@ -172,7 +172,7 @@ async function storeSignedInUserSocialPosts({ db, logger, collectionRegistry, ci
                 date: date,
                 user_id: Number(cid),
                 user_type: 'SIGNED_IN_USER',
-                posts_data: JSON.stringify({ posts: postsMap, postCount: posts.length }), // BigQuery JSON type requires a string
+                posts_data: { posts: postsMap, postCount: posts.length },
                 fetched_at: new Date().toISOString()
             };
             
@@ -257,7 +257,7 @@ async function storePopularInvestorPortfolio({ db, logger, collectionRegistry, c
                 date: date,
                 user_id: Number(cid),
                 user_type: 'POPULAR_INVESTOR',
-                portfolio_data: JSON.stringify(portfolioDoc), // BigQuery JSON type requires a string
+                portfolio_data: portfolioDoc,
                 fetched_at: new Date().toISOString()
             };
             
@@ -316,7 +316,7 @@ async function storePopularInvestorTradeHistory({ db, logger, collectionRegistry
                 date: date,
                 user_id: Number(cid),
                 user_type: 'POPULAR_INVESTOR',
-                history_data: JSON.stringify(historyData), // BigQuery JSON type requires a string
+                history_data: historyData,
                 fetched_at: new Date().toISOString()
             };
             
@@ -383,7 +383,7 @@ async function storePopularInvestorSocialPosts({ db, logger, collectionRegistry,
                 date: date,
                 user_id: Number(cid),
                 user_type: 'POPULAR_INVESTOR',
-                posts_data: JSON.stringify({ posts: postsMap, postCount: posts.length }), // BigQuery JSON type requires a string
+                posts_data: { posts: postsMap, postCount: posts.length },
                 fetched_at: new Date().toISOString()
             };
             

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulltrackers-module",
-  "version": "1.0.766",
+  "version": "1.0.769",
   "description": "Helper Functions for Bulltrackers.",
   "main": "index.js",
   "files": [

package/functions/computation-system-v2/computations/PopularInvestorRiskAssessment.js

@@ -1,176 +0,0 @@
-/**
- * @fileoverview Popular Investor Risk Assessment - v2
- * 
- * This computation DEPENDS on PopularInvestorProfileMetrics.
- * It uses the profile metrics to calculate additional risk assessments.
- * 
- * This tests:
- * 1. Dependency declaration works
- * 2. Pass assignment is incremented (should be Pass 2)
- * 3. Dependency data is loaded and passed to process()
- */
-
-const { Computation } = require('../framework');
-
-class PopularInvestorRiskAssessment extends Computation {
-    
-    static getConfig() {
-        return {
-            name: 'PopularInvestorRiskAssessment',
-            category: 'popular_investor',
-            
-            // Only needs rankings for additional risk factors
-            requires: {
-                'pi_rankings': {
-                    lookback: 0,
-                    mandatory: true,
-                    filter: null
-                }
-            },
-            
-            // DEPENDS ON PopularInvestorProfileMetrics!
-            dependencies: ['PopularInvestorProfileMetrics'],
-            
-            type: 'per-entity',
-            isHistorical: false,
-            ttlDays: 30
-        };
-    }
-    
-    static getSchema() {
-        return {
-            type: 'object',
-            properties: {
-                riskScore: { type: 'number' },
-                riskLevel: { type: 'string' },
-                diversificationScore: { type: 'number' },
-                volatilityScore: { type: 'number' },
-                concentrationRisk: { type: 'number' },
-                sectorConcentration: { type: 'object' },
-                recommendations: { type: 'array' }
-            }
-        };
-    }
-    
-    static getWeight() {
-        return 3.0;
-    }
-    
-    async process(context) {
-        const { date, entityId: userId, data, dependencies } = context;
-        
-        // Get the profile metrics from our dependency
-        const profileMetrics = dependencies?.['popularinvestorprofilemetrics']?.[userId];
-        
-        // Get rankings data
-        const rankingsData = data['pi_rankings'];
-        const rankEntry = this._findRankEntry(rankingsData, userId);
-        
-        // Initialize result
-        const result = {
-            riskScore: 0,
-            riskLevel: 'Unknown',
-            diversificationScore: 0,
-            volatilityScore: 0,
-            concentrationRisk: 0,
-            sectorConcentration: {},
-            recommendations: []
-        };
-        
-        // If we don't have profile metrics, we can still calculate basic risk from rankings
-        if (rankEntry) {
-            const riskScore = rankEntry.RiskScore || rankEntry.riskScore || 0;
-            result.riskScore = riskScore;
-            result.riskLevel = this._getRiskLevel(riskScore);
-        }
-        
-        // If we have profile metrics, enhance the assessment
-        if (profileMetrics) {
-            // Use sector exposure for diversification analysis
-            const sectorExposure = profileMetrics.sectorExposure?.data || {};
-            const sectors = Object.keys(sectorExposure);
-            
-            if (sectors.length > 0) {
-                // Diversification score (more sectors = better diversification)
-                result.diversificationScore = Math.min(100, sectors.length * 15);
-                
-                // Concentration risk (highest sector weight)
-                const maxExposure = Math.max(...Object.values(sectorExposure), 0);
-                result.concentrationRisk = maxExposure;
-                
-                // Copy sector breakdown
-                result.sectorConcentration = sectorExposure;
-                
-                // Generate recommendations
-                if (maxExposure > 50) {
-                    result.recommendations.push(`High concentration in single sector (${maxExposure.toFixed(1)}%). Consider diversifying.`);
-                }
-                if (sectors.length < 3) {
-                    result.recommendations.push('Portfolio is concentrated in few sectors. Consider adding exposure to other sectors.');
-                }
-            }
-            
-            // Use portfolio summary for additional risk factors
-            const portfolioSummary = profileMetrics.portfolioSummary || {};
-            if (portfolioSummary.profitPercent < -10) {
-                result.recommendations.push('Portfolio showing significant losses. Review position sizing.');
-            }
-            
-            // Use rankings data from profile for win ratio analysis
-            const rankingsFromProfile = profileMetrics.rankingsData || {};
-            if (rankingsFromProfile.winRatio < 0.5) {
-                result.volatilityScore = 80;  // Lower win ratio = higher volatility risk
-                result.recommendations.push('Win ratio below 50%. Trading strategy may need review.');
-            } else {
-                result.volatilityScore = Math.max(0, 100 - (rankingsFromProfile.winRatio * 100));
-            }
-            
-            // Adjust overall risk score based on analysis
-            const adjustedRisk = (
-                (result.riskScore * 0.4) +
-                (result.concentrationRisk * 0.3) +
-                (result.volatilityScore * 0.3)
-            );
-            result.riskScore = Math.round(adjustedRisk);
-            result.riskLevel = this._getRiskLevel(result.riskScore);
-        }
-        
-        this.setResult(userId, result);
-    }
-    
-    _findRankEntry(rankings, userId) {
-        if (!rankings) return null;
-        
-        // Rankings might be date-keyed or an array
-        if (typeof rankings === 'object' && !Array.isArray(rankings)) {
-            const dates = Object.keys(rankings).sort().reverse();
-            for (const dateStr of dates) {
-                const dayRankings = rankings[dateStr];
-                if (Array.isArray(dayRankings)) {
-                    const entry = dayRankings.find(r => 
-                        String(r.CustomerId || r.pi_id || r.userId) === String(userId)
-                    );
-                    if (entry) return entry;
-                }
-            }
-        }
-        
-        if (Array.isArray(rankings)) {
-            return rankings.find(r => 
-                String(r.CustomerId || r.pi_id || r.userId) === String(userId)
-            );
-        }
-        
-        return null;
-    }
-    
-    _getRiskLevel(score) {
-        if (score <= 2) return 'Very Low';
-        if (score <= 4) return 'Low';
-        if (score <= 6) return 'Medium';
-        if (score <= 8) return 'High';
-        return 'Very High';
-    }
-}
-
-module.exports = PopularInvestorRiskAssessment;