BuyAtLimit is not triggering in SM (Trade-Ideas)

Frank1972

#1

12/15/2016 3:30 PM

Hi,

I have created a script, put it into strategy monitor and configured it to use SPY on a 1 minute basis. The script will never take a trade for SPY but will use SetContext to switch to a different symbol and try and enter into the trade for that symbol. After SetContext and a BuyAtLimit, RestoreContext is called.

When I run this the BuyAtLimit is never triggered resulting in an position that is in the ActivePositions. On a long entry (BuyAtLimit) I can see that the stock price drops below the limit price yet the position is never created and put into the ActivePositions.

The code that I use for this shown below:

CODE:
Please log in to see this code.

I must be doing something wrong but can't see or understand why my code doesn't result in an actual position.

Thanks,

-Frank

Cone

#2

12/15/2016 3:55 PM

If you can't see the problem with all of your code, it's not likely we can see the problem with only part of it ;)

In short, it's not enough code to determine what's wrong. There are undefined variables and objects, etc.

Edit:
Although, if you're running it on SPY, and want to trade SPY, why would you use SetContext() to another symbol?

Frank1972

#3

12/15/2016 4:07 PM

Cone,

Thanks for the quick reply. First let me describe what the code is doing so that it will make some sense when you read it. I am using an external trading source, TradeIdeas, to generate entries and exits. I do not know what symbol they are going to recommend so I have to use SetContext when I get the entry order. I have a TCP server running in the script that Trade-Ideas will connect to and send orders to. I have verified that the connection works and entry and exit orders are coming in.

CODE:
Please log in to see this code.

Size:

Color:

Cone,

Thanks for the quick reply. First let me describe what the code is doing so that it will make some sense when you read it. I am using an external trading source, TradeIdeas, to generate entries and exits. I do not know what symbol they are going to recommend so I have to use SetContext when I get the entry order. I have a TCP server running in the script that Trade-Ideas will connect to and send orders to. I have verified that the connection works and entry and exit orders are coming in.
[code]
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using WealthLab;
using System.Net.Sockets;

namespace WealthLabScript {
	public class MyStrategy : WealthScript{
		private TcpListener server = null;
		private TcpClient client;
		private NetworkStream stream;
		private String tradeIdeaOrders;
        private bool isDone = false;
		List<OrderToOpen> ordersToOpen = new List<OrderToOpen>();
        StreamWriter log = null;
        
        public class OrderToOpen {
            public String orderStr = "";
            public int barCnt = 0;

public OrderToOpen(String orderStr) {
                this.orderStr = orderStr;
            }
        }
		
		protected override void Execute(){
            log = new StreamWriter(@"c:\users\frank\documents\ScriptLog.txt", true);
            logIt("Excecute - Starting... ordersToOpen.Count=" + ordersToOpen.Count);
			PlotStops();
			tradeIdeaOrders = "";

DateTime lastBarDateTime = DateTime.Now;
	
            logIt("Excecute - Connecting...");
			Connect("127.0.0.1");
			
            logIt("Excecute - Entering bar for loop...");
			for(int bar = 0; bar < Bars.Count; bar++){
                if (bar == Bars.Count - 1 && isDone == false) {
                    logIt("Excecute - Receive1 ordersToOpen.Count=" + ordersToOpen.Count);
                    isDone = Receive(bar);
                    logIt("Excecute - Receive2 ordersToOpen.Count=" + ordersToOpen.Count);
                    processOrders(bar);
                    logIt("Excecute - processOrders2 ordersToOpen.Count=" + ordersToOpen.Count);
                }

lastBarDateTime = Date[bar];
			}

if (ActivePositions.Count > 0) {
                for (int i = ActivePositions.Count - 1; i >= 0; i--) {
                    Position pos = ActivePositions[i];
                    logIt("Execute - ActivePosition[" + i + "]=" + pos.Symbol + " Type=" + pos.PositionType + " Shares=" + pos.Shares);
                }
            } else {
                logIt("Execute - No Active Positions");
            }
			
            logIt("Excecute - Disconnecting...");
			Disconnect(lastBarDateTime);
            logIt("Excecute - Done... ordersToOpen.Count=" + ordersToOpen.Count);
		}

void logIt(string message) {
            log.WriteLine(message);
            log.Flush();
        }
		
		void processOrders(int bar){
			// See if there are new order strings to open or close positions
			List<string> ordersToClose = new List<string>();

logIt("processOrders -  processNewOrderStrings1 - ordersToOpen.Count=" + ordersToOpen.Count);
			processNewOrderStrings(ref ordersToClose);
            logIt("processOrders -  processNewOrderStrings2 - ordersToOpen.Count=" + ordersToOpen.Count);
			
            // Deal with exits before doing entries to free up capital for the new orders
            bool didExit = processExitOrders(bar, ref ordersToClose);
            logIt("processOrders -  processExitOrders - ordersToOpen.Count=" + ordersToOpen.Count);
			
			// Only deal with entries after all exits have been processed
			// 		 so that the most capital is available for the entry
			// If an exit has been placed on the next bar then don't enter until after the next bar
			if(didExit == false){
				// Deal with entries now
				processEntryOrders(bar);
                logIt("processOrders -  processEntryOrders - ordersToOpen.Count=" + ordersToOpen.Count);
			}
		}

void processNewOrderStrings(ref List<String> ordersToClose){
			if(tradeIdeaOrders.Length > 0){
				// Sort orders into entries and exits
				String[] orders = tradeIdeaOrders.Split('$');			
				
				tradeIdeaOrders = "";				
				
				foreach(String order in orders){
					String[] data = order.Split('\t');

if (data.Length == 7) {
                        logIt("processNewOrderStrings - Open Order = \n" + order);
                        ordersToOpen.Add(new OrderToOpen(order));
                    } else if (data.Length == 10) {
                        logIt("processNewOrderStrings - Close Order = \n" + order);
                        ordersToClose.Add(order);
                    } else if(data.Length == 1 && data[0] == "Done") {
                        logIt("processNewOrderStrings - Done");
                        isDone = true;
					} else if(data.Length != 1) {
                        logIt("processNewOrderStrings - Bad Order=\n" + order);
						PrintDebug("Bad Order: ");
						for(int i = 0; i < data.Length; i++){
							PrintDebug("data[" + i + "] = " + data[i]);
						}
					}
				}
			}
		}

bool closeOrder(String[] data, int bar){
			String symbol = data[0];
			bool isNew = Boolean.Parse(data[1]);
			bool isOpen = Boolean.Parse(data[2]);
			bool isLong = Boolean.Parse(data[3]);
			long entryTimeMS = Int64.Parse(data[4]);
			double entryPrice = Double.Parse(data[5]);
			double stopWidth = Double.Parse(data[6]);
			long exitTimeMS = Int64.Parse(data[7]);
			double exitPrice = Double.Parse(data[8]);
			String exitReason = data[9];

logIt("closeOrder - Trying to Close sym=" + symbol + " exitPrice=" + exitPrice);

// Find Position
			Position pos = null;
			bool symbolFound = false;
							
			for(int i = ActivePositions.Count - 1; i >= 0; i--){
				pos = ActivePositions[i];
								
				if(pos.Symbol.Equals(symbol)){
                    SetContext(symbol, true);

if (pos.PositionType == PositionType.Long) {
                        logIt("closeOrder - Calling SellAtMarket");
                        SellAtMarket(bar + 1, pos, exitReason);
                    } else {
                        logIt("closeOrder - Calling CoverAtMarket");
                        CoverAtMarket(bar + 1, pos, exitReason);
                    }

RestoreContext();
					symbolFound = true;
					break;
				}
			}

logIt("closeOrder - symbolFound=" + symbolFound);
			return symbolFound;
		}
		
		void removeFromOpenOrders(String symbol){
			foreach(OrderToOpen o in ordersToOpen){
				String[] d = o.orderStr.Split('\t');
				String orderSymbol = d[0];
							
				if(symbol == orderSymbol){
                    logIt("removeFromOpenOrders - removing order:" + o.orderStr);
					ordersToOpen.Remove(o);
					break;
				}
			}
		}
		
		void processEntryOrders(int bar){
            logIt("processEntryOrders - Begin");
            List<OrderToOpen> ordersToRemove = new List<OrderToOpen>();

foreach(OrderToOpen order in ordersToOpen){
                logIt("processEntryOrders - Processing order:" + order.orderStr);
				String[] data = order.orderStr.Split('\t');

String symbol = data[0];
				bool isNew = Boolean.Parse(data[1]);
				bool isOpen = Boolean.Parse(data[2]);
				bool isLong = Boolean.Parse(data[3]);
				long entryTimeMS = Int64.Parse(data[4]);
				double entryPrice = Double.Parse(data[5]);
				double stopWidth = Double.Parse(data[6]);
						
                // Check to see if there is an active position first because the order my have triggered on the last bar
                for (int i = ActivePositions.Count - 1; i >= 0; i--) {
                    Position pos = ActivePositions[i];

if (pos.Symbol.Equals(symbol)) {
                        logIt("processEntryOrders - Found Active Position for " + symbol + " no longer trying to enter market");
                        ordersToRemove.Add(order);
                        isNew = false; // <-- Don't process this order because it filled on the last bar
                        break;
                    }
                }

// Deal with opening a position
				if(isNew && isOpen){
					SetContext(symbol, true);
                    Position pos = null;
						
					if(isLong){
                        logIt("processEntryOrders - Calling BuyAtLimit sym=" + symbol + " entryPrice=" + entryPrice);
						pos = BuyAtLimit(bar + 1, entryPrice);
							
						if(pos != null){
                            logIt("processEntryOrders - Calling pos.RiskStopLevel sym=" + symbol + " StopWidth=" + stopWidth);
							pos.RiskStopLevel = entryPrice - stopWidth;
							PrintDebug(pos.Symbol + " Long at price: " + pos.EntryPrice + " Date:" + pos.EntryDate + " Stop:" + pos.RiskStopLevel);
                        }
					} else {
                        logIt("processEntryOrders - Calling ShortAtLimit sym=" + symbol + " entryPrice=" + entryPrice);
						pos = ShortAtLimit(bar + 1, entryPrice);
							
						if(pos != null){
                            logIt("processEntryOrders - Calling pos.RiskStopLevel sym=" + symbol + " StopWidth=" + stopWidth);
							pos.RiskStopLevel = entryPrice + stopWidth;
							PrintDebug(pos.Symbol + " Short at price: " + pos.EntryPrice + " Date:" + pos.EntryDate + " Stop:" + pos.RiskStopLevel);
						}
					}

if (pos == null) {
                        order.barCnt++;

// Stop trying to enter after 5 minutes
                        if (order.barCnt >= 5) {
                            logIt("processEntryOrders - order.barCnt=" + order.barCnt + " removing order=" + order.orderStr);
                            ordersToRemove.Add(order);
                        }
                    }

RestoreContext();
				} else {
                    logIt("processEntryOrders - Not New and Open removing order:" + order.orderStr);
                    ordersToRemove.Add(order);
                }
			}

// Remove orders
            foreach(OrderToOpen order in ordersToRemove) {
                logIt("processEntryOrders - Processing ordersToRemove - Removing:" + order.orderStr);
                ordersToOpen.Remove(order);
            }

logIt("processEntryOrders - End");
		}
		
        private bool processExitOrders(int bar, ref List<string> ordersToClose) {
            bool exitHappend = false;

foreach(String order in ordersToClose){
				String[] data = order.Split('\t');
				String symbol = data[0];
				
				exitHappend = closeOrder(data, bar);
					
				// Check to see if the symbol is in ordersToOpen list and remove it
				if(exitHappend == false){
					removeFromOpenOrders(symbol);
				}
			}

return exitHappend;
        }

void Connect(String ip) {
            logIt("Connect - Begin");
			if(client == null){
                logIt("Connect - client is null");
				Object obj = GetGlobal("TIClient");

if(obj == null){
                    logIt("Connect - GetGlobal(\"TIClient\") is null");
					try {
						// Set the TcpListener on port 13000.
						Int32 port = 13000;
						System.Net.IPAddress localAddr = System.Net.IPAddress.Parse(ip);
		
						// TcpListener server = new TcpListener(port);
						//String t = new TcpListener(localAddr, port);
						server = new TcpListener(localAddr, port);
		
						// Start listening for client requests.
						server.Start();
		
						PrintDebug("Waiting for a connection... ");
		
						// Perform a blocking call to accept requests.
						// You could also user server.AcceptSocket() here.
						client = server.AcceptTcpClient();
						PrintDebug("Connected!");
						stream = client.GetStream();

logIt("Connect - Calling SetGlobal");
						SetGlobal("TIClient", client);
						SetGlobal("TIStream", stream);
                        SetGlobal("ordersToOpen", ordersToOpen);
					} catch (System.Net.Sockets.SocketException e) {
						PrintDebug("SocketException: {0}", e);
					}
				} else {
                    logIt("Connect - GetGlobal(\"TIClient\") is set");
					client = (TcpClient)obj;
					stream = (NetworkStream)GetGlobal("TIStream");
                    ordersToOpen = (List<OrderToOpen>)GetGlobal("ordersToOpen");
                    logIt("Connect - Done setting with GetGlobal");
				}
			}
		}

bool Receive(int bar) {
			try {
                /* This is for testing with a SocketClient
				String timeStr = "" + Date[bar].ToFileTimeUtc();
				byte[] wdata = System.Text.Encoding.ASCII.GetBytes(timeStr);
				stream.Write(wdata, 0, wdata.Length);
                */

// uncomment this as it is needed for live trading
                logIt("Receive - client.Available = " + client.Available);

if (client.Available > 0) {
                    // Buffer to store the response bytes.
                    byte[] data = new byte[client.Available + 256];
                    Int32 bytesRead = stream.Read(data, 0, data.Length);
                    logIt("Receive - bytesRead=" + bytesRead);

while (true) {
                        if (bytesRead > 0) {
                            String recData = System.Text.Encoding.ASCII.GetString(data, 0, bytesRead);
                            logIt("Receive - recData=" + recData);

// Remove this as it is only for debug
                            if (recData == "DONE") {
                                return true;
                            }

if (recData != "OK") {
                                tradeIdeaOrders += recData;
                                logIt("Receive - tradeIdeaOrders=" + tradeIdeaOrders);
                            }

// Keep Reading if there is more
                            if (client.Available > 0) {
                                bytesRead = stream.Read(data, 0, data.Length);
                                logIt("Receive - bytesRead2=" + bytesRead);
                            } else {
                                break;
                            }
                        } else {
                            break;
                        }
                    }
                }
			} catch (ArgumentNullException e) {
				PrintDebug("Receive - ArgumentNullException: " + e);
			} catch (SocketException e) {
				PrintDebug("Receive - SocketException: " + e);
			}

return false;
		}

void Disconnect(DateTime lastBarDateTime) {
            int hour = lastBarDateTime.Hour;
            int min = lastBarDateTime.Minute;

logIt("Disconnect - hour=" + hour + " minute=" + min);

if (hour == 16) {
                logIt("Disconnect - Closing stream and client");
                try {
                    // Close everything.
                    stream.Close();
                    client.Close();
                    SetGlobal("TIClient", null);
                    SetGlobal("TIStream", null);
                } catch (ArgumentNullException e) {
                    PrintDebug("Disconnect - ArgumentNullException: " + e);
                } catch (SocketException e) {
                    PrintDebug("Disconnect - SocketException: " + e);
                }
                logIt("Disconnect - Disocnnect Complete...");
            }
		}
	}

public class MyHelper : StrategyHelper {
        public override string Author {
            get {
                return "Frank";
            }
        }

public override DateTime CreationDate {
            get {
                return new DateTime();
            }
        }

public override string Description {
            get {
                return "Trade-Ideas Strategy";
            }
        }

public override Guid ID {
            get {
                return new Guid("1BDFD27A-9C08-49BD-86E7-84D1CA8250DA");
            }
        }

public override DateTime LastModifiedDate {
            get {
                return new DateTime();
            }
        }

public override string Name {
            get {
                return "Trade-Ideas Strategy";
            }
        }

public override Type WealthScriptType {
            get {
                return typeof(MyStrategy);
            }
        }
    }
}
[/code]

Frank1972

#4

12/15/2016 4:42 PM

Cone,

If you need to see this running I have another application that can be used to test this code. Let me know if you need that.

Thanks again for you time and help.

-Frank

Eugene

#5

12/15/2016 5:22 PM

Frank, does the strategy work as intended in the Strategy window?

Frank1972

#6

12/15/2016 5:31 PM

Eugene,

I have never seen a BuyAtLimit or ShortAtLimit result in an ActivePosition in the Strategy window or the Strategy Monitor.

Thanks again for helping me out with this.

-Frank

Eugene

#7

12/16/2016 12:52 PM

Frank, your strategy code is pretty complex in its present state. It would be optimal if you could make it more manageable. To avoid troubleshooting your TCP listener we need to focus on the WealthScript part of the code. I'd suggest to simplify the code and replace the TCP and logging parts with some dummy code.

Cone

#8

12/16/2016 5:16 PM

It looks like you're trying to load historical trades based on an input file.

If so, where do you synchronize bar with the trade time in the input file?

If not, what is this supposed to do?

Frank1972

#9

12/16/2016 6:55 PM

Eugene and Cone,

Thank you for looking into this issue. As it turns out my strategy is working I wasn't understanding how the Strategy Monitor works. I went and re-read that section in the User's Guide and things make sense now. Sorry to have troubled you.

Thanks again,

-Frank