w-trade-solve 1.0.5 → 2.0.2

package/src/estimKeys.mjs

@@ -7,13 +7,15 @@ import size from 'lodash-es/size.js'
 import cint from 'wsemi/src/cint.mjs'
 import dig from 'wsemi/src/dig.mjs'
 import fsCreateFolder from 'wsemi/src/fsCreateFolder.mjs'
-import fsDeleteFile from 'wsemi/src/fsDeleteFile.mjs'
+import fsIsFile from 'wsemi/src/fsIsFile.mjs'
 import fsIsFolder from 'wsemi/src/fsIsFolder.mjs'
+import fsReadJson from 'wsemi/src/fsReadJson.mjs'
 import fsWriteJson from 'wsemi/src/fsWriteJson.mjs'
-import haskey from 'wsemi/src/haskey.mjs'
 import isearr from 'wsemi/src/isearr.mjs'
 import isestr from 'wsemi/src/isestr.mjs'
 import isnum from 'wsemi/src/isnum.mjs'
+import isbol from 'wsemi/src/isbol.mjs'
+import isfun from 'wsemi/src/isfun.mjs'
 import rang from 'wsemi/src/rang.mjs'
 import wround from 'wsemi/src/round.mjs'
 import omlRGA from 'w-optimization/src/omlRGA.mjs'
@@ -23,7 +25,6 @@ import omlPSO from 'w-optimization/src/omlPSO.mjs'
 import omlACO from 'w-optimization/src/omlACO.mjs'
 import dataProvide from 'w-data-tdprovide'
 import runStrategy from 'w-trade-backtest/src/runStrategy.mjs'
-import readStrategies from './readStrategies.mjs'
 import genTid from './genTid.mjs'
 import genSid from './genSid.mjs'
 import p2r from './p2r.mjs'
@@ -37,8 +38,9 @@ import genStrategyFileName from './genStrategyFileName.mjs'
  *
  * 設計變數為[止損比例, 止盈比例, ...各key之門檻]，止損與止盈由opt.thsSl與opt.thsTp給予之百分比清單離散取值
  * 各key門檻取值範圍為[-thLim,thLim]切為thLim*20段，並各自平移+vdir與-vdir(vdir=thLim*5)為兩組，使解值恆大於0代表'>'條件、恆小於0代表'<'條件，還原時再扣除平移值，故單一設計變數即同時涵蓋大於與小於兩種條件
- * 以w-optimization之最佳化函數求解，由opt.methodOml指定演算法，各次計算皆以w-trade-backtest之runStrategy回測並經calcFitness計算適應值
- * 各次計算結果若同時滿足交易次數、勝率與最終等效年化盈虧三門檻，則以genStrategyFileName產生檔名存入fdData；同tid且同交易次數級距(tkid)已有策略時，僅於最終等效年化盈虧更佳時抽換，並刪除較差者
+ * 以w-optimization之最佳化函數求解，由opt.methodOml指定演算法，各次計算皆以w-trade-backtest之runStrategy回測並經calcFitness計算適應值；亦可由opt.funRunStrategyCustom注入自訂評估核心加速求解(如以w-trade-backtest之buildStrategyFastSession預算first-touch表與因子對位序列)，注入僅回傳精簡欄位之核心時可配合opt.useRunStrategyBeforeSave於存檔前重跑完整回測，使落地summary維持完整欄位口徑；存檔前重跑後檔內numTrade、levelNumTrade、tkid、fitness與檔名皆由重跑之summary重新衍生，確保檔名與檔案內容同源一致；重算檔名與原檔名不同(評估核心與重跑結果跨級距)時，對新檔名重做存在檢查、身分驗證與優劣比較，新檔名已有更佳者則放棄本次寫入
+ * 各次計算結果若同時滿足交易次數、勝率與最終等效年化盈虧三門檻，則以genStrategyFileName產生檔名存入fdData；檔名為tkid(tid+交易次數級距)之純函數，故直接組出檔名查詢既有策略(O(1)，不列舉全庫)，同tkid已有策略時僅於最終等效年化盈虧更佳時原地覆寫，故同tkid恆僅一檔；覆寫前驗證舊檔內tkid、name與interval與本次一致，不一致代表雜湊碰撞，直接throw以避免無聲覆寫
+ * 策略檔內容除策略本體(tid、sid、name、symbol、interval、keyOhlc、mode、conds、settings)與summary、fitness外，另落地tkid、numTrade、levelNumTrade、keys與solve區塊(timeStart、timeEnd、methodOml、thNumTrade、thRWin、thREquivalentCumuProfitOrLossFinalNormYear、thsTp、thsSl、timeSolved)，使識別與求解條件欄位自足，不依賴檔名
  * opt除下列各欄位外，其餘欄位皆原樣傳遞至所選之最佳化函數，兩者欄位名稱無重疊，故可一併給予求解設定
  * 各演算法共通之設定為NContiguous(最佳解連續未更新次數上限，預設100)、NRepeat、NCore、ModeOutLimit、UseRepeat、UseImmigration、LocalSearchMethod與funGetBetter、funGenerationBefore、funGenerationAfter三接口；族群數與迴圈數之欄位名稱各演算法不同，RGA與DE為Np與Ng、PSO為Np與Nl、HS為Ns與Ni、ACO為Na與Nl；另各演算法有其專屬超參數，如PSO之psoC1Start、RGA之rgaCrossover、DE之deF、HS之hsHMCR與ACO之acoAlphaStart等
  * 預設之求解量甚大(單一key約需1萬7千次回測)，僅需快速試算時可調小族群數與NContiguous
@@ -46,7 +48,7 @@ import genStrategyFileName from './genStrategyFileName.mjs'
  *
  * Unit Test: {@link https://github.com/yuda-lyu/w-trade-solve/blob/master/test/unit-estimKeys.test.mjs Github}
  * @function
- * @param {Function} ott 輸入時區時間函數，傳入時間字串回傳dayjs時間物件，可用src/ott.mjs
+ * @param {Function} ott 輸入時區時間函數，傳入時間字串回傳dayjs時間物件，未傳入時回傳當下時間(供solve.timeSolved記錄)，可用src/ott.mjs
  * @param {String} name 輸入幣種名稱字串，例如'btc'，用於組出K線序列key(`${name}_price_${interval}`)與縮寫tid
  * @param {String} symbol 輸入交易對名稱字串，例如'BTCUSDT'，僅儲存至策略內供辨識
  * @param {String} interval 輸入K線週期字串，例如'4hr'
@@ -64,6 +66,9 @@ import genStrategyFileName from './genStrategyFileName.mjs'
  * @param {Number} [opt.thNumTrade=1] 輸入策略須儲存之最少交易次數數值，預設1
  * @param {Number} [opt.thRWin=0.5] 輸入策略須儲存之最低勝率比例數值，預設0.5
  * @param {Number} [opt.thREquivalentCumuProfitOrLossFinalNormYear=0.15] 輸入策略須儲存之最低最終等效年化盈虧比例數值，預設0.15
+ * @param {Function} [opt.funRunStrategyCustom=null] 輸入自訂回測評估async函數，傳入{ott,strategy,funGetSeries}物件，須回傳{summary}且summary至少含numTrade、rWin、uEquityFinal與rEquivalentCumuProfitOrLossFinalNormYear四欄，各欄語義須與runStrategy等值，回傳之準確性由注入端負責；未給時採runStrategy，預設null
+ * @param {Boolean} [opt.useRunStrategyBeforeSave=false] 輸入存檔前是否重跑一次回測並以其summary重新衍生檔案內容與檔名布林值，注入僅回傳精簡欄位之評估核心時應設true以維持策略檔欄位口徑，求解搜索仍全程使用自訂函數不受影響，預設false
+ * @param {Function} [opt.funRunStrategyCustomBeforeSave=null] 輸入存檔前重跑用之自訂回測async函數，介面同opt.funRunStrategyCustom，僅於opt.useRunStrategyBeforeSave為true時生效，未給時採runStrategy，預設null
  * @param {Boolean} [opt.useShowLog=false] 輸入是否顯示求解過程log布林值，預設false
  * @returns {Promise} 回傳Promise，resolve為求解結果物件，含bestSolution(最佳解，內有ps設計變數陣列與fitness適應值)、stopMode(觸發停止之機制字串)、stopIteration(停止時之迴圈數)與stopExecutions(停止時之核心分析次數)等欄位
  * @example
@@ -129,8 +134,8 @@ let estimKeys = async (ott, name, symbol, interval, fdOhlc, fdParam, timeStart,
     }
 
     let methodOml = get(opt, 'methodOml', '')
-    if (!isestr(methodOml)) {
-        methodOml = 'PSO'
+    if (methodOml !== 'RGA' && methodOml !== 'DE' && methodOml !== 'HS' && methodOml !== 'PSO' && methodOml !== 'ACO') {
+        methodOml = 'PSO' //非五者之一時採PSO, 使solve.methodOml記錄實際採用之演算法
     }
     let thsTp = get(opt, 'thsTp', null)
     if (!isearr(thsTp)) {
@@ -152,6 +157,12 @@ let estimKeys = async (ott, name, symbol, interval, fdOhlc, fdParam, timeStart,
     if (!isnum(thREquivalentCumuProfitOrLossFinalNormYear)) {
         thREquivalentCumuProfitOrLossFinalNormYear = 0.15
     }
+    let funRunStrategyCustom = get(opt, 'funRunStrategyCustom', null)
+    let useRunStrategyBeforeSave = get(opt, 'useRunStrategyBeforeSave', null)
+    if (!isbol(useRunStrategyBeforeSave)) {
+        useRunStrategyBeforeSave = false
+    }
+    let funRunStrategyCustomBeforeSave = get(opt, 'funRunStrategyCustomBeforeSave', null)
     let useShowLog = get(opt, 'useShowLog', null)
 
     //provideData
@@ -254,6 +265,50 @@ let estimKeys = async (ott, name, symbol, interval, fdOhlc, fdParam, timeStart,
 
     }
 
+    //checkSavable, 檢查指定檔名處是否可寫入策略: 無檔案或舊檔非合法json回傳true(直接寫入);
+    //  舊檔身分(tkid/name/interval)與本次不一致代表雜湊碰撞, 直接throw以避免無聲覆寫;
+    //  新等效年化盈虧較佳時回傳true(原地覆寫), 否則回傳false(保留既有較佳者)
+    let checkSavable = (fpStrategy, fnStrategy, tkid, rEquivalentCumuProfitOrLossFinalNormYearNew) => {
+
+        //check, 無同檔名策略, 新出現須儲存
+        if (!fsIsFile(fpStrategy)) {
+            return true
+        }
+
+        //dataOld
+        let dOld = fsReadJson(fpStrategy) //回傳{success}或{error}, 讀取或解析失敗時為null
+        let dataOld = get(dOld, 'success', null)
+
+        //check, 舊檔非合法json, 直接覆寫
+        if (dataOld === null) {
+            return true
+        }
+
+        //覆寫前驗證舊檔身分與本次一致, 不一致代表雜湊碰撞, 直接throw以避免無聲覆寫
+        let tkidOld = get(dataOld, 'tkid', '')
+        let nameOld = get(dataOld, 'name', '')
+        let intervalOld = get(dataOld, 'interval', '')
+        if ((isestr(tkidOld) && tkidOld !== tkid) || (isestr(nameOld) && nameOld !== name) || (isestr(intervalOld) && intervalOld !== interval)) {
+            throw new Error(`hash collision: fnStrategy[${fnStrategy}], tkidOld[${tkidOld}] vs tkid[${tkid}], nameOld[${nameOld}] vs name[${name}], intervalOld[${intervalOld}] vs interval[${interval}]`)
+        }
+
+        //rEquivalentCumuProfitOrLossFinalNormYearOld
+        let rEquivalentCumuProfitOrLossFinalNormYearOld = p2r(get(dataOld, 'summary.rEquivalentCumuProfitOrLossFinalNormYear', ''))
+
+        //check, 出現更好的等效盈虧比例, 原地覆寫
+        if (rEquivalentCumuProfitOrLossFinalNormYearNew > rEquivalentCumuProfitOrLossFinalNormYearOld) {
+
+            if (useShowLog) {
+                console.log(`覆寫較差策略...`, `${rEquivalentCumuProfitOrLossFinalNormYearNew} > ${rEquivalentCumuProfitOrLossFinalNormYearOld}`, fpStrategy)
+            }
+
+            return true
+        }
+
+        //新等效盈虧未較佳, 不寫入
+        return false
+    }
+
     //ifun, fitnessMin
     let ifun = 0
     let fitnessMin = 1e20
@@ -342,41 +397,69 @@ let estimKeys = async (ott, name, symbol, interval, fdOhlc, fdParam, timeStart,
         }
 
         //runStrategy
-        let r = await runStrategy(ott, strategy, funGetSeries)
+        let r = null
+        if (isfun(funRunStrategyCustom)) {
+            r = await funRunStrategyCustom({ ott, strategy, funGetSeries })
+        }
+        else {
+            r = await runStrategy(ott, strategy, funGetSeries)
+        }
         // console.log(ifun, 'summary', r.summary)
 
-        //numTrade
-        let numTrade = cint(r.summary.numTrade)
+        //rEquivalentCumuProfitOrLossFinalNormYear
+        let rEquivalentCumuProfitOrLossFinalNormYear = p2r(r.summary.rEquivalentCumuProfitOrLossFinalNormYear)
 
         //rWin
         let rWin = p2r(r.summary.rWin)
 
-        // //rCumuProfitOrLossFinal
-        // let rCumuProfitOrLossFinal = p2r(r.summary.rCumuProfitOrLossFinal)
+        //genRes
+        let genRes = (r) => {
 
-        // //rTradeAllMax
-        // let rTradeAllMax = p2r(r.summary.rTradeAllMax)
+            //fitness
+            let fitness = calcFitness(strategy.settings, r.summary)
 
-        // //rEquivalentCumuProfitOrLossFinal
-        // let rEquivalentCumuProfitOrLossFinal = p2r(r.summary.rEquivalentCumuProfitOrLossFinal)
+            //numTrade
+            let numTrade = cint(r.summary.numTrade)
 
-        //rEquivalentCumuProfitOrLossFinalNormYear
-        let rEquivalentCumuProfitOrLossFinalNormYear = p2r(r.summary.rEquivalentCumuProfitOrLossFinalNormYear)
+            //levelNumTrade
+            let levelNumTrade = calcLevelNumTrade(numTrade)
 
-        //fitness
-        let fitness = calcFitness(strategy.settings, r.summary)
+            //tkid
+            let tkid = `${tid}:${levelNumTrade}`
 
-        //res
-        let res = {
+            return {
+
+                ...strategy,
 
-            ...strategy,
+                tkid,
+                numTrade,
+                levelNumTrade,
+                keys,
 
-            summary: r.summary,
+                summary: r.summary,
 
-            fitness,
+                fitness,
 
+                solve: {
+                    timeStart,
+                    timeEnd,
+                    methodOml,
+                    thNumTrade,
+                    thRWin,
+                    thREquivalentCumuProfitOrLossFinalNormYear,
+                    thsTp,
+                    thsSl,
+                    timeSolved: ott().format('YYYY-MM-DDTHH:mm:ss'),
+                },
+
+            }
         }
+
+        //res, 除策略本體與summary、fitness外, 落地tkid、levelNumTrade、keys與solve使欄位自足, 識別與求解條件不依賴檔名
+        let res = genRes(r)
         //  console.log(ifun, res)
+
+        //resBrief
         let resBrief = {
 
             '方向': res.mode,
@@ -399,20 +482,20 @@ let estimKeys = async (ott, name, symbol, interval, fdOhlc, fdParam, timeStart,
         // console.log(ifun, resBrief)
 
         //update fitnessMin
-        if (fitnessMin > fitness) {
+        if (fitnessMin > res.fitness) {
 
             if (useShowLog) {
                 console.log(ifun, '更新最佳解', resBrief)
             }
 
             //update
-            fitnessMin = fitness
+            fitnessMin = res.fitness
 
         }
 
         //儲存可用參數組
         if (
-            numTrade >= thNumTrade &&
+            res.numTrade >= thNumTrade &&
             rWin >= thRWin &&
             // rCumuProfitOrLossFinal > 0 &&
             // rTradeAllMax <= 0.8 &&
@@ -425,73 +508,58 @@ let estimKeys = async (ott, name, symbol, interval, fdOhlc, fdParam, timeStart,
                 console.log(ifun, '可用參數組', resBrief)
             }
 
-            //kpTid
-            let kpTkid = {}
-            if (true) {
-                let ss = readStrategies(fdData, { readContent: false })
-                each(ss, (s) => {
-                    kpTkid[s.tkid] = s
-                })
-            }
-            // console.log('kpTkid', kpTkid)
-
-            //levelNumTrade
-            let levelNumTrade = calcLevelNumTrade(numTrade)
-
-            //tkid
-            let tkid = `${tid}:${levelNumTrade}`
-
-            //b
-            let b = false
+            //fnStrategy, 檔名為tkid之純函數, 故可直接組出檔名查詢既有策略, 不需列舉全庫
+            let fnStrategy = genStrategyFileName(name, interval, mode, keys, strategy.settings, r.summary)
 
-            //rEquivalentCumuProfitOrLossFinalNormYearNew
-            let rEquivalentCumuProfitOrLossFinalNormYearNew = rEquivalentCumuProfitOrLossFinalNormYear
+            //fpStrategy
+            let fpStrategy = path.resolve(fdData, fnStrategy)
 
-            //檢查是否已有tid策略
-            if (haskey(kpTkid, tkid)) {
+            //b, 檢查是否已有同tkid策略, 無檔案或舊檔非合法json即寫入, 已有者僅於新等效年化盈虧更佳時覆寫
+            let b = checkSavable(fpStrategy, fnStrategy, res.tkid, rEquivalentCumuProfitOrLossFinalNormYear)
 
-                //rEquivalentCumuProfitOrLossFinalNormYearOld
-                let rEquivalentCumuProfitOrLossFinalNormYearOld = p2r(kpTkid[tkid].rEquivalentCumuProfitOrLossFinalNormYear)
-
-                //check
-                if (rEquivalentCumuProfitOrLossFinalNormYearNew > rEquivalentCumuProfitOrLossFinalNormYearOld) {
+            //save
+            if (b) {
 
-                    //出現更好的等效盈虧比例, 須抽換
-                    b = true
+                //useRunStrategyBeforeSave
+                if (useRunStrategyBeforeSave) {
 
-                    //先刪除較差tid策略
-                    if (useShowLog) {
-                        console.log(`刪除較差策略...`, `${rEquivalentCumuProfitOrLossFinalNormYearNew} > ${rEquivalentCumuProfitOrLossFinalNormYearOld}`, kpTkid[tkid].path)
+                    if (isfun(funRunStrategyCustomBeforeSave)) {
+                        r = await funRunStrategyCustomBeforeSave({ ott, strategy, funGetSeries })
+                    }
+                    else {
+                        r = await runStrategy(ott, strategy, funGetSeries)
                     }
-                    fsDeleteFile(kpTkid[tkid].path)
 
-                }
+                    //res, 檔內全部衍生欄位由重跑之summary重新衍生, 確保檔案內容同源一致
+                    res = genRes(r)
 
-            }
-            else {
+                    //fnStrategyRe, 以重跑之summary重算檔名, 使檔名級距與檔內同源
+                    let fnStrategyRe = genStrategyFileName(name, interval, mode, keys, strategy.settings, r.summary)
 
-                //新出現須儲存
-                b = true
+                    //check, 檔名有變代表評估核心與重跑結果跨級距, 新檔名須重做存在檢查/身分驗證/優劣比較, 不可沿用原檔名之通過結果
+                    if (fnStrategyRe !== fnStrategy) {
 
-            }
+                        //fnStrategy, fpStrategy
+                        fnStrategy = fnStrategyRe
+                        fpStrategy = path.resolve(fdData, fnStrategy)
 
-            //save
-            if (b) {
+                        //b, 以重跑之等效年化盈虧對新檔名重檢
+                        b = checkSavable(fpStrategy, fnStrategy, res.tkid, p2r(get(r, 'summary.rEquivalentCumuProfitOrLossFinalNormYear', '')))
 
-                //fnStrategy
-                let fnStrategy = genStrategyFileName(name, interval, mode, keys, strategy.settings, r.summary)
+                    }
 
-                //fpStrategy
-                let fpStrategy = path.resolve(fdData, fnStrategy)
+                }
 
                 //fsWriteJson
-                fsWriteJson(fpStrategy, res, { useFormat: true })
+                if (b) {
+                    fsWriteJson(fpStrategy, res, { useFormat: true })
+                }
 
             }
 
         }
 
-        return fitness
+        return res.fitness
     }
 
     //oml

package/src/genStrategyFileName.mjs

@@ -1,5 +1,5 @@
+import crypto from 'crypto'
 import cint from 'wsemi/src/cint.mjs'
-import cont from './cont.mjs'
 import genTid from './genTid.mjs'
 import calcLevelNumTrade from './calcLevelNumTrade.mjs'
 
@@ -7,9 +7,12 @@ import calcLevelNumTrade from './calcLevelNumTrade.mjs'
 /**
  * 產生策略儲存檔名
  *
- * 檔名為`${tid}${cont.dlmPkgs}${levelNumTrade}${cont.dlmPkgs}${rEquivalentCumuProfitOrLossFinalNormYear}.json`
+ * 檔名為`${mode}_${levelNumTrade}_${hash}.json`，hash為md5(`${coin}:${interval}:${tid}:${levelNumTrade}`)取前16碼(64bits)
  * tid由genTid以coin、interval、mode與keys產生，levelNumTrade由calcLevelNumTrade以summary.numTrade產生
- * 因tid與levelNumTrade皆入檔名，故可由檔名反解出同組keys與同交易次數級距之既有策略，供readStrategies列舉比較
+ * 檔名為(coin,interval,tid,levelNumTrade)之純函數且與求解結果(等效年化盈虧)無關，故同tkid恆對應同一檔名，
+ * 存檔端可直接組出檔名以fsIsFile查詢既有策略(O(1))，不需列舉全庫，且更新為原地覆寫，結構上不會出現同tkid多檔
+ * 因genTid會剔除`${coin}_`與`${interval}_`樣式，不同幣種或週期之同組keys會得到相同tid，故hash輸入需含coin與interval以避免跨幣種/跨週期碰撞
+ * 採定長雜湊係因NTFS單一檔名段上限為255字元(UTF-16計，LongPathsEnabled無法放寬)，keys個數多時舊式`${tid} ⊙ ...`檔名會超限
  * settings目前未參與檔名組成
  *
  * Unit Test: {@link https://github.com/yuda-lyu/w-trade-solve/blob/master/test/unit-genStrategyFileName.test.mjs Github}
@@ -19,7 +22,7 @@ import calcLevelNumTrade from './calcLevelNumTrade.mjs'
  * @param {String} mode 輸入交易方向字串，可選'long'或'short'
  * @param {Array} keys 輸入指標key字串陣列
  * @param {Object} settings 輸入策略設定物件
- * @param {Object} summary 輸入回測統計摘要物件，需含numTrade(交易次數)與rEquivalentCumuProfitOrLossFinalNormYear(最終等效年化盈虧百分比字串)欄位
+ * @param {Object} summary 輸入回測統計摘要物件，需含numTrade(交易次數)欄位
  * @returns {String} 回傳策略儲存檔名字串
  * @example
  *
@@ -31,7 +34,8 @@ import calcLevelNumTrade from './calcLevelNumTrade.mjs'
  *
  * let fn = genStrategyFileName('btc', '4hr', 'long', keys, settings, summary)
  * console.log(fn)
- * // => 'long ║ p_ma_1day ⊙ 12 ⊙ 31.25%.json'
+ * // => 'long_12_9fce6961e8f56493.json'
+ * //tid為'long ║ p_ma_1day', 級距為12, hash為md5('btc:4hr:long ║ p_ma_1day:12')前16碼
  *
  */
 let genStrategyFileName = (coin, interval, mode, keys, settings, summary) => {
@@ -46,11 +50,11 @@ let genStrategyFileName = (coin, interval, mode, keys, settings, summary) => {
     //levelNumTrade
     let levelNumTrade = calcLevelNumTrade(numTrade)
 
-    //rEquivalentCumuProfitOrLossFinalNormYear
-    let rEquivalentCumuProfitOrLossFinalNormYear = summary.rEquivalentCumuProfitOrLossFinalNormYear
+    //hash, 含coin與interval避免跨幣種/跨週期之同名tid碰撞
+    let hash = crypto.createHash('md5').update(`${coin}:${interval}:${tid}:${levelNumTrade}`, 'utf8').digest('hex').slice(0, 16)
 
     //fnStrategy
-    let fnStrategy = `${tid}${cont.dlmPkgs}${levelNumTrade}${cont.dlmPkgs}${rEquivalentCumuProfitOrLossFinalNormYear}.json`
+    let fnStrategy = `${mode}_${levelNumTrade}_${hash}.json`
 
     return fnStrategy
 }

package/src/readStrategies.mjs

@@ -3,6 +3,7 @@ import each from 'lodash-es/each.js'
 import filter from 'lodash-es/filter.js'
 import get from 'lodash-es/get.js'
 import size from 'lodash-es/size.js'
+import cstr from 'wsemi/src/cstr.mjs'
 import fsIsFolder from 'wsemi/src/fsIsFolder.mjs'
 import fsReadJson from 'wsemi/src/fsReadJson.mjs'
 import fsTreeFolder from 'wsemi/src/fsTreeFolder.mjs'
@@ -12,37 +13,47 @@ import sep from 'wsemi/src/sep.mjs'
 import cont from './cont.mjs'
 
 
+//ptnFnHash, genStrategyFileName所產生之雜湊檔名樣式`${mode}_${levelNumTrade}_${hash16}.json`
+let ptnFnHash = /^(long|short)_\d+_[0-9a-f]{16}\.json$/
+
+
 /**
  * 讀取儲存策略資料夾內各策略檔資訊
  *
  * 僅列舉fd第1層之檔案，資料夾不列入，fd非資料夾或無任何檔案時回傳空陣列
- * 各檔以主檔名(剔除'.json')依cont.dlmPkgs切段，依序為tid、levelNumTrade與rEquivalentCumuProfitOrLossFinalNormYear，即genStrategyFileName所產生之檔名，切不出tid者予以略過
- * tid再依cont.dlmSeps切段，首段為mode，其餘為各key所組成之ps
+ * 各檔依opt.fromContent決定解析來源:
+ *   'filename'為舊式檔名反解: 以主檔名(剔除'.json')依cont.dlmPkgs切段，依序為tid、levelNumTrade與rEquivalentCumuProfitOrLossFinalNormYear，切不出tid者予以略過
+ *   'content'為讀取檔內json之tid、tkid、levelNumTrade與summary等欄位(即estimKeys所寫出之策略內容)，非合法json或無tid欄位者予以略過，因需讀檔故較'filename'慢
+ *   'auto'(預設)為逐檔判別: 檔名符合genStrategyFileName雜湊格式(`${mode}_${levelNumTrade}_${hash16}.json`)者走'content'，其餘走'filename'，故新舊格式混存時皆可列舉
+ * tid依cont.dlmSeps切段，首段為mode，其餘為各key所組成之ps
  * tkid為`${tid}:${levelNumTrade}`，與estimKeys內用於判斷同組keys與同交易次數級距之組合方式一致
  *
  * Unit Test: {@link https://github.com/yuda-lyu/w-trade-solve/blob/master/test/unit-readStrategies.test.mjs Github}
  * @function
  * @param {String} fd 輸入儲存策略資料夾字串
  * @param {Object} [opt={}] 輸入設定物件，預設{}
- * @param {Boolean} [opt.readContent=false] 輸入是否讀取策略檔內容布林值，為true時各元素額外提供data欄位，內容非合法json時data為null，預設false
+ * @param {Boolean} [opt.readContent=false] 輸入是否額外提供策略檔內容布林值，為true時各元素額外提供data欄位，內容非合法json時data為null，預設false
+ * @param {String} [opt.fromContent='auto'] 輸入解析來源字串，可選'filename'(由檔名反解)、'content'(讀檔內json欄位)與'auto'(依檔名格式逐檔判別)，給予其他值時亦採'auto'，預設'auto'
  * @returns {Array} 回傳策略資訊陣列，各元素為{path,name,tkid,tid,levelNumTrade,rEquivalentCumuProfitOrLossFinalNormYear,mode,ps}，opt.readContent為true時額外提供data
  * @example
  *
  * import fs from 'fs'
- * import cont from './src/cont.mjs'
+ * import genStrategyFileName from './src/genStrategyFileName.mjs'
  *
  * let fd = './tmp/data-strategy'
  * fs.mkdirSync(fd, { recursive: true })
  *
- * //以genStrategyFileName之檔名規則儲存策略檔
- * let fn = `long${cont.dlmSeps}ma_1day${cont.dlmPkgs}12${cont.dlmPkgs}31.25%.json`
- * fs.writeFileSync(`${fd}/${fn}`, JSON.stringify({ mode: 'long' }), 'utf8')
+ * //以genStrategyFileName之檔名規則儲存策略檔, 檔名為雜湊格式, 識別資訊由檔內json承載
+ * let summary = { numTrade: 30, rEquivalentCumuProfitOrLossFinalNormYear: '31.25%' }
+ * let fn = genStrategyFileName('btc', '4hr', 'long', ['btc_4hr_ma_1day'], {}, summary)
+ * let data = { tid: 'long ║ ma_1day', tkid: 'long ║ ma_1day:12', levelNumTrade: 12, mode: 'long', summary }
+ * fs.writeFileSync(`${fd}/${fn}`, JSON.stringify(data), 'utf8')
  *
  * console.log(readStrategies(fd))
  * // => [
  * //   {
- * //     path: './tmp/data-strategy/long ║ ma_1day ⊙ 12 ⊙ 31.25%.json',
- * //     name: 'long ║ ma_1day ⊙ 12 ⊙ 31.25%.json',
+ * //     path: './tmp/data-strategy/long_12_a7578526a1fc57d8.json',
+ * //     name: 'long_12_a7578526a1fc57d8.json',
  * //     tkid: 'long ║ ma_1day:12',
  * //     tid: 'long ║ ma_1day',
  * //     levelNumTrade: '12',
@@ -58,6 +69,12 @@ let readStrategies = (fd, opt = {}) => {
     //readContent
     let readContent = get(opt, 'readContent', false)
 
+    //fromContent
+    let fromContent = get(opt, 'fromContent', '')
+    if (fromContent !== 'filename' && fromContent !== 'content') {
+        fromContent = 'auto'
+    }
+
     //check
     if (!fsIsFolder(fd)) {
         console.log(`invalid fd[${fd}]`)
@@ -79,44 +96,111 @@ let readStrategies = (fd, opt = {}) => {
     let ss = []
     each(vfps, (v) => {
 
-        //qs
-        let name = replace(v.name, '.json', '')
-        let qs = sep(name, cont.dlmPkgs)
-
-        //tid
-        let tid = get(qs, 0, '')
-
-        //check
-        if (!isestr(tid)) {
-            return true //跳出換下一個
+        //useContent, 'auto'依檔名是否符合雜湊格式逐檔判別
+        let useContent = fromContent === 'content'
+        if (fromContent === 'auto') {
+            useContent = ptnFnHash.test(v.name)
         }
 
-        //levelNumTrade, rEquivalentCumuProfitOrLossFinalNormYear, ps, mode
-        let levelNumTrade = get(qs, 1, '')
-        let rEquivalentCumuProfitOrLossFinalNormYear = get(qs, 2, '')
-        let ps = sep(tid, cont.dlmSeps)
-        let mode = get(ps, 0, '')
-        ps = drop(ps)
-
-        //tkid
-        let tkid = `${tid}:${levelNumTrade}`
-
         //s
-        let s = {
-            path: v.path,
-            name: v.name,
-            tkid,
-            tid,
-            levelNumTrade,
-            rEquivalentCumuProfitOrLossFinalNormYear,
-            mode,
-            ps,
+        let s = null
+
+        if (useContent) {
+
+            //data, 由檔內json取各欄位
+            let d = fsReadJson(v.path) //回傳{success}或{error}, 讀取或解析失敗時為null
+            let data = get(d, 'success', null)
+
+            //check
+            if (data === null) {
+                return true //跳出換下一個
+            }
+
+            //tid
+            let tid = get(data, 'tid', '')
+
+            //check
+            if (!isestr(tid)) {
+                return true //跳出換下一個
+            }
+
+            //levelNumTrade, 為與檔名反解之回傳格式一致, 轉為字串
+            let levelNumTrade = cstr(get(data, 'levelNumTrade', ''))
+
+            //rEquivalentCumuProfitOrLossFinalNormYear
+            let rEquivalentCumuProfitOrLossFinalNormYear = get(data, 'summary.rEquivalentCumuProfitOrLossFinalNormYear', '')
+
+            //ps, mode
+            let ps = sep(tid, cont.dlmSeps)
+            let mode = get(ps, 0, '')
+            ps = drop(ps)
+
+            //tkid, 舊內容無tkid欄位時由tid與levelNumTrade組出
+            let tkid = get(data, 'tkid', '')
+            if (!isestr(tkid)) {
+                tkid = `${tid}:${levelNumTrade}`
+            }
+
+            //s
+            s = {
+                path: v.path,
+                name: v.name,
+                tkid,
+                tid,
+                levelNumTrade,
+                rEquivalentCumuProfitOrLossFinalNormYear,
+                mode,
+                ps,
+            }
+
+            //readContent
+            if (readContent) {
+                s.data = data
+            }
+
         }
+        else {
+
+            //qs
+            let name = replace(v.name, '.json', '')
+            let qs = sep(name, cont.dlmPkgs)
+
+            //tid
+            let tid = get(qs, 0, '')
+
+            //check
+            if (!isestr(tid)) {
+                return true //跳出換下一個
+            }
+
+            //levelNumTrade, rEquivalentCumuProfitOrLossFinalNormYear, ps, mode
+            let levelNumTrade = get(qs, 1, '')
+            let rEquivalentCumuProfitOrLossFinalNormYear = get(qs, 2, '')
+            let ps = sep(tid, cont.dlmSeps)
+            let mode = get(ps, 0, '')
+            ps = drop(ps)
+
+            //tkid
+            let tkid = `${tid}:${levelNumTrade}`
+
+            //s
+            s = {
+                path: v.path,
+                name: v.name,
+                tkid,
+                tid,
+                levelNumTrade,
+                rEquivalentCumuProfitOrLossFinalNormYear,
+                mode,
+                ps,
+            }
+
+            //readContent
+            if (readContent) {
+                let d = fsReadJson(v.path) //回傳{success}或{error}, 讀取或解析失敗時data為null
+                s.data = get(d, 'success', null)
+            }
 
-        //readContent
-        if (readContent) {
-            let d = fsReadJson(v.path) //回傳{success}或{error}, 讀取或解析失敗時data為null
-            s.data = get(d, 'success', null)
         }
 
         //push