private void LogConfiguration(PatternConfig settings)
{
var symbol = "All Pairs";
var interval = "All Intervals";
var retention = settings.Retention;
var threshold = settings.Threshold;
var file = Path;
var defaultSl = settings.DefaultStopLoss;
var DynamicSl = settings.DynamicStopLoss;
if (!string.IsNullOrWhiteSpace(settings.Symbol))
{
symbol = settings.Symbol;
}
if (!string.IsNullOrWhiteSpace(settings.Interval))
{
interval = settings.Interval;
}
var msg = String.Format("Running analysis for {0}_{1} for {2}, MA Aggregation: {3}, Accuracy: {4}, Default Stop Loss Threshold: {5}, Dynamic Stop Loss Threshold: {6}", symbol, interval, file, retention, threshold, defaultSl, DynamicSl);
_logger.Info(msg);
}
public Dictionary <string, IPattern> GenerateSettings(TesterOutput output)
{
var patternsRepository = new Dictionary <string, IPattern>();
var patterns = GetRelevantPatterns(output.Patterns);
foreach (var p in patterns)
{
foreach (var symbol in output.Symbols)
{
foreach (var interval in output.Intervals)
{
for (var r = output.retention.Min; r <= output.retention.Max; r += output.retention.Increment)
{
for (var t = output.threshold.Min; t <= output.threshold.Max; t += output.threshold.Increment)
{
for (var def = output.defaultSLThreshold.Min; def <= output.defaultSLThreshold.Max; def += output.defaultSLThreshold.Increment)
{
for (var dyn = output.dynamicSLThreshold.Min; dyn <= output.dynamicSLThreshold.Max; dyn += output.dynamicSLThreshold.Increment)
{
var patternConfig = new PatternConfig(p, symbol, interval, true, t, (int)r, def, dyn);
var hash = p + "_" + symbol + "_" + interval + "_" + r + "_" + t + "_" + def + "_" + dyn;
var pattern = NewPattern(p, patternConfig, hash);
patternsRepository.Add(hash, pattern);
}
}
}
}
}
}
}
return(patternsRepository);
}
public void SetWaveConfig(PatternConfig patternConfig) //(this waveConfig here is a local variable.)
/* This method allows you to know which path is using from another script(in this case is the wave(one of WaveConfig) chosen in EnemySpawner.cs)
* automatically instead of putting script manually via serializeField.
*/
{
this.patternConfig = patternConfig;//1st waveConfig is from this script, 2nd waveConfig is from this method.
}
public Pattern(PatternConfig settings, ILogger _logger, string engineName = "Generic")
{
logger = _logger;
Symbol = settings.Symbol;
Interval = settings.Interval;
Name = settings.Name;
Engine = new TradeEngine(logger, engineName);
}
public void UpdateSettings(PatternConfig config)
{
this.Name = config.Name;
this.Interval = config.Interval;
this.DefaultStopLossThreshold = config.DefaultStopLoss;
this.DynamicStopLoss = config.DynamicStopLoss;
this.Symbol = config.Symbol;
}
public MetadataParser1(
ILogger <MetadataParser> logger,
IDocumentTypeParser documentTypeParser,
IOptions <PatternConfig> patternConfig)
{
_logger = logger;
_patternConfig = patternConfig.Value;
_documentTypeParser = documentTypeParser;
}
public RulePattern(ILogger _logger, PatternConfig settings, string engineName = "Generic")
: base(settings, _logger, engineName)
{
Rules = new List <IRule>();
Retention = settings.Retention;
Name = settings.Name;
Threshold = settings.Threshold;
logger = _logger;
DefaultStopLossThreshold = settings.DefaultStopLoss;
DynamicStopLossThreshold = settings.DynamicStopLoss;
AddRules();
}
// GET: Patterns
public ActionResult Random()
{
var logger = new Logger("RobertWeb");
var conf = new PatternConfig("Test", "ETHBTC", "15m");
var pattern = new PatternModel();
pattern.Name = "TestModel";
pattern.Symbol = "BTCUSD";
pattern.Interval = "1d";
return(View(pattern));
}
private static void SetHeight(PatternConfig obj)
{
int length = PatternConfig.width * obj.height;
while (obj.blocks.Count < length)
{
obj.blocks.Insert(0, BlockType.Null);
}
while (obj.blocks.Count > length)
{
obj.blocks.RemoveAt(0);
}
}
public StreakPattern(ILogger logger, PatternConfig settings, string engineName = "Generic") : base(settings, logger, engineName)
{
_logger = logger;
Streak = 0;
LastPrice = 0;
LastOpen = 0;
PriceQueue = new Queue <decimal>();
VolumeQueue = new Queue <decimal>();
Retention = settings.Retention;
HighPrice = 0;
Threshold = settings.Threshold;
Name = "Streak";
}
private IEnumerator SpawnAllEnemiesInPattern(PatternConfig patternConfig)
{
for (int enemyCount = 0; enemyCount < patternConfig.GetNumberOfEnemies(); enemyCount++)
{
if (enemyCount == 0)
{
yield return(new WaitForSeconds(0.8f));
}
var newEnemy = Instantiate(patternConfig.GetEnemyPrefab(), patternConfig.GetWayPoints()[0].transform.position, Quaternion.identity);
newEnemy.GetComponent <EnemyPathing>().SetWaveConfig(patternConfig); //Ask this enemy to have specific path(in this case is following currentWave).
yield return(new WaitForSeconds(patternConfig.GetTimeBetweenSpawns()));
}
yield return(new WaitForSeconds(patternConfig.GetTimeBetweenWaves()));
}
private static FilesingConfig GenerateConfig(Regex regex, string searchDir, GenericLogger log, string inFile)
{
FilesingConfig config;
if (regex == null)
{
log.WriteLine(
FilesingConstants.LightVerbosity,
"- Using regexes from config file '{0}'",
inFile
);
config = XmlLoader.LoadConfigFromXml(inFile, searchDir);
}
else
{
log.WriteLine(
FilesingConstants.LightVerbosity,
"- Regex specified on command line. Using regex '" + regex.ToString() + "'"
);
if (string.IsNullOrWhiteSpace(inFile))
{
log.WriteLine(
FilesingConstants.LightVerbosity,
"- No config file specified, not ignoring any files or directories."
);
config = new FilesingConfig();
}
else
{
log.WriteLine(
FilesingConstants.LightVerbosity,
"- Config file '{0}' specified. Using config file's global ignores and requires. Ignoring file's patterns since 'regex' was specified on CLI.",
inFile
);
config = XmlLoader.LoadConfigFromXml(inFile, searchDir);
}
config.PatternConfigs.Clear();
PatternConfig patternConfig = new PatternConfig(regex);
config.PatternConfigs.Add(patternConfig);
}
config.SearchDirectoryLocation = searchDir;
return(config);
}
public TrendShiftPattern(ILogger logger, PatternConfig settings, string engineName = "Generic") : base(settings, logger, engineName)
{
Rules = new Dictionary <string, bool>();
PriceQueue = new Queue <decimal>();
avgPriceList = new Queue <decimal>();
Retention = settings.Retention;
Name = settings.Name;
Trend = 0;
Threshold = settings.Threshold;
avgPrice = 0;
avgPriceDelta = 0;
avgPriceChange = 0;
lastAvgPrice = 0;
_logger = logger;
DefaultStopLossThreshold = settings.DefaultStopLoss;
DynamicStopLossThreshold = settings.DynamicStopLoss;
}
public SpringPattern(ILogger logger, PatternConfig settings, string engineName = "Generic") : base(settings, logger, engineName)
{
Rules = new Dictionary <string, bool>();
PriceQueue = new Queue <decimal>();
Retention = settings.Retention;
Name = settings.Name;
ResetRules();
Trend = false;
Threshold = settings.Threshold;
Low = 0;
High = 0;
Spring = 0;
Pivot = 0;
LastPrice = 0;
_logger = logger;
DefaultStopLossThreshold = settings.DefaultStopLoss;
DynamicStopLossThreshold = settings.DynamicStopLoss;
}
private void PreparePatternSpringConfig(JObject settings)
{
Config.PatternsConfig = new Dictionary <string, PatternConfig>();
var pConfig = new PatternConfig();
pConfig.Name = settings["Name"].ToString();
pConfig.Symbol = settings["Symbol"].ToString();
pConfig.Interval = settings["Interval"].ToString();
pConfig.Threshold = decimal.Parse(settings["Threshold"].ToString());
pConfig.Retention = int.Parse(settings["Retention"].ToString());
pConfig.DefaultStopLoss = decimal.Parse(settings["DefaultSLThreshold"].ToString());
pConfig.DynamicStopLoss = decimal.Parse(settings["DynamicSLThreshold"].ToString());
pConfig.IsActive = true;
Config.PatternSpringThreshold = decimal.Parse(settings["Threshold"].ToString());
Config.PatternSpringToKeep = int.Parse(settings["Retention"].ToString());
var hash = pConfig.Name + "_" + pConfig.Symbol + "_" + pConfig.Interval;
Config.PatternsConfig.Add(hash, pConfig);
}
private Pattern NewPattern(string name, PatternConfig settings, string engineName)
{
var p = new Object();
switch (name)
{
case "Spring":
{
p = new SpringPattern(logger, settings, engineName);
break;
}
case "Streak":
{
p = new StreakPattern(logger, settings, engineName);
break;
}
case "TrendShift":
{
p = new TrendShiftPattern(logger, settings, engineName);
break;
}
case "TrendIncline":
{
p = new TrendInclinePattern(logger, settings, engineName);
break;
}
case "RulePattern":
{
p = new RulePattern(logger, settings, engineName);
break;
}
}
return((Pattern)p);
}
public MetadataParser(ILogger <MetadataParser> logger, IOptions <PatternConfig> patternConfig)
{
_logger = logger;
_patternConfig = patternConfig.Value;
}
public void XmlLoadTest()
{
string fileName = Path.Combine(testFilesDir, "TestConfig.xml");
FilesingConfig config = XmlLoader.LoadConfigFromXml(fileName, TestDirManager.TestDir);
// Check global ignore config
{
Assert.AreEqual(1, config.GlobalIgnoreConfigs.Count);
IgnoreConfig globalIgnoreConfig = config.GlobalIgnoreConfigs[0];
// Should only contain 1 file:
Assert.AreEqual(1, globalIgnoreConfig.IgnoredFiles.Count);
PathExistsInCollection(globalIgnoreConfig.IgnoredFiles, TestDirManager.RootFile1);
// Should only contain 1 dir:
Assert.AreEqual(1, globalIgnoreConfig.IgnoredDirectories.Count);
PathExistsInCollection(globalIgnoreConfig.IgnoredDirectories, TestDirManager.Dir2_MyDir);
// Should only contain 1 file with regex:
Assert.AreEqual(1, globalIgnoreConfig.IgnoredFilesWithRegex.Count);
FileRegexExistsInCollection(globalIgnoreConfig.IgnoredFilesWithRegex, "myFile.+", false);
// Should only contain 1 dir with regex:
Assert.AreEqual(1, globalIgnoreConfig.IgnoredDirectoriesWithRegex.Count);
DirRegexExistsInCollection(globalIgnoreConfig.IgnoredDirectoriesWithRegex, "dir3", true);
// Should contain 2 extensions to ignore.
Assert.AreEqual(2, globalIgnoreConfig.IgnoredFileExtensions.Count);
FileRegexExistsInCollection(globalIgnoreConfig.IgnoredFileExtensions, @"\.html", true);
FileRegexExistsInCollection(globalIgnoreConfig.IgnoredFileExtensions, @"\.dll", false);
}
// Check Requirements Config
{
Assert.AreEqual(1, config.GlobalRequireConfigs.Count);
RequireConfig globalRequireConfig = config.GlobalRequireConfigs[0];
// Should only contain 1 file:
Assert.AreEqual(1, globalRequireConfig.RequiredFiles.Count);
PathExistsInCollection(globalRequireConfig.RequiredFiles, TestDirManager.Dir1_HelloHtml);
// Should only contain 1 dir:
Assert.AreEqual(1, globalRequireConfig.RequiredDirs.Count);
PathExistsInCollection(globalRequireConfig.RequiredDirs, TestDirManager.Dir1);
}
// Check Patterns
Assert.AreEqual(3, config.PatternConfigs.Count);
// Check pattern 0
{
PatternConfig config0 = config.PatternConfigs[0];
Assert.AreEqual("public", config0.Pattern.ToString());
Assert.AreEqual(RegexOptions.Compiled | RegexOptions.IgnoreCase, config0.Pattern.Options);
// No ignores or requirements.
Assert.AreEqual(0, config0.IgnoreConfigs.Count);
Assert.AreEqual(0, config0.RequireConfigs.Count);
}
// Check pattern 1:
{
PatternConfig config1 = config.PatternConfigs[1];
Assert.AreEqual("class", config1.Pattern.ToString());
Assert.AreEqual(RegexOptions.Compiled, config1.Pattern.Options);
// Check ignore config
{
Assert.AreEqual(1, config1.IgnoreConfigs.Count);
IgnoreConfig ignoreConfig = config1.IgnoreConfigs[0];
// Should only contain 1 file:
Assert.AreEqual(1, ignoreConfig.IgnoredFiles.Count);
PathExistsInCollection(ignoreConfig.IgnoredFiles, TestDirManager.RootFile2);
// Should only contain 1 dir:
Assert.AreEqual(1, ignoreConfig.IgnoredDirectories.Count);
PathExistsInCollection(ignoreConfig.IgnoredDirectories, TestDirManager.Dir1);
// Should only contain 1 file with regex:
Assert.AreEqual(1, ignoreConfig.IgnoredFilesWithRegex.Count);
FileRegexExistsInCollection(ignoreConfig.IgnoredFilesWithRegex, "Hello", false);
// Should only contain 1 dir with regex:
Assert.AreEqual(1, ignoreConfig.IgnoredDirectoriesWithRegex.Count);
DirRegexExistsInCollection(ignoreConfig.IgnoredDirectoriesWithRegex, "Dir1", false);
// Should contain 2 extensions to ignore.
Assert.AreEqual(2, ignoreConfig.IgnoredFileExtensions.Count);
FileRegexExistsInCollection(ignoreConfig.IgnoredFileExtensions, @"\.txt", true);
FileRegexExistsInCollection(ignoreConfig.IgnoredFileExtensions, @"\.EXE", false);
}
// Check requirements config
{
Assert.AreEqual(1, config1.RequireConfigs.Count);
RequireConfig requireConfig = config1.RequireConfigs[0];
// Should only contain 1 file:
Assert.AreEqual(1, requireConfig.RequiredFiles.Count);
PathExistsInCollection(requireConfig.RequiredFiles, TestDirManager.Dir2_MyfileTxt);
// Should only contain 1 dir:
Assert.AreEqual(1, requireConfig.RequiredDirs.Count);
PathExistsInCollection(requireConfig.RequiredDirs, TestDirManager.Dir2_MyDir);
}
}
// Check pattern 2:
{
PatternConfig config2 = config.PatternConfigs[2];
Assert.AreEqual("hello", config2.Pattern.ToString());
Assert.AreEqual(RegexOptions.Compiled | RegexOptions.IgnoreCase, config2.Pattern.Options);
// No ignores or requirements.
Assert.AreEqual(0, config2.IgnoreConfigs.Count);
Assert.AreEqual(0, config2.RequireConfigs.Count);
}
}
private void PatternConfiguration(PatternConfig settings)
{
PatternConfig.Add(settings.Name, settings);
}
