Datasembly

datasembly

Automating My Manual Scalping Trading Strategy One of the advantages of running automatic trading strategies is that you can quickly and consistently act on price action. Even if you have enough time to trade the same idea manually, you need to watch the market movement very closely and keep paying attention to multiple monitors. With algorithmic trading, you can automate this on . Alpaca Also, please keep in mind that this is only an example to help get you started. Consider testing a strategy in paper trading to see if and how it works before trying it in a live brokerage account. If you'd prefer to "fast forward" to full code, go ! directly to the GitHub repository What is Scalping Strategy? There are many types of trading strategies, but this one is called . “scalping” strategy Scalping attempts to take smaller profits quicker, which can add up, without risking your assets holding for long. It requires a strict exit strategy, though, because one large loss could eliminate the many small gains. The above-referenced article explains the strategy in more detail, as well as the different types of scalping. Many day traders are applying this idea, but in order to do this manually, a lot of energy and attention is required in order to keep monitoring the large amounts of information on the screen. Why Scalping Strategy for Algorithmic Trading? When looking back at the intraday chart at the end of the day, it is possible to see different missed opportunities. However, it's not always possible to act during market hours. There could also be even more opportunities if it were possible to monitor a dozen stocks independently versus just looking at one stock. For example, when looking at a TradingView chart for SPY with 20 minute simple moving average on 10/04/19 (below), it's possible to see price crossover where it would have been possible to have taken a small profit if the position had been timely. With the scalping strategy, the goal isn't for a large profit margin, rather, aim for a small upward price movement while it’s going up. It's usually too hard to monitor even a few charts at the same time manually, so that's where algorithms come in. Automate This! Python’s asyncio to Manage Algo Flow What if I can have many of me watching each stock. I started coding based on the idea and found Python’s asyncio is pretty useful to manage algorithm flow for multiple stocks, each of which I found to be pretty simple. Check out Python's Asyncio here! Starting with a Single Stock To begin with a single stock, I wrote a class that manages simple state and event handler for a single stock using (simplified below). Alpaca API self._symbol = symbol
     self._bars = []
     self._state = self._bars =  self._bars.append(bar) self._state == : self._check_signal():
         self._submit_buy()
         self._state = event == : self._state == :
         self._submit_sell( self._get_last_price() + )
         self._state = self._state == :
         self._state = : class ScalpAlgo : def __init__ (self, symbol) 'TO_BUY' : def on_bar (self, bar) '''called when new bar arrives''' if 'TO_BUY' if 'BUY_SUBMITTED' : def on_order_event (self, event) '''called if order status changes''' if 'fill' if 'BUY_SUBMITTED' 0.01 'SELL_SUBMITTED' elif 'SELL_SUBMITTED' 'TO_BUY' The main flow is pretty simple as you can see. It is basically a state machine with 4 distinct states, and given the new event (signal can be triggers, order fills, etc.), the state transitions to look for the next action. In the , I am calculating 20-minute simple moving average and compare with the price. _check_signal() function mavg =  self._bars.rolling( ).mean().close.values
    closes =  self._bars.close.values closes[ ] < mavg[ ] closes[ ] > mavg[ ]: : : def _calc_buy_signal (self) 20 if -2 -2 and -1 -1 return True else return False Subscribing Websockets Since it is important to take action as quickly as the signal triggers, we subscribe to the real-time bar updates from Polygon websockets as well as Alpaca’s order event websockets. Everything is event-driven. stream = alpaca.StreamConn()
  algo = ScalpAlgo( )  @stream.on( ) algo.on_bar(data)  @stream.on( ) algo.on_order_event(data.event)
  stream.run([ , ]) : def main () 'SPY' 'AM.SPY' async : def on_bar (conn, channel, data) 'trade_updates' async : def on_order_event (conn, channel, data) 'AM.SPY' 'trade_updates' This run() function runs in definitely until the program stops. All events are dispatched to the event handlers in Python’s asyncio loop, driven by the new messages from websockets. Focus on the State Transitions Once the structure is built, all you need to do is to focus on the state transitions in a couple of different cases. Beyond the simplified sample code above, you may want to handle cancel/rejection event for your buy order. If you want to forget about it since you don’t have the position, but want to get in next time the same signal triggers, then you will set the state to TO_BUY so you can reset the state. You may also want to consider setting those orders to cancel orders if they don’t fill within the reasonable timeframe after submission. Or those working orders may be canceled from dashboard. Now, the question is how to scale this to dozens of stocks? It’s important to keep the signal as strict as possible so that you don’t get into a position under an unintended situation to buy. The more you tighten the signal rule, the less entry opportunities you have. However, you should have more opportunities if you run this against dozens of stocks. Concurrent algorithm Scaling This to Multiple Stocks To scale this idea to many stocks you want to watch, there is actually not much more to do. The ScalpAlgo already takes the stock symbol as parameter, and manages state for this symbol only, which means you just need to create more of this class instance with different symbols. As an example: stream = alpaca.StreamConn()
  fleet = {}
  symbols = ( , , ) symbol symbols:
    fleet[symbol] = ScalpAlgo(symbol)  @stream.on( ) data.symbol fleet:
       fleet[data.symbl].on_bar(data)  @stream.on( ) order = data.order order[ ]:
      fleet[order[ ]).on_order_event(data.event)  stream.run([ + symbol symbols] + [ ]) : def main () 'SPY' 'QQQ' 'DIA' for in 'AM.*' async : def on_bar (conn, channel, data) if in 'trade_updates' async : def on_order_event (conn, channel, data) if 'symbol' 'symbol' 'AM.' for 'trade_updates' The fleet holds each algorithm instance in a dictionary using symbol as the key. This way, each of the algorithm code does not even need to know if there is another algo working on something different at the time. Putting Together Read the full code here! As you can see, the entire script including logging and corner case handling is less than 300 lines. The only dependency is and you can also use pipenv to create virtualenv. Once API key is set in environment variables and dependency is installed you'll see something like the following: Alpaca Python SDK $ python main.py SPY FB TLT Then, you will see something like this. : : , :main.py: :INFO:SPY:received bar start = : : : , close = , len(bars) = : : , :main.py: :INFO:SPY:closes[ :] = [ ], mavg[ :] = [ ] : : , :main.py: :INFO:FB:received bar start = : : : , close = , len(bars) = : : , :main.py: :INFO:FB:closes[ :] = [ ], mavg[ :] = [ ] : : , :main.py: :INFO:AAPL:received bar start = : : : , close = , len(bars) = : : , :main.py: :INFO:AAPL:closes[ :] = [ ], mavg[ :] = [ ] : : , :main.py: :INFO:TLT:received bar start = : : : , close = , len(bars) = : : , :main.py: :INFO:TLT:buy signal: closes[ ] < mavg[ ] closes[ ] > mavg[ ] : : , :main.py: :INFO:TLT:submitted buy Order({ : , : , : , : , : , : , : , : , : , : , : , : , : , : , : , : , : , : , : , : , : , : , : , : , : , : }) 2019 -10 -04 18 49 04 250 119 2019 -10 -04 14 48 00 -04 00 293.71 319 2019 -10 -04 18 49 04 254 106 -2 293.64 293.71 -2 293.618215 293.62921 2019 -10 -04 18 49 04 281 119 2019 -10 -04 14 48 00 -04 00 180.69 319 2019 -10 -04 18 49 04 286 106 -2 180.609 180.69 -2 180.488985 180.511485 2019 -10 -04 18 49 04 437 119 2019 -10 -04 14 48 00 -04 00 227.33 319 2019 -10 -04 18 49 04 441 106 -2 227.3088 227.33 -2 227.114355 227.13985 2019 -10 -04 18 49 04 455 119 2019 -10 -04 14 48 00 -04 00 145.65 319 2019 -10 -04 18 49 04 458 101 -2 145.6 -2 145.60542 -1 145.65 -1 145.60992000000002 2019 -10 -04 18 49 04 676 180 'asset_class' 'us_equity' 'asset_id' '1f8bfbdf-083a-4ebe-ad36-eaf6b6f0cb9d' 'canceled_at' None 'client_order_id' 'f3c7a968-baba-454b-9691-a90810a389b4' 'created_at' ' 2019-10-04 T 18:49:04 .658502572Z' 'expired_at' None 'extended_hours' False 'failed_at' None 'filled_at' None 'filled_avg_price' None 'filled_qty' '0' 'id' '1aeeb723-34bc-4561-8016-8f916538509c' 'limit_price' '145.65' 'order_type' 'limit' 'qty' '13' 'replaced_at' None 'replaced_by' None 'replaces' None 'side' 'buy' 'status' 'new' 'stop_price' None 'submitted_at' ' 2019-10-04 T 18:49:04 .635271258Z' 'symbol' 'TLT' 'time_in_force' 'day' 'type' 'limit' 'updated_at' ' 2019-10-04 T 18:49:04 .662862495Z' This is just one example of how to write an algorithm that trades multiple stocks concurrently. There are other frameworks such as , but it's up to you and your preferences. pylivetrader Technology and services are offered by AlpacaDB, Inc. Brokerage services are provided by Alpaca Securities LLC ( alpaca.markets ), member FINRA/SIPC. Alpaca Securities LLC is a wholly-owned subsidiary of AlpacaDB, Inc. Tweet us @AlpacaHQ

Stories, News & Mentions about DATASEMBLY

Datasembly’s Stories on HackerNoon