/// <summary>
        /// Initialization of the package; this method is called right after the package is sited, so this is the place
        /// where you can put all the initialization code that rely on services provided by VisualStudio.
        /// </summary>
        /// <param name="cancellationToken">A cancellation token to monitor for initialization cancellation, which can occur when VS is shutting down.</param>
        /// <param name="progress">A provider for progress updates.</param>
        /// <returns>A task representing the async work of package initialization, or an already completed task if there is none. Do not return null from this method.</returns>
        protected override void Initialize()
        {
            var root = Path_.Directory(Assembly.GetExecutingAssembly().Location);

            AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve;
            Assembly?CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
            {
                var path = Path_.CombinePath(root, new AssemblyName(args.Name).Name + ".dll");

                if (!Path_.FileExists(path))
                {
                    return(null);
                }
                return(Assembly.LoadFrom(path));
            }

            // When initialized asynchronously, the current thread may be a background thread at this point.
            // Do any initialization that requires the UI thread after switching to the UI thread.
            //await this.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
            base.Initialize();

            // Add our command handlers for menu
            if (GetService <IMenuCommandService>() is OleMenuCommandService mcs)
            {
                mcs.AddCommand(new AlignMenuCommand(this));
                mcs.AddCommand(new UnalignMenuCommand(this));
            }
        }
Exemple #2
0
        /// <summary>Called when a new user account has been assigned</summary>
        private void HandleAcctChanged(object sender = null, EventArgs e = null)
        {
            // Ensure closed
            Util.Dispose(ref m_db);

            // If there is no account id, don't open a database
            if (Model == null || !Model.Acct.AccountId.HasValue())
            {
                return;
            }

            // Open a database of the trade history and other user account related info
            var filepath = Path_.CombinePath(Settings.General.AcctDataCacheDir, "Acct_{0}.db".Fmt(Model.Acct.AccountId));

            m_db = new Sqlite.Database(filepath);

            // Tweak some DB settings for performance
            m_db.Execute(Sqlite.Sql("PRAGMA synchronous = OFF"));
            m_db.Execute(Sqlite.Sql("PRAGMA journal_mode = MEMORY"));

            // Ensure the table of trades exists
            var sql = Sqlite.Sql("create table if not exists ", Table.TradeHistory, " (\n",
                                 "[", nameof(Trade.Id), "] text primary key,\n",
                                 "[", nameof(Trade.SymbolCode), "] text)");

            m_db.Execute(sql);

            // Ensure the table of orders exists
            sql = Sqlite.Sql("create table if not exists ", Table.Orders, " (\n",
                             "[", nameof(Order.Id), "] integer primary key,\n",
                             "[", ("TradeId"), "] text,\n",
                             "[", nameof(Order.SymbolCode), "] text,\n",
                             "[", nameof(Order.TradeType), "] integer)");
            m_db.Execute(sql);
        }
Exemple #3
0
        // Notes:
        // This is a base class for an entry signal trigger.
        // Derived types use various methods to guess where price is going.
        // Derived types add 'Feature' objects to the 'Features' collection, these are basically
        // values in the range [-1.0,+1.0] where -1.0 = strong sell, +1.0 = strong buy.

        public Predictor(Rylobot bot, string name)
        {
            Bot          = bot;
            Name         = name;
            CurrentIndex = 0;
            Instrument   = new Instrument(bot);
            Features     = new List <Feature>();
            LogFilepath  = Path_.CombinePath(@"P:\projects\Tradee\Rylobot\Rylobot\net\Data", "{0}.predictions.csv".Fmt(name));
        }
Exemple #4
0
        public StrategyDataCollector(Rylobot bot)
            : base(bot, "StrategyDataCollector")
        {
            NNet = new PredictorNeuralNet(bot);

            WindowSize   = 20;
            RtRThreshold = 2.0;

            // Generate the training and test data
            var outdir = @"P:\projects\Tradee\Rylobot\Rylobot\net\Data";

            m_training = new StreamWriter(Path_.CombinePath(outdir, "training.txt"));
            m_testing  = new StreamWriter(Path_.CombinePath(outdir, "testing.txt"));
        }
Exemple #5
0
        public void TestPathNames()
        {
            string path;

            //path = Path_.RelativePath(@"A:\dir\subdir\file.ext", @"A:\dir");
            //Assert.Equal(@".\subdir\file.ext", path);

            path = Path_.CombinePath(@"A:\", @".\dir\subdir2", @"..\subdir\", "file.ext");
            Assert.Equal(@"A:\dir\subdir\file.ext", path);

            path = Path_.SanitiseFileName("1_path@\"[{+\\!@#$%^^&*()\'/?", "@#$%", "A");
            Assert.Equal("1_pathAA[{+A!AAAA^^&A()'AA", path);

            const string noquotes   = "C:\\a b\\path.ext";
            const string withquotes = "\"C:\\a b\\path.ext\"";

            Assert.Equal(withquotes, Path_.Quote(noquotes, true));
            Assert.Equal(withquotes, Path_.Quote(withquotes, true));
            Assert.Equal(noquotes, Path_.Quote(noquotes, false));
            Assert.Equal(noquotes, Path_.Quote(withquotes, false));
        }
Exemple #6
0
        public StartupOptions(string[] args)
        {
            var exe_dir = Util.ResolveAppPath();

            if (!Path_.DirExists(exe_dir))
            {
                throw new ArgumentException("Cannot determine the current executable directory");
            }

            // Check the command line options
            for (int i = 0, iend = args.Length; i != iend; ++i)
            {
                var arg = args[i].ToLowerInvariant();

                // No option character implies the file to load
                if (arg[0] != '-' && arg[0] != '/')
                {
                    if (FileToLoad != null)
                    {
                        throw new ArgumentException("Command line should specify a single file path only. If the file path contains white space, remember to use quotes. e.g. RyLogViewer \"my file.txt\"");
                    }
                    FileToLoad = arg;
                    continue;
                }

                // Helper for comparing option strings
                bool IsOption(string opt) => string.CompareOrdinal(arg, 0, opt, 0, opt.Length) == 0;

                // (order these by longest option first)
                if (IsOption(CmdLineOption.RDelim))
                {
                    RowDelim = arg.Substring(CmdLineOption.RDelim.Length);
                }
                else if (IsOption(CmdLineOption.CDelim))
                {
                    ColDelim = arg.Substring(CmdLineOption.CDelim.Length);
                }
                else if (IsOption(CmdLineOption.NoGUI))
                {
                    NoGUI = true;
                }
                else if (IsOption(CmdLineOption.Silent))
                {
                    Silent = true;
                }
                else if (IsOption(CmdLineOption.PatternSet))
                {
                    PatternSetFilepath = arg.Substring(CmdLineOption.PatternSet.Length);
                }
                else if (IsOption(CmdLineOption.SettingsPath))
                {
                    SettingsPath = arg.Substring(CmdLineOption.SettingsPath.Length);
                }
                else if (IsOption(CmdLineOption.LogFilePath))
                {
                    LogFilePath = arg.Substring(CmdLineOption.LogFilePath.Length);
                }
                else if (IsOption(CmdLineOption.Export))
                {
                    ExportPath = arg.Substring(CmdLineOption.Export.Length);
                }
                else if (IsOption(CmdLineOption.Portable))
                {
                    PortableMode = true;
                }
                else if (IsOption(CmdLineOption.ShowHelp))
                {
                    ShowHelp = true;
                }
                else if (IsOption(CmdLineOption.ShowHelp2))
                {
                    ShowHelp = true;
                }
                else
                {
                    throw new ArgumentException("Unknown command line option '" + arg + "'.");
                }
            }

            // Determine whether to run the app in portable mode
            PortableMode |= Path_.FileExists(Path_.CombinePath(exe_dir, "portable"));

            // Set the UserDataDir based on whether we're running in portable mode or not
            UserDataDir = PortableMode
                                ? Util.ResolveAppPath()
                                : Util.ResolveUserDocumentsPath(Util.AppCompany, Util.AppProductName);

            // If we're in portable mode, check that we have write access to the local directory
            if (PortableMode)
            {
                if (!Path_.DirExists(UserDataDir) || (new DirectoryInfo(UserDataDir).Attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
                {
                    throw new IOException("Unable to run in portable mode as the directory ('" + UserDataDir + "') is readonly.");
                }
            }
            // If not in portable mode, check the UserDataDir directory exists (or can be created)
            else
            {
                if (!Path_.DirExists(UserDataDir))
                {
                    Directory.CreateDirectory(UserDataDir);
                }
            }

            // If the export option is given, a 'FileToLoad' must also be given
            if (ExportPath != null && FileToLoad == null)
            {
                throw new ArgumentException("A file to export must be given if the '-e' option is used");
            }

            // If a settings path has not been given, use the defaults
            if (SettingsPath == null)
            {
                SettingsPath = Path.Combine(UserDataDir, "settings2.xml");
            }

            // Set the licence file path
            LicenceFilepath = PortableMode
                                ? Path.Combine(exe_dir, "licence.xml")
                                : Path.Combine(UserDataDir, "licence.xml");

            // If no licence file exists, create the free one
            if (!Path_.FileExists(LicenceFilepath))
            {
                new Licence().WriteLicenceFile(LicenceFilepath);
            }
        }
Exemple #7
0
        /// <summary>Pull 'filename' from EDDB. Returns true if the file was downloaded, and the output filepath</summary>
        public async Task <DownloadFileResult> DownloadFile(string file_url, string output_dir, TimeSpan?maximum_age = null)
        {
            var filename    = Path_.FileName(file_url);
            var output_path = Path_.CombinePath(Path_.CreateDirs(output_dir), filename);

            using (StatusStack.NewStatusMessage($"Downloading '{filename}'..."))
            {
                try
                {
                    HttpRequestMessage  req;
                    HttpResponseMessage resp;

                    // Request the head information about the target file
                    Log.Write(ELogLevel.Info, $"Checking size and timestamp of '{filename}'");
                    req  = new HttpRequestMessage(HttpMethod.Head, file_url);
                    resp = await Client.SendAsync(req, Shutdown);

                    if (!resp.IsSuccessStatusCode)
                    {
                        Log.Write(ELogLevel.Error, $"Downloading information for '{filename}' failed: {resp.StatusCode} {resp.ReasonPhrase}");
                        throw new HttpRequestException($"{resp.ReasonPhrase} ({resp.StatusCode})");
                    }

                    // Only download if the server version is newer.
                    if (maximum_age != null && Path_.FileExists(output_path))
                    {
                        var time_diff = new FileInfo(output_path).LastWriteTime - resp.Content.Headers.LastModified;
                        if (time_diff > -maximum_age.Value)
                        {
                            Log.Write(ELogLevel.Info, $"Local copy of '{filename}' is less than {Settings.Instance.DataAge.ToPrettyString(trailing_zeros:false)} older than the latest version");
                            return(new DownloadFileResult(file_url, output_path, false));
                        }
                    }

                    // Get the download size (remember it might be compressed)
                    var length = resp.Content.Headers.ContentLength;

                    // The server version is newer, download the whole file
                    Log.Write(ELogLevel.Info, $"Downloading '{filename}' ({length} bytes)");
                    using (Scope.Create(() => Downloading = true, () => Downloading = false))
                    {
                        // Make the web request
                        req  = new HttpRequestMessage(HttpMethod.Get, file_url);
                        resp = await Client.SendAsync(req, Shutdown);

                        if (!resp.IsSuccessStatusCode)
                        {
                            Log.Write(ELogLevel.Error, $"Downloading '{filename}' failed: {resp.StatusCode} {resp.ReasonPhrase}");
                            throw new HttpRequestException($"{resp.ReasonPhrase} ({resp.StatusCode})");
                        }

                        // Read the response content into a file
                        using (var file = new FileStream(output_path, FileMode.Create, FileAccess.Write, FileShare.Read))
                        {
                            // Decompress if the content is compressed
                            if (resp.Content.Headers.ContentEncoding.Any(x => x == "gzip"))
                            {
                                using (var content = await resp.Content.ReadAsStreamAsync())
                                    using (var gzip = new GZipStream(content, CompressionMode.Decompress))
                                        await gzip.CopyToAsync(file);
                            }
                            else
                            {
                                await resp.Content.CopyToAsync(file);
                            }

                            Log.Write(ELogLevel.Info, $"Download complete '{filename}'");
                            return(new DownloadFileResult(file_url, output_path, true));
                        }
                    }
                }
                catch
                {
                    Log.Write(ELogLevel.Error, $"Data file '{filename}' was not available from {file_url}.");
                    return(new DownloadFileResult(file_url, output_path, false));
                }
            }
        }
Exemple #8
0
        // Notes:
        //  - Parsed command line options

        public StartupOptions(string[] args)
        {
            FilesToLoad  = new List <string>();
            SettingsPath = null !;

            var exe_dir = Util.ResolveAppPath();

            if (!Path_.DirExists(exe_dir))
            {
                throw new ArgumentException("Cannot determine the current executable directory");
            }

            // Check the command line options
            for (int i = 0, iend = args.Length; i != iend; ++i)
            {
                var arg = args[i].ToLowerInvariant();

                // No option character implies the file to load
                if (arg[0] != '-' && arg[0] != '/')
                {
                    FilesToLoad.Add(arg);
                    continue;
                }

                // Helper for comparing option strings
                bool IsOption(string opt) => string.CompareOrdinal(arg, 0, opt, 0, opt.Length) == 0;

                // (order these by longest option first)
                if (IsOption(CmdLine.SettingsPath))
                {
                    SettingsPath = arg.Substring(CmdLine.SettingsPath.Length);
                }
                else if (IsOption(CmdLine.Portable))
                {
                    PortableMode = true;
                }
                else if (IsOption(CmdLine.ShowHelp))
                {
                    ShowHelp = true;
                }
                else if (IsOption(CmdLine.ShowHelp2))
                {
                    ShowHelp = true;
                }
                else
                {
                    throw new ArgumentException($"Unknown command line option '{arg}'.");
                }
            }

            // Determine whether to run the app in portable mode
            PortableMode |= Path_.FileExists(Path_.CombinePath(exe_dir, "portable"));

            // Set the UserDataDir based on whether we're running in portable mode or not
            UserDataDir = Path.GetFullPath(PortableMode ? Path_.CombinePath(exe_dir, "UserData") : Util.ResolveUserDocumentsPath("Rylogic", "LDraw"));
            Path_.CreateDirs(UserDataDir);

            // Check that we have write access to the user data directory
            if (!Path_.DirExists(UserDataDir) || (new DirectoryInfo(UserDataDir).Attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)
            {
                throw new IOException($"The user data directory ('{UserDataDir}') is readonly.");
            }

            // If a settings path has not been given, use the defaults
            SettingsPath ??= Path_.CombinePath(UserDataDir, "settings2.xml");
        }
Exemple #9
0
        /// <summary>
        /// Smart copy from 'src' to 'dst'. Loosely like XCopy.
        /// 'src' can be a single file, a comma separated list of files, or a directory<para/>
        /// 'dst' can be a
        /// if 'src' is a directory, </summary>
        public static void Copy(string src, string dst, bool overwrite = false, bool only_if_modified = false, bool ignore_non_existing = false, Action <string>?feedback = null, bool show_unchanged = false)
        {
            var src_is_dir = Path_.IsDirectory(src);
            var dst_is_dir = Path_.IsDirectory(dst) || dst.EndsWith("/") || dst.EndsWith("\\") || src_is_dir;

            // Find the names of the source files to copy
            var files = new List <string>();

            if (src_is_dir)
            {
                files = Path_.EnumFileSystem(src, SearchOption.AllDirectories).Select(x => x.FullName).ToList();
            }
            else if (Path_.FileExists(src))
            {
                files = new List <string>()
                {
                    src
                }
            }
            ;
            else if (src.Contains('*') || src.Contains('?'))
            {
                files = Path_.EnumFileSystem(src, SearchOption.AllDirectories, new Pattern(EPattern.Wildcard, src).RegexString).Select(x => x.FullName).ToList();
            }
            else if (!ignore_non_existing)
            {
                throw new FileNotFoundException($"'{src}' does not exist");
            }

            // If the 'src' represents multiple files, 'dst' must be a directory
            if (src_is_dir || files.Count > 1)
            {
                // if 'dst' doesn't exist, assume it's a directory
                if (!Path_.DirExists(dst))
                {
                    dst_is_dir = true;
                }

                // or if it does exist, check that it is actually a directory
                else if (!dst_is_dir)
                {
                    throw new FileNotFoundException($"'{dst}' is not a valid directory");
                }
            }

            // Ensure that 'dstdir' exists. (Canonicalise fixes the case where 'dst' is a drive, e.g. 'C:\')
            var dstdir = Path_.Canonicalise((dst_is_dir ? dst : Path_.Directory(dst)).TrimEnd('/', '\\'));

            if (!Path_.DirExists(dstdir))
            {
                Directory.CreateDirectory(dstdir);
            }

            // Copy the file(s) to 'dst'
            foreach (var srcfile in files)
            {
                // If 'dst' is a directory, use the same filename from 'srcfile'
                var dstfile = string.Empty;
                if (dst_is_dir)
                {
                    var spath = src_is_dir ? Path_.RelativePath(src, srcfile) : Path_.FileName(srcfile);
                    dstfile = Path_.CombinePath(dstdir, spath);
                }
                else
                {
                    dstfile = dst;
                }

                // If 'srcfile' is a directory, ensure the directory exists at the destination
                if (Path_.IsDirectory(srcfile))
                {
                    if (!dst_is_dir)
                    {
                        throw new Exception($"ERROR: {dst} is not a directory");
                    }

                    // Create the directory at the destination
                    if (!Path_.DirExists(dstfile))
                    {
                        System.IO.Directory.CreateDirectory(dstfile);
                    }
                    if (feedback != null)
                    {
                        feedback(srcfile + " --> " + dstfile);
                    }
                }
                else
                {
                    // Copy if modified or always based on the flag
                    if (only_if_modified && !Path_.DiffContent(srcfile, dstfile))
                    {
                        if (feedback != null && show_unchanged)
                        {
                            feedback(srcfile + " --> unchanged");
                        }
                        continue;
                    }

                    // Ensure the directory path exists
                    var d = Path_.Directory(dstfile);
                    var f = Path_.FileName(dstfile);
                    if (!Path_.DirExists(d))
                    {
                        System.IO.Directory.CreateDirectory(d);
                    }
                    if (feedback != null)
                    {
                        feedback(srcfile + " --> " + dstfile);
                    }
                    File.Copy(srcfile, dstfile, overwrite);
                }
            }
        }
Exemple #10
0
 public static string CacheDBFilePath(Settings settings, string sym)
 {
     return(Path_.CombinePath(settings.General.PriceDataCacheDir, "PriceData_{0}.db".Fmt(sym)));
 }