Exemple #1
0
        public PyDataType TrashItems(PyList itemIDs, CallInformation call)
        {
            foreach (PyDataType itemID in itemIDs)
            {
                // ignore non integer values and the current
                if (itemID is PyInteger integer == false)
                {
                    continue;
                }
                PyInteger value = itemID as PyInteger;

                // do not trash the active ship
                if (value == call.Client.ShipID)
                {
                    throw new CantMoveActiveShip();
                }

                ItemEntity item = this.ItemManager.GetItem(itemID as PyInteger);
                // store it's location id
                int oldLocationID = item.LocationID;
                // remove the item off the ItemManager
                this.ItemManager.DestroyItem(item);
                // notify the client of the change
                call.Client.NotifyItemLocationChange(item, item.Flag, oldLocationID);
            }

            return(null);
        }
        public static Task <double[, ]> VectorizeDocumentsTFIDF(IEnumerable <string> documents)
        {
            return(Task.Run(() =>
            {
                try
                {
                    using (Py.GIL())
                    {
                        dynamic sklear_feature_extraction_text = Py.Import("sklearn.feature_extraction.text");
                        dynamic tfidfVectorizer = sklear_feature_extraction_text.TfidfVectorizer();

                        dynamic countMatrixObject = tfidfVectorizer.fit_transform(documents);
                        PyList countMatrix = PyList.AsList(countMatrixObject.toarray());
                        var matrix = (double[][])countMatrix.AsManagedObject(typeof(double[][]));

                        return ConvertMatrix(matrix);
                    }
                }
                catch (PythonException e)
                {
                    if (e.Message.Contains("NoneType"))
                    {
                        return new double[0, 0];
                    }
                    else
                    {
                        throw e;
                    }
                }
            }));
        }
Exemple #3
0
        public PyDataType Page(PyList destinationMailboxes, PyString subject, PyString message, CallInformation call)
        {
            int callerCharacterID = call.Client.EnsureCharacterIsSelected();

            foreach (PyDataType destinationID in destinationMailboxes)
            {
                // only mail to integer channel id's are supported
                if (destinationID is PyInteger == false)
                {
                    continue;
                }

                ulong messageID = this.MessagesDB.StoreMail(destinationID as PyInteger, callerCharacterID, subject, message, out string mailboxType);

                // send notification to the destination
                PyTuple notification = new PyTuple(5)
                {
                    [0] = destinationMailboxes,
                    [1] = messageID,
                    [2] = callerCharacterID,
                    [3] = subject,
                    [4] = DateTime.UtcNow.ToFileTimeUtc()
                };

                // *multicastID are a special broadcast type that allows to notify different users based on things like charid or corpid
                // under the same notification, making things easier for us
                // sadly supporting that is more painful that actually spamming the cluster controller with single corpid or charid type broadcast
                // but supporting multicastIDs would be perfect

                // the list of id's on a *multicastID would be a PyTuple with the type and the id in it, instead of just a list of integers
                call.Client.ClusterConnection.SendNotification("OnMessage", mailboxType, destinationID as PyInteger, notification);
            }

            return(null);
        }
Exemple #4
0
        public PyDataType AccessControl(PyInteger channelID, PyInteger characterID, PyInteger accessLevel, CallInformation call)
        {
            int callerCharacterID = call.Client.EnsureCharacterIsSelected();

            if (this.DB.IsCharacterOperatorOrAdminOfChannel(channelID, callerCharacterID) == false)
            {
                throw new LSCCannotAccessControl("Insufficient permissions");
            }

            this.DB.UpdatePermissionsForCharacterOnChannel(channelID, characterID, accessLevel);

            PyTuple args = new PyTuple(6)
            {
                [0] = characterID,
                [1] = accessLevel,
                [2] = new PyNone(),
                [3] = accessLevel,
                [4] = "",
                [5] = accessLevel == ChatDB.CHATROLE_CREATOR
            };

            PyDataType notification = GenerateLSCNotification("AccessControl", channelID, args, call.Client);

            // get users in the channel that are online now
            PyList characters = this.DB.GetOnlineCharsOnChannel(channelID);

            call.Client.ClusterConnection.SendNotification("OnLSC", "charid", characters, notification);

            // TODO: CHECK IF THIS IS A CHARACTER'S ADDRESS BOOK AND CHECK FOR OTHER CHARACTER'S ADDRESSBOOK STATUS
            // TODO: TO ENSURE THEY DON'T HAVE US BLOCKED

            return(null);
        }
        /// <summary>
        /// Simple helper method that creates a correct IntegerIntegerListDictionary and returns
        /// it's PyDataType representation, ready to be sent to the EVE Online client
        ///
        /// IMPORTANT: The first field MUST be ordered (direction doesn't matter) for this method
        /// to properly work
        /// </summary>
        /// <param name="reader">The MySqlDataReader to read the data from</param>
        /// <returns></returns>
        public static PyDictionary <PyInteger, PyList <PyInteger> > FromMySqlDataReader(MySqlDataReader reader)
        {
            PyDictionary <PyInteger, PyList <PyInteger> > result = new PyDictionary <PyInteger, PyList <PyInteger> >();

            Type keyType = reader.GetFieldType(0);
            Type valType = reader.GetFieldType(1);

            if (keyType != typeof(long) && keyType != typeof(int) && keyType != typeof(short) &&
                keyType != typeof(byte) && keyType != typeof(ulong) && keyType != typeof(uint) &&
                keyType != typeof(ushort) && keyType != typeof(sbyte) && valType != typeof(long) &&
                valType != typeof(int) && valType != typeof(short) && valType != typeof(byte) &&
                valType != typeof(ulong) && valType != typeof(uint) && valType != typeof(ushort) &&
                valType != typeof(sbyte))
            {
                throw new InvalidDataException("Expected two fields of type int");
            }

            // get first key and start preparing the values
            int key = 0;

            PyList <PyInteger> currentList = new PyList <PyInteger>();

            while (reader.Read() == true)
            {
                // ignore null keys
                if (reader.IsDBNull(0) == true)
                {
                    continue;
                }

                int newKey = reader.GetInt32(0);
                int val    = 0;

                // if the read key doesn't match the one read earlier
                if (newKey != key)
                {
                    // do not add an entry to the dict unless the old id was present
                    if (key != 0)
                    {
                        result[key] = currentList;
                    }

                    currentList = new PyList <PyInteger>();
                    key         = newKey;
                }

                if (reader.IsDBNull(1) == false)
                {
                    val = reader.GetInt32(1);
                }

                // add the current value to the list
                currentList.Add(val);
            }

            // ensure the last key is saved to the list
            result[key] = currentList;

            return(result);
        }
Exemple #6
0
        public PyDataType GetGuests(CallInformation call)
        {
            if (call.Client.StationID == null)
            {
                throw new CanOnlyDoInStations();
            }

            Station station = this.ItemManager.GetStation((int)call.Client.StationID);
            PyList  result  = new PyList();

            foreach (KeyValuePair <int, Character> pair in station.Guests)
            {
                // TODO: UPDATE WHEN FACTION WARS ARE SUPPORTED
                result.Add(new PyTuple(4)
                {
                    [0] = pair.Value.CharacterID,
                    [1] = pair.Value.Corporation.ID,
                    [2] = pair.Value.Corporation.AllianceID,
                    [3] = 0     // facWarID
                }
                           );
            }

            return(result);
        }
Exemple #7
0
        public PyDataType GetCharacterAppearanceList(PyList ids, CallInformation call)
        {
            PyList result = new PyList(ids.Count);

            int index = 0;

            foreach (PyDataType id in ids)
            {
                // ignore non-integers
                if (id is PyInteger == false)
                {
                    continue;
                }

                Rowset dbResult = this.DB.GetCharacterAppearanceInfo(id as PyInteger);

                if (dbResult.Rows.Count != 0)
                {
                    result[index] = dbResult;
                }

                index++;
            }

            return(result);
        }
Exemple #8
0
 public CodeExpression VisitList(PyList l)
 {
     return(m.ListInitializer(
                l.elts
                .Where(e => e != null)
                .Select(e => e.Accept(this))));
 }
Exemple #9
0
        public PyDataType LeaveChannels(PyList channels, PyDataType boolUnsubscribe, PyInteger role, CallInformation call)
        {
            foreach (PyDataType channelInfo in channels)
            {
                if (channelInfo is PyTuple == false)
                {
                    Log.Error("LSC received a channel identifier in LeaveChannels that doesn't resemble anything we know");
                    continue;
                }

                PyTuple tuple = channelInfo as PyTuple;

                if (tuple.Count != 2)
                {
                    Log.Error(
                        "LSC received a tuple for channel in LeaveChannels that doesn't resemble anything we know");
                    return(null);
                }

                PyDataType channelID = tuple[0];
                PyBool     announce  = tuple[1] as PyBool;

                this.LeaveChannel(channelID, announce, call);
            }

            return(null);
        }
        /// <summary>
        /// Gets the symbols/string from a PyObject
        /// </summary>
        /// <param name="pyObject">PyObject containing symbols</param>
        /// <returns>List of symbols</returns>
        public List <Symbol> GetSymbolsFromPyObject(PyObject pyObject)
        {
            using (Py.GIL())
            {
                // If not a PyList, convert it into one
                if (!PyList.IsListType(pyObject))
                {
                    var tmp = new PyList();
                    tmp.Append(pyObject);
                    pyObject = tmp;
                }

                var symbols = new List <Symbol>();
                foreach (PyObject item in pyObject)
                {
                    var symbol = (Symbol)item.AsManagedObject(typeof(Symbol));

                    if (string.IsNullOrWhiteSpace(symbol.Value))
                    {
                        continue;
                    }

                    symbols.Add(symbol);
                }
                return(symbols.Count == 0 ? null : symbols);
            }
        }
Exemple #11
0
        private PyList ArrayToPyList(dynamic arr)
        {
            using (Py.GIL())
            {
                System.Type NestedType = arr.GetType().GetElementType();
                PyList      res        = new PyList();
                if (NestedType == typeof(int))
                {
                    foreach (int d in arr)
                    {
                        res.Append(d.ToPython());
                    }
                }
                else if (NestedType == typeof(double))
                {
                    foreach (double d in arr)
                    {
                        res.Append(d.ToPython());
                    }
                }
                else
                {
                    throw new PythonException("Nested Datatype not supported!");
                }

                return(res);
            }
        }
Exemple #12
0
        /// <summary>
        /// Try to get the length of arguments of a method
        /// </summary>
        /// <param name="pyObject">Object representing a method</param>
        /// <param name="length">Lenght of arguments</param>
        /// <returns>True if pyObject is a method</returns>
        private static bool TryGetArgLength(PyObject pyObject, out long length)
        {
            using (Py.GIL())
            {
                var inspect = lazyInspect.Value;
                if (inspect.isfunction(pyObject))
                {
                    var args   = inspect.getargspec(pyObject).args as PyObject;
                    var pyList = new PyList(args);
                    length = pyList.Length();
                    pyList.Dispose();
                    args.Dispose();
                    return(true);
                }

                if (inspect.ismethod(pyObject))
                {
                    var args   = inspect.getargspec(pyObject).args as PyObject;
                    var pyList = new PyList(args);
                    length = pyList.Length() - 1;
                    pyList.Dispose();
                    args.Dispose();
                    return(true);
                }
            }
            length = 0;
            return(false);
        }
Exemple #13
0
        /// <summary>
        /// Simple helper method that creates a correct tupleset and returns
        /// it's PyDataType representation, ready to be sent to the EVE Online client
        /// </summary>
        /// <param name="reader">The MySqlDataReader to read the data from</param>
        /// <returns></returns>
        public static PyDataType FromMySqlDataReader(MySqlDataReader reader)
        {
            if (reader.FieldCount == 0)
            {
                return(new PyTuple(0));
            }

            PyList columns = new PyList(reader.FieldCount);
            PyList rows    = new PyList();

            for (int i = 0; i < columns.Count; i++)
            {
                columns[i] = new PyString(reader.GetName(i));
            }

            while (reader.Read() == true)
            {
                PyList linedata = new PyList(columns.Count);

                for (int i = 0; i < columns.Count; i++)
                {
                    linedata[i] = Utils.ObjectFromColumn(reader, i);
                }

                rows.Add(linedata);
            }

            return(new PyTuple(new PyDataType[]
            {
                columns, rows
            }));
        }
Exemple #14
0
        public string GetStringValueFromObject(PyObject obj)
        {
            string type = GetTypeName(obj);

            switch (type)
            {
            case "str":
                return(new PyStr(obj.BaseAddress, MemoryReader).String);

            case "unicode":
                return(new PyUnicode(obj.BaseAddress, MemoryReader).String);

            case "float":
                return(new PyFloat(obj.BaseAddress, MemoryReader).Float.ToString());

            case "int":
                return(new PyInt(obj.BaseAddress, MemoryReader).Int.ToString());

            case "bool":
                return(new PyBool(obj.BaseAddress, MemoryReader).Bool.ToString());

            case "list":
                PyList list = new PyList(obj.BaseAddress, MemoryReader);
                return("List with " + ((list.Items == null) ? 0 : list.Items.Length).ToString() + " elements");

            default:
                return(obj.BaseAddress.ToString("x"));
            }
        }
Exemple #15
0
        public void NotifyByCharacterID(PyPacket packet, PyAddressBroadcast destination)
        {
            lock (this.Clients)
            {
                PyList idlist = destination.IDsOfInterest;

                foreach (PyDataType idData in idlist)
                {
                    PyInteger id = idData as PyInteger;

                    foreach (KeyValuePair <long, ClientConnection> entry in this.Clients)
                    {
                        if (entry.Value.CharacterID == id)
                        {
                            // use the key instead of AccountID as this should be faster
                            packet.UserID = entry.Key;
                            // change the ids of interest to hide the character's we've notified
                            destination.IDsOfInterest = new PyDataType[] { id };
                            // queue the packet for the user
                            entry.Value.Socket.Send(packet);
                        }
                    }
                }
            }
        }
Exemple #16
0
        public void TestEmptyCtor()
        {
            var s = new PyList();

            Assert.IsInstanceOf(typeof(PyList), s);
            Assert.AreEqual(0, s.Length());
        }
        /// <summary>
        /// Generate the asset allocation pie chart using the python libraries.
        /// </summary>
        public override string Render()
        {
            var backtestSeries = Metrics.AssetAllocations(_backtestPortfolios);
            var liveSeries     = Metrics.AssetAllocations(_livePortfolios);

            PyObject result;

            using (Py.GIL())
            {
                var data     = new PyList();
                var liveData = new PyList();

                data.Append(backtestSeries.SortBy(x => - x).Where(x => x.Value != 0).Keys.Select(x => x.Value).ToList().ToPython());
                data.Append(backtestSeries.SortBy(x => - x).Where(x => x.Value != 0).Values.ToList().ToPython());

                liveData.Append(liveSeries.SortBy(x => - x).Where(x => x.Value != 0).Keys.Select(x => x.Value).ToList().ToPython());
                liveData.Append(liveSeries.SortBy(x => - x).Where(x => x.Value != 0).Values.ToList().ToPython());

                result = Charting.GetAssetAllocation(data, liveData);
            }

            var base64 = result.ConvertToDictionary <string, string>();

            if (base64.ContainsKey("Live Asset Allocation"))
            {
                return(base64["Live Asset Allocation"]);
            }

            return(base64["Backtest Asset Allocation"]);
        }
Exemple #18
0
        public PyDataType DestroyChannel(PyInteger channelID, CallInformation call)
        {
            int callerCharacterID = call.Client.EnsureCharacterIsSelected();

            // ensure the character has enough permissions
            if (this.DB.IsCharacterAdminOfChannel(channelID, callerCharacterID) == false)
            {
                throw new LSCCannotDestroy("Insufficient permissions");
            }

            // get users in the channel that are online now
            PyList characters = this.DB.GetOnlineCharsOnChannel(channelID);

            // remove channel off the database
            this.DB.DestroyChannel(channelID);

            // notify everyone in the channel only when it should
            PyDataType notification =
                GenerateLSCNotification("DestroyChannel", channelID, new PyTuple(0), call.Client);

            // notify all characters in the channel
            call.Client.ClusterConnection.SendNotification("OnLSC", "charid", characters, notification);

            return(null);
        }
Exemple #19
0
 public PyObject(bool isType2, PyTuple header, PyList list = null, PyDictionary dict = null) : base(PyObjectType.Object)
 {
     this.IsType2    = isType2;
     this.Header     = header;
     this.List       = list ?? new PyList();
     this.Dictionary = dict ?? new PyDictionary();
 }
Exemple #20
0
        /// <summary>
        /// <seealso cref="Marshal.ProcessObject"/>
        ///
        /// Opcodes supported:
        /// <seealso cref="Opcode.ObjectType1"/>
        /// <seealso cref="Opcode.ObjectType2"/>
        /// </summary>
        /// <param name="opcode">Type of object to parse</param>
        /// <returns>The decoded python type</returns>
        /// <exception cref="InvalidDataException">If any error was found in the data</exception>
        protected virtual PyDataType ProcessObject(Opcode opcode)
        {
            if (opcode != Opcode.ObjectType1 && opcode != Opcode.ObjectType2)
            {
                throw new InvalidDataException($"Trying to parse a {opcode} as ObjectEx");
            }

            PyTuple      header = this.Process(false) as PyTuple;
            PyList       list   = new PyList();
            PyDictionary dict   = new PyDictionary();

            while (this.mReader.PeekChar() != Marshal.PACKED_TERMINATOR)
            {
                list.Add(this.Process(false));
            }

            // ignore packed terminator
            this.mReader.ReadByte();

            while (this.mReader.PeekChar() != Marshal.PACKED_TERMINATOR)
            {
                PyString   key   = this.Process(false) as PyString;
                PyDataType value = this.Process(false);

                dict[key] = value;
            }

            // ignore packed terminator
            this.mReader.ReadByte();

            return(new PyObject(opcode == Opcode.ObjectType2, header, list, dict));
        }
        /// <summary>
        /// Generate the daily returns plot using the python libraries.
        /// </summary>
        public override string Render()
        {
            var backtestReturns = ResultsUtil.EquityPoints(_backtest);
            var liveReturns     = ResultsUtil.EquityPoints(_live);

            var backtestSeries = new Series <DateTime, double>(backtestReturns.Keys, backtestReturns.Values);
            var liveSeries     = new Series <DateTime, double>(liveReturns.Keys, liveReturns.Values);

            // The following two operations are equivalent to the Pandas `DataFrame.resample(...)` method
            var backtestResampled = backtestSeries.PercentChange().ResampleEquivalence(date => date.Date, s => s.Sum()) * 100;
            var liveResampled     = liveSeries.PercentChange().ResampleEquivalence(date => date.Date, s => s.Sum()) * 100;

            var base64 = "";

            using (Py.GIL())
            {
                var backtestList = new PyList();
                backtestList.Append(backtestResampled.Keys.ToList().ToPython());
                backtestList.Append(backtestResampled.Values.ToList().ToPython());

                var liveList = new PyList();
                liveList.Append(liveResampled.Keys.ToList().ToPython());
                liveList.Append(liveResampled.Values.ToList().ToPython());

                base64 = Charting.GetDailyReturns(backtestList, liveList);

                backtestList.Dispose();
                liveList.Dispose();
            }

            return(base64);
        }
Exemple #22
0
        /// <summary>
        /// <seealso cref="Marshal.ProcessList"/>
        ///
        /// Opcodes supported:
        /// <seealso cref="Opcode.ListEmpty"/>
        /// <seealso cref="Opcode.List"/>
        /// </summary>
        /// <param name="opcode">Type of object to parse</param>
        /// <returns>The decoded python type</returns>
        /// <exception cref="InvalidDataException">If any error was found in the data</exception>
        protected virtual PyDataType ProcessList(Opcode opcode)
        {
            switch (opcode)
            {
            case Opcode.ListEmpty:
                return(new PyList());

            case Opcode.ListOne:
                return(new PyList(1)
                {
                    [0] = this.Process(false)
                });

            case Opcode.List:
            {
                uint   count = this.mReader.ReadSizeEx();
                PyList list  = new PyList((int)count);

                for (int i = 0; i < count; i++)
                {
                    list[i] = this.Process(false);
                }

                return(list);
            }

            default:
                throw new InvalidDataException($"Trying to parse a {opcode} as List");
            }
        }
Exemple #23
0
        public PyDataType GetMembers(PyList characterIDs, int corporationID, SparseRowsetHeader header, Dictionary <PyDataType, int> rowsIndex)
        {
            // TODO: GENERATE PROPER FIELDS FOR THE FOLLOWING FIELDS
            // TODO: titleMask, grantableRoles, grantableRolesAtHQ, grantableRolesAtBase, grantableRolesAtOther
            // TODO: divisionID, squadronID
            // TODO: CHECK IF THIS startDateTime IS THE CORP'S MEMBERSHIP OR CHARACTER'S MEMBERSHIP

            Dictionary <string, object> parameters = new Dictionary <string, object>();

            string query = "SELECT" +
                           " characterID, title, startDateTime, corpRole AS roles, rolesAtHQ, rolesAtBase, rolesAtOther," +
                           " titleMask, 0 AS grantableRoles, 0 AS grantableRolesAtHQ, 0 AS grantableRolesAtBase," +
                           " 0 AS grantableRolesAtOther, 0 AS divisionID, 0 AS squadronID, 0 AS baseID, " +
                           " 0 AS blockRoles, gender " +
                           "FROM chrInformation " +
                           "WHERE corporationID=@corporationID AND characterID IN (";

            foreach (PyDataType id in characterIDs)
            {
                parameters["@characterID" + parameters.Count.ToString("X")] = (int)(id as PyInteger);
            }

            // prepare the correct list of arguments
            query += String.Join(',', parameters.Keys) + ")";

            parameters["@corporationID"] = corporationID;
            MySqlConnection connection = null;
            MySqlDataReader reader     = Database.PrepareQuery(ref connection, query, parameters);

            using (connection)
                using (reader)
                {
                    return(header.DataFromMySqlReader(0, reader, rowsIndex));
                }
        }
Exemple #24
0
        public PyDataType GetOffices(PyList itemIDs, int corporationID, SparseRowsetHeader header, Dictionary <PyDataType, int> rowsIndex)
        {
            Dictionary <string, object> parameters = new Dictionary <string, object>();

            string query = "SELECT" +
                           " itemID, stationID, typeID, officeFolderID " +
                           "FROM chrInformation " +
                           "LEFT JOIN invItems ON invItems.itemID = chrInformation.activeCloneID " +
                           "WHERE corporationID=@corporationID AND itemID IN (";

            foreach (PyDataType id in itemIDs)
            {
                parameters["@itemID" + parameters.Count.ToString("X")] = (int)(id as PyInteger);
            }

            // prepare the correct list of arguments
            query += String.Join(',', parameters.Keys) + ")";

            parameters["@corporationID"] = corporationID;

            // TODO: GENERATE PROPER FIELDS FOR THE FOLLOWING FIELDS
            // TODO: titleMask, grantableRoles, grantableRolesAtHQ, grantableRolesAtBase, grantableRolesAtOther
            // TODO: divisionID, squadronID
            // TODO: CHECK IF THIS startDateTime IS THE CORP'S MEMBERSHIP OR CHARACTER'S MEMBERSHIP
            MySqlConnection connection = null;
            MySqlDataReader reader     = Database.PrepareQuery(ref connection, query, parameters);

            using (connection)
                using (reader)
                {
                    return(header.DataFromMySqlReader(0, reader, rowsIndex));
                }
        }
Exemple #25
0
        public CRowset(DBRowDescriptor descriptor)
        {
            this.Header = descriptor;
            this.Rows   = new PyList();

            this.PrepareColumnNames();
        }
Exemple #26
0
        public void UnaryMinus_ThrowsOnBadType()
        {
            dynamic list  = new PyList();
            var     error = Assert.Throws <PythonException>(() => list = -list);

            Assert.AreEqual("TypeError", error.Type.Name);
        }
Exemple #27
0
        public CRowset(DBRowDescriptor descriptor, PyList rows)
        {
            this.Header = descriptor;
            this.Rows   = rows;

            this.PrepareColumnNames();
        }
Exemple #28
0
        /// <summary>
        /// Get list of symbols from a PyObject
        /// </summary>
        /// <param name="pyObject">PyObject containing a list of tickers</param>
        /// <returns>List of Symbol</returns>
        private List <Symbol> GetSymbolsFromPyObject(PyObject pyObject, bool isEquity = false)
        {
            using (Py.GIL())
            {
                // If not a PyList, convert it into one
                if (!PyList.IsListType(pyObject))
                {
                    var tmp = new PyList();
                    tmp.Append(pyObject);
                    pyObject = tmp;
                }

                var symbols = new List <Symbol>();
                foreach (PyObject item in pyObject)
                {
                    var symbol = (Symbol)item.AsManagedObject(typeof(Symbol));

                    if (isEquity && string.IsNullOrWhiteSpace(symbol.Value))
                    {
                        var ticker = (string)item.AsManagedObject(typeof(string));
                        symbol = new Symbol(SecurityIdentifier.GenerateEquity(ticker, Market.USA), ticker);
                    }

                    symbols.Add(symbol);
                }
                return(symbols.Count == 0 || string.IsNullOrEmpty(symbols.First().Value) ? null : symbols);
            }
        }
Exemple #29
0
        /// <summary>
        /// Simple helper method that creates a correct IndexRowset and returns
        /// it's PyDataType representation, ready to be sent to the EVE Online client
        ///
        /// </summary>
        /// <param name="reader">The MySqlDataReader to read the data from</param>
        /// <returns></returns>
        public static IndexRowset FromMySqlDataReader(MySqlDataReader reader, int indexField)
        {
            string indexFieldName = reader.GetName(indexField);

            PyList headers = new PyList(reader.FieldCount);

            for (int i = 0; i < reader.FieldCount; i++)
            {
                headers[i] = reader.GetName(i);
            }

            IndexRowset rowset = new IndexRowset(indexFieldName, headers);

            while (reader.Read() == true)
            {
                PyList row = new PyList(reader.FieldCount);

                for (int i = 0; i < row.Count; i++)
                {
                    row[i] = Utils.ObjectFromColumn(reader, i);
                }

                rowset.AddRow(reader.GetInt32(indexField), row);
            }

            return(rowset);
        }
Exemple #30
0
        /// <summary>
        /// Generate the rolling sharpe using the python libraries.
        /// </summary>
        public override string Render()
        {
            var backtestPoints = ResultsUtil.EquityPoints(_backtest);
            var livePoints     = ResultsUtil.EquityPoints(_live);

            var backtestRollingSharpe = Rolling.Sharpe(new Series <DateTime, double>(backtestPoints), 6).DropMissing();
            var liveRollingSharpe     = Rolling.Sharpe(new Series <DateTime, double>(livePoints), 6).DropMissing();

            var base64 = "";

            using (Py.GIL())
            {
                var backtestList = new PyList();
                var liveList     = new PyList();

                backtestList.Append(backtestRollingSharpe.Keys.ToList().ToPython());
                backtestList.Append(backtestRollingSharpe.Values.ToList().ToPython());

                liveList.Append(liveRollingSharpe.Keys.ToList().ToPython());
                liveList.Append(liveRollingSharpe.Values.ToList().ToPython());

                base64 = Charting.GetRollingSharpeRatio(backtestList, liveList);
            }

            return(base64);
        }
Exemple #31
0
        public static PyObject DBResultToPackedRowList(ref MySqlDataReader result)
        {
            PyList res = new PyList();
            DBRowDescriptor header = new DBRowDescriptor(ref result);

            while (result.Read())
            {
                res.Items.Add(CreatePackedRow(header, ref result));
            }

            return res;
        }
Exemple #32
0
        public bool Decode(PyObject info)
        {
            if (info.Type != PyObjectType.ObjectData)
            {
                Log.Error("NodeInfo", "Wrong type for ObjectData");
                return false;
            }

            PyObjectData data = info.As<PyObjectData>();

            if (data.Name != "machoNet.nodeInfo")
            {
                Log.Error("NodeInfo", "Wrong object name, expected machoNet.nodeInfo but got " + data.Name);
                return false;
            }

            if (data.Arguments.Type != PyObjectType.Tuple)
            {
                Log.Error("NodeInfo", "Wrong type for ObjectData arguments, expected Tuple");
                return false;
            }

            PyTuple args = data.Arguments.As<PyTuple>();

            if (args.Items[0].Type != PyObjectType.Long)
            {
                Log.Error("NodeInfo", "Wrong type for tuple0 item0, expected int");
                return false;
            }

            nodeID = args.Items[0].As<PyInt>().Value;

            if (args.Items[1].Type != PyObjectType.List)
            {
                Log.Error("NodeInfo", "Wrong type for tuple0 item1, expected list");
                return false;
            }

            solarSystems = args.Items[1].As<PyList>();

            return true;
        }
Exemple #33
0
 private static string PrintList(PyList list)
 {
     return "[PyList " + list.Items.Count + " items]";
 }
Exemple #34
0
 public void VisitList(PyList l)
 {
     throw new NotImplementedException();
 }
Exemple #35
0
        public static PyObject DBResultToTupleSet(ref MySqlDataReader result)
        {
            int column = result.FieldCount;
            if (column == 0)
                return new PyTuple();

            int r = 0;

            PyTuple res = new PyTuple();
            PyList cols = new PyList();
            PyList reslist = new PyList();

            for (r = 0; r < column; r++)
            {
                cols.Items.Add(new PyString(result.GetName(r)));
            }

            while (result.Read())
            {
                PyList linedata = new PyList();
                for (r = 0; r < column; r++)
                {
                    linedata.Items.Add(DBColumnToPyObject(r, ref result));
                }

                reslist.Items.Add(linedata);
            }

            res.Items.Add(cols);
            res.Items.Add(reslist);

            return res;
        }
Exemple #36
0
        public static PyObject DBResultToRowset(ref MySqlDataReader dat)
        {
            int column = dat.FieldCount;
            if (column == 0)
            {
                return new PyObjectData("util.Rowset", new PyDict());
            }

            PyDict args = new PyDict();

            PyList header = new PyList();
            for (int i = 0; i < column; i++)
            {
                header.Items.Add(new PyString(dat.GetName(i)));
            }

            args.Set("header", header);

            args.Set("RowClass", new PyToken("util.Row"));

            PyList rowlist = new PyList();

            while (dat.Read())
            {
                PyList linedata = new PyList();
                for (int r = 0; r < column; r++)
                {
                    linedata.Items.Add(DBColumnToPyObject(r, ref dat));
                }

                rowlist.Items.Add(linedata);
            }

            dat.Close();

            return new PyObjectData("util.Rowset", args);
        }