internal void Init(OptionsBase options)
{
this.isInitializing = true;
this.options = options;
this.OnInit();
this.isInitializing = false;
}
// -- constructor
public ImportPipeline(OptionsBase options, FactoryBase factory, RuntimeBase runtime)
{
Arguments = new Dictionary <SimulationTypes, ArgumentsBase>();
Options = options;
Factory = factory;
Runtime = runtime;
}
private static void InitLogger(OptionsBase options)
{
var eventLevel = options.Verbose ? LogEventLevel.Verbose : LogEventLevel.Information;
var logFile = Path.Combine(ApplicationDataDirectory.FullName, "logs", "log_.txt");
var config = new LoggerConfiguration()
.WriteTo.Console(restrictedToMinimumLevel: eventLevel)
#if DEBUG
.WriteTo.Debug(restrictedToMinimumLevel: LogEventLevel.Verbose)
#endif
.MinimumLevel.Verbose();
if (!options.NoLog)
{
config = config.WriteTo.File(
logFile, restrictedToMinimumLevel: eventLevel,
rollingInterval: RollingInterval.Day, retainedFileCountLimit: 7);
}
Log.Logger = config.CreateLogger();
Log.Information("Operating system: {0}", RuntimeInformation.OSDescription);
Log.Information("Runtime: {0}", RuntimeInformation.FrameworkDescription);
Log.Information("GUI version: {0}", VersionStatistics.AppVersion);
foreach (var kvp in VersionStatistics.LoadedAssemblyVersions)
{
Log.Information("Using {0} v{1}", kvp.Key.GetName().Name, kvp.Value);
}
Log.Verbose($"Application directory: {ApplicationDirectory.FullName}");
Log.Verbose($"Data directory: {ApplicationDataDirectory.FullName}");
}
private static async Task InitProgramAsync(OptionsBase options)
{
var restartArgs = new List <string>(3);
if (options.Verbose)
{
restartArgs.Add("--verbose");
}
if (options.NoLog)
{
restartArgs.Add("--no-log");
}
if (!string.IsNullOrWhiteSpace(options.AppDataPath))
{
restartArgs.Add($"--app-data=\"{options.AppDataPath}\"");
}
RestartArgs = string.Join(" ", restartArgs);
var factory = new GlobalSingletonFactory(ApplicationDirectory, ApplicationDataDirectory);
Settings = factory.LoadSettings();
(Manager, Locations, ModStateManager) = await factory.CreateManagerAsync(Settings);
Locations.ModsReloaded += async(s, e) =>
{
_modpacks = await LoadModpacksAsync();
};
_modpacks = await LoadModpacksAsync();
}
public SignalrClient(AppSettings appSettings, OptionsBase options)
{
string host = appSettings.Host;
int port = appSettings.RpcPort;
if (!string.IsNullOrWhiteSpace(options.Host))
{
host = options.Host;
}
if (options.Port.HasValue)
{
port = options.Port.Value;
}
this.connection = new HubConnectionBuilder().WithUrl(new UriBuilder(appSettings.UseTls ? "https" : "http", host, port, "signal").ToString()).WithAutomaticReconnect().AddJsonProtocol(options2 => {
options2.PayloadSerializerOptions.WriteIndented = false;
}).Build();
this.connection.Closed += async error => {
await Task.Delay(new Random().Next(0, 5) * 1000).ConfigureAwait(false);
await this.connection.StartAsync().ConfigureAwait(false);
};
}
public static bool AzureAuth(OptionsBase o)
{
if (o.AccountKey is null)
{
Offline = true;
return(true);
}
if (o.AccountKey.EndsWith(".txt"))
{
if (!File.Exists(o.AccountKey))
{
Console.WriteLine($"Account key file '{o.AccountKey}' does not exist. Aborting...");
return(false);
}
o.AccountKey = File.ReadAllText(o.AccountKey);
}
try
{
var credentials = new StorageCredentials(o.AccountName, o.AccountKey);
Account = new CloudStorageAccount(credentials, true);
Experiment = o.Experiment;
return(true);
}
catch (Exception e)
{
File.WriteAllText("log.txt", e.ToString());
Console.WriteLine("Azure authentication failed. Aborting...");
return(false);
}
}
public PKVesrionOptionPage(OptionsBase option)
{
InitializeComponent();
this.controlledOption = option;
VerCB.Items.Clear();
VerCB.Items.Add(new PKVer("Manual select", string.Empty));
//string s = Environment.GetEnvironmentVariable("SPOCLIENT");
//if (!string.IsNullOrEmpty(s))
//{
// VerCB.Items.Add(new PKVer("Environment variable", s));
//}
using (RegistryKey key = Registry.LocalMachine.OpenSubKey(@"Software\Microsoft\.NETMicroFrameworkPortingKit"))
{
if (key != null)
{
foreach (string str in key.GetSubKeyNames())
{
using (RegistryKey key1 = key.OpenSubKey(str))
{
if (key1 != null)
{
VerCB.Items.Add(new PKVer(str, key1.GetValue("InstallRoot").ToString()));
}
}
}
}
}
VerCB.SelectedIndex = 0;
string s = Environment.GetEnvironmentVariable("SPOCLIENT");
if (s[s.Length - 1] != '\\')
{
s += "\\";
}
if (!string.IsNullOrEmpty(s))
{
PathTB.Text = s;
PKVersionOption po = this.controlledOption as PKVersionOption;
for (int i = 1; i < VerCB.Items.Count; i++)
{
PKVer ver = VerCB.Items[i] as PKVer;
if (ver != null)
{
if (String.Compare(ver.Path, s, true) == 0)
{
VerCB.SelectedIndex = i;
}
}
}
}
}
public override void SetOption(OptionsBase option)
{
base.SetOption(option);
((EnvironmentOption)option).OnApplyChanges();
this.RefreshControl();
ModifiedChange();
}
internal async Task <MatchDescriptor> HostMatch(string gameName, OptionsBase options)
{
Endpoint e = Endpoint.NewGame(_gameServer.TranslateGameName(gameName), Player.Secret);
ConnectorPayloadBase payload = new NewMatchPayload(Player.Name, options);
MatchDescriptor match = await _gameServer.PostJSON <MatchDescriptor>(e, payload);
CurrentMatchID = match.MatchId;
return(match);
}
internal BaseMultiCombiner(IHostEnvironment env, string name, OptionsBase args)
{
Contracts.AssertValue(env);
env.AssertNonWhiteSpace(name);
Host = env.Register(name);
Host.CheckValue(args, nameof(args));
Normalize = args.Normalize;
}
private static ErrorCode HandleError(Exception e, OptionsBase options)
{
Console.WriteLine("Unexpected error occured. Show this to your programmer");
Console.WriteLine("Error:");
Console.WriteLine(e.Message);
Console.WriteLine("Stacktrace:");
Console.WriteLine(e.StackTrace);
return(ErrorCode.Fail);
}
public BoosterParameterBase(OptionsBase options)
{
Contracts.CheckUserArg(options.MinimumSplitGain >= 0, nameof(OptionsBase.MinimumSplitGain), "must be >= 0.");
Contracts.CheckUserArg(options.MinimumChildWeight >= 0, nameof(OptionsBase.MinimumChildWeight), "must be >= 0.");
Contracts.CheckUserArg(options.SubsampleFraction > 0 && options.SubsampleFraction <= 1, nameof(OptionsBase.SubsampleFraction), "must be in (0,1].");
Contracts.CheckUserArg(options.FeatureFraction > 0 && options.FeatureFraction <= 1, nameof(OptionsBase.FeatureFraction), "must be in (0,1].");
Contracts.CheckUserArg(options.L2Regularization >= 0, nameof(OptionsBase.L2Regularization), "must be >= 0.");
Contracts.CheckUserArg(options.L1Regularization >= 0, nameof(OptionsBase.L1Regularization), "must be >= 0.");
BoosterOptions = options;
}
protected SweeperBase(OptionsBase options, IHostEnvironment env, IValueGenerator[] sweepParameters, string name)
{
Contracts.CheckValue(env, nameof(env));
env.CheckNonWhiteSpace(name, nameof(name));
Host = env.Register(name);
Host.CheckValue(options, nameof(options));
Host.CheckValue(sweepParameters, nameof(sweepParameters));
_options = options;
SweepParameters = sweepParameters;
}
protected SweeperBase(OptionsBase options, IHostEnvironment env, string name)
{
Contracts.CheckValue(env, nameof(env));
env.CheckNonWhiteSpace(name, nameof(name));
Host = env.Register(name);
Host.CheckValue(options, nameof(options));
Host.CheckNonEmpty(options.SweptParameters, nameof(options.SweptParameters));
_options = options;
SweepParameters = options.SweptParameters.Select(p => p.CreateComponent(Host)).ToArray();
}
internal static ICache CreateCache(OptionsBase options)
{
if (options.ConnectionOptions == null)
{
return(CacheManager.GetCache(
options.CacheId));
}
else
{
return(CacheManager.GetCache(options.CacheId, options.ConnectionOptions.CacheConnectionOptions));
}
}
protected ExeConfigRunnerBase(OptionsBase args, IHostEnvironment env, string registrationName)
{
Contracts.AssertValue(env);
Host = env.Register(registrationName);
Host.CheckUserArg(!string.IsNullOrEmpty(args.ArgsPattern), nameof(args.ArgsPattern), "The command pattern is missing");
Host.CheckUserArg(!string.IsNullOrEmpty(args.OutputFolderName), nameof(args.OutputFolderName), "Please specify an output folder");
ArgsPattern = args.ArgsPattern;
OutputFolder = GetOutputFolderPath(args.OutputFolderName);
Prefix = string.IsNullOrEmpty(args.Prefix) ? "" : args.Prefix;
ResultProcessor = args.ResultProcessor.CreateComponent(Host);
_calledFromUnitTestSuite = args.CalledFromUnitTestSuite;
RunNums = new List <int>();
}
private void OnEnable()
{
options = OptionsBase.LoadFromFile(
Paths.GetOptionsFilePath()) as Options;
calibratingTouchscreen = true;
RefreshRadioButtons();
RefreshSliders();
RefreshInputFields();
stopwatch = new System.Diagnostics.Stopwatch();
stopwatch.Start();
bgSource.Play();
}
public async Task TestConfigFailure(string fileName, Strings expectedMessage)
{
var client = A.Fake <IStoreClient>();
var logger = new MockLogger();
var stringprovider = new StringProvider();
var command = new MockCommandBase(client, logger, stringprovider);
var options = new OptionsBase
{
ConfigFile = $"{this.GetExecutingPath()}\\Files\\{fileName}"
};
var result = await command.DoCommand(options);
logger.Message.ElementAt(logger.Message.Count - 2).Should().Be(string.Format(stringprovider.GetString(expectedMessage), options.ConfigFile), "because there is something wrong with the config file");
result.Should().BeNegative("the config file is invalid");
}
public async Task TestLoginSuccess()
{
var client = A.Fake <IStoreClient>();
A.CallTo(() => client.Login("myId", "myKey", "myTenantId")).Returns(Task.Factory.StartNew(() => true));
var logger = new MockLogger();
var stringprovider = new StringProvider();
var command = new MockCommandBase(client, logger, stringprovider);
var options = new OptionsBase
{
ConfigFile = $"{this.GetExecutingPath()}\\Files\\.valid_config"
};
var result = await command.DoCommand(options);
result.Should().BeGreaterOrEqualTo(0, "client credentials do not match");
A.CallTo(() => client.Login("myId", "myKey", "myTenantId")).MustHaveHappened();
}
private static void SetDirectories(OptionsBase options)
{
// Application directory
var assembly = Assembly.GetEntryAssembly();
ApplicationDirectory = new DirectoryInfo(Path.GetDirectoryName(assembly !.Location) !);
// Data directory
if (string.IsNullOrWhiteSpace(options.AppDataPath))
{
ApplicationDataDirectory = GetApplicationDataDirectory();
if (!ApplicationDataDirectory.Exists)
{
ApplicationDataDirectory.Create();
}
}
else
{
try
{
ApplicationDataDirectory = new DirectoryInfo(options.AppDataPath);
if (!ApplicationDataDirectory.Exists)
{
ApplicationDataDirectory.Create();
}
}
catch
{
// We play it safe here and fall back to the default since at this point
// in the app lifetime we cannot properly handle this error except crashing
ApplicationDataDirectory = GetApplicationDataDirectory();
if (!ApplicationDataDirectory.Exists)
{
ApplicationDataDirectory.Create();
}
}
}
// Temporary directory
TemporaryDirectory = new DirectoryInfo(Path.Combine(Path.GetTempPath(), "ModMyFactoryGUI"));
if (!TemporaryDirectory.Exists)
{
TemporaryDirectory.Create();
}
}
public EnvironmentOptionsPage(OptionsBase option)
{
InitializeComponent();
this.controlledOption = option;
ToolCB.Items.Clear();
ToolCB.Items.Add("GCC");
ToolCB.Items.Add("GCCOP");
ToolCB.Items.Add("MDK");
ToolCB.Items.Add("RVDS");
ToolCB.Items.Add("SHC");
ToolCB.Items.Add("VS");
ToolCB.SelectedIndex = 3;
UpdatePath();
this.Modified = false;
}
/// <summary>
/// Initializes the <see cref="MetaMulticlassClassificationTrainer{TTransformer, TModel}"/> from the <see cref="OptionsBase"/> class.
/// </summary>
/// <param name="env">The private instance of the <see cref="IHostEnvironment"/>.</param>
/// <param name="options">The legacy arguments <see cref="OptionsBase"/>class.</param>
/// <param name="name">The component name.</param>
/// <param name="labelColumn">The label column for the metalinear trainer and the binary trainer.</param>
/// <param name="singleEstimator">The binary estimator.</param>
/// <param name="calibrator">The calibrator. If a calibrator is not explicitly provided, it will default to <see cref="PlattCalibratorTrainer"/></param>
internal MetaMulticlassClassificationTrainer(IHostEnvironment env, OptionsBase options, string name, string labelColumn = null,
TScalarTrainer singleEstimator = null, ICalibratorTrainer calibrator = null)
{
Host = Contracts.CheckRef(env, nameof(env)).Register(name);
Host.CheckValue(options, nameof(options));
Args = options;
if (labelColumn != null)
LabelColumn = new SchemaShape.Column(labelColumn, SchemaShape.Column.VectorKind.Scalar, NumberDataViewType.UInt32, true);
Trainer = singleEstimator ?? CreateTrainer();
Calibrator = calibrator ?? new PlattCalibratorTrainer(env);
if (options.Calibrator != null)
Calibrator = options.Calibrator.CreateComponent(Host);
// Regarding caching, no matter what the internal predictor, we're performing many passes
// simply by virtue of this being a meta-trainer, so we will still cache.
Info = new TrainerInfo(normalization: Trainer.Info.NeedNormalization);
}
private void LoadOrCreateOptions()
{
options = null;
try
{
options = OptionsBase.LoadFromFile(
Paths.GetOptionsFilePath()) as Options;
}
catch (IOException)
{
options = new Options();
}
// Find all resolutions, as well as resolutionIndex.
resolutions = new List <Resolution>();
resolutionIndex = -1;
for (int i = 0; i < Screen.resolutions.Length; i++)
{
Resolution r = Screen.resolutions[i];
resolutions.Add(r);
if (r.width == options.width &&
r.height == options.height &&
r.refreshRate == options.refreshRate)
{
resolutionIndex = i;
}
}
if (resolutionIndex == -1)
{
// Restore default resolution.
resolutionIndex = resolutions.Count - 1;
options.width = resolutions[resolutionIndex].width;
options.height = resolutions[resolutionIndex].height;
options.refreshRate = resolutions[resolutionIndex].refreshRate;
}
}
public DataStrategyWithOptions(DataStrategy wrappedStrategy, OptionsBase options)
{
_options = options;
_wrappedStrategy = wrappedStrategy.Clone();
_wrappedStrategy.GetAdapter().Options = options;
}
internal BaseMultiAverager(IHostEnvironment env, string name, OptionsBase args)
: base(env, name, args)
{
}
protected SerializerBase(OptionsBase options)
{
_hooks = CollectionUtils.Cast <IJsmlSerializerHook>(new JsmlSerializerHookExtensionPoint().CreateExtensions());
Options = options;
}
public DeobfuscatorBase(OptionsBase optionsBase)
{
this.optionsBase = optionsBase;
StringFeatures = StringFeatures.AllowAll;
DefaultDecrypterType = DecrypterType.Static;
}
public SignalrClient(AppSettings appSettings, OptionsBase options, IApiEvents eventHandler) : this(appSettings, options)
{
// make sure we can receive events
this.RegisterEvents(eventHandler);
}
public UniformRandomSweeper(IHostEnvironment env, OptionsBase options, IValueGenerator[] sweepParameters)
: base(options, env, sweepParameters, "UniformRandom")
{
}
public UniformRandomSweeper(IHostEnvironment env, OptionsBase options)
: base(options, env, "UniformRandom")
{
}
private void AddNodes(TreeNodeCollection nodes, OptionsBase options)
{
foreach (OptionsBase options1 in (IEnumerable<OptionsBase>) options.SubOptions)
{
OptionsNode optionsNode = new OptionsNode(options1);
nodes.Add((TreeNode) optionsNode);
if (!this.optionsNodes.ContainsKey(options1.GetType()))
this.optionsNodes.Add(options1.GetType(), optionsNode);
this.AddNodes(optionsNode.Nodes, options1);
}
if (nodes.Count <= 0 || options is AppOptions)
return;
GeneralOptionsNode generalOptionsNode = new GeneralOptionsNode(options);
nodes.Insert(0, (TreeNode) generalOptionsNode);
}
public dynamic WithOptions(OptionsBase options)
{
return new DataStrategyWithOptions(this, options);
}
public GeneralOptionsNode(OptionsBase options) : base(options)
{
this.Text = "General";
}
public OptionsNode(OptionsBase options) : base(options.Text)
{
this.Options = options;
}
public static void SetOptions(OptionsBase options)
{
options.Host = Global.DefaultHost;
options.SourceDir = Global.AssemblyDir;
options.OutputDir = Global.TempDir;
}
public DataStrategyWithOptions(DataStrategy wrappedStrategy, OptionsBase options)
{
_options = options;
_wrappedStrategy = wrappedStrategy.Clone();
_wrappedStrategy.GetAdapter().Options = options;
}
