public int FindColumn(string name)
{
int cc = ColumnCount();
PyString stringName = new PyString(name);
for (int i = 0; i < cc; i++)
{
if (stringName == columnList.Items[i])
{
return i;
}
}
return cc;
}
public void IsStringTrue()
{
var t = new PyString("foo");
Assert.True(PyString.IsStringType(t));
}
/// <summary>
/// Get the pandas.DataFrame of the current <see cref="PandasData"/> state
/// </summary>
/// <param name="levels">Number of levels of the multi index</param>
/// <returns>pandas.DataFrame object</returns>
public PyObject ToPandasDataFrame(int levels = 2)
{
var empty = new PyString(string.Empty);
var list = Enumerable.Repeat <PyObject>(empty, 5).ToList();
list[3] = _symbol.ID.ToString().ToPython();
if (_symbol.SecurityType == SecurityType.Future)
{
list[0] = _symbol.ID.Date.ToPython();
list[3] = _symbol.ID.ToString().ToPython();
}
if (_symbol.SecurityType == SecurityType.Option)
{
list[0] = _symbol.ID.Date.ToPython();
list[1] = _symbol.ID.StrikePrice.ToPython();
list[2] = _symbol.ID.OptionRight.ToString().ToPython();
list[3] = _symbol.ID.ToString().ToPython();
}
// Create the index labels
var names = "expiry,strike,type,symbol,time";
if (levels == 2)
{
names = "symbol,time";
list.RemoveRange(0, 3);
}
if (levels == 3)
{
names = "expiry,symbol,time";
list.RemoveRange(1, 2);
}
Func <object, bool> filter = x =>
{
var isNaNOrZero = x is double && ((double)x).IsNaNOrZero();
var isNullOrWhiteSpace = x is string && string.IsNullOrWhiteSpace((string)x);
var isFalse = x is bool && !(bool)x;
return(x == null || isNaNOrZero || isNullOrWhiteSpace || isFalse);
};
Func <DateTime, PyTuple> selector = x =>
{
list[list.Count - 1] = x.ToPython();
return(new PyTuple(list.ToArray()));
};
// creating the pandas MultiIndex is expensive so we keep a cash
var indexCache = new Dictionary <List <DateTime>, dynamic>(new ListComparer <DateTime>());
using (Py.GIL())
{
// Returns a dictionary keyed by column name where values are pandas.Series objects
var pyDict = new PyDict();
var splitNames = names.Split(',');
foreach (var kvp in _series)
{
var values = kvp.Value.Item2;
if (values.All(filter))
{
continue;
}
dynamic index;
if (!indexCache.TryGetValue(kvp.Value.Item1, out index))
{
var tuples = kvp.Value.Item1.Select(selector).ToArray();
index = _pandas.MultiIndex.from_tuples(tuples, names: splitNames);
indexCache[kvp.Value.Item1] = index;
}
pyDict.SetItem(kvp.Key, _pandas.Series(values, index));
}
_series.Clear();
return(ApplySymbolMapper(_pandas.DataFrame(pyDict)));
}
}
public PyDataType SendMessage(PyDataType channel, PyString message, CallInformation call)
{
int callerCharacterID = call.Client.EnsureCharacterIsSelected();
int channelID;
int? entityID;
string channelType;
try
{
this.ParseChannelIdentifier(channel, out channelID, out channelType, out entityID);
}
catch (InvalidDataException)
{
throw new LSCCannotSendMessage("Cannot get channel information");
}
// ensure the player is allowed to chat in there
if (channelType == ChatDB.CHANNEL_TYPE_NORMAL && this.DB.IsPlayerAllowedToChat(channelID, callerCharacterID) == false)
{
throw new LSCCannotSendMessage("Insufficient permissions");
}
if (channelType != ChatDB.CHANNEL_TYPE_NORMAL && this.DB.IsPlayerAllowedToChatOnRelatedEntity((int)entityID, callerCharacterID) == false)
{
throw new LSCCannotSendMessage("Insufficient permissions");
}
PyTuple notificationBody = new PyTuple(1)
{
[0] = message
};
if (channelType == ChatDB.CHANNEL_TYPE_NORMAL)
{
PyDataType notification =
GenerateLSCNotification("SendMessage", channelID, notificationBody, call.Client);
call.Client.ClusterConnection.SendNotification(
"OnLSC",
"charid",
this.DB.GetOnlineCharsOnChannel(channelID),
notification
);
}
else
{
PyTuple identifier = new PyTuple(1)
{
[0] = new PyTuple(2)
{
[0] = channelType,
[1] = entityID
}
};
PyDataType notification =
GenerateLSCNotification("SendMessage", identifier, notificationBody, call.Client);
call.Client.ClusterConnection.SendNotification(
"OnLSC",
channelType,
new PyDataType [] { entityID },
notification
);
}
return(null);
}
/// <summary>
/// Get the pandas.Series of the current <see cref="PandasData"/> state
/// </summary>
/// <param name="pandas">pandas module</param>
/// <param name="levels">Number of levels of the multi index</param>
/// <returns>Dictionary keyed by column name where values are pandas.Series objects</returns>
private Dictionary <string, dynamic> GetPandasSeries(dynamic pandas, int levels = 2)
{
var pyObjectArray = new PyObject[levels];
pyObjectArray[levels - 2] = _symbol.ToString().ToPython();
if (_symbol.SecurityType == SecurityType.Future)
{
pyObjectArray[0] = _symbol.ID.Date.ToPython();
pyObjectArray[1] = _symbol.Value.ToPython();
}
if (_symbol.SecurityType == SecurityType.Option)
{
pyObjectArray[0] = _symbol.ID.Date.ToPython();
pyObjectArray[1] = _symbol.ID.StrikePrice.ToPython();
pyObjectArray[2] = _symbol.ID.OptionRight.ToString().ToPython();
pyObjectArray[3] = _symbol.Value.ToPython();
}
// Set null to python empty string
for (var i = 0; i < levels - 1; i++)
{
if (pyObjectArray[i] == null)
{
pyObjectArray[i] = new PyString(string.Empty);
}
}
// Create the index labels
var names = "symbol,time";
if (levels == 3)
{
names = "expiry,symbol,time";
}
if (levels == 5)
{
names = "expiry,strike,type,symbol,time";
}
using (Py.GIL())
{
// Create a pandas multi index
var tuples = _timeIndex.Select(x =>
{
pyObjectArray[levels - 1] = x.ToPython();
return(new PyTuple(pyObjectArray));
}).ToArray();
var index = pandas.MultiIndex.from_tuples(tuples, names: names.Split(','));
// Returns a dictionary keyed by column name where values are pandas.Series objects
var pandasSeries = new Dictionary <string, dynamic>();
foreach (var kvp in _series)
{
if (kvp.Value.Count != tuples.Length)
{
continue;
}
pandasSeries.Add(kvp.Key, pandas.Series(kvp.Value, index));
}
return(pandasSeries);
}
}
/*
* [PyObjectEx Type1]
* header:
* [PyToken "blue.DBRowDescriptor"]
* [PyTuple 1]
* [PyTuple columns.Count]
* columns as
* [PyTuple 2]
* [PyString "columnName"]
* [PyInt columnDBType]
* [PyList] (optional)
* keywords
* create with: new DBRowDescriptor();
*/
public DBRowDescriptor(PyTuple header)
: base()
{
if (header == null)
{
throw new InvalidDataException("DBRowDescriptor: null header.");
}
if (header.Items.Count < 2)
{
throw new InvalidDataException("DBRowDescriptor: Wrong tuple size expected 2 got " + header.Items.Count);
}
if (header.Items.Count == 3 && header.Items[2] is PyList)
{
keywords = header.Items[2] as PyList;
}
PyTuple tuple = header.Items[1] as PyTuple;
if (tuple == null)
{
throw new InvalidDataException("DBRowDescriptor: null tuple.");
}
if (tuple.Items.Count > 1)
{
throw new InvalidDataException("DBRowDescriptor: Wrong tuple size expected 1 got" + tuple.Items.Count);
}
PyTuple columns = tuple.Items[0] as PyTuple;
if (columns == null)
{
throw new InvalidDataException("DBRowDescriptor: no columns.");
}
int columnCount = columns.Items.Count;
if (keywords != null)
{
columnCount += keywords.Items.Count;
}
Columns = new List <Column>(columnCount);
foreach (var obj in columns.Items)
{
PyTuple entry = obj as PyTuple;
if (entry == null || entry.Items.Count < 2)
{
continue;
}
PyString name = entry.Items[0] as PyString;
if (name == null)
{
continue;
}
Columns.Add(new Column(name.Value, (FieldType)entry.Items[1].IntValue));
}
if (keywords != null)
{
foreach (var obj in keywords.Items)
{
PyTuple entry = obj as PyTuple;
if (entry == null || entry.Items.Count < 2)
{
continue;
}
PyString name = entry.Items[0] as PyString;
if (name == null)
{
continue;
}
PyToken token = entry.Items[1] as PyToken;
if (token == null)
{
continue;
}
Columns.Add(new Column(name.Value, token.Token));
}
}
}
public PyDataType GetMultiAllianceShortNamesEx(PyList <PyInteger> ids)
{
MySqlConnection connection = null;
MySqlDataReader reader = Database.PrepareQuery(ref connection,
$"SELECT allianceID, shortName FROM alliance_shortnames WHERE allianceID IN ({PyString.Join(',', ids)}"
).ExecuteReader();
using (connection)
using (reader)
{
return(TupleSet.FromMySqlDataReader(Database, reader));
}
}
public static bool IsString(this PyObject obj)
{
return(PyString.IsStringType(obj));
}
public void HighPosMinLowPosMaxNegStep()
{
PyString ps = new PyString("swords");
Assert.That(ps[5, 1, -2], Is.EqualTo("sr"));
}
public void TestIsLongTypeFalse()
{
var s = new PyString("Foo");
Assert.False(PyLong.IsLongType(s));
}
public override void Create(Stream output, IEnumerable <Entry> list, ResourceOptions options,
EntryCallback callback)
{
var rpa_options = GetOptions <RpaOptions> (options);
int callback_count = 0;
var file_table = new Dictionary <PyString, ArrayList>();
long data_offset = 0x22;
output.Position = data_offset;
foreach (var entry in list)
{
if (null != callback)
{
callback(callback_count++, entry, arcStrings.MsgAddingFile);
}
string name = entry.Name.Replace(@"\", "/");
var rpa_entry = new RpaEntry {
Name = name
};
using (var file = File.OpenRead(entry.Name))
{
var size = file.Length;
if (size > uint.MaxValue)
{
throw new FileSizeException();
}
int header_size = (int)Math.Min(size, 0x10);
rpa_entry.Offset = output.Position ^ rpa_options.Key;
rpa_entry.Header = new byte[header_size];
rpa_entry.UnpackedSize = (uint)size ^ rpa_options.Key;
rpa_entry.Size = (uint)(size - header_size);
file.Read(rpa_entry.Header, 0, header_size);
file.CopyTo(output);
}
var py_name = new PyString(name);
if (file_table.ContainsKey(py_name))
{
file_table[py_name].Add(rpa_entry);
}
else
{
file_table[py_name] = new ArrayList {
rpa_entry
}
};
}
long index_pos = output.Position;
string signature = string.Format(CultureInfo.InvariantCulture, "RPA-3.0 {0:x16} {1:x8}\n",
index_pos, rpa_options.Key);
var header = Encoding.ASCII.GetBytes(signature);
if (header.Length > data_offset)
{
throw new ApplicationException("Signature serialization failed.");
}
if (null != callback)
{
callback(callback_count++, null, arcStrings.MsgWritingIndex);
}
using (var index = new ZLibStream(output, CompressionMode.Compress, CompressionLevel.Level9, true))
{
var pickle = new Pickle(index);
if (!pickle.Dump(file_table))
{
throw new ApplicationException("Archive index serialization failed.");
}
}
output.Position = 0;
output.Write(header, 0, header.Length);
}
}
public PyDataType SendClientStackTraceAlert(PyTuple stackInfo, PyString stackTrace, PyString type, PyDictionary namedPayload, Client client)
{
Log.Fatal(
"Received the following client's stack trace:" + Environment.NewLine +
$"------------------ {type.Value} ------------------" + Environment.NewLine +
$"{(stackInfo[1] as PyString).Value}" + Environment.NewLine +
stackTrace.Value
);
// The client should receive anything to know that the stack trace arrived to the server
return(new PyNone());
}
/// <summary>
/// Create a new Python exception based on a PyString message
/// </summary>
/// <param name="message">The exception message as a PyString</param>
public PyException(PyString message) : this(message.InternalValue)
{
}
private PyObject __init__impl(PyException self, PyString message)
{
return(__init__impl(self, message.InternalValue));
}
/// <summary>
/// Creates a PyDataType of the given column (specified by <paramref name="index"/>) based off the given
/// MySqlDataReader
/// </summary>
/// <param name="reader">Reader to get the data from</param>
/// <param name="index">Column of the current result read in the MySqlDataReader to create the PyDataType</param>
/// <returns></returns>
/// <exception cref="InvalidDataException">If any error was found during the creation of the PyDataType</exception>
public static PyDataType ObjectFromColumn(MySqlDataReader reader, int index)
{
Type type = reader.GetFieldType(index);
PyDataType data = null;
bool isnull = reader.IsDBNull(index);
if (type == typeof(string))
{
data = new PyString((isnull) ? "" : reader.GetString(index), true);
}
else if (type == typeof(ulong))
{
data = (isnull) ? 0 : reader.GetUInt64(index);
}
else if (type == typeof(long))
{
data = (isnull) ? 0 : reader.GetInt64(index);
}
else if (type == typeof(uint))
{
data = (isnull) ? 0 : reader.GetUInt32(index);
}
else if (type == typeof(int))
{
data = (isnull) ? 0 : reader.GetInt32(index);
}
else if (type == typeof(ushort))
{
data = (isnull) ? 0 : reader.GetUInt16(index);
}
else if (type == typeof(short))
{
data = (isnull) ? 0 : reader.GetInt16(index);
}
else if (type == typeof(byte))
{
data = (isnull) ? 0 : reader.GetByte(index);
}
else if (type == typeof(sbyte))
{
data = (isnull) ? 0 : reader.GetSByte(index);
}
else if (type == typeof(byte[]))
{
data = (isnull) ? new byte[0] : (byte[])reader.GetValue(index);
}
else if (type == typeof(float))
{
data = (isnull) ? 0 : reader.GetFloat(index);
}
else if (type == typeof(double))
{
data = (isnull) ? 0 : reader.GetDouble(index);
}
else if (type == typeof(bool))
{
data = (!isnull) && reader.GetBoolean(index);
}
else
{
throw new InvalidDataException($"Unknown data type {type}");
}
return(data);
}
public void IsFloatFalse()
{
var i = new PyString("Foo");
Assert.False(PyFloat.IsFloatType(i));
}
public PyDataType SetPlayerStanding(PyInteger characterID, PyDecimal standing, PyString reason, CallInformation call)
{
int callerCharacterID = call.Client.EnsureCharacterIsSelected();
this.DB.CreateStandingTransaction((int)StandingEventType.StandingPlayerSetStanding, callerCharacterID, characterID, standing, reason);
this.DB.SetPlayerStanding(callerCharacterID, characterID, standing);
// send standing change notification to the player
PyTuple notification = new PyTuple(3)
{
[0] = callerCharacterID,
[1] = characterID,
[2] = standing
};
// send the same notification to both players
call.Client.ClusterConnection.SendNotification("OnStandingSet", "charid", callerCharacterID, call.Client, notification);
call.Client.ClusterConnection.SendNotification("OnStandingSet", "charid", characterID, notification);
return(null);
}
public void LowPosMinHighPosMax()
{
PyString ps = new PyString("words");
Assert.That(ps[1, 3], Is.EqualTo("or"));
}
public async Task <FutureAwaiter <PyInteger> > dialog_wrapper(IInterpreter interpreter, IScheduler scheduler, FrameContext context, PyString message, PyList choices)
{
var choicesStr = new string[choices.list.Count];
for (int i = 0; i < choices.list.Count; ++i)
{
var iPyStr = (PyString)choices.list[i];
choicesStr[i] = iPyStr.str;
}
ShowDialogs(choicesStr);
// Prep the integer since we have all the things we need to invoke the constructor right here.
choicePyInt = (PyInteger)await PyIntegerClass.Instance.Call(interpreter, context, new object[0]);
dialogFuture = new FutureAwaiter <PyInteger>(scheduler, context);
scheduler.NotifyBlocked(context, dialogFuture);
//dialogFuture.SetResult(choicePyInt);
await dialogFuture;
return(dialogFuture);
}
public void NegIndex()
{
PyString ps = new PyString("words");
Assert.That(ps[-5], Is.EqualTo("w"));
}
public PyDataType SendClientStackTraceAlert(PyTuple stackInfo, PyString stackTrace, PyString type, PyDataType extra = null, CallInformation call = null)
{
Log.Fatal(
"Received the following client's stack trace:" + Environment.NewLine +
$"------------------ {type.Value} ------------------" + Environment.NewLine +
$"{(stackInfo[1] as PyString).Value}" + Environment.NewLine +
stackTrace.Value
);
// the client should receive anything to know that the stack trace arrived to the server
return(null);
}
public void NegMinNullMax()
{
PyString ps = new PyString("words");
Assert.That(ps[-4, null], Is.EqualTo("ords"));
}
public PyDataType BookmarkLocation(PyInteger itemID, PyNone unk, PyString name, PyString comment, CallInformation call)
{
if (ItemManager.IsStaticData(itemID) == false)
{
throw new CustomError("Bookmarks for non-static locations are not supported yet!");
}
ItemEntity item = this.ItemManager.GetItem(itemID);
if (item.HasPosition == false)
{
throw new CustomError("Cannot bookmark a non-location item");
}
ulong bookmarkID = this.DB.CreateBookmark(call.Client.EnsureCharacterIsSelected(), item.ID, item.Type.ID,
name, comment, (double)item.X, (double)item.Y, (double)item.Z, item.LocationID);
PyDataType bookmark = KeyVal.FromDictionary(new PyDictionary
{
["bookmarkID"] = bookmarkID,
["itemID"] = item.ID,
["typeID"] = item.Type.ID,
["memo"] = name,
["comment"] = comment,
["x"] = item.X,
["y"] = item.Y,
["z"] = item.Z,
["locationID"] = item.LocationID,
["created"] = DateTime.UtcNow.ToFileTimeUtc()
}
);
// send a request to the client to update the bookmarks
call.Client.ClusterConnection.SendServiceCall(call.Client, "addressbook", "OnBookmarkAdd",
new PyTuple(1)
{
[0] = bookmark
}, new PyDictionary(), null, null, null, 0);
return(new PyTuple(7)
{
[0] = bookmarkID, // bookmarkID
[1] = itemID, // itemID
[2] = item.Type.ID, // typeID
[3] = item.X, // x
[4] = item.Y, // y
[5] = item.Z, // z
[6] = item.LocationID //locationID
});
}
public void NegMinNullMaxNegStep()
{
PyString ps = new PyString("swords");
Assert.That(ps[-3, null, -1], Is.EqualTo("rows"));
}
public void TestStringIsListType()
{
var s = new PyString("foo");
Assert.False(PyList.IsListType(s));
}
public void NegMinNullMaxPosStep()
{
PyString ps = new PyString("words");
Assert.That(ps[-2, null, 1], Is.EqualTo("ds"));
}
public PyDataType Invite(PyInteger characterID, PyInteger channelID, PyString channelTitle, PyBool addAllowed, CallInformation call)
{
int callerCharacterID = call.Client.EnsureCharacterIsSelected();
try
{
if (characterID == callerCharacterID)
{
throw new ChtCannotInviteSelf();
}
if (ItemManager.IsNPC(characterID) == true)
{
// NPCs should be loaded, so the character instance can be used willy-nilly
Character npcChar = this.ItemManager.GetItem(characterID) as Character;
throw new ChtNPC(npcChar.Name);
}
// ensure our character has admin perms first
if (this.DB.IsCharacterOperatorOrAdminOfChannel(channelID, callerCharacterID) == false)
{
throw new ChtWrongRole(this.DB.GetChannelName(channelID), "Operator");
}
// ensure the character is not there already
if (this.DB.IsCharacterMemberOfChannel(channelID, characterID) == true)
{
throw new ChtAlreadyInChannel(this.CharacterDB.GetCharacterName(characterID));
}
Character character = this.ItemManager.GetItem(callerCharacterID) as Character;
PyTuple args = new PyTuple(4)
{
[0] = callerCharacterID,
[1] = character.Name,
[2] = character.Gender,
[3] = channelID
};
InviteExtraInfo info = new InviteExtraInfo
{
OriginalCall = call,
Arguments = args,
ChannelID = channelID,
ToCharacterID = characterID,
FromCharacterID = callerCharacterID
};
// no timeout for this call
call.Client.ClusterConnection.SendServiceCall(
characterID,
"LSC", "ChatInvite", args, new PyDictionary(),
InviteAnswerCallback, InviteTimeoutCallback,
info, ProvisionalResponse.DEFAULT_TIMEOUT - 5
);
// subscribe the user to the chat
this.DB.JoinChannel(channelID, characterID);
}
catch (ArgumentOutOfRangeException)
{
Log.Warning("Trying to invite a non-online character, aborting...");
}
// return SOMETHING to the client with the provisional data
// the real answer will come later on
throw new ProvisionalResponse(new PyString("OnDummy"), new PyTuple(0));
}
public void PosIndex()
{
PyString ps = new PyString("words");
Assert.That(ps[4], Is.EqualTo("s"));
}
private void ProcessString(PyString str)
{
this.mStringBuilder.AppendFormat("[PyString {0} char(s): '{1}']", str.Length, str.Value);
this.mStringBuilder.AppendLine();
}
public void PosMinNullMaxNegStep()
{
PyString ps = new PyString("words");
Assert.That(ps[2, null, -1], Is.EqualTo("row"));
}
public void IsStringFalse()
{
var t = new PyInt(5);
Assert.False(PyString.IsStringType(t));
}
public void PosMinNullMaxPosStep()
{
PyString ps = new PyString("swords");
Assert.That(ps[1, null, 2], Is.EqualTo("wrs"));
}
/// <summary>
/// Get the pandas.DataFrame of the current <see cref="PandasData"/> state
/// </summary>
/// <param name="levels">Number of levels of the multi index</param>
/// <returns>pandas.DataFrame object</returns>
public PyObject ToPandasDataFrame(int levels = 2)
{
var empty = new PyString(string.Empty);
var list = Enumerable.Repeat <PyObject>(empty, 5).ToList();
list[3] = _symbol.ID.ToString().ToPython();
if (_symbol.SecurityType == SecurityType.Future)
{
list[0] = _symbol.ID.Date.ToPython();
list[3] = _symbol.ID.ToString().ToPython();
}
if (_symbol.SecurityType.IsOption())
{
list[0] = _symbol.ID.Date.ToPython();
list[1] = _symbol.ID.StrikePrice.ToPython();
list[2] = _symbol.ID.OptionRight.ToString().ToPython();
list[3] = _symbol.ID.ToString().ToPython();
}
// Create the index labels
var names = "expiry,strike,type,symbol,time";
if (levels == 2)
{
names = "symbol,time";
list.RemoveRange(0, 3);
}
if (levels == 3)
{
names = "expiry,symbol,time";
list.RemoveRange(1, 2);
}
Func <object, bool> filter = x =>
{
var isNaNOrZero = x is double && ((double)x).IsNaNOrZero();
var isNullOrWhiteSpace = x is string && string.IsNullOrWhiteSpace((string)x);
var isFalse = x is bool && !(bool)x;
return(x == null || isNaNOrZero || isNullOrWhiteSpace || isFalse);
};
Func <DateTime, PyTuple> selector = x =>
{
list[list.Count - 1] = x.ToPython();
return(new PyTuple(list.ToArray()));
};
// creating the pandas MultiIndex is expensive so we keep a cash
var indexCache = new Dictionary <List <DateTime>, dynamic>(new ListComparer <DateTime>());
using (Py.GIL())
{
// Returns a dictionary keyed by column name where values are pandas.Series objects
var pyDict = new PyDict();
var splitNames = names.Split(',');
foreach (var kvp in _series)
{
var values = kvp.Value.Item2;
if (values.All(filter))
{
continue;
}
dynamic index;
if (!indexCache.TryGetValue(kvp.Value.Item1, out index))
{
var tuples = kvp.Value.Item1.Select(selector).ToArray();
index = _pandas.MultiIndex.from_tuples(tuples, names: splitNames);
indexCache[kvp.Value.Item1] = index;
}
// Adds pandas.Series value keyed by the column name
// CreateSeries will create an original pandas.Series
// We are not using the wrapper class to avoid unnecessary and expensive
// index wrapping operations when the Series are packed into a DataFrame
pyDict.SetItem(kvp.Key, _pandas.CreateSeries(values, index));
}
_series.Clear();
// Create a DataFrame with wrapper class.
// This is the starting point. The types of all DataFrame and Series that result from any operation will
// be wrapper classes. Index and MultiIndex will be converted when required by index operations such as
// stack, unstack, merge, union, etc.
return(_pandas.DataFrame(pyDict));
}
}
public bool Decode(PyObject data)
{
if (data.Type != PyObjectType.ObjectEx)
{
Log.Error("PyException", "Wrong container type");
return(false);
}
PyObjectEx p = data.As <PyObjectEx>();
if (p.IsType2 == true)
{
Log.Error("PyException", "Wrong PyObjectEx type, expected Normal, but got Type2");
return(false);
}
if (p.Header.Type != PyObjectType.Tuple)
{
Log.Error("PyException", "Wrong item 1 type");
return(false);
}
PyTuple args = p.Header.As <PyTuple>();
if (args.Items.Count != 3)
{
Log.Error("PyException", "Wrong tuple 1 item count, expected 3 but got " + args.Items.Count);
return(false);
}
if (args.Items[0].Type != PyObjectType.Token)
{
Log.Error("PyException", "Wrong tuple item 1 type");
return(false);
}
PyToken type = args.Items[0].As <PyToken>();
exception_type = type.Token;
if (exception_type.StartsWith("exceptions.") == false)
{
Log.Warning("PyException", "Trying to decode a non-exception packet: " + exception_type);
return(false);
}
if (args.Items[1].Type != PyObjectType.Tuple)
{
Log.Error("PyException", "Wrong tuple item 2 type");
return(false);
}
PyTuple msg = args.Items[1].As <PyTuple>();
if (msg.Items.Count != 1)
{
Log.Error("PyException", "Wrong item 2 tuple count, expected 1 but got " + msg.Items.Count);
return(false);
}
if (msg.Items[0].Type != PyObjectType.String)
{
Log.Error("PyException", "Wrong tuple 2 item 1 type");
return(false);
}
PyString msg_data = msg.Items[0].As <PyString>();
message = msg_data.Value;
if (args.Items[2].Type != PyObjectType.Dict)
{
Log.Error("PyException", "Wrong tuple 1 item 3 type");
return(false);
}
PyDict info = args.Items[2].As <PyDict>();
if (info.Contains("origin") == false)
{
Log.Error("PyException", "Dict item 1 doesnt has key origin");
return(false);
}
origin = info.Get("origin").As <PyString>().Value;
if (info.Contains("reasonArgs") == false)
{
Log.Error("PyException", "Dict item 1 doesn has key reasonArgs");
return(false);
}
reasonArgs = info.Get("reasonArgs").As <PyDict>();
if (info.Contains("clock") == false)
{
Log.Error("PyException", "Dict item 1 doesnt has key clock");
return(false);
}
clock = info.Get("clock").IntValue;
if (info.Contains("loggedOnUserCount") == false)
{
Log.Error("PyException", "Dict item 1 doesnt has key loggedOnUserCount");
return(false);
}
loggedOnUserCount = info.Get("loggedOnUserCount");
if (info.Contains("region") == false)
{
Log.Error("PyException", "Dict item 1 doesnt has key region");
return(false);
}
region = info.Get("region").As <PyString>().Value;
if (info.Contains("reason") == false)
{
Log.Error("PyException", "Dict item 1 doesnt has key reason");
return(false);
}
reason = info.Get("reason").As <PyString>().Value;
if (info.Contains("version") == false)
{
Log.Error("PyException", "Dict item 1 doesnt has key version");
return(false);
}
version = info.Get("version").As <PyFloat>().Value;
if (info.Contains("build") == false)
{
Log.Error("PyException", "Dict item 1 doesnt has key build");
return(false);
}
build = info.Get("build").As <PyInt>().Value;
if (info.Contains("reasonCode") == false)
{
Log.Error("PyException", "Dict item 1 doesnt has key reasonCode");
return(false);
}
reasonCode = info.Get("reasonCode").StringValue;
if (info.Contains("codename") == false)
{
Log.Error("PyException", "Dict item 1 doesnt has key codename");
return(false);
}
codename = info.Get("codename").As <PyString>().Value;
if (info.Contains("machoVersion") == false)
{
Log.Error("PyException", "Dict item 1 doesnt has key machoVersion");
return(false);
}
machoVersion = info.Get("machoVersion").As <PyInt>().Value;
return(true);
}
public PyObjectData(PyString name, PyDataType arguments) : base(PyObjectType.ObjectData)
{
this.Name = name;
this.Arguments = arguments;
}
public PyAddressClient(PyInteger clientID, PyInteger callID = null, PyString service = null) : this(clientID)
{
this.CallID = callID;
this.Service = service;
}
protected PyAddress(PyString type)
{
this.Type = type;
}
public void TestIsIntTypeFalse()
{
var s = new PyString("Foo");
Assert.False(PyInt.IsIntType(s));
}
public PyAddressNode(PyInteger nodeID, PyInteger callID = null, PyString service = null) : this(nodeID)
{
this.CallID = callID;
this.Service = service;
}
public PyDataType GetMultiLocationsEx(PyList <PyInteger> ids)
{
MySqlConnection connection = null;
MySqlDataReader reader = Database.PrepareQuery(ref connection,
$"SELECT itemID as locationID, itemName as locationName, x, y, z FROM invItems LEFT JOIN eveNames USING(itemID) LEFT JOIN invPositions USING (itemID) WHERE itemID IN ({PyString.Join(',', ids)})"
).ExecuteReader();
using (connection)
using (reader)
{
return(TupleSet.FromMySqlDataReader(Database, reader));
}
}
