Upload 243 files

.gitattributes

@@ -0,0 +1,12 @@
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+.csv filter=lfs diff=lfs merge=lfs -text
+*.csv filter=lfs diff=lfs merge=lfs -text
+ABIDES/data/synthetic_fundamental.bz2 filter=lfs diff=lfs merge=lfs -text
+ABIDES/data/trades/trades_2014/ct_20140128.bgz filter=lfs diff=lfs merge=lfs -text
+ABIDES/realism/visualizations/market_replay_TSLA_2015-01-29_11-00-00_pov_0.1_40.png filter=lfs diff=lfs merge=lfs -text
+ABIDES/util/plotting/rmsc03_two_hour.png filter=lfs diff=lfs merge=lfs -text
+ABIDES/util/plotting/world_agent_sim.png filter=lfs diff=lfs merge=lfs -text
+data/architecture.jpg filter=lfs diff=lfs merge=lfs -text
+data/INTC/INTC.zip filter=lfs diff=lfs merge=lfs -text
+data/simulations-1.png filter=lfs diff=lfs merge=lfs -text
+data/simulations.jpg filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,20 @@
+__pycache__
+data/reconstructions
+data/TSLA
+data/INTC/INTC_*
+data/INTC/t*
+data/INTC/v*
+data/plot
+data/checkpoints
+ABIDEs/log/paper/IABS*
+ABIDES/log
+*.pdf
+trash
+lightning_logs/
+data/generated_orders.csv
+data/real_orders.csv
+wandb/
+output
+launch.sh
+env
+launch_sim.sh

.vscode/launch.json

@@ -0,0 +1,45 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Python: Current File2",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "${file}",
+            "console": "integratedTerminal",
+            "args": ["-u", "ABIDES/abides.py", "-m", "TRADES", "-c", "world_agent_sim", "-t", "TSLA", "-date", "20150129", "-seed", "40", "-st", "'09:30:00'", "-et", "'10:00:00'", "-d", "True", "-id", "0.811", "-type", "DDIM"]
+        },
+        {
+            "name": "Python: Current File",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "${file}",
+            "console": "integratedTerminal",
+            "args": [
+                "-u",
+                "ABIDES/abides.py",
+                "-c",
+                "world_agent_sim",
+                "-t",
+                "INTC",
+                "-date",
+                "20150130",
+                "-s",
+                "1234",
+                "-d",
+                "True",
+                "-m",
+                "CGAN",
+                "-st",
+                "'09:30:00'",
+                "-et",
+                "'10:00:00'",
+                "-id",
+                "-1.05518"
+            ]
+        }
+    ],
+}

ABIDES/.gitignore

@@ -0,0 +1,13 @@
+
+__pycache__/
+batch_output/
+cache/
+local/
+.idea/
+results/
+util/crypto/datasets
+venv/
+.idea/
+.ipynb/
+.ipynb_checkpoints/
+log/IABS_1/

ABIDES/Kernel.py

@@ -0,0 +1,575 @@
+import numpy as np
+import pandas as pd
+
+import os, queue, sys
+from message.Message import MessageType
+
+from util.util import log_print
+from util.plotting import liquidity_telemetry
+from main import plot_graphs
+from evaluation.quantitative_eval import predictive_lstm
+
+class Kernel:
+
+  def __init__(self, kernel_name, random_state = None):
+    # kernel_name is for human readers only.
+    self.name = kernel_name
+    self.random_state = random_state
+
+    if not random_state:
+      raise ValueError("A valid, seeded np.random.RandomState object is required " +
+             "for the Kernel", self.name)
+      sys.exit()
+
+    # A single message queue to keep everything organized by increasing
+    # delivery timestamp.
+    self.messages = queue.PriorityQueue()
+
+    # currentTime is None until after kernelStarting() event completes
+    # for all agents.  This is a pd.Timestamp that includes the date.
+    self.currentTime = None
+
+    # Timestamp at which the Kernel was created.  Primarily used to
+    # create a unique log directory for this run.  Also used to
+    # print some elapsed time and messages per second statistics.
+    self.kernelWallClockStart = pd.Timestamp('now')
+
+    # TODO: This is financial, and so probably should not be here...
+    self.meanResultByAgentType = {}
+    self.agentCountByType = {}
+
+    # The Kernel maintains a summary log to which agents can write
+    # information that should be centralized for very fast access
+    # by separate statistical summary programs.  Detailed event
+    # logging should go only to the agent's individual log.  This
+    # is for things like "final position value" and such.
+    self.summaryLog = []
+
+    log_print ("Kernel initialized: {}", self.name)
+
+
+  # This is called to actually start the simulation, once all agent
+  # configuration is done.
+  def runner(self, agents = [], startTime = None, stopTime = None,
+             num_simulations = 1, defaultComputationDelay = 1,
+             defaultLatency = 1, agentLatency = None, latencyNoise = [ 1.0 ],
+             agentLatencyModel = None, skip_log = False,
+             seed = None, oracle = None, log_dir = None):
+
+    # agents must be a list of agents for the simulation,
+    #        based on class agent.Agent
+    self.agents = agents
+
+    # Simulation custom state in a freeform dictionary.  Allows config files
+    # that drive multiple simulations, or require the ability to generate
+    # special logs after simulation, to obtain needed output without special
+    # case code in the Kernel.  Per-agent state should be handled using the
+    # provided updateAgentState() method.
+    self.custom_state = {}
+
+    # The kernel start and stop time (first and last timestamp in
+    # the simulation, separate from anything like exchange open/close).
+    self.startTime = startTime
+    self.stopTime = stopTime
+
+    # The global seed, NOT used for anything agent-related.
+    self.seed = seed
+
+    # Should the Kernel skip writing agent logs?
+    self.skip_log = skip_log
+
+    # The data oracle for this simulation, if needed.
+    self.oracle = oracle
+
+    # If a log directory was not specified, use the initial wallclock.
+    self.log_dir = log_dir
+
+    # The kernel maintains a current time for each agent to allow
+    # simulation of per-agent computation delays.  The agent's time
+    # is pushed forward (see below) each time it awakens, and it
+    # cannot receive new messages/wakeups until the global time
+    # reaches the agent's time.  (i.e. it cannot act again while
+    # it is still "in the future")
+
+    # This also nicely enforces agents being unable to act before
+    # the simulation startTime.
+    self.agentCurrentTimes = [self.startTime] * len(agents)
+
+    # agentComputationDelays is in nanoseconds, starts with a default
+    # value from config, and can be changed by any agent at any time
+    # (for itself only).  It represents the time penalty applied to
+    # an agent each time it is awakened  (wakeup or recvMsg).  The
+    # penalty applies _after_ the agent acts, before it may act again.
+    # TODO: this might someday change to pd.Timedelta objects.
+    self.agentComputationDelays = [defaultComputationDelay] * len(agents)
+
+    # If an agentLatencyModel is defined, it will be used instead of
+    # the older, non-model-based attributes.
+    self.agentLatencyModel = agentLatencyModel
+
+    # If an agentLatencyModel is NOT defined, the older parameters:
+    # agentLatency (or defaultLatency) and latencyNoise should be specified.
+    # These should be considered deprecated and will be removed in the future.
+
+    # If agentLatency is not defined, define it using the defaultLatency.
+    # This matrix defines the communication delay between every pair of
+    # agents.
+    if agentLatency is None:
+      self.agentLatency = [[defaultLatency] * len(agents)] * len(agents)
+    else:
+      self.agentLatency = agentLatency
+
+    # There is a noise model for latency, intended to be a one-sided
+    # distribution with the peak at zero.  By default there is no noise
+    # (100% chance to add zero ns extra delay).  Format is a list with
+    # list index = ns extra delay, value = probability of this delay.
+    self.latencyNoise = latencyNoise
+
+    # The kernel maintains an accumulating additional delay parameter
+    # for the current agent.  This is applied to each message sent
+    # and upon return from wakeup/receiveMessage, in addition to the
+    # agent's standard computation delay.  However, it never carries
+    # over to future wakeup/receiveMessage calls.  It is useful for
+    # staggering of sent messages.
+    self.currentAgentAdditionalDelay = 0
+
+    log_print ("Kernel started: {}", self.name)
+    log_print ("Simulation started!")
+
+    # Note that num_simulations has not yet been really used or tested
+    # for anything.  Instead we have been running multiple simulations
+    # with coarse parallelization from a shell script.
+    for sim in range(num_simulations):
+      log_print ("Starting sim {}", sim)
+
+      # Event notification for kernel init (agents should not try to
+      # communicate with other agents, as order is unknown).  Agents
+      # should initialize any internal resources that may be needed
+      # to communicate with other agents during agent.kernelStarting().
+      # Kernel passes self-reference for agents to retain, so they can
+      # communicate with the kernel in the future (as it does not have
+      # an agentID).
+      log_print ("\n--- Agent.kernelInitializing() ---")
+      for agent in self.agents:
+        agent.kernelInitializing(self)
+
+      # Event notification for kernel start (agents may set up
+      # communications or references to other agents, as all agents
+      # are guaranteed to exist now).  Agents should obtain references
+      # to other agents they require for proper operation (exchanges,
+      # brokers, subscription services...).  Note that we generally
+      # don't (and shouldn't) permit agents to get direct references
+      # to other agents (like the exchange) as they could then bypass
+      # the Kernel, and therefore simulation "physics" to send messages
+      # directly and instantly or to perform disallowed direct inspection
+      # of the other agent's state.  Agents should instead obtain the
+      # agent ID of other agents, and communicate with them only via
+      # the Kernel.  Direct references to utility objects that are not
+      # agents are acceptable (e.g. oracles).
+      log_print ("\n--- Agent.kernelStarting() ---")
+      for agent in self.agents:
+        agent.kernelStarting(self.startTime)
+
+      # Set the kernel to its startTime.
+      self.currentTime = self.startTime
+      log_print ("\n--- Kernel Clock started ---")
+      log_print ("Kernel.currentTime is now {}", self.currentTime)
+
+      # Start processing the Event Queue.
+      log_print ("\n--- Kernel Event Queue begins ---")
+      log_print ("Kernel will start processing messages.  Queue length: {}", len(self.messages.queue))
+
+      # Track starting wall clock time and total message count for stats at the end.
+      eventQueueWallClockStart = pd.Timestamp('now')
+      ttl_messages = 0
+
+      # Process messages until there aren't any (at which point there never can
+      # be again, because agents only "wake" in response to messages), or until
+      # the kernel stop time is reached.
+      while not self.messages.empty() and self.currentTime and (self.currentTime <= self.stopTime):
+        # Get the next message in timestamp order (delivery time) and extract it.
+        self.currentTime, event = self.messages.get()
+        msg_recipient, msg_type, msg = event
+        
+        # Periodically print the simulation time and total messages, even if muted.
+        if ttl_messages % 100000 == 0:
+          print("msg_recipient: ", msg_recipient, "msg_type: ", msg_type, "msg: ", msg)
+          print ("\n--- Simulation time: {}, messages processed: {}, wallclock elapsed: {} ---\n".format(
+                         self.fmtTime(self.currentTime), ttl_messages, pd.Timestamp('now') - eventQueueWallClockStart))
+
+        #log_print ("\n--- Kernel Event Queue pop ---")
+        #log_print ("Kernel handling {} message for agent {} at time {}", msg_type, msg_recipient, self.fmtTime(self.currentTime))
+
+        ttl_messages += 1
+
+        # In between messages, always reset the currentAgentAdditionalDelay.
+        self.currentAgentAdditionalDelay = 0
+
+        # Dispatch message to agent.
+        if msg_type == MessageType.WAKEUP:
+
+          # Who requested this wakeup call?
+          agent = msg_recipient
+
+          # Test to see if the agent is already in the future.  If so,
+          # delay the wakeup until the agent can act again.
+          if self.agentCurrentTimes[agent] > self.currentTime:
+            # Push the wakeup call back into the PQ with a new time.
+            self.messages.put((self.agentCurrentTimes[agent],
+                              (msg_recipient, msg_type, msg)))
+            #log_print ("Agent in future: wakeup requeued for {}", self.fmtTime(self.agentCurrentTimes[agent]))
+            continue
+            
+          # Set agent's current time to global current time for start
+          # of processing.
+          self.agentCurrentTimes[agent] = self.currentTime
+
+          # Wake the agent.
+          agents[agent].wakeup(self.currentTime)
+
+          # Delay the agent by its computation delay plus any transient additional delay requested.
+          self.agentCurrentTimes[agent] += pd.Timedelta(self.agentComputationDelays[agent] +
+                                                        self.currentAgentAdditionalDelay)
+
+          #log_print ("After wakeup return, agent {} delayed from {} to {}", agent, self.fmtTime(self.currentTime), self.fmtTime(self.agentCurrentTimes[agent]))
+
+        elif msg_type == MessageType.MESSAGE:
+
+          # Who is receiving this message?
+          agent = msg_recipient
+
+          # Test to see if the agent is already in the future.  If so,
+          # delay the message until the agent can act again.
+          if self.agentCurrentTimes[agent] > self.currentTime:
+            # Push the message back into the PQ with a new time.
+            self.messages.put((self.agentCurrentTimes[agent],
+                              (msg_recipient, msg_type, msg)))
+            #log_print ("Agent in future: message requeued for {}", self.fmtTime(self.agentCurrentTimes[agent]))
+            continue
+
+          # Set agent's current time to global current time for start
+          # of processing.
+          self.agentCurrentTimes[agent] = self.currentTime
+
+          # Deliver the message.
+          agents[agent].receiveMessage(self.currentTime, msg)
+
+          # Delay the agent by its computation delay plus any transient additional delay requested.
+          self.agentCurrentTimes[agent] += pd.Timedelta(self.agentComputationDelays[agent] +
+                                                        self.currentAgentAdditionalDelay)
+
+          #log_print ("After receiveMessage return, agent {} delayed from {} to {}",
+          #           agent, self.fmtTime(self.currentTime), self.fmtTime(self.agentCurrentTimes[agent]))
+
+        else:
+          raise ValueError("Unknown message type found in queue",
+                           "currentTime:", self.currentTime,
+                           "messageType:", self.msg.type)
+
+      if self.messages.empty():
+        log_print ("\n--- Kernel Event Queue empty ---")
+
+      if self.currentTime and (self.currentTime > self.stopTime):
+        log_print ("\n--- Kernel Stop Time surpassed ---")
+
+      # Record wall clock stop time and elapsed time for stats at the end.
+      eventQueueWallClockStop = pd.Timestamp('now')
+
+      eventQueueWallClockElapsed = eventQueueWallClockStop - eventQueueWallClockStart
+
+      # Event notification for kernel end (agents may communicate with
+      # other agents, as all agents are still guaranteed to exist).
+      # Agents should not destroy resources they may need to respond
+      # to final communications from other agents.
+      log_print ("\n--- Agent.kernelStopping() ---")
+      for agent in agents:
+        agent.kernelStopping()
+
+      # Event notification for kernel termination (agents should not
+      # attempt communication with other agents, as order of termination
+      # is unknown).  Agents should clean up all used resources as the
+      # simulation program may not actually terminate if num_simulations > 1.
+      log_print ("\n--- Agent.kernelTerminating() ---")
+      for agent in agents:
+        agent.kernelTerminating()
+
+      print ("Event Queue elapsed: {}, messages: {}, messages per second: {:0.1f}".format(
+             eventQueueWallClockElapsed, ttl_messages, 
+             ttl_messages / (eventQueueWallClockElapsed / (np.timedelta64(1, 's')))))
+      log_print ("Ending sim {}", sim)
+
+
+    # The Kernel adds a handful of custom state results for all simulations,
+    # which configurations may use, print, log, or discard.
+    self.custom_state['kernel_event_queue_elapsed_wallclock'] = eventQueueWallClockElapsed
+    self.custom_state['kernel_slowest_agent_finish_time'] = max(self.agentCurrentTimes)
+
+    # Agents will request the Kernel to serialize their agent logs, usually
+    # during kernelTerminating, but the Kernel must write out the summary
+    # log itself.
+    self.writeSummaryLog()
+
+    # This should perhaps be elsewhere, as it is explicitly financial, but it
+    # is convenient to have a quick summary of the results for now.
+    print ("Mean ending value by agent type:")
+    for a in self.meanResultByAgentType:
+      value = self.meanResultByAgentType[a]
+      count = self.agentCountByType[a]
+      print ("{}: {:d}".format(a, int(round(value / count))))
+
+    print ("Simulation ending!")
+    stock_name = self.log_dir.split("_")[2]
+    date = self.log_dir.split("_")[3]
+    time = self.log_dir.split("_")[4]
+    path = os.path.join(os.getcwd(), "ABIDES", "log", self.log_dir)
+    liquidity_telemetry.main(
+      exchange_path=path+"/EXCHANGE_AGENT.bz2", 
+      ob_path=path+f"/ORDERBOOK_{stock_name}_FULL.bz2", 
+      outfile=path+"/world_agent_sim.png", 
+      plot_config="ABIDES/util/plotting/configs/plot_09.30_12.00.json"
+    )
+    real_data_path = os.path.join(os.getcwd(), "ABIDES", "log", "paper", f"market_replay_{stock_name}_{date}_{time}", "processed_orders.csv")
+    trades_data_path = os.path.join(os.getcwd(), "ABIDES", "log", self.log_dir, "processed_orders.csv")
+    plot_graphs(real_data_path, trades_data_path, trades_data_path, trades_data_path)
+    predictive_lstm.main(real_data_path, trades_data_path)
+    return self.custom_state
+
+
+  def sendMessage(self, sender = None, recipient = None, msg = None, delay = 0):
+    # Called by an agent to send a message to another agent.  The kernel
+    # supplies its own currentTime (i.e. "now") to prevent possible
+    # abuse by agents.  The kernel will handle computational delay penalties
+    # and/or network latency.  The message must derive from the message.Message class.
+    # The optional delay parameter represents an agent's request for ADDITIONAL
+    # delay (beyond the Kernel's mandatory computation + latency delays) to represent
+    # parallel pipeline processing delays (that should delay the transmission of messages
+    # but do not make the agent "busy" and unable to respond to new messages).
+    
+    if sender is None:
+      raise ValueError("sendMessage() called without valid sender ID",
+                       "sender:", sender, "recipient:", recipient,
+                       "msg:", msg)
+
+    if recipient is None:
+      raise ValueError("sendMessage() called without valid recipient ID",
+                       "sender:", sender, "recipient:", recipient,
+                       "msg:", msg)
+
+    if msg is None:
+      raise ValueError("sendMessage() called with message == None",
+                       "sender:", sender, "recipient:", recipient,
+                       "msg:", msg)
+
+    # Apply the agent's current computation delay to effectively "send" the message
+    # at the END of the agent's current computation period when it is done "thinking".
+    # NOTE: sending multiple messages on a single wake will transmit all at the same
+    # time, at the end of computation.  To avoid this, use Agent.delay() to accumulate
+    # a temporary delay (current cycle only) that will also stagger messages.
+
+    # The optional pipeline delay parameter DOES push the send time forward, since it
+    # represents "thinking" time before the message would be sent.  We don't use this
+    # for much yet, but it could be important later.
+
+    # This means message delay (before latency) is the agent's standard computation delay
+    # PLUS any accumulated delay for this wake cycle PLUS any one-time requested delay
+    # for this specific message only.
+    sentTime = self.currentTime + pd.Timedelta(self.agentComputationDelays[sender] + 
+                                               self.currentAgentAdditionalDelay + delay)
+
+    # Apply communication delay per the agentLatencyModel, if defined, or the
+    # agentLatency matrix [sender][recipient] otherwise.
+    if self.agentLatencyModel is not None:
+      latency = self.agentLatencyModel.get_latency(sender_id = sender, recipient_id = recipient)
+      deliverAt = sentTime + pd.Timedelta(latency)
+      log_print ("Kernel applied latency {}, accumulated delay {}, one-time delay {} on sendMessage from: {} to {}, scheduled for {}",
+                 latency, self.currentAgentAdditionalDelay, delay, self.agents[sender].name, self.agents[recipient].name,
+                 self.fmtTime(deliverAt))
+    else:
+      latency = self.agentLatency[sender][recipient]
+      noise = self.random_state.choice(len(self.latencyNoise), 1, self.latencyNoise)[0]
+      deliverAt = sentTime + pd.Timedelta(latency + noise)
+      log_print ("Kernel applied latency {}, noise {}, accumulated delay {}, one-time delay {} on sendMessage from: {} to {}, scheduled for {}",
+                 latency, noise, self.currentAgentAdditionalDelay, delay, self.agents[sender].name, self.agents[recipient].name,
+                 self.fmtTime(deliverAt))
+
+    # Finally drop the message in the queue with priority == delivery time.
+    self.messages.put((deliverAt, (recipient, MessageType.MESSAGE, msg)))
+
+    log_print ("Sent time: {}, current time {}, computation delay {}", sentTime, self.currentTime, self.agentComputationDelays[sender])
+    log_print ("Message queued: {}", msg)
+
+
+
+  def setWakeup(self, sender = None, requestedTime = None):
+    # Called by an agent to receive a "wakeup call" from the kernel
+    # at some requested future time.  Defaults to the next possible
+    # timestamp.  Wakeup time cannot be the current time or a past time.
+    # Sender is required and should be the ID of the agent making the call.
+    # The agent is responsible for maintaining any required state; the
+    # kernel will not supply any parameters to the wakeup() call.
+
+    if requestedTime is None:
+        requestedTime = self.currentTime + pd.TimeDelta(1)
+
+    if sender is None:
+      raise ValueError("setWakeup() called without valid sender ID",
+                       "sender:", sender, "requestedTime:", requestedTime)
+
+    if self.currentTime and (requestedTime < self.currentTime):
+      raise ValueError("setWakeup() called with requested time not in future",
+                       "currentTime:", self.currentTime,
+                       "requestedTime:", requestedTime)
+
+    #log_print ("Kernel adding wakeup for agent {} at time {}",
+     #          sender, self.fmtTime(requestedTime))
+
+    self.messages.put((requestedTime,
+                      (sender, MessageType.WAKEUP, None)))
+
+
+  def getAgentComputeDelay(self, sender = None):
+    # Allows an agent to query its current computation delay.
+    return self.agentComputationDelays[sender]
+
+
+  def setAgentComputeDelay(self, sender = None, requestedDelay = None):
+    # Called by an agent to update its computation delay.  This does
+    # not initiate a global delay, nor an immediate delay for the
+    # agent.  Rather it sets the new default delay for the calling
+    # agent.  The delay will be applied upon every return from wakeup
+    # or recvMsg.  Note that this delay IS applied to any messages
+    # sent by the agent during the current wake cycle (simulating the
+    # messages popping out at the end of its "thinking" time).
+
+    # Also note that we DO permit a computation delay of zero, but this should
+    # really only be used for special or massively parallel agents.
+
+    # requestedDelay should be in whole nanoseconds.
+    if not type(requestedDelay) is int:
+      raise ValueError("Requested computation delay must be whole nanoseconds.",
+                       "requestedDelay:", requestedDelay)
+
+    # requestedDelay must be non-negative.
+    if not requestedDelay >= 0:
+      raise ValueError("Requested computation delay must be non-negative nanoseconds.",
+                       "requestedDelay:", requestedDelay)
+
+    self.agentComputationDelays[sender] = requestedDelay
+
+
+
+  def delayAgent(self, sender = None, additionalDelay = None):
+    # Called by an agent to accumulate temporary delay for the current wake cycle.
+    # This will apply the total delay (at time of sendMessage) to each message,
+    # and will modify the agent's next available time slot.  These happen on top
+    # of the agent's compute delay BUT DO NOT ALTER IT.  (i.e. effects are transient)
+    # Mostly useful for staggering outbound messages.
+
+    # additionalDelay should be in whole nanoseconds.
+    if not type(additionalDelay) is int:
+      raise ValueError("Additional delay must be whole nanoseconds.",
+                       "additionalDelay:", additionalDelay)
+
+    # additionalDelay must be non-negative.
+    if not additionalDelay >= 0:
+      raise ValueError("Additional delay must be non-negative nanoseconds.",
+                       "additionalDelay:", additionalDelay)
+
+    self.currentAgentAdditionalDelay += additionalDelay
+
+
+
+  def findAgentByType(self, type):
+    # Called to request an arbitrary agent ID that matches the class or base class
+    # passed as "type".  For example, any ExchangeAgent, or any NasdaqExchangeAgent.
+    # This method is rather expensive, so the results should be cached by the caller!
+
+    for agent in self.agents:
+      if isinstance(agent, type):
+        return agent.id
+
+
+  def writeLog (self, sender, dfLog, filename=None):
+    # Called by any agent, usually at the very end of the simulation just before
+    # kernel shutdown, to write to disk any log dataframe it has been accumulating
+    # during simulation.  The format can be decided by the agent, although changes
+    # will require a special tool to read and parse the logs.  The Kernel places
+    # the log in a unique directory per run, with one filename per agent, also
+    # decided by the Kernel using agent type, id, etc.
+
+    # If there are too many agents, placing all these files in a directory might
+    # be unfortunate.  Also if there are too many agents, or if the logs are too
+    # large, memory could become an issue.  In this case, we might have to take
+    # a speed hit to write logs incrementally.
+
+    # If filename is not None, it will be used as the filename.  Otherwise,
+    # the Kernel will construct a filename based on the name of the Agent
+    # requesting log archival.
+
+    if self.skip_log: return
+
+    path = os.path.join(os.getcwd(), "ABIDES", "log", self.log_dir)
+
+    if filename:
+      file = "{}.bz2".format(filename)
+    else:
+      file = "{}.bz2".format(self.agents[sender].name.replace(" ",""))
+
+    if not os.path.exists(path):
+      os.makedirs(path)
+
+    dfLog.to_pickle(os.path.join(path, file), compression='bz2')
+
+
+  def appendSummaryLog (self, sender, eventType, event):
+    # We don't even include a timestamp, because this log is for one-time-only
+    # summary reporting, like starting cash, or ending cash.
+    self.summaryLog.append({ 'AgentID' : sender,
+                             'AgentStrategy' : self.agents[sender].type,
+                             'EventType' : eventType, 'Event' : event })
+
+
+  def writeSummaryLog (self):
+    path = os.path.join("ABIDES", "log", self.log_dir)
+    file = "summary_log.bz2"
+
+    if not os.path.exists(path):
+      os.makedirs(path)
+
+    dfLog = pd.DataFrame(self.summaryLog)
+
+    dfLog.to_pickle(os.path.join(path, file), compression='bz2')
+
+
+  def updateAgentState (self, agent_id, state):
+    """ Called by an agent that wishes to replace its custom state in the dictionary
+        the Kernel will return at the end of simulation.  Shared state must be set directly,
+        and agents should coordinate that non-destructively.
+
+        Note that it is never necessary to use this kernel state dictionary for an agent
+        to remember information about itself, only to report it back to the config file.
+    """
+
+    if 'agent_state' not in self.custom_state: self.custom_state['agent_state'] = {}
+    self.custom_state['agent_state'][agent_id] = state
+
+ 
+  @staticmethod
+  def fmtTime(simulationTime):
+    # The Kernel class knows how to pretty-print time.  It is assumed simulationTime
+    # is in nanoseconds since midnight.  Note this is a static method which can be
+    # called either on the class or an instance.
+
+    # Try just returning the pd.Timestamp now.
+    return (simulationTime)
+
+    ns = simulationTime
+    hr = int(ns / (1000000000 * 60 * 60))
+    ns -= (hr * 1000000000 * 60 * 60)
+    m = int(ns / (1000000000 * 60))
+    ns -= (m * 1000000000 * 60)
+    s = int(ns / 1000000000)
+    ns = int(ns - (s * 1000000000))
+
+    return "{:02d}:{:02d}:{:02d}.{:09d}".format(hr, m, s, ns)
+

ABIDES/LICENSE.txt

@@ -0,0 +1,89 @@
+The authors of ABIDES are David Byrd and Dr. Tucker Balch of the Georgia Institute of Technology.
+
+
+BSD 3-Clause License
+
+Copyright (c) 2019 Georgia Tech Research Corporation
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+
+Funding Acknowledgement
+
+This material is based upon work supported by the National Science Foundation under Award No. 1741026.  Any opinions, findings, and conclusions or recommendations expressed in this publication are those of the author(s) and do not necessarily reflect the views of the National Science Foundation.
+
+
+
+This software uses the pandas library for Python:
+
+
+BSD 3-Clause License
+
+Copyright (c) 2008-2012, AQR Capital Management, LLC, Lambda Foundry, Inc. and PyData Development Team
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+
+This software uses the NumPy library for Python:
+
+
+Copyright © 2005-2018, NumPy Developers.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+    Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+    Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+    Neither the name of the NumPy Developers nor the names of any contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

ABIDES/README.md

@@ -0,0 +1,4 @@
+# ABIDES: Agent-Based Interactive Discrete Event Simulation environment
+
+> ABIDES is an Agent-Based Interactive Discrete Event Simulation environment. It was developed by David Byrd, Mahmoud Mahfouz, Danial Dervovic, Maria Hybinette and Tucker Hybinette Balch.
+> We only extended it to perform market simulations with our world agent represented by the diffusion model. So, our contribution are the files WorldAgent.py in agent DIR, and world_agent_sim.py in the config DIR.

ABIDES/abides.py

@@ -0,0 +1,32 @@
+import argparse
+import importlib
+import os
+import sys
+
+if __name__ == '__main__':
+
+  # Print system banner.
+  system_name = "ABIDES: Agent-Based Interactive Discrete Event Simulation"  
+  sys.path.insert(0, os.getcwd())
+  print ("=" * len(system_name))
+  print (system_name)
+  print ("=" * len(system_name))
+  print ()
+
+  # Test command line parameters.  Only peel off the config file.
+  # Anything else should be left FOR the config file to consume as agent
+  # or experiment parameterization.
+  parser = argparse.ArgumentParser(description='Simulation configuration.')
+  parser.add_argument('-c', '--config', required=True,
+                      help='Name of config file to execute')
+  parser.add_argument('--config-help', action='store_true',
+                    help='Print argument options for the specific config file.')
+
+  args, config_args = parser.parse_known_args()
+
+  # First parameter supplied is config file.
+  config_file = args.config
+
+  config = importlib.import_module('config.{}'.format(config_file),
+                                   package=None)
+

ABIDES/agent/Agent.py

@@ -0,0 +1,185 @@
+import pandas as pd
+
+from copy import deepcopy
+from util.util import log_print
+
+class Agent:
+
+  def __init__ (self, id, name, type, random_state, log_to_file=True):
+
+    # ID must be a unique number (usually autoincremented).
+    # Name is for human consumption, should be unique (often type + number).
+    # Type is for machine aggregation of results, should be same for all
+    # agents following the same strategy (incl. parameter settings).
+    # Every agent is given a random state to use for any stochastic needs.
+    # This is an np.random.RandomState object, already seeded.
+    self.id = id
+    self.name = name
+    self.type = type
+    self.log_to_file = log_to_file
+    self.random_state = random_state
+
+    if not random_state:
+      raise ValueError("A valid, seeded np.random.RandomState object is required " +
+             "for every agent.Agent", self.name)
+      sys.exit()
+
+    # Kernel is supplied via kernelInitializing method of kernel lifecycle.
+    self.kernel = None
+
+    # What time does the agent think it is?  Should be updated each time
+    # the agent wakes via wakeup or receiveMessage.  (For convenience
+    # of reference throughout the Agent class hierarchy, NOT THE
+    # CANONICAL TIME.)
+    self.currentTime = None
+
+    # Agents may choose to maintain a log.  During simulation,
+    # it should be stored as a list of dictionaries.  The expected
+    # keys by default are: EventTime, EventType, Event.  Other
+    # Columns may be added, but will then require specializing
+    # parsing and will increase output dataframe size.  If there
+    # is a non-empty log, it will be written to disk as a Dataframe
+    # at kernel termination.
+
+    # It might, or might not, make sense to formalize these log Events
+    # as a class, with enumerated EventTypes and so forth.
+    self.log = []
+    self.logEvent("AGENT_TYPE", type)
+
+
+  ### Flow of required kernel listening methods:
+  ### init -> start -> (entire simulation) -> end -> terminate
+
+  def kernelInitializing (self, kernel):
+    # Called by kernel one time when simulation first begins.
+    # No other agents are guaranteed to exist at this time.
+
+    # Kernel reference must be retained, as this is the only time the
+    # agent can "see" it.
+
+    self.kernel = kernel
+
+    log_print ("{} exists!", self.name)
+
+
+  def kernelStarting (self, startTime):
+    # Called by kernel one time _after_ simulationInitializing.
+    # All other agents are guaranteed to exist at this time.
+    # startTime is the earliest time for which the agent can
+    # schedule a wakeup call (or could receive a message).
+
+    # Base Agent schedules a wakeup call for the first available timestamp.
+    # Subclass agents may override this behavior as needed.
+
+    log_print ("Agent {} ({}) requesting kernel wakeup at time {}",
+           self.id, self.name, self.kernel.fmtTime(startTime))
+
+    self.setWakeup(startTime)
+
+
+  def kernelStopping (self):
+    # Called by kernel one time _before_ simulationTerminating.
+    # All other agents are guaranteed to exist at this time.
+
+    pass
+
+
+  def kernelTerminating (self):
+    # Called by kernel one time when simulation terminates.
+    # No other agents are guaranteed to exist at this time.
+
+    # If this agent has been maintaining a log, convert it to a Dataframe
+    # and request that the Kernel write it to disk before terminating.
+    if self.log and self.log_to_file:
+      dfLog = pd.DataFrame(self.log)
+      dfLog.set_index('EventTime', inplace=True)
+      self.writeLog(dfLog)
+
+
+  ### Methods for internal use by agents (e.g. bookkeeping).
+
+  def logEvent (self, eventType, event = '', appendSummaryLog = False):
+    # Adds an event to this agent's log.  The deepcopy of the Event field,
+    # often an object, ensures later state changes to the object will not
+    # retroactively update the logged event.
+
+    # We can make a single copy of the object (in case it is an arbitrary
+    # class instance) for both potential log targets, because we don't
+    # alter logs once recorded.
+    e = deepcopy(event)
+    self.log.append({ 'EventTime' : self.currentTime, 'EventType' : eventType,
+                      'Event' : e })
+
+    if appendSummaryLog: self.kernel.appendSummaryLog(self.id, eventType, e)
+
+
+  ### Methods required for communication from other agents.
+  ### The kernel will _not_ call these methods on its own behalf,
+  ### only to pass traffic from other agents..
+
+  def receiveMessage (self, currentTime, msg):
+    # Called each time a message destined for this agent reaches
+    # the front of the kernel's priority queue.  currentTime is
+    # the simulation time at which the kernel is delivering this
+    # message -- the agent should treat this as "now".  msg is
+    # an object guaranteed to inherit from the message.Message class.
+
+    self.currentTime = currentTime
+
+    log_print ("At {}, agent {} ({}) received: {}",
+                  self.kernel.fmtTime(currentTime), self.id, self.name, msg)
+
+
+  def wakeup (self, currentTime):
+    # Agents can request a wakeup call at a future simulation time using
+    # Agent.setWakeup().  This is the method called when the wakeup time
+    # arrives.
+
+    self.currentTime = currentTime
+
+    log_print ("At {}, agent {} ({}) received wakeup.",
+                  self.kernel.fmtTime(currentTime), self.id, self.name)
+
+
+  ### Methods used to request services from the Kernel.  These should be used
+  ### by all agents.  Kernel methods should _not_ be called directly!
+
+  ### Presently the kernel expects agent IDs only, not agent references.
+  ### It is possible this could change in the future.  Normal agents will
+  ### not typically wish to request additional delay.
+  def sendMessage (self, recipientID, msg, delay = 0):
+    self.kernel.sendMessage(self.id, recipientID, msg, delay=delay)
+
+  def setWakeup (self, requestedTime):
+    self.kernel.setWakeup(self.id, requestedTime)
+
+  def getComputationDelay (self):
+    return self.kernel.getAgentComputeDelay(sender = self.id)
+
+  def setComputationDelay (self, requestedDelay):
+    self.kernel.setAgentComputeDelay(sender = self.id, requestedDelay = requestedDelay)
+
+  def delay (self, additionalDelay):
+    self.kernel.delayAgent(sender = self.id, additionalDelay = additionalDelay)
+
+  def writeLog (self, dfLog, filename=None):
+    self.kernel.writeLog(self.id, dfLog, filename)
+
+  def updateAgentState (self, state):
+    """ Agents should use this method to replace their custom state in the dictionary
+        the Kernel will return to the experimental config file at the end of the
+        simulation.  This is intended to be write-only, and agents should not use
+        it to store information for their own later use.
+    """
+
+    self.kernel.updateAgentState(self.id, state)
+
+
+  ### Internal methods that should not be modified without a very good reason.
+
+  def __lt__(self, other):
+    # Required by Python3 for this object to be placed in a priority queue.
+
+    return ("{}".format(self.id) <
+            "{}".format(other.id))
+

ABIDES/agent/ExchangeAgent.py

@@ -0,0 +1,415 @@
+# The ExchangeAgent expects a numeric agent id, printable name, agent type, timestamp to open and close trading,
+# a list of equity symbols for which it should create order books, a frequency at which to archive snapshots
+# of its order books, a pipeline delay (in ns) for order activity, the exchange computation delay (in ns),
+# the levels of order stream history to maintain per symbol (maintains all orders that led to the last N trades),
+# whether to log all order activity to the agent log, and a random state object (already seeded) to use
+# for stochasticity.
+from agent.FinancialAgent import FinancialAgent
+from message.Message import Message
+from util.OrderBook import OrderBook
+from util.util import log_print
+
+import datetime as dt
+
+import warnings
+warnings.simplefilter(action='ignore', category=FutureWarning)
+warnings.simplefilter(action='ignore', category=UserWarning)
+
+import pandas as pd
+pd.set_option('display.max_rows', 500)
+
+from copy import deepcopy
+
+
+class ExchangeAgent(FinancialAgent):
+
+  def __init__(self, id, name, type, mkt_open, mkt_close, symbols, book_freq='S', wide_book=False, pipeline_delay = 40000,
+               computation_delay = 1, stream_history = 0, log_orders = False, random_state = None):
+
+    super().__init__(id, name, type, random_state)
+
+    # Do not request repeated wakeup calls.
+    self.reschedule = False
+
+    # Store this exchange's open and close times.
+    self.mkt_open = mkt_open
+    self.mkt_close = mkt_close
+
+    # Right now, only the exchange agent has a parallel processing pipeline delay.  This is an additional
+    # delay added only to order activity (placing orders, etc) and not simple inquiries (market operating
+    # hours, etc).
+    self.pipeline_delay = pipeline_delay
+
+    # Computation delay is applied on every wakeup call or message received.
+    self.computation_delay = computation_delay
+
+    # The exchange maintains an order stream of all orders leading to the last L trades
+    # to support certain agents from the auction literature (GD, HBL, etc).
+    self.stream_history = stream_history
+
+    # Log all order activity?
+    self.log_orders = log_orders
+
+    # Create an order book for each symbol.
+    self.order_books = {}
+
+    for symbol in symbols:
+      self.order_books[symbol] = OrderBook(self, symbol)
+
+    # At what frequency will we archive the order books for visualization and analysis?
+    self.book_freq = book_freq
+
+    # Store orderbook in wide format? ONLY WORKS with book_freq == 0
+    self.wide_book = wide_book
+
+    # The subscription dict is a dictionary with the key = agent ID,
+    # value = dict (key = symbol, value = list [levels (no of levels to recieve updates for),
+    # frequency (min number of ns between messages), last agent update timestamp]
+    # e.g. {101 : {'AAPL' : [1, 10, pd.Timestamp(10:00:00)}}
+    self.subscription_dict = {}
+
+  # The exchange agent overrides this to obtain a reference to an oracle.
+  # This is needed to establish a "last trade price" at open (i.e. an opening
+  # price) in case agents query last trade before any simulated trades are made.
+  # This can probably go away once we code the opening cross auction.
+  def kernelInitializing (self, kernel):
+    super().kernelInitializing(kernel)
+
+    self.oracle = self.kernel.oracle
+
+    # Obtain opening prices (in integer cents).  These are not noisy right now.
+    for symbol in self.order_books:
+      try:
+        self.order_books[symbol].last_trade = self.oracle.getDailyOpenPrice(symbol, self.mkt_open)
+        #log_print ("Opening price for {} is {}", symbol, self.order_books[symbol].last_trade)
+      except AttributeError as e:
+        log_print(str(e))
+
+
+  # The exchange agent overrides this to additionally log the full depth of its
+  # order books for the entire day.
+  def kernelTerminating (self):
+    super().kernelTerminating()
+
+    # If the oracle supports writing the fundamental value series for its
+    # symbols, write them to disk.
+    if hasattr(self.oracle, 'f_log'):
+      for symbol in self.oracle.f_log:
+        dfFund = pd.DataFrame(self.oracle.f_log[symbol])
+        if not dfFund.empty:
+          dfFund.set_index('FundamentalTime', inplace=True)
+          self.writeLog(dfFund, filename='fundamental_{}'.format(symbol))
+          #log_print("Fundamental archival complete.")
+    if self.book_freq is None: return
+    else:
+      # Iterate over the order books controlled by this exchange.
+      for symbol in self.order_books:
+        start_time = dt.datetime.now()
+        self.logOrderBookSnapshots(symbol)
+        end_time = dt.datetime.now()
+        print("Time taken to log the order book: {}".format(end_time - start_time))
+        print("Order book archival complete.")
+
+  def receiveMessage(self, currentTime, msg):
+    super().receiveMessage(currentTime, msg)
+
+    # Unless the intent of an experiment is to examine computational issues within an Exchange,
+    # it will typically have either 1 ns delay (near instant but cannot process multiple orders
+    # in the same atomic time unit) or 0 ns delay (can process any number of orders, always in
+    # the atomic time unit in which they are received).  This is separate from, and additional
+    # to, any parallel pipeline delay imposed for order book activity.
+
+    # Note that computation delay MUST be updated before any calls to sendMessage.
+    self.setComputationDelay(self.computation_delay)
+
+    # Is the exchange closed?  (This block only affects post-close, not pre-open.)
+    if currentTime > self.mkt_close:
+      # Most messages after close will receive a 'MKT_CLOSED' message in response.  A few things
+      # might still be processed, like requests for final trade prices or such.
+      if msg.body['msg'] in ['LIMIT_ORDER', 'MARKET_ORDER', 'CANCEL_ORDER', 'MODIFY_ORDER']:
+        #log_print("{} received {}: {}", self.name, msg.body['msg'], msg.body['order'])
+        self.sendMessage(msg.body['sender'], Message({"msg": "MKT_CLOSED"}))
+
+        # Don't do any further processing on these messages!
+        return
+      elif 'QUERY' in msg.body['msg']:
+        # Specifically do allow querying after market close, so agents can get the
+        # final trade of the day as their "daily close" price for a symbol.
+        pass
+      else:
+        #log_print("{} received {}, discarded: market is closed.", self.name, msg.body['msg'])
+        self.sendMessage(msg.body['sender'], Message({"msg": "MKT_CLOSED"}))
+
+        # Don't do any further processing on these messages!
+        return
+
+    # Log order messages only if that option is configured. Log all other messages.
+    if msg.body['msg'] in ['LIMIT_ORDER', 'MARKET_ORDER', 'CANCEL_ORDER', 'MODIFY_ORDER']:
+      if self.log_orders: self.logEvent(msg.body['msg'], msg.body['order'].to_dict())
+    else:
+      self.logEvent(msg.body['msg'], msg.body['sender'])
+
+    # Handle the DATA SUBSCRIPTION request and cancellation messages from the agents.
+    if msg.body['msg'] in ["MARKET_DATA_SUBSCRIPTION_REQUEST", "MARKET_DATA_SUBSCRIPTION_CANCELLATION"]:
+      #log_print("{} received {} request from agent {}", self.name, msg.body['msg'], msg.body['sender'])
+      self.updateSubscriptionDict(msg, currentTime)
+
+    # Handle all message types understood by this exchange.
+    if msg.body['msg'] == "WHEN_MKT_OPEN":
+      #log_print("{} received WHEN_MKT_OPEN request from agent {}", self.name, msg.body['sender'])
+
+      # The exchange is permitted to respond to requests for simple immutable data (like "what are your
+      # hours?") instantly.  This does NOT include anything that queries mutable data, like equity
+      # quotes or trades.
+      self.setComputationDelay(0)
+
+      self.sendMessage(msg.body['sender'], Message({"msg": "WHEN_MKT_OPEN", "data": self.mkt_open}))
+    elif msg.body['msg'] == "WHEN_MKT_CLOSE":
+      #log_print("{} received WHEN_MKT_CLOSE request from agent {}", self.name, msg.body['sender'])
+
+      # The exchange is permitted to respond to requests for simple immutable data (like "what are your
+      # hours?") instantly.  This does NOT include anything that queries mutable data, like equity
+      # quotes or trades.
+      self.setComputationDelay(0)
+
+      self.sendMessage(msg.body['sender'], Message({"msg": "WHEN_MKT_CLOSE", "data": self.mkt_close}))
+    elif msg.body['msg'] == "QUERY_LAST_TRADE":
+      symbol = msg.body['symbol']
+      if symbol not in self.order_books:
+        log_print("Last trade request discarded.  Unknown symbol: {}", symbol)
+      else:
+        #log_print("{} received QUERY_LAST_TRADE ({}) request from agent {}", self.name, symbol, msg.body['sender'])
+
+        # Return the single last executed trade price (currently not volume) for the requested symbol.
+        # This will return the average share price if multiple executions resulted from a single order.
+        self.sendMessage(msg.body['sender'], Message({"msg": "QUERY_LAST_TRADE", "symbol": symbol,
+                                                      "data": self.order_books[symbol].last_trade,
+                                                      "mkt_closed": True if currentTime > self.mkt_close else False}))
+    elif msg.body['msg'] == "QUERY_SPREAD":
+      symbol = msg.body['symbol']
+      depth = msg.body['depth']
+      if symbol not in self.order_books:
+        log_print("Bid-ask spread request discarded.  Unknown symbol: {}", symbol)
+      else:
+        #log_print("{} received QUERY_SPREAD ({}:{}) request from agent {}", self.name, symbol, depth, msg.body['sender'])
+
+        # Return the requested depth on both sides of the order book for the requested symbol.
+        # Returns price levels and aggregated volume at each level (not individual orders).
+        self.sendMessage(msg.body['sender'], Message({"msg": "QUERY_SPREAD", "symbol": symbol, "depth": depth,
+                                                      "bids": self.order_books[symbol].getInsideBids(depth),
+                                                      "asks": self.order_books[symbol].getInsideAsks(depth),
+                                                      "data": self.order_books[symbol].last_trade,
+                                                      "mkt_closed": True if currentTime > self.mkt_close else False,
+                                                      "book": ''}))
+
+        # It is possible to also send the pretty-printed order book to the agent for logging, but forcing pretty-printing
+        # of a large order book is very slow, so we should only do it with good reason.  We don't currently
+        # have a configurable option for it.
+        # "book": self.order_books[symbol].prettyPrint(silent=True) }))
+    elif msg.body['msg'] == "QUERY_ORDER_STREAM":
+      symbol = msg.body['symbol']
+      length = msg.body['length']
+
+      if symbol not in self.order_books:
+        log_print("Order stream request discarded.  Unknown symbol: {}", symbol)
+      else:
+        log_print("{} received QUERY_ORDER_STREAM ({}:{}) request from agent {}", self.name, symbol, length, msg.body['sender'])
+
+      # We return indices [1:length] inclusive because the agent will want "orders leading up to the last
+      # L trades", and the items under index 0 are more recent than the last trade.
+      self.sendMessage(msg.body['sender'], Message({"msg": "QUERY_ORDER_STREAM", "symbol": symbol, "length": length,
+                                                    "mkt_closed": True if currentTime > self.mkt_close else False,
+                                                    "orders": self.order_books[symbol].history[1:length + 1]
+                                                    }))
+    elif msg.body['msg'] == 'QUERY_TRANSACTED_VOLUME':
+      symbol = msg.body['symbol']
+      lookback_period = msg.body['lookback_period']
+      if symbol not in self.order_books:
+        log_print("Order stream request discarded.  Unknown symbol: {}", symbol)
+      else:
+        log_print("{} received QUERY_TRANSACTED_VOLUME ({}:{}) request from agent {}", self.name, symbol, lookback_period, msg.body['sender'])
+      self.sendMessage(msg.body['sender'], Message({"msg": "QUERY_TRANSACTED_VOLUME", "symbol": symbol,
+                                                    "transacted_volume": self.order_books[symbol].get_transacted_volume(lookback_period),
+                                                    "mkt_closed": True if currentTime > self.mkt_close else False
+                                                    }))
+    elif msg.body['msg'] == "LIMIT_ORDER":
+      order = msg.body['order']
+      #log_print("{} received LIMIT_ORDER: {}", self.name, order)
+      if order.symbol not in self.order_books:
+        log_print("Limit Order discarded.  Unknown symbol: {}", order.symbol)
+      else:
+        # Hand the order to the order book for processing.
+        self.order_books[order.symbol].handleLimitOrder(deepcopy(order))
+        #self.publishOrderBookData()
+    elif msg.body['msg'] == "MARKET_ORDER":
+      order = msg.body['order']
+      #log_print("{} received MARKET_ORDER: {}", self.name, order)
+      if order.symbol not in self.order_books:
+        log_print("Market Order discarded.  Unknown symbol: {}", order.symbol)
+      else:
+        # Hand the market order to the order book for processing.
+        self.order_books[order.symbol].handleMarketOrder(deepcopy(order))
+
+    elif msg.body['msg'] == "CANCEL_ORDER":
+      # Note: this is somewhat open to abuse, as in theory agents could cancel other agents' orders.
+      # An agent could also become confused if they receive a (partial) execution on an order they
+      # then successfully cancel, but receive the cancel confirmation first.  Things to think about
+      # for later...
+      order = msg.body['order']
+      #log_print("{} received CANCEL_ORDER: {}", self.name, order)
+      if order.symbol not in self.order_books:
+        log_print("Cancellation request discarded.  Unknown symbol: {}", order.symbol)
+      else:
+        # Hand the order to the order book for processing.
+        self.order_books[order.symbol].cancelOrder(deepcopy(order))
+        self.publishOrderBookData()
+    elif msg.body['msg'] == 'MODIFY_ORDER':
+      # Replace an existing order with a modified order.  There could be some timing issues
+      # here.  What if an order is partially executed, but the submitting agent has not
+      # yet received the norification, and submits a modification to the quantity of the
+      # (already partially executed) order?  I guess it is okay if we just think of this
+      # as "delete and then add new" and make it the agent's problem if anything weird
+      # happens.
+      order = msg.body['order']
+      new_order = msg.body['new_order']
+      #log_print("{} received MODIFY_ORDER: {}, new order: {}".format(self.name, order, new_order))
+      if order.symbol not in self.order_books:
+        log_print("Modification request discarded.  Unknown symbol: {}".format(order.symbol))
+      else:
+        self.order_books[order.symbol].modifyOrder(deepcopy(order), deepcopy(new_order))
+        self.publishOrderBookData()
+
+  def updateSubscriptionDict(self, msg, currentTime):
+    # The subscription dict is a dictionary with the key = agent ID,
+    # value = dict (key = symbol, value = list [levels (no of levels to recieve updates for),
+    # frequency (min number of ns between messages), last agent update timestamp]
+    # e.g. {101 : {'AAPL' : [1, 10, pd.Timestamp(10:00:00)}}
+    if msg.body['msg'] == "MARKET_DATA_SUBSCRIPTION_REQUEST":
+      agent_id, symbol, levels, freq = msg.body['sender'], msg.body['symbol'], msg.body['levels'], msg.body['freq']
+      self.subscription_dict[agent_id] = {symbol: [levels, freq, currentTime]}
+    elif msg.body['msg'] == "MARKET_DATA_SUBSCRIPTION_CANCELLATION":
+      agent_id, symbol = msg.body['sender'], msg.body['symbol']
+      del self.subscription_dict[agent_id][symbol]
+
+  def publishOrderBookData(self):
+    '''
+    The exchange agents sends an order book update to the agents using the subscription API if one of the following
+    conditions are met:
+    1) agent requests ALL order book updates (freq == 0)
+    2) order book update timestamp > last time agent was updated AND the orderbook update time stamp is greater than
+    the last agent update time stamp by a period more than that specified in the freq parameter.
+    '''
+    for agent_id, params in self.subscription_dict.items():
+      for symbol, values in params.items():
+        levels, freq, last_agent_update = values[0], values[1], values[2]
+        orderbook_last_update = self.order_books[symbol].last_update_ts
+        if (freq == 0) or \
+           ((orderbook_last_update > last_agent_update) and ((orderbook_last_update - last_agent_update).delta >= freq)):
+          self.sendMessage(agent_id, Message({"msg": "MARKET_DATA",
+                                              "symbol": symbol,
+                                              "bids": self.order_books[symbol].getInsideBids(levels),
+                                              "asks": self.order_books[symbol].getInsideAsks(levels),
+                                              "last_transaction": self.order_books[symbol].last_trade,
+                                              "exchange_ts": self.currentTime}))
+          self.subscription_dict[agent_id][symbol][2] = orderbook_last_update
+
+  def logOrderBookSnapshots(self, symbol):
+    """
+    Log full depth quotes (price, volume) from this order book at some pre-determined frequency. Here we are looking at
+    the actual log for this order book (i.e. are there snapshots to export, independent of the requested frequency).
+    """
+    def get_quote_range_iterator(s):
+      """ Helper method for order book logging. Takes pandas Series and returns python range() from first to last
+          element.
+      """
+      forbidden_values = [0, 19999900] # TODO: Put constant value in more sensible place!
+      quotes = sorted(s)
+      for val in forbidden_values:
+        try: quotes.remove(val)
+        except ValueError:
+          pass
+      return quotes
+
+    book = self.order_books[symbol]
+
+    if book.book_log:
+
+      print("Logging order book to file...")
+      dfLog = book.book_log_to_df()
+      dfLog.set_index('QuoteTime', inplace=True)
+      dfLog = dfLog[~dfLog.index.duplicated(keep='last')]
+      dfLog.sort_index(inplace=True)
+
+      if str(self.book_freq).isdigit() and int(self.book_freq) == 0:  # Save all possible information
+        # Get the full range of quotes at the finest possible resolution.
+        quotes = get_quote_range_iterator(dfLog.columns.unique())
+
+        # Restructure the log to have multi-level rows of all possible pairs of time and quote
+        # with volume as the only column.
+        if not self.wide_book:
+          filledIndex = pd.MultiIndex.from_product([dfLog.index, quotes], names=['time', 'quote'])
+          dfLog = dfLog.stack()
+          dfLog = dfLog.reindex(filledIndex)
+
+        filename = f'ORDERBOOK_{symbol}_FULL'
+
+      else:  # Sample at frequency self.book_freq
+        # With multiple quotes in a nanosecond, use the last one, then resample to the requested freq.
+        dfLog = dfLog.resample(self.book_freq).ffill()
+        dfLog.sort_index(inplace=True)
+
+        # Create a fully populated index at the desired frequency from market open to close.
+        # Then project the logged data into this complete index.
+        time_idx = pd.date_range(self.mkt_open, self.mkt_close, freq=self.book_freq, closed='right')
+        dfLog = dfLog.reindex(time_idx, method='ffill')
+        dfLog.sort_index(inplace=True)
+
+        if not self.wide_book:
+          dfLog = dfLog.stack()
+          dfLog.sort_index(inplace=True)
+
+          # Get the full range of quotes at the finest possible resolution.
+          quotes = get_quote_range_iterator(dfLog.index.get_level_values(1).unique())
+
+          # Restructure the log to have multi-level rows of all possible pairs of time and quote
+          # with volume as the only column.
+          filledIndex = pd.MultiIndex.from_product([time_idx, quotes], names=['time', 'quote'])
+          dfLog = dfLog.reindex(filledIndex)
+
+        filename = f'ORDERBOOK_{symbol}_FREQ_{self.book_freq}'
+
+      # Final cleanup
+      if not self.wide_book:
+        dfLog.rename('Volume')
+        df = pd.SparseDataFrame(index=dfLog.index)
+        df['Volume'] = dfLog
+      else:
+        df = dfLog
+        df = df.reindex(sorted(df.columns), axis=1)
+
+      # Archive the order book snapshots directly to a file named with the symbol, rather than
+      # to the exchange agent log.
+      self.writeLog(df, filename=filename)
+      print("Order book logging complete!")
+
+  def sendMessage (self, recipientID, msg):
+    # The ExchangeAgent automatically applies appropriate parallel processing pipeline delay
+    # to those message types which require it.
+    # TODO: probably organize the order types into categories once there are more, so we can
+    # take action by category (e.g. ORDER-related messages) instead of enumerating all message
+    # types to be affected.
+    if msg.body['msg'] in ['ORDER_ACCEPTED', 'ORDER_CANCELLED', 'ORDER_EXECUTED']:
+      # Messages that require order book modification (not simple queries) incur the additional
+      # parallel processing delay as configured.
+      super().sendMessage(recipientID, msg, delay = self.pipeline_delay)
+      if self.log_orders: self.logEvent(msg.body['msg'], msg.body['order'].to_dict())
+    else:
+      # Other message types incur only the currently-configured computation delay for this agent.
+      super().sendMessage(recipientID, msg)
+
+  # Simple accessor methods for the market open and close times.
+  def getMarketOpen(self):
+    return self.__mkt_open
+
+  def getMarketClose(self):
+    return self.__mkt_close

ABIDES/agent/FinancialAgent.py

@@ -0,0 +1,36 @@
+from agent.Agent import Agent
+import sys
+import traceback
+
+# The FinancialAgent class contains attributes and methods that should be available
+# to all agent types (traders, exchanges, etc) in a financial market simulation.
+# To be honest, it mainly exists because the base Agent class should not have any
+# finance-specific aspects and it doesn't make sense for ExchangeAgent to inherit
+# from TradingAgent.  Hopefully we'll find more common ground for traders and
+# exchanges to make this more useful later on.
+class FinancialAgent(Agent):
+
+  def __init__(self, id, name, type, random_state, log_to_file=True):
+    # Base class init.
+    super().__init__(id, name, type, random_state, log_to_file)
+
+  # Used by any subclass to dollarize an int-cents price for printing.
+  def dollarize (self, cents):
+    return dollarize(cents)
+
+  pass
+
+
+# Dollarizes int-cents prices for printing.  Defined outside the class for
+# utility access by non-agent classes.
+
+def dollarize(cents):
+  if type(cents) is list:
+    return ( [ dollarize(x) for x in cents ] )
+  elif type(cents) is int:
+    return "${:0.2f}".format(cents / 100)
+  else:
+    # If cents is already a float, there is an error somewhere.
+    print ("ERROR: dollarize(cents) called without int or list of ints: {}".format(cents))
+    traceback.print_stack()
+    sys.exit()

ABIDES/agent/FundamentalTrackingAgent.py

@@ -0,0 +1,64 @@
+from agent.TradingAgent import TradingAgent
+from util.util import log_print
+import numpy as np
+import pandas as pd
+
+
+class FundamentalTrackingAgent(TradingAgent):
+    """ Agent who collects and saves to disk noise-free observations of the fundamental. """
+
+    def __init__(self, id, name, type, log_frequency, symbol, log_orders=False):
+        """ Constructor for FundamentalTrackingAgent
+
+            :param log_frequency: Frequency to update log (in nanoseconds)
+            :param symbol: symbol for which fundamental is being logged
+        """
+        super().__init__(id, name, type, starting_cash=0, log_orders=log_orders,
+                         random_state=np.random.RandomState(seed=np.random.randint(low=0,
+                                                                                   high=2 ** 32,
+                                                                                   dtype='uint64')))
+
+        self.log_freqency = log_frequency
+        self.fundamental_series = []
+        self.symbol = symbol
+
+    def kernelStarting(self, startTime):
+        # self.kernel is set in Agent.kernelInitializing()
+        # self.exchangeID is set in TradingAgent.kernelStarting()
+        super().kernelStarting(startTime)
+        self.oracle = self.kernel.oracle
+
+
+    def kernelStopping(self):
+        """ Stops kernel and saves fundamental series to disk. """
+        # Always call parent method to be safe.
+        super().kernelStopping()
+        self.writeFundamental()
+
+    def measureFundamental(self):
+        """ Saves the fundamental value at self.currentTime to self.fundamental_series. """
+        obs_t = self.oracle.observePrice(self.symbol, self.currentTime, sigma_n=0)
+        self.fundamental_series.append({'FundamentalTime': self.currentTime, 'FundamentalValue': obs_t})
+
+    def wakeup(self, currentTime):
+        """ Advances agent in time and takes measurement of fundamental. """
+        # Parent class handles discovery of exchange times and market_open wakeup call.
+        super().wakeup(currentTime)
+
+        if not self.mkt_open or not self.mkt_close:
+            # No logging if market is closed
+            return
+
+        self.measureFundamental()
+        self.setWakeup(currentTime + self.getWakeFrequency())
+
+    def writeFundamental(self):
+        """ Logs fundamental series to file. """
+        dfFund = pd.DataFrame(self.fundamental_series)
+        dfFund.set_index('FundamentalTime', inplace=True)
+        self.writeLog(dfFund, filename='fundamental_{symbol}_freq_{self.log_frequency}_ns'.format(self.symbol))
+
+        print("Noise-free fundamental archival complete.")
+
+    def getWakeFrequency(self):
+        return pd.Timedelta(self.log_freqency, unit='ns')

ABIDES/agent/HeuristicBeliefLearningAgent.py

@@ -0,0 +1,174 @@
+from agent.ZeroIntelligenceAgent import ZeroIntelligenceAgent
+from message.Message import Message
+from util.util import log_print
+
+from math import sqrt
+import numpy as np
+import pandas as pd
+import sys
+
+np.set_printoptions(threshold=np.inf)
+
+
+class HeuristicBeliefLearningAgent(ZeroIntelligenceAgent):
+
+    def __init__(self, id, name, type, symbol='IBM', starting_cash=100000, sigma_n=1000,
+                 r_bar=100000, kappa=0.05, sigma_s=100000, q_max=10, sigma_pv=5000000, R_min=0,
+                 R_max=250, eta=1.0, lambda_a=0.005, L=8, log_orders=False,
+                 random_state=None):
+
+        # Base class init.
+        super().__init__(id, name, type, symbol=symbol, starting_cash=starting_cash, sigma_n=sigma_n,
+                         r_bar=r_bar, kappa=kappa, sigma_s=sigma_s, q_max=q_max, sigma_pv=sigma_pv, R_min=R_min,
+                         R_max=R_max, eta=eta, lambda_a=lambda_a, log_orders=log_orders,
+                         random_state=random_state)
+
+        # Store important parameters particular to the HBL agent.
+        self.L = L  # length of order book history to use (number of transactions)
+
+    def wakeup(self, currentTime):
+        # Parent class handles discovery of exchange times and market_open wakeup call.
+        # Also handles ZI-style "background agent" needs that are not specific to HBL.
+        super().wakeup(currentTime)
+
+        # Only if the superclass leaves the state as ACTIVE should we proceed with our
+        # trading strategy.
+        if self.state != 'ACTIVE': return
+
+        # To make trade decisions, the HBL agent requires recent order stream information.
+        self.getOrderStream(self.symbol, length=self.L)
+        self.state = 'AWAITING_STREAM'
+
+    def placeOrder(self):
+        # Called when it is time for the agent to determine a limit price and place an order.
+        # This method implements the HBL strategy and falls back to the ZI (superclass)
+        # strategy if there is not enough information for the HBL strategy.
+
+        # See if there is enough history for HBL.  If not, we will _exactly_ perform the
+        # ZI placeOrder().  If so, we will use parts of ZI but compute our limit price
+        # differently.  Note that we are not given orders more recent than the most recent
+        # trade.
+
+        if len(self.stream_history[self.symbol]) < self.L:
+            # Not enough history for HBL.
+            log_print("Insufficient history for HBL: length {}, L {}", len(self.stream_history[self.symbol]), self.L)
+            super().placeOrder()
+            return
+
+        # There is enough history for HBL.
+
+        # Use the superclass (ZI) method to obtain an observation, update internal estimate
+        # parameters, decide to buy or sell, and calculate the total unit valuation, because
+        # all of this logic is identical to ZI.
+        v, buy = self.updateEstimates()
+
+        # Walk through the visible order history and accumulate values needed for HBL's
+        # estimation of successful transaction by limit price.
+        low_p = sys.maxsize
+        high_p = 0
+
+        # Find the lowest and highest observed prices in the order history.
+        for h in self.stream_history[self.symbol]:
+            for id, order in h.items():
+                p = order['limit_price']
+                if p < low_p: low_p = p
+                if p > high_p: high_p = p
+
+        # Set up the ndarray we will use for our computation.
+        # idx 0-7 are sa, sb, ua, ub, num, denom, Pr, Es
+        nd = np.zeros((high_p - low_p + 1, 8))
+
+        # Iterate through the history and compile our observations.
+        for h in self.stream_history[self.symbol]:
+            # h follows increasing "transactions into the past", with index zero being orders
+            # after the most recent transaction.
+            for id, order in h.items():
+                p = order['limit_price']
+                if p < low_p: low_p = p
+                if p > high_p: high_p = p
+
+                # For now if there are any transactions, consider the order successful.  For single
+                # unit orders, this is sufficient.  For multi-unit orders,
+                # we may wish to switch to a proportion of shares executed.
+                if order['is_buy_order']:
+                    if order['transactions']:
+                        nd[p - low_p, 1] += 1
+                    else:
+                        nd[p - low_p, 3] += 1
+                else:
+                    if order['transactions']:
+                        nd[p - low_p, 0] += 1
+                    else:
+                        nd[p - low_p, 2] += 1
+
+        # Compute the sums and cumulative sums required, from our observations,
+        # to drive the HBL's transaction probability estimates.
+        if buy:
+            nd[:, [0, 1, 2]] = np.cumsum(nd[:, [0, 1, 2]], axis=0)
+            nd[::-1, 3] = np.cumsum(nd[::-1, 3], axis=0)
+            nd[:, 4] = np.sum(nd[:, [0, 1, 2]], axis=1)
+        else:
+            nd[::-1, [0, 1, 3]] = np.cumsum(nd[::-1, [0, 1, 3]], axis=0)
+            nd[:, 2] = np.cumsum(nd[:, 2], axis=0)
+            nd[:, 4] = np.sum(nd[:, [0, 1, 3]], axis=1)
+
+        nd[:, 5] = np.sum(nd[:, 0:4], axis=1)
+
+        # Okay to ignore divide by zero errors here because we expect that in
+        # some cases (0/0 can happen) and we immediately convert the resulting
+        # nan to zero, which is the right answer for us.
+
+        # Compute probability estimates for successful transaction at all price levels.
+        with np.errstate(divide='ignore', invalid='ignore'):
+            nd[:, 6] = np.nan_to_num(np.divide(nd[:, 4], nd[:, 5]))
+
+        # Compute expected surplus for all price levels.
+        if buy:
+            nd[:, 7] = nd[:, 6] * (v - np.arange(low_p, high_p + 1))
+        else:
+            nd[:, 7] = nd[:, 6] * (np.arange(low_p, high_p + 1) - v)
+
+        # Extract the price and other data for the maximum expected surplus.
+        best_idx = np.argmax(nd[:, 7])
+        best_Es, best_Pr = nd[best_idx, [7, 6]]
+        best_p = low_p + best_idx
+
+        # If the best expected surplus is positive, go for it.
+        if best_Es > 0:
+            log_print("Numpy: {} selects limit price {} with expected surplus {} (Pr = {:0.4f})", self.name, best_p,
+                      int(round(best_Es)), best_Pr)
+
+            # Place the constructed order.
+            self.placeLimitOrder(self.symbol, 100, buy, int(round(best_p)))
+        else:
+            # Do nothing if best limit price has negative expected surplus with below code.
+            log_print("Numpy: {} elects not to place an order (best expected surplus <= 0)", self.name)
+
+            # OTHER OPTION 1: Allow negative expected surplus with below code.
+            # log_print ("Numpy: {} placing undesirable order (best expected surplus <= 0)", self.name)
+            # self.placeLimitOrder(self.symbol, 1, buy, int(round(best_p)))
+
+            # OTHER OPTION 2: Force fallback to ZI logic on negative surplus with below code (including return).
+            # log_print ("Numpy: no desirable order for {}, acting as ZI", self.name)
+            # super().placeOrder()
+
+    def receiveMessage(self, currentTime, msg):
+
+        # We have been awakened by something other than our scheduled wakeup.
+        # If our internal state indicates we were waiting for a particular event,
+        # check if we can transition to a new state.
+
+        # Allow parent class to handle state + message combinations it understands.
+        super().receiveMessage(currentTime, msg)
+
+        # Do our special stuff.
+        if self.state == 'AWAITING_STREAM':
+            # We were waiting to receive the recent order stream.
+            if msg.body['msg'] == 'QUERY_ORDER_STREAM':
+                # This is what we were waiting for.
+
+                # But if the market is now closed, don't advance.
+                if self.mkt_closed: return
+
+                self.getCurrentSpread(self.symbol)
+                self.state = 'AWAITING_SPREAD'

ABIDES/agent/NoiseAgent.py

@@ -0,0 +1,161 @@
+from agent.TradingAgent import TradingAgent
+from util.util import log_print
+
+from math import sqrt
+import numpy as np
+import pandas as pd
+
+
+class NoiseAgent(TradingAgent):
+
+    def __init__(self, id, name, type, symbol='IBM', starting_cash=100000,
+                 log_orders=False, log_to_file=True, random_state=None, wakeup_time = None ):
+
+        # Base class init.
+        super().__init__(id, name, type, starting_cash=starting_cash, log_orders=log_orders,
+                         log_to_file=log_to_file, random_state=random_state)
+
+        self.wakeup_time = wakeup_time,
+
+        self.symbol = symbol  # symbol to trade
+
+        # The agent uses this to track whether it has begun its strategy or is still
+        # handling pre-market tasks.
+        self.trading = False
+
+        # The agent begins in its "complete" state, not waiting for
+        # any special event or condition.
+        self.state = 'AWAITING_WAKEUP'
+
+        # The agent must track its previous wake time, so it knows how many time
+        # units have passed.
+        self.prev_wake_time = None
+
+        self.size = np.random.randint(20, 50)
+
+    def kernelStarting(self, startTime):
+        # self.kernel is set in Agent.kernelInitializing()
+        # self.exchangeID is set in TradingAgent.kernelStarting()
+
+        super().kernelStarting(startTime)
+
+        self.oracle = self.kernel.oracle
+
+    def kernelStopping(self):
+        # Always call parent method to be safe.
+        super().kernelStopping()
+        return
+        # Print end of day valuation.
+        H = int(round(self.getHoldings(self.symbol), -2) / 100)
+
+        #noise trader surplus is marked to EOD
+        bid, bid_vol, ask, ask_vol = self.getKnownBidAsk(self.symbol)
+
+        if bid and ask:
+            rT = int(bid + ask)/2
+        else:
+            rT = self.last_trade[self.symbol]
+
+        # final (real) fundamental value times shares held.
+        surplus = rT * H
+
+        log_print("surplus after holdings: {}", surplus)
+
+        # Add ending cash value and subtract starting cash value.
+        surplus += self.holdings['CASH'] - self.starting_cash
+        surplus = float(surplus) / self.starting_cash
+
+        self.logEvent('FINAL_VALUATION', surplus, True)
+
+        log_print(
+            "{} final report.  Holdings {}, end cash {}, start cash {}, final fundamental {}, surplus {}",
+            self.name, H, self.holdings['CASH'], self.starting_cash, rT, surplus)
+
+        print("Final relative surplus", self.name, surplus)
+
+    def wakeup(self, currentTime):
+        # Parent class handles discovery of exchange times and market_open wakeup call.
+        super().wakeup(currentTime)
+
+        self.state = 'INACTIVE'
+
+        if not self.mkt_open or not self.mkt_close:
+            # TradingAgent handles discovery of exchange times.
+            return
+        else:
+            if not self.trading:
+                self.trading = True
+
+                # Time to start trading!
+                log_print("{} is ready to start trading now.", self.name)
+
+        # Steady state wakeup behavior starts here.
+
+        # If we've been told the market has closed for the day, we will only request
+        # final price information, then stop.
+        if self.mkt_closed and (self.symbol in self.daily_close_price):
+            # Market is closed and we already got the daily close price.
+            return
+
+        if self.wakeup_time[0] >currentTime:
+            self.setWakeup(self.wakeup_time[0])
+
+        if self.mkt_closed and (not self.symbol in self.daily_close_price):
+            self.getCurrentSpread(self.symbol)
+            self.state = 'AWAITING_SPREAD'
+            return
+
+        if type(self) == NoiseAgent:
+            self.getCurrentSpread(self.symbol)
+            self.state = 'AWAITING_SPREAD'
+        else:
+            self.state = 'ACTIVE'
+
+    def placeOrder(self):
+        #place order in random direction at a mid
+        buy_indicator = np.random.randint(0, 1 + 1)
+        bid, bid_vol, ask, ask_vol = self.getKnownBidAsk(self.symbol)
+
+        if buy_indicator and ask:
+            self.placeLimitOrder(self.symbol, self.size, buy_indicator, ask)
+        elif not buy_indicator and bid:
+            self.placeLimitOrder(self.symbol, self.size, buy_indicator, bid)
+
+    def receiveMessage(self, currentTime, msg):
+        # Parent class schedules market open wakeup call once market open/close times are known.
+        super().receiveMessage(currentTime, msg)
+
+        # We have been awakened by something other than our scheduled wakeup.
+        # If our internal state indicates we were waiting for a particular event,
+        # check if we can transition to a new state.
+
+        if self.state == 'AWAITING_SPREAD':
+            # We were waiting to receive the current spread/book.  Since we don't currently
+            # track timestamps on retained information, we rely on actually seeing a
+            # QUERY_SPREAD response message.
+
+            if msg.body['msg'] == 'QUERY_SPREAD':
+                # This is what we were waiting for.
+
+                # But if the market is now closed, don't advance to placing orders.
+                if self.mkt_closed: return
+
+                # We now have the information needed to place a limit order with the eta
+                # strategic threshold parameter.
+                self.placeOrder()
+                self.state = 'AWAITING_WAKEUP'
+
+    # Internal state and logic specific to this agent subclass.
+
+    # Cancel all open orders.
+    # Return value: did we issue any cancellation requests?
+    def cancelOrders(self):
+        if not self.orders: return False
+
+        for id, order in self.orders.items():
+            self.cancelOrder(order)
+
+        return True
+
+    def getWakeFrequency(self):
+        return pd.Timedelta(self.random_state.randint(low=0, high=100), unit='ns')

ABIDES/agent/OrderBookImbalanceAgent.py

@@ -0,0 +1,193 @@
+from agent.TradingAgent import TradingAgent
+import pandas as pd
+from util.util import log_print
+
+import matplotlib
+matplotlib.use('TkAgg')
+import matplotlib.pyplot as plt
+
+
+class OrderBookImbalanceAgent(TradingAgent):
+
+    # The OrderBookImbalanceAgent is a simple example of an agent that predicts the short term
+    # price movement of a security by the preponderance of directionality in the limit order
+    # book.  Specifically, it predicts the price will fall if the ratio of bid volume to total volume
+    # in the first N levels of the book is greater than a configurable threshold, and will rise if
+    # that ratio is below a symmetric value.  There is a trailing stop on the bid_pct to exit.
+    #
+    # Note that this means the current iteration of the OBI agent is treating order book imbalance
+    # as an oscillating indicator rather than a momentum indicator.  (Imbalance to the buy side
+    # indicates "overbought" rather than an upward trend.)
+    #
+    # Parameters unique to this agent:
+    # Levels: how much order book depth should be considered when evaluating imbalance?
+    # Entry Threshold: how much imbalance is required before the agent takes a non-flat position?
+    #                  For example, entry_threshold=0.1 causes long entry at 0.6 or short entry at 0.4.
+    # Trail Dist: how far behind the peak bid_pct should the trailing stop follow?
+
+    def __init__(self, id, name, type, symbol=None, levels=10, entry_threshold=0.17, trail_dist=0.085, freq=3600000000000, starting_cash=1000000, log_orders=True, random_state=None):
+        super().__init__(id, name, type, starting_cash=starting_cash, log_orders=log_orders, random_state=random_state)
+        self.symbol = symbol
+        self.levels = levels
+        self.entry_threshold = entry_threshold
+        self.trail_dist = trail_dist
+        self.freq = freq
+        self.last_market_data_update = None
+        self.is_long = False
+        self.is_short = False
+
+        self.trailing_stop = None
+        self.plotme = []
+
+
+    def kernelStarting(self, startTime):
+        super().kernelStarting(startTime)
+
+    def wakeup(self, currentTime):
+        super().wakeup(currentTime)
+        super().requestDataSubscription(self.symbol, levels=self.levels, freq=self.freq)
+        self.setComputationDelay(1)
+
+    def receiveMessage(self, currentTime, msg):
+        super().receiveMessage(currentTime, msg)
+        if msg.body['msg'] == 'MARKET_DATA':
+            self.cancelOrders()
+
+            self.last_market_data_update = currentTime
+            bids, asks = msg.body['bids'], msg.body['asks']
+
+            bid_liq = sum(x[1] for x in bids)
+            ask_liq = sum(x[1] for x in asks)
+
+            log_print("bid, ask levels: {}", len(bids), len(asks))
+            log_print("bids: {}, asks: {}", bids, asks)
+
+            # OBI strategy.
+            target = 0
+
+            if bid_liq == 0 or ask_liq == 0:
+                log_print("OBI agent inactive: zero bid or ask liquidity")
+                return
+            else:
+                # bid_pct encapsulates both sides of the question, as a normalized expression
+                # representing what fraction of total visible volume is on the buy side.
+                bid_pct = bid_liq / (bid_liq + ask_liq)
+
+                # If we are short, we need to decide if we should hold or exit.
+                if self.is_short:
+                    # Update trailing stop.
+                    if bid_pct - self.trail_dist > self.trailing_stop:
+                        log_print("Trailing stop updated: new > old ({:2f} > {:2f})", bid_pct - self.trail_dist, self.trailing_stop)
+                        self.trailing_stop = bid_pct - self.trail_dist
+                    else:
+                        log_print("Trailing stop remains: potential < old ({:2f} < {:2f})", bid_pct - self.trail_dist, self.trailing_stop)
+
+                    # Check the trailing stop.
+                    if bid_pct < self.trailing_stop: 
+                        log_print("OBI agent exiting short position: bid_pct < trailing_stop ({:2f} < {:2f})", bid_pct, self.trailing_stop)
+                        target = 0
+                        self.is_short = False
+                        self.trailing_stop = None
+                    else:
+                        log_print("OBI agent holding short position: bid_pct > trailing_stop ({:2f} > {:2f})", bid_pct, self.trailing_stop)
+                        target = -100
+                # If we are long, we need to decide if we should hold or exit.
+                elif self.is_long:
+                    if bid_pct + self.trail_dist < self.trailing_stop:
+                        log_print("Trailing stop updated: new < old ({:2f} < {:2f})", bid_pct + self.trail_dist, self.trailing_stop)
+                        self.trailing_stop = bid_pct + self.trail_dist
+                    else:
+                        log_print("Trailing stop remains: potential > old ({:2f} > {:2f})", bid_pct + self.trail_dist, self.trailing_stop)
+
+                    # Check the trailing stop.
+                    if bid_pct > self.trailing_stop: 
+                        log_print("OBI agent exiting long position: bid_pct > trailing_stop ({:2f} > {:2f})", bid_pct, self.trailing_stop)
+                        target = 0
+                        self.is_long = False
+                        self.trailing_stop = None
+                    else:
+                        log_print("OBI agent holding long position: bid_pct < trailing_stop ({:2f} < {:2f})", bid_pct, self.trailing_stop)
+                        target = 100
+                # If we are flat, we need to decide if we should enter (long or short).
+                else:
+                  if bid_pct > (0.5 + self.entry_threshold):
+                      log_print("OBI agent entering long position: bid_pct < entry_threshold ({:2f} < {:2f})", bid_pct, 0.5 - self.entry_threshold)
+                      target = 100
+                      self.is_long = True
+                      self.trailing_stop = bid_pct + self.trail_dist
+                      log_print("Initial trailing stop: {:2f}", self.trailing_stop)
+                  elif bid_pct < (0.5 - self.entry_threshold):
+                      log_print("OBI agent entering short position: bid_pct > entry_threshold ({:2f} > {:2f})", bid_pct, 0.5 + self.entry_threshold)
+                      target = -100
+                      self.is_short = True
+                      self.trailing_stop = bid_pct - self.trail_dist
+                      log_print("Initial trailing stop: {:2f}", self.trailing_stop)
+                  else:
+                      log_print("OBI agent staying flat: long_entry < bid_pct < short_entry ({:2f} < {:2f} < {:2f})", 0.5 - self.entry_threshold, bid_pct, 0.5 + self.entry_threshold)
+                      target = 0
+
+
+                self.plotme.append( { 'currentTime' : self.currentTime, 'midpoint' : (asks[0][0] + bids[0][0]) / 2, 'bid_pct' : bid_pct } )
+
+
+            # Adjust holdings to target.
+            holdings = self.holdings[self.symbol] if self.symbol in self.holdings else 0
+            delta = target - holdings
+            direction = True if delta > 0 else False
+            price = self.computeRequiredPrice(direction, abs(delta), bids, asks)
+
+            log_print("Current holdings: {}", self.holdings)
+
+            if delta == 0:
+                log_print("No adjustments to holdings needed.")
+            else:
+                log_print("Adjusting holdings by {}", delta)
+                self.placeLimitOrder(self.symbol, abs(delta), direction, price)
+
+
+    def getWakeFrequency(self):
+        return pd.Timedelta('1s')
+
+
+    # Computes required limit price to immediately execute a trade for the specified quantity
+    # of shares.
+    def computeRequiredPrice (self, direction, shares, known_bids, known_asks):
+        book = known_asks if direction else known_bids
+
+        # Start at the inside and add up the shares.
+        t = 0
+
+        for i in range(len(book)):
+            p, v = book[i]
+            t += v
+
+            # If we have accumulated enough shares, return this price.
+            if t >= shares:
+                return p
+
+        # Not enough shares.  Just return worst price (highest ask, lowest bid).
+        return book[-1][0]
+
+
+    # Cancel all open orders.
+    # Return value: did we issue any cancellation requests?
+    def cancelOrders(self):
+        if not self.orders: return False
+
+        for id, order in self.orders.items():
+            self.cancelOrder(order)
+
+        return True
+
+
+    # Lifecycle.
+    def kernelTerminating(self):
+      # Plotting code is probably not needed here long term, but helps during development.
+
+      #df = pd.DataFrame(self.plotme)
+      #df.set_index('currentTime', inplace=True)
+      #df.rolling(30).mean().plot(secondary_y=['bid_pct'], figsize=(12,9))
+      ##plt.show()
+      super().kernelTerminating()
+
+

ABIDES/agent/TradingAgent.py

@@ -0,0 +1,643 @@
+from agent.FinancialAgent import FinancialAgent
+from agent.ExchangeAgent import ExchangeAgent
+from message.Message import Message
+from util.order.LimitOrder import LimitOrder
+from util.order.MarketOrder import MarketOrder
+from util.util import log_print
+
+from copy import deepcopy
+import sys
+
+# The TradingAgent class (via FinancialAgent, via Agent) is intended as the
+# base class for all trading agents (i.e. not things like exchanges) in a
+# market simulation.  It handles a lot of messaging (inbound and outbound)
+# and state maintenance automatically, so subclasses can focus just on
+# implementing a strategy without too much bookkeeping.
+class TradingAgent(FinancialAgent):
+
+  def __init__(self, id, name, type, random_state=None, starting_cash=100000, log_orders=False, log_to_file=True):
+    # Base class init.
+    super().__init__(id, name, type, random_state, log_to_file)
+
+    # We don't yet know when the exchange opens or closes.
+    self.mkt_open = None
+    self.mkt_close = None
+
+    # Log order activity?
+    self.log_orders = log_orders
+
+    # Log all activity to file?
+    if log_orders is None:
+      self.log_orders = False
+      self.log_to_file = False
+
+    # Store starting_cash in case we want to refer to it for performance stats.
+    # It should NOT be modified.  Use the 'CASH' key in self.holdings.
+    # 'CASH' is always in cents!  Note that agents are limited by their starting
+    # cash, currently without leverage.  Taking short positions is permitted,
+    # but does NOT increase the amount of at-risk capital allowed.
+    self.starting_cash = starting_cash
+
+    # TradingAgent has constants to support simulated market orders.
+    self.MKT_BUY = sys.maxsize
+    self.MKT_SELL = 0
+
+    # The base TradingAgent will track its holdings and outstanding orders.
+    # Holdings is a dictionary of symbol -> shares.  CASH is a special symbol
+    # worth one cent per share.  Orders is a dictionary of active, open orders
+    # (not cancelled, not fully executed) keyed by order_id.
+    self.holdings = { 'CASH' : starting_cash }
+    self.orders = {}
+
+    # The base TradingAgent also tracks last known prices for every symbol
+    # for which it has received as QUERY_LAST_TRADE message.  Subclass
+    # agents may use or ignore this as they wish.  Note that the subclass
+    # agent must request pricing when it wants it.  This agent does NOT
+    # automatically generate such requests, though it has a helper function
+    # that can be used to make it happen.
+    self.last_trade = {}
+
+    # used in subscription mode to record the timestamp for which the data was current in the ExchangeAgent
+    self.exchange_ts = {}
+
+    # When a last trade price comes in after market close, the trading agent
+    # automatically records it as the daily close price for a symbol.
+    self.daily_close_price = {}
+    
+    self.nav_diff = 0
+    self.basket_size = 0
+
+    # The agent remembers the last known bids and asks (with variable depth,
+    # showing only aggregate volume at each price level) when it receives
+    # a response to QUERY_SPREAD.
+    self.known_bids = {}
+    self.known_asks = {}
+
+    # The agent remembers the order history communicated by the exchange
+    # when such is requested by an agent (for example, a heuristic belief
+    # learning agent).
+    self.stream_history = {}
+
+    # The agent records the total transacted volume in the exchange for a given symbol and lookback period
+    self.transacted_volume = {}
+
+    # Each agent can choose to log the orders executed
+    self.executed_orders = []
+
+    # For special logging at the first moment the simulator kernel begins
+    # running (which is well after agent init), it is useful to keep a simple
+    # boolean flag.
+    self.first_wake = True
+
+    # Remember whether we have already passed the exchange close time, as far
+    # as we know.
+    self.mkt_closed = False
+
+    # This is probably a transient feature, but for now we permit the exchange
+    # to return the entire order book sometimes, for development and debugging.
+    # It is very expensive to pass this around, and breaks "simulation physics",
+    # but can really help understand why agents are making certain decisions.
+    # Subclasses should NOT rely on this feature as part of their strategy,
+    # as it will go away.
+    self.book = ''
+
+
+  # Simulation lifecycle messages.
+
+  def kernelStarting(self, startTime):
+    # self.kernel is set in Agent.kernelInitializing()
+    self.logEvent('STARTING_CASH', self.starting_cash, True)
+
+    # Find an exchange with which we can place orders.  It is guaranteed
+    # to exist by now (if there is one).
+    self.exchangeID = self.kernel.findAgentByType(ExchangeAgent)
+
+    log_print ("Agent {} requested agent of type Agent.ExchangeAgent.  Given Agent ID: {}",
+               self.id, self.exchangeID)
+
+    # Request a wake-up call as in the base Agent.
+    super().kernelStarting(startTime)
+
+
+  def kernelStopping (self):
+    # Always call parent method to be safe.
+    super().kernelStopping()
+
+    # Print end of day holdings.
+    self.logEvent('FINAL_HOLDINGS', self.fmtHoldings(self.holdings))
+    self.logEvent('FINAL_CASH_POSITION', self.holdings['CASH'], True)
+
+    # Mark to market.
+    cash = self.markToMarket(self.holdings)
+
+    self.logEvent('ENDING_CASH', cash, True)
+    print ("Final holdings for {}: {}.  Marked to market: {}".format(self.name, self.fmtHoldings(self.holdings),
+                                                                     cash))
+    
+    # Record final results for presentation/debugging.  This is an ugly way
+    # to do this, but it is useful for now.
+    mytype = self.type
+    gain = cash - self.starting_cash
+
+    if mytype in self.kernel.meanResultByAgentType:
+      self.kernel.meanResultByAgentType[mytype] += gain
+      self.kernel.agentCountByType[mytype] += 1
+    else:
+      self.kernel.meanResultByAgentType[mytype] = gain
+      self.kernel.agentCountByType[mytype] = 1
+
+
+  # Simulation participation messages.
+
+  def wakeup (self, currentTime):
+    super().wakeup(currentTime)
+
+    if self.first_wake:
+      # Log initial holdings.
+      self.logEvent('HOLDINGS_UPDATED', self.holdings)
+      self.first_wake = False
+
+    if self.mkt_open is None:
+      # Ask our exchange when it opens and closes.
+      self.sendMessage(self.exchangeID, Message({ "msg" : "WHEN_MKT_OPEN", "sender": self.id }))
+      self.sendMessage(self.exchangeID, Message({ "msg" : "WHEN_MKT_CLOSE", "sender": self.id }))
+
+    # For the sake of subclasses, TradingAgent now returns a boolean
+    # indicating whether the agent is "ready to trade" -- has it received
+    # the market open and closed times, and is the market not already closed.
+    return (self.mkt_open and self.mkt_close) and not self.mkt_closed
+
+  def requestDataSubscription(self, symbol, levels, freq):
+      self.sendMessage(recipientID = self.exchangeID,
+                       msg = Message({"msg": "MARKET_DATA_SUBSCRIPTION_REQUEST",
+                                      "sender": self.id, "symbol": symbol, "levels": levels, "freq": freq}))
+
+  # Used by any Trading Agent subclass to cancel subscription to market data from the Exchange Agent
+  def cancelDataSubscription(self, symbol):
+    self.sendMessage(recipientID=self.exchangeID,
+                     msg=Message({"msg": "MARKET_DATA_SUBSCRIPTION_CANCELLATION",
+                                  "sender": self.id, "symbol": symbol}))
+
+
+  def receiveMessage (self, currentTime, msg):
+    super().receiveMessage(currentTime, msg)
+
+    # Do we know the market hours?
+    had_mkt_hours = self.mkt_open is not None and self.mkt_close is not None
+
+    # Record market open or close times.
+    if msg.body['msg'] == "WHEN_MKT_OPEN":
+      self.mkt_open = msg.body['data']
+
+      log_print ("Recorded market open: {}", self.kernel.fmtTime(self.mkt_open))
+
+    elif msg.body['msg'] == "WHEN_MKT_CLOSE":
+      self.mkt_close = msg.body['data']
+
+      log_print ("Recorded market close: {}", self.kernel.fmtTime(self.mkt_close))
+
+    elif msg.body['msg'] == "ORDER_EXECUTED":
+      # Call the orderExecuted method, which subclasses should extend.  This parent
+      # class could implement default "portfolio tracking" or "returns tracking"
+      # behavior.
+      order = msg.body['order']
+
+      self.orderExecuted(order)
+
+    elif msg.body['msg'] == "ORDER_ACCEPTED":
+      # Call the orderAccepted method, which subclasses should extend.
+      order = msg.body['order']
+
+      self.orderAccepted(order)
+
+    elif msg.body['msg'] == "ORDER_CANCELLED":
+      # Call the orderCancelled method, which subclasses should extend.
+      order = msg.body['order']
+
+      self.orderCancelled(order)
+
+    elif msg.body['msg'] == "MKT_CLOSED":
+      # We've tried to ask the exchange for something after it closed.  Remember this
+      # so we stop asking for things that can't happen.
+
+      self.marketClosed()
+
+    elif msg.body['msg'] == 'QUERY_LAST_TRADE':
+      # Call the queryLastTrade method, which subclasses may extend.
+      # Also note if the market is closed.
+      if msg.body['mkt_closed']: self.mkt_closed = True
+
+      self.queryLastTrade(msg.body['symbol'], msg.body['data'])
+
+    elif msg.body['msg'] == 'QUERY_SPREAD':
+      # Call the querySpread method, which subclasses may extend.
+      # Also note if the market is closed.
+      if msg.body['mkt_closed']: self.mkt_closed = True
+
+      self.querySpread(msg.body['symbol'], msg.body['data'], msg.body['bids'], msg.body['asks'], msg.body['book'])
+
+    elif msg.body['msg'] == 'QUERY_ORDER_STREAM':
+      # Call the queryOrderStream method, which subclasses may extend.
+      # Also note if the market is closed.
+      if msg.body['mkt_closed']: self.mkt_closed = True
+
+      self.queryOrderStream(msg.body['symbol'], msg.body['orders'])
+
+    elif msg.body['msg'] == 'QUERY_TRANSACTED_VOLUME':
+      if msg.body['mkt_closed']: self.mkt_closed = True
+      self.query_transacted_volume(msg.body['symbol'], msg.body['transacted_volume'])
+
+    elif msg.body['msg'] == 'MARKET_DATA':
+      self.handleMarketData(msg)
+
+    # Now do we know the market hours?
+    have_mkt_hours = self.mkt_open is not None and self.mkt_close is not None
+
+    # Once we know the market open and close times, schedule a wakeup call for market open.
+    # Only do this once, when we first have both items.
+    if have_mkt_hours and not had_mkt_hours:
+      # Agents are asked to generate a wake offset from the market open time.  We structure
+      # this as a subclass request so each agent can supply an appropriate offset relative
+      # to its trading frequency.
+      ns_offset = self.getWakeFrequency()
+
+      self.setWakeup(currentTime + ns_offset)
+
+
+  # Used by any Trading Agent subclass to query the last trade price for a symbol.
+  # This activity is not logged.
+  def getLastTrade (self, symbol):
+    self.sendMessage(self.exchangeID, Message({ "msg" : "QUERY_LAST_TRADE", "sender": self.id,
+                                                "symbol" : symbol })) 
+
+
+  # Used by any Trading Agent subclass to query the current spread for a symbol.
+  # This activity is not logged.
+  def getCurrentSpread (self, symbol, depth=1):
+    self.sendMessage(self.exchangeID, Message({ "msg" : "QUERY_SPREAD", "sender": self.id,
+                                                "symbol" : symbol, "depth" : depth }))
+
+
+  # Used by any Trading Agent subclass to query the recent order stream for a symbol.
+  def getOrderStream (self, symbol, length=1):
+    self.sendMessage(self.exchangeID, Message({ "msg" : "QUERY_ORDER_STREAM", "sender": self.id,
+                                                "symbol" : symbol, "length" : length }))
+
+  def get_transacted_volume(self, symbol, lookback_period='10min'):
+    """ Used by any trading agent subclass to query the total transacted volume in a given lookback period """
+    self.sendMessage(self.exchangeID, Message({ "msg": "QUERY_TRANSACTED_VOLUME", "sender": self.id,
+                                                "symbol": symbol, "lookback_period": lookback_period}))
+
+  # Used by any Trading Agent subclass to place a limit order.  Parameters expect:
+  # string (valid symbol), int (positive share quantity), bool (True == BUY), int (price in cents).
+  # The call may optionally specify an order_id (otherwise global autoincrement is used) and
+  # whether cash or risk limits should be enforced or ignored for the order.
+  def placeLimitOrder (self, symbol, quantity, is_buy_order, limit_price, order_id=None, ignore_risk = True, tag = None):
+    order = LimitOrder(self.id, self.currentTime, symbol, quantity, is_buy_order, limit_price, order_id, tag)
+
+    if quantity > 0:
+      # Test if this order can be permitted given our at-risk limits.
+      new_holdings = self.holdings.copy()
+
+      q = order.quantity if order.is_buy_order else -order.quantity
+
+      if order.symbol in new_holdings: new_holdings[order.symbol] += q
+      else: new_holdings[order.symbol] = q
+
+      # If at_risk is lower, always allow.  Otherwise, new_at_risk must be below starting cash.
+      if not ignore_risk:
+        # Compute before and after at-risk capital.
+        at_risk = self.markToMarket(self.holdings) - self.holdings['CASH']
+        new_at_risk = self.markToMarket(new_holdings) - new_holdings['CASH']
+
+        if (new_at_risk > at_risk) and (new_at_risk > self.starting_cash):
+          log_print ("TradingAgent ignored limit order due to at-risk constraints: {}\n{}", order, self.fmtHoldings(self.holdings))
+          return
+
+      # Copy the intended order for logging, so any changes made to it elsewhere
+      # don't retroactively alter our "as placed" log of the order.  Eventually
+      # it might be nice to make the whole history of the order into transaction
+      # objects inside the order (we're halfway there) so there CAN be just a single
+      # object per order, that never alters its original state, and eliminate all these copies.
+      self.orders[order.order_id] = deepcopy(order)
+      self.sendMessage(self.exchangeID, Message({ "msg" : "LIMIT_ORDER", "sender": self.id,
+                                                   "order" : order }))
+
+      # Log this activity.
+      if self.log_orders: self.logEvent('ORDER_SUBMITTED', order.to_dict())
+
+    else:
+      log_print ("TradingAgent ignored limit order of quantity zero: {}", order)
+
+  def placeMarketOrder(self, symbol, quantity, is_buy_order, order_id=None, ignore_risk = True, tag=None):
+    """
+      Used by any Trading Agent subclass to place a market order. The market order is created as multiple limit orders
+      crossing the spread walking the book until all the quantities are matched.
+      :param symbol (str):        name of the stock traded
+      :param quantity (int):      order quantity
+      :param is_buy_order (bool): True if Buy else False
+      :param order_id:            Order ID for market replay
+      :param ignore_risk (bool):  Determines whether cash or risk limits should be enforced or ignored for the order
+      :return:
+    """
+    order = MarketOrder(self.id, self.currentTime, symbol, quantity, is_buy_order, order_id)
+    if quantity > 0:
+      # compute new holdings
+      new_holdings = self.holdings.copy()
+      q = order.quantity if order.is_buy_order else -order.quantity
+      if order.symbol in new_holdings: new_holdings[order.symbol] += q
+      else: new_holdings[order.symbol] = q
+
+      if not ignore_risk:
+        # Compute before and after at-risk capital.
+        at_risk = self.markToMarket(self.holdings) - self.holdings['CASH']
+        new_at_risk = self.markToMarket(new_holdings) - new_holdings['CASH']
+
+        if (new_at_risk > at_risk) and (new_at_risk > self.starting_cash):
+          log_print("TradingAgent ignored market order due to at-risk constraints: {}\n{}",
+                    order, self.fmtHoldings(self.holdings))
+          return
+      self.orders[order.order_id] = deepcopy(order)
+      self.sendMessage(self.exchangeID, Message({"msg" : "MARKET_ORDER", "sender": self.id, "order": order}))
+      if self.log_orders: self.logEvent('ORDER_SUBMITTED', order.to_dict())
+    else:
+      log_print("TradingAgent ignored market order of quantity zero: {}", order)
+
+  def cancelOrder(self, order):
+    """Used by any Trading Agent subclass to cancel any order.  The order must currently
+    appear in the agent's open orders list."""
+    if isinstance(order, LimitOrder):
+      self.sendMessage(self.exchangeID, Message({"msg": "CANCEL_ORDER", "sender": self.id,
+                                                 "order": order}))
+      # Log this activity.
+      if self.log_orders: self.logEvent('CANCEL_SUBMITTED', order.to_dict())
+    else:
+      log_print("order {} of type, {} cannot be cancelled", order, type(order))
+
+  def modifyOrder (self, order, newOrder):
+    """ Used by any Trading Agent subclass to modify any existing limit order.  The order must currently
+        appear in the agent's open orders list.  Some additional tests might be useful here
+        to ensure the old and new orders are the same in some way."""
+    self.sendMessage(self.exchangeID, Message({ "msg" : "MODIFY_ORDER", "sender": self.id,
+                                                "order" : order, "new_order" : newOrder}))
+
+    # Log this activity.
+    if self.log_orders: self.logEvent('MODIFY_ORDER', order.to_dict())
+
+
+  # Handles ORDER_EXECUTED messages from an exchange agent.  Subclasses may wish to extend,
+  # but should still call parent method for basic portfolio/returns tracking.
+  def orderExecuted (self, order):
+    log_print ("Received notification of execution for: {}", order)
+
+    # Log this activity.
+    if self.log_orders: self.logEvent('ORDER_EXECUTED', order.to_dict())
+
+    # At the very least, we must update CASH and holdings at execution time.
+    qty = order.quantity if order.is_buy_order else -1 * order.quantity
+    sym = order.symbol
+
+    if sym in self.holdings:
+      self.holdings[sym] += qty
+    else:
+      self.holdings[sym] = qty
+
+    if self.holdings[sym] == 0: del self.holdings[sym]
+
+    # As with everything else, CASH holdings are in CENTS.
+    self.holdings['CASH'] -= (qty * order.fill_price)
+    
+    # If this original order is now fully executed, remove it from the open orders list.
+    # Otherwise, decrement by the quantity filled just now.  It is _possible_ that due
+    # to timing issues, it might not be in the order list (i.e. we issued a cancellation
+    # but it was executed first, or something).
+    if order.order_id in self.orders:
+      o = self.orders[order.order_id]
+
+      if order.quantity >= o.quantity: del self.orders[order.order_id]
+      else: o.quantity -= order.quantity
+
+    else:
+      log_print ("Execution received for order not in orders list: {}", order)
+
+    log_print ("After execution, agent open orders: {}", self.orders)
+
+    # After execution, log holdings.
+    self.logEvent('HOLDINGS_UPDATED', self.holdings)
+
+
+  # Handles ORDER_ACCEPTED messages from an exchange agent.  Subclasses may wish to extend.
+  def orderAccepted (self, order):
+    log_print ("Received notification of acceptance for: {}", order)
+
+    # Log this activity.
+    if self.log_orders: self.logEvent('ORDER_ACCEPTED', order.to_dict())
+
+
+    # We may later wish to add a status to the open orders so an agent can tell whether
+    # a given order has been accepted or not (instead of needing to override this method).
+
+
+  # Handles ORDER_CANCELLED messages from an exchange agent.  Subclasses may wish to extend.
+  def orderCancelled (self, order):
+    log_print ("Received notification of cancellation for: {}", order)
+
+    # Log this activity.
+    if self.log_orders: self.logEvent('ORDER_CANCELLED', order.to_dict())
+
+    # Remove the cancelled order from the open orders list.  We may of course wish to have
+    # additional logic here later, so agents can easily "look for" cancelled orders.  Of
+    # course they can just override this method.
+    if order.order_id in self.orders:
+      del self.orders[order.order_id]
+    else:
+      log_print ("Cancellation received for order not in orders list: {}", order)
+
+
+  # Handles MKT_CLOSED messages from an exchange agent.  Subclasses may wish to extend.
+  def marketClosed (self):
+    log_print ("Received notification of market closure.")
+
+    # Log this activity.
+    self.logEvent('MKT_CLOSED')
+
+    # Remember that this has happened.
+    self.mkt_closed = True
+
+
+  # Handles QUERY_LAST_TRADE messages from an exchange agent.
+  def queryLastTrade (self, symbol, price):
+    self.last_trade[symbol] = price
+
+    log_print ("Received last trade price of {} for {}.", self.last_trade[symbol], symbol)
+
+    if self.mkt_closed:
+      # Note this as the final price of the day.
+      self.daily_close_price[symbol] = self.last_trade[symbol]
+
+      log_print ("Received daily close price of {} for {}.", self.last_trade[symbol], symbol)
+
+
+  # Handles QUERY_SPREAD messages from an exchange agent.
+  def querySpread (self, symbol, price, bids, asks, book):
+    # The spread message now also includes last price for free.
+    self.queryLastTrade(symbol, price)
+
+    self.known_bids[symbol] = bids
+    self.known_asks[symbol] = asks
+
+    if bids: best_bid, best_bid_qty = (bids[0][0], bids[0][1])
+    else: best_bid, best_bid_qty = ('No bids', 0)
+
+    if asks: best_ask, best_ask_qty = (asks[0][0], asks[0][1])
+    else: best_ask, best_ask_qty = ('No asks', 0)
+
+    log_print ("Received spread of {} @ {} / {} @ {} for {}", best_bid_qty, best_bid, best_ask_qty, best_ask, symbol)
+
+    self.logEvent("BID_DEPTH", bids)
+    self.logEvent("ASK_DEPTH", asks)
+    self.logEvent("IMBALANCE", [sum([x[1] for x in bids]), sum([x[1] for x in asks])])
+
+    self.book = book
+
+  def handleMarketData(self, msg):
+    '''
+    Handles Market Data messages for agents using subscription mechanism
+    '''
+    symbol = msg.body['symbol']
+    self.known_asks[symbol] = msg.body['asks']
+    self.known_bids[symbol] = msg.body['bids']
+    self.last_trade[symbol] = msg.body['last_transaction']
+    self.exchange_ts[symbol] = msg.body['exchange_ts']
+
+
+  # Handles QUERY_ORDER_STREAM messages from an exchange agent.
+  def queryOrderStream (self, symbol, orders):
+    # It is up to the requesting agent to do something with the data, which is a list of dictionaries keyed
+    # by order id.  The list index is 0 for orders since the most recent trade, 1 for orders that led up to
+    # the most recent trade, and so on.  Agents are not given index 0 (orders more recent than the last
+    # trade).
+    self.stream_history[self.symbol] = orders
+
+  def query_transacted_volume(self, symbol, transacted_volume):
+    """ Handles the QUERY_TRANSACTED_VOLUME messages from the exchange agent"""
+    self.transacted_volume[symbol] = transacted_volume
+
+  # Utility functions that perform calculations from available knowledge, but implement no
+  # particular strategy.
+
+
+  # Extract the current known bid and asks. This does NOT request new information.
+  def getKnownBidAsk (self, symbol, best=True):
+    if best:
+      bid = self.known_bids[symbol][0][0] if self.known_bids[symbol] else None
+      ask = self.known_asks[symbol][0][0] if self.known_asks[symbol] else None
+      bid_vol = self.known_bids[symbol][0][1] if self.known_bids[symbol] else 0
+      ask_vol = self.known_asks[symbol][0][1] if self.known_asks[symbol] else 0
+      return bid, bid_vol, ask, ask_vol
+    else:
+      bids = self.known_bids[symbol] if self.known_bids[symbol] else None
+      asks = self.known_asks[symbol] if self.known_asks[symbol] else None
+      return bids, asks
+
+
+  # Extract the current bid and ask liquidity within a certain proportion of the
+  # inside bid and ask.  (i.e. within=0.01 means to report total BID shares
+  # within 1% of the best bid price, and total ASK shares within 1% of the best
+  # ask price)
+  #
+  # Returns bid_liquidity, ask_liquidity.  Note that this is from the order book
+  # perspective, not the agent perspective.  (The agent would be selling into the
+  # bid liquidity, etc.)
+  def getKnownLiquidity (self, symbol, within=0.00):
+    bid_liq = self.getBookLiquidity(self.known_bids[symbol], within)
+    ask_liq = self.getBookLiquidity(self.known_asks[symbol], within)
+
+    log_print ("Bid/ask liq: {}, {}", bid_liq, ask_liq)
+    log_print ("Known bids: {}", self.known_bids[self.symbol])
+    log_print ("Known asks: {}", self.known_asks[self.symbol])
+
+    return bid_liq, ask_liq
+
+
+  # Helper function for the above.  Checks one side of the known order book.
+  def getBookLiquidity (self, book, within):
+    liq = 0
+    for i, (price, shares) in enumerate(book):
+      if i == 0:
+        best = price
+
+      # Is this price within "within" proportion of the best price?
+      if abs(best - price) <= int(round(best * within)):
+        log_print ("Within {} of {}: {} with {} shares", within, best, price, shares)
+        liq += shares
+
+    return liq
+
+
+  # Marks holdings to market (including cash).
+  def markToMarket (self, holdings, use_midpoint=False):
+    cash = holdings['CASH']
+    
+    cash += self.basket_size * self.nav_diff
+    
+    for symbol, shares in holdings.items():
+      if symbol == 'CASH': continue
+      if self.last_trade[symbol] is None:
+        self.logEvent('MARKED_TO_MARKET', cash)
+        return cash
+      if use_midpoint:
+        bid, ask, midpoint = self.getKnownBidAskMidpoint(symbol)
+        if bid is None or ask is None or midpoint is None:
+          value = self.last_trade[symbol] * shares
+        else:
+          value = midpoint * shares
+      else:
+        value = self.last_trade[symbol] * shares
+
+      cash += value
+
+      self.logEvent('MARK_TO_MARKET', "{} {} @ {} == {}".format(shares, symbol,
+                    self.last_trade[symbol], value))
+
+    self.logEvent('MARKED_TO_MARKET', cash)
+
+    return cash
+
+
+  # Gets holdings.  Returns zero for any symbol not held.
+  def getHoldings (self, symbol):
+    if symbol in self.holdings: return self.holdings[symbol]
+    return 0
+
+
+  # Get the known best bid, ask, and bid/ask midpoint from cached data.  No volume.
+  def getKnownBidAskMidpoint (self, symbol) :
+    bid = self.known_bids[symbol][0][0] if self.known_bids[symbol] else None
+    ask = self.known_asks[symbol][0][0] if self.known_asks[symbol] else None
+
+    midpoint = int(round((bid + ask) / 2)) if bid is not None and ask is not None else None
+
+    return bid, ask, midpoint
+
+  def get_average_transaction_price(self):
+    """ Calculates the average price paid (weighted by the order size) """
+    return round(sum(executed_order.quantity * executed_order.fill_price for executed_order in self.executed_orders) / \
+                 sum(executed_order.quantity for executed_order in self.executed_orders), 2)
+
+  # Prints holdings.  Standard dictionary->string representation is almost fine, but it is
+  # less confusing to see the CASH holdings in dollars and cents, instead of just integer
+  # cents.  We could change to a Holdings object that knows to print CASH "special".
+  def fmtHoldings (self, holdings):
+    h = ''
+    for k,v in sorted(holdings.items()):
+      if k == 'CASH': continue
+      h += "{}: {}, ".format(k,v)
+
+    # There must always be a CASH entry.
+    h += "{}: {}".format('CASH', holdings['CASH'])
+    h = '{ ' + h + ' }'
+    return h
+
+
+  pass

ABIDES/agent/ValueAgent.py

@@ -0,0 +1,260 @@
+from agent.TradingAgent import TradingAgent
+from util.util import log_print
+
+from math import sqrt
+import numpy as np
+import pandas as pd
+
+
+class ValueAgent(TradingAgent):
+
+    def __init__(self, id, name, type, symbol='IBM', starting_cash=100000, sigma_n=10000,
+                 r_bar=100000, kappa=0.05, sigma_s=100000,
+                 lambda_a=0.005, log_orders=False, log_to_file=True, random_state=None, wakeup_time=pd.Timedelta('0s')):
+
+        # Base class init.
+        super().__init__(id, name, type, starting_cash=starting_cash,
+                         log_orders=log_orders, log_to_file=log_to_file, random_state=random_state)
+
+        # Store important parameters particular to the ZI agent.
+        self.symbol = symbol  # symbol to trade
+        self.sigma_n = sigma_n  # observation noise variance
+        self.r_bar = r_bar  # true mean fundamental value
+        self.kappa = kappa  # mean reversion parameter
+        self.sigma_s = sigma_s  # shock variance
+        self.lambda_a = lambda_a  # mean arrival rate of ZI agents
+        self.wakeup_time = wakeup_time
+        # The agent uses this to track whether it has begun its strategy or is still
+        # handling pre-market tasks.
+        self.trading = False
+
+        # The agent begins in its "complete" state, not waiting for
+        # any special event or condition.
+        self.state = 'AWAITING_WAKEUP'
+
+        # The agent maintains two priors: r_t and sigma_t (value and error estimates).
+        self.r_t = r_bar
+        self.sigma_t = 0
+
+        # The agent must track its previous wake time, so it knows how many time
+        # units have passed.
+        self.prev_wake_time = None
+
+        self.percent_aggr = 0.1                 #percent of time that the agent will aggress the spread
+        self.size = np.random.randint(20, 50)   #size that the agent will be placing
+        self.depth_spread = 2
+
+    def kernelStarting(self, startTime):
+        # self.kernel is set in Agent.kernelInitializing()
+        # self.exchangeID is set in TradingAgent.kernelStarting()
+
+        super().kernelStarting(startTime)
+
+        self.oracle = self.kernel.oracle
+
+    def kernelStopping(self):
+        # Always call parent method to be safe.
+        super().kernelStopping()
+        return 
+        # Print end of day valuation.
+        H = int(round(self.getHoldings(self.symbol), -2) / 100)
+        # May request real fundamental value from oracle as part of final cleanup/stats.
+        #marked to fundamental
+        rT = self.oracle.observePrice(self.symbol, self.currentTime, sigma_n=0, random_state=self.random_state)
+
+        # final (real) fundamental value times shares held.
+        surplus = rT * H
+
+        log_print("surplus after holdings: {}", surplus)
+
+        # Add ending cash value and subtract starting cash value.
+        surplus += self.holdings['CASH'] - self.starting_cash
+        surplus = float( surplus )/self.starting_cash
+
+        self.logEvent('FINAL_VALUATION', surplus, True)
+
+        log_print(
+            "{} final report.  Holdings {}, end cash {}, start cash {}, final fundamental {}, surplus {}",
+            self.name, H, self.holdings['CASH'], self.starting_cash, rT, surplus)
+
+        #print("Final surplus", self.name, surplus)
+
+    def wakeup(self, currentTime):
+        # Parent class handles discovery of exchange times and market_open wakeup call.
+        super().wakeup(currentTime)
+
+        self.state = 'INACTIVE'
+
+        if not self.mkt_open or not self.mkt_close:
+            # TradingAgent handles discovery of exchange times.
+            return
+        else:
+            if not self.trading:
+                self.trading = True
+
+                # Time to start trading!
+                log_print("{} is ready to start trading now.", self.name)
+
+        # Steady state wakeup behavior starts here.
+
+        # If we've been told the market has closed for the day, we will only request
+        # final price information, then stop.
+        if self.mkt_closed and (self.symbol in self.daily_close_price):
+            # Market is closed and we already got the daily close price.
+            return
+
+        delta_time = self.random_state.exponential(scale=1.0 / self.lambda_a)
+        self.setWakeup(currentTime + pd.Timedelta('{}ns'.format(int(round(delta_time)))))
+        
+        if currentTime <= self.wakeup_time:
+            # This wakeup was set by the agent itself.
+            return
+        
+        if self.mkt_closed and (not self.symbol in self.daily_close_price):
+            self.getCurrentSpread(self.symbol)
+            self.state = 'AWAITING_SPREAD'
+            return
+
+        self.cancelOrders()
+
+        if type(self) == ValueAgent:
+            self.getCurrentSpread(self.symbol)
+            self.state = 'AWAITING_SPREAD'
+        else:
+            self.state = 'ACTIVE'
+
+    def updateEstimates(self):
+        # Called by a background agent that wishes to obtain a new fundamental observation,
+        # update its internal estimation parameters, and compute a new total valuation for the
+        # action it is considering.
+
+        # The agent obtains a new noisy observation of the current fundamental value
+        # and uses this to update its internal estimates in a Bayesian manner.
+        obs_t = self.oracle.observePrice(self.symbol, self.currentTime, sigma_n=self.sigma_n,
+                                         random_state=self.random_state)
+
+        log_print("{} observed {} at {}", self.name, obs_t, self.currentTime)
+
+        # Update internal estimates of the current fundamental value and our error of same.
+
+        # If this is our first estimate, treat the previous wake time as "market open".
+        if self.prev_wake_time is None: self.prev_wake_time = self.mkt_open
+
+        # First, obtain an intermediate estimate of the fundamental value by advancing
+        # time from the previous wake time to the current time, performing mean
+        # reversion at each time step.
+
+        # delta must be integer time steps since last wake
+        delta = (self.currentTime - self.prev_wake_time) / np.timedelta64(1, 'ns')
+
+        # Update r estimate for time advancement.
+        r_tprime = (1 - (1 - self.kappa) ** delta) * self.r_bar
+        r_tprime += ((1 - self.kappa) ** delta) * self.r_t
+
+        # Update sigma estimate for time advancement.
+        sigma_tprime = ((1 - self.kappa) ** (2 * delta)) * self.sigma_t
+        sigma_tprime += ((1 - (1 - self.kappa) ** (2 * delta)) / (1 - (1 - self.kappa) ** 2)) * self.sigma_s
+
+        # Apply the new observation, with "confidence" in the observation inversely proportional
+        # to the observation noise, and "confidence" in the previous estimate inversely proportional
+        # to the shock variance.
+        self.r_t = (self.sigma_n / (self.sigma_n + sigma_tprime)) * r_tprime
+        self.r_t += (sigma_tprime / (self.sigma_n + sigma_tprime)) * obs_t
+
+        self.sigma_t = (self.sigma_n * self.sigma_t) / (self.sigma_n + self.sigma_t)
+
+        # Now having a best estimate of the fundamental at time t, we can make our best estimate
+        # of the final fundamental (for time T) as of current time t.  Delta is now the number
+        # of time steps remaining until the simulated exchange closes.
+        delta = max(0, (self.mkt_close - self.currentTime) / np.timedelta64(1, 'ns'))
+
+        # IDEA: instead of letting agent "imagine time forward" to the end of the day,
+        #       impose a maximum forward delta, like ten minutes or so.  This could make
+        #       them think more like traders and less like long-term investors.  Add
+        #       this line of code (keeping the max() line above) to try it.
+        # delta = min(delta, 1000000000 * 60 * 10)
+
+        r_T = (1 - (1 - self.kappa) ** delta) * self.r_bar
+        r_T += ((1 - self.kappa) ** delta) * self.r_t
+
+        # Our final fundamental estimate should be quantized to whole units of value.
+        r_T = int(round(r_T))
+
+        # Finally (for the final fundamental estimation section) remember the current
+        # time as the previous wake time.
+        self.prev_wake_time = self.currentTime
+
+        log_print("{} estimates r_T = {} as of {}", self.name, r_T, self.currentTime)
+
+        return r_T
+
+    def placeOrder(self):
+        #estimate final value of the fundamental price
+        #used for surplus calculation
+        r_T = self.updateEstimates()
+        bid, bid_vol, ask, ask_vol = self.getKnownBidAsk(self.symbol)
+
+        if bid and ask:
+            mid = int((ask+bid)/2)
+            spread = abs(ask - bid)
+
+            if np.random.rand() < self.percent_aggr:
+                adjust_int = 0
+            else:
+                adjust_int = np.random.randint( 0, self.depth_spread*spread )
+                #adjustment to the limit price, allowed to post inside the spread
+                #or deeper in the book as a passive order to maximize surplus
+
+            if r_T < mid:
+                #fundamental belief that price will go down, place a sell order
+                buy = False
+                p = bid + adjust_int #submit a market order to sell, limit order inside the spread or deeper in the book
+            elif r_T >= mid:
+                #fundamental belief that price will go up, buy order
+                buy = True
+                p = ask - adjust_int #submit a market order to buy, a limit order inside the spread or deeper in the book
+        else:
+            # initialize randomly
+            buy = np.random.randint(0, 1 + 1)
+            p = r_T
+
+        # Place the order
+        self.placeLimitOrder(self.symbol, self.size, buy, p)
+
+    def receiveMessage(self, currentTime, msg):
+        # Parent class schedules market open wakeup call once market open/close times are known.
+        super().receiveMessage(currentTime, msg)
+
+        # We have been awakened by something other than our scheduled wakeup.
+        # If our internal state indicates we were waiting for a particular event,
+        # check if we can transition to a new state.
+
+        if self.state == 'AWAITING_SPREAD':
+            # We were waiting to receive the current spread/book.  Since we don't currently
+            # track timestamps on retained information, we rely on actually seeing a
+            # QUERY_SPREAD response message.
+
+            if msg.body['msg'] == 'QUERY_SPREAD':
+                # This is what we were waiting for.
+
+                # But if the market is now closed, don't advance to placing orders.
+                if self.mkt_closed: return
+
+                # We now have the information needed to place a limit order with the eta
+                # strategic threshold parameter.
+                self.placeOrder()
+                self.state = 'AWAITING_WAKEUP'
+
+        # Cancel all open orders.
+        # Return value: did we issue any cancellation requests?
+
+    def cancelOrders(self):
+        if not self.orders: return False
+
+        for id, order in self.orders.items():
+            self.cancelOrder(order)
+
+        return True
+
+    def getWakeFrequency(self):
+        return pd.Timedelta(self.random_state.randint(low=0, high=100), unit='ns')

ABIDES/agent/WorldAgent.py

@@ -0,0 +1,871 @@
+import os
+from copy import deepcopy
+
+from scipy import stats
+import torch
+from agent.Agent import Agent
+from agent.ExchangeAgent import ExchangeAgent
+from agent.TradingAgent import TradingAgent
+from torch import nn
+from torch.nn import functional as F
+from util.order.LimitOrder import LimitOrder
+from util.util import log_print
+from message.Message import Message
+
+from math import sqrt
+import numpy as np
+import pandas as pd
+import datetime
+
+from ABIDES.util.order.MarketOrder import MarketOrder
+from utils.utils_data import reset_indexes, normalize_messages, one_hot_encoding_type, to_sparse_representation, tanh_encoding_type
+import constants as cst
+
+class WorldAgent(Agent):
+    # the objective of this world agent is to replicate the market for the first 30mins and then
+    # generated new orderr with the help of a diffusion model for the rest of the day,
+    # the diffusion model takes in input the last orders or the last snapshot of the order book
+    # and generates new orders for the next time step
+
+
+    def __init__(self, id, name, type, symbol, date, date_trading_days, model, data_dir, log_orders=True, random_state=None, normalization_terms=None, 
+                 using_diffusion=False, chosen_model=None, seq_len=256, cond_seq_size=255, cond_type='full', size_type_emb=3, gen_seq_size=1):
+
+        super().__init__(id, name, type, random_state=random_state, log_to_file=log_orders)
+        self.count_neg_size = 0
+        self.next_historical_orders_index = 0
+        self.lob_snapshots = []
+        self.sparse_lob_snapshots = []
+        self.symbol = symbol
+        self.date = date
+        self.gen_seq_size = gen_seq_size
+        self.size_type_emb = size_type_emb
+        self.log_orders = log_orders
+        self.executed_trades = dict()
+        self.state = 'AWAITING_WAKEUP'
+        self.model = model
+        self.historical_orders, self.historical_lob = self._load_orders_lob(self.symbol, data_dir, self.date, date_trading_days)
+        self.historical_order_ids = self.historical_orders[:, 2]
+        self.unused_order_ids = np.setdiff1d(np.arange(0, 99999999), self.historical_order_ids)
+        self.next_orders = None
+        self.subscription_requested = False
+        self.date_trading_days = date_trading_days
+        self.first_wakeup = True
+        self.active_limit_orders = {}
+        self.placed_orders = []
+        self.count_diff_placed_orders = 0
+        self.count_modify = 0
+        self.cond_type = cond_type
+        self.cond_seq_size = cond_seq_size
+        self.seq_len = seq_len
+        self.first_generation = True
+        self.normalization_terms = normalization_terms
+        self.ignored_cancel = 0
+        self.generated_orders_out_of_depth = 0
+        self.generated_cancel_orders_empty_depth = 0
+        self.diff_limit_order_placed = 0
+        self.diff_market_order_placed = 0
+        self.diff_cancel_order_placed = 0
+        self.depth_rounding = 0
+        self.last_bid_price = 0
+        self.last_ask_price = 0
+        self.using_diffusion = using_diffusion
+        self.chosen_model = chosen_model
+        if using_diffusion:
+            self.starting_time_diffusion = '15min'
+            #self.model.type_embedder.weight.data = torch.tensor([[ 0.4438, -0.2984,  0.2888], [ 0.8249,  0.5847,  0.1448], [ 1.5600, -1.2847,  1.0294]], device=cst.DEVICE, dtype=torch.float32)
+            #print(self.model.type_embedder.weight.data)
+            #self.model.type_embedder.weight.data = torch.tensor([[ 0.1438, -0.4984,  0.5888], [ 0.8249,  0.3847,  0.0448], [ 1.6600, -1.9847,  1.7294]], device=cst.DEVICE, dtype=torch.float32)
+            #exit()
+        else:
+            self.starting_time_diffusion = '157780min'
+
+    def kernelStarting(self, startTime):
+        # self.kernel is set in Agent.kernelInitializing()
+        super().kernelStarting(startTime)
+        self.oracle = self.kernel.oracle
+        self.exchangeID = self.kernel.findAgentByType(ExchangeAgent)
+        self.mkt_open = startTime
+
+    def kernelTerminating(self):
+        # self.kernel is set in Agent.kernelInitializing()
+        super().kernelTerminating()
+        print("World Agent terminating.")
+        print("World Agent ignored {} cancel orders".format(self.ignored_cancel))
+
+    def requestDataSubscription(self, symbol, levels):
+        self.sendMessage(recipientID=self.exchangeID,
+                         msg=Message({"msg": "MARKET_DATA_SUBSCRIPTION_REQUEST",
+                                      "sender": self.id,
+                                      "symbol": symbol,
+                                      "levels": levels,
+                                      "freq": 0})  # if freq is 0 all the LOB updates will be provided
+                         )
+        
+    def cancelDataSubscription(self):
+        self.sendMessage(recipientID=self.exchangeID,
+                         msg=Message({"msg": "CANCEL_MARKET_DATA_SUBSCRIPTION",
+                                      "sender": self.id,
+                                      "symbol": self.symbol})
+                         )
+
+    def wakeup(self, currentTime):
+        super().wakeup(currentTime)
+        #make a print every 5 minutes
+        
+        if currentTime.minute % 5 == 0 and currentTime.second == 00:
+            print("Current time: {}".format(currentTime))
+            #print("Number of generated orders out of depth: {}".format(self.generated_orders_out_of_depth))
+            #print("Number of generated cancel orders unmatched: {}".format(self.generated_cancel_orders_empty_depth))
+            #print("Number of generated cancel orders matched: {}".format(self.diff_cancel_order_placed))
+            #print("Number of negative size: {}".format(self.count_neg_size))
+            #print("Number of generated placed orders: {}".format(self.count_diff_placed_orders))
+            #print("Of which {} market order and {} limit order".format(self.diff_market_order_placed, self.diff_limit_order_placed))
+            now = datetime.datetime.now()
+            current_time = now.strftime("%H:%M:%S")
+            #print("Current Time =", current_time)
+
+        if self.first_wakeup:
+            self.state = 'PRE_GENERATING'
+            offset = datetime.timedelta(seconds=self.historical_orders[0, 0])
+            time_next_wakeup = currentTime + offset
+            self.setWakeup(time_next_wakeup)
+            self.requestDataSubscription(self.symbol, levels=10)
+            self.first_wakeup = False
+
+        # if current time is between 09:30 and 09:45, then we are in the pre-open phase
+        elif self.mkt_open <= currentTime <= self.mkt_open + pd.Timedelta(self.starting_time_diffusion):
+            next_order = self.historical_orders[self.next_historical_orders_index]
+            self.last_offset_time = next_order[0]
+            self.placeOrder(currentTime, next_order)
+            self.next_historical_orders_index += 1
+            if self.next_historical_orders_index < len(self.historical_orders):
+                offset = datetime.timedelta(seconds=self.historical_orders[self.next_historical_orders_index, 0])
+                self.setWakeup(currentTime + offset + datetime.timedelta(microseconds=1))
+            else:
+                return
+            
+        elif currentTime > self.mkt_open + pd.Timedelta(self.starting_time_diffusion) and not self.using_diffusion:
+            print("cancelling data subscription")
+            self.cancelDataSubscription()
+            
+        elif currentTime > self.mkt_open + pd.Timedelta(self.starting_time_diffusion) and self.using_diffusion:
+            self.state = 'GENERATING'
+            # we generate the first order then the others will be generated everytime we receive the update of the lob
+            if self.first_generation:
+                if self.chosen_model == 'CGAN':        
+                    # we need to fit the temporal distance with a gamma distribution
+                    temporal_distance = self.historical_orders[:, 0]
+                    # remove all the zeros from the temporal distance
+                    temporal_distance = temporal_distance[temporal_distance > 0]
+                    self.shape_temp_distance, self.loc_temp_distance, self.scale_temp_distance = stats.gamma.fit(temporal_distance)
+        
+                generated_orders = self._generate_order(currentTime)
+                self.next_orders = generated_orders
+                self.first_generation = False
+                offset_time = datetime.timedelta(seconds=generated_orders[0][0])
+                self.setWakeup(currentTime + offset_time + datetime.timedelta(microseconds=1))
+                return
+
+            #check if in the kernel messages queue there are messages for the first agent
+            wait = False
+            for timestamp, msg in self.kernel.messages.queue:
+                if msg[0] == self.id:
+                    wait = True
+                    
+            # first we place the last order generated and next we generate the next order
+            if self.next_orders is not None and not wait:
+                self.placeOrder(currentTime, self.next_orders[0])
+                self.next_orders = self.next_orders[1:]
+                
+            elif wait:
+                self.setWakeup(currentTime + datetime.timedelta(microseconds=1))
+                return 
+            
+            if len(self.next_orders) == 0:
+                self.next_orders = self._generate_order(currentTime)
+                offset_time = datetime.timedelta(seconds=self.next_orders[0][0])
+                self.setWakeup(currentTime + offset_time + datetime.timedelta(microseconds=1))
+                return 
+
+        
+    def receiveMessage(self, currentTime, msg):
+        if currentTime > self.mkt_open + pd.Timedelta(self.starting_time_diffusion) and not self.using_diffusion:
+            return
+        
+        super().receiveMessage(currentTime, msg)
+        if msg.body['msg'] == 'MARKET_DATA':
+            self._update_lob_snapshot(msg)
+            self._update_active_limit_orders()
+
+        # if we had placed a market order and it is executed we receive the message of the limit order filled, so if it was a buy we receive a sell
+        elif msg.body['msg'] == 'ORDER_EXECUTED':
+            direction = 1 if msg.body['order'].is_buy_order else -1
+            self.placed_orders.append(np.array([self.last_offset_time, 4, msg.body['order'].order_id, msg.body['order'].quantity, msg.body['order'].limit_price, direction]))
+            self.logEvent('ORDER_EXECUTED', msg.body['order'].to_dict())
+
+        elif msg.body['msg'] == 'ORDER_ACCEPTED':
+            direction = 1 if msg.body['order'].is_buy_order else -1
+            self.placed_orders.append(np.array([self.last_offset_time, 1, msg.body['order'].order_id, msg.body['order'].quantity, msg.body['order'].limit_price, direction]))
+            self.logEvent('ORDER_ACCEPTED', msg.body['order'].to_dict())
+
+        elif msg.body['msg'] == 'ORDER_CANCELLED':
+            direction = 1 if msg.body['order'].is_buy_order else -1
+            self.placed_orders.append(np.array([self.last_offset_time, 3, msg.body['order'].order_id, msg.body['order'].quantity, msg.body['order'].limit_price, direction]))
+            self.logEvent('ORDER_CANCELLED', msg.body['order'].to_dict())
+
+    def placeOrder(self, currentTime, order):
+        order_id = order[2]
+        type = order[1]
+        quantity = order[3]
+        price = int(order[4])
+        direction = order[5]
+        if quantity > 0:
+            direction = False if direction == -1 else True
+            if type == 1:
+                self.placeLimitOrder(self.symbol, quantity, is_buy_order=direction, limit_price=price, order_id=order_id)
+
+            elif type == 2 or type == 3:
+                if order_id in self.active_limit_orders:
+                    old_order = self.active_limit_orders[order_id]
+                    del self.active_limit_orders[order_id]
+                else:
+                    self.ignored_cancel += 1
+                    return
+                    # raise Exception("trying to cancel an order that doesn't exist")
+                if type == 3:
+                    # total deletion of a limit order
+                    self.cancelOrder(old_order)
+                elif type == 2:
+                    # partial deletion of a limit order
+                    new_order = LimitOrder(
+                        agent_id=self.id, 
+                        time_placed=self.currentTime, 
+                        symbol=self.symbol, 
+                        quantity=old_order.quantity-quantity, 
+                        is_buy_order=old_order.is_buy_order, 
+                        limit_price=old_order.limit_price, 
+                        order_id=old_order.order_id, 
+                        tag=None
+                    )
+                    self.modifyOrder(old_order, new_order)
+                    self.placed_orders.append(np.array([order[0], 2, new_order.order_id, quantity, new_order.limit_price, direction]))
+
+            elif type == 4:
+                # if type == 4 it means that it is an execution order, so if it is an execution order of a sell limit order
+                # we place a buy market order of the same quantity and viceversa
+                is_buy_order = False if direction else True
+                # the current order_id is the order_id of the sell (buy) limit order filled, 
+                # so we need to assign to the market order another order_id
+                order_id = self.unused_order_ids[0]
+                self.unused_order_ids = self.unused_order_ids[1:]
+                self.placeMarketOrder(self.symbol, quantity, is_buy_order=is_buy_order, order_id=order_id)
+        else:
+            log_print("Agent ignored order of quantity zero: {}", order)
+
+    def _generate_order(self, currentTime):
+        generated = None
+        post_processed_orders = []
+        while len(post_processed_orders) == 0:
+            if self.chosen_model == 'TRADES':
+                if self.cond_type == 'full':
+                    orders = np.array(self.placed_orders[-self.cond_seq_size:])
+                    cond_orders = self._preprocess_orders_for_diff_cond(orders, np.array(self.lob_snapshots[-self.cond_seq_size -1:]))
+                    lob_snapshots = np.array(self.lob_snapshots[-self.cond_seq_size-1:])
+                    cond_lob = torch.from_numpy(self._z_score_orderbook(lob_snapshots)).to(cst.DEVICE, torch.float32)
+                    cond_lob = cond_lob.unsqueeze(0)
+                elif self.cond_type == 'only_event':
+                    orders = np.array(self.placed_orders[-self.cond_seq_size:])
+                    cond_orders = self._preprocess_orders_for_diff_cond(orders, np.array(self.lob_snapshots[-self.cond_seq_size -1:]))
+                    cond_lob = None
+                else:
+                    raise ValueError("cond_type not recognized")
+                cond_orders = cond_orders.unsqueeze(0)   
+                x = torch.zeros(1, self.gen_seq_size, cst.LEN_ORDER, device=cst.DEVICE, dtype=torch.float32)
+                generated = self.model.sample(cond_orders=cond_orders, x=x, cond_lob=cond_lob)
+                post_processed_orders = []
+                for i in range(generated.shape[1]):
+                    order = self._postprocess_generated_TRADES(generated[0, i, :])
+                    if order is not None:
+                        post_processed_orders.append(order)
+                
+            elif self.chosen_model == 'CGAN':
+                cond_market_features = self._preprocess_market_features_for_cgan(np.array(self.lob_snapshots[-(self.seq_len)*2+1:]))
+                '''
+                 cond_market_features = 
+                    ['volume_imbalance_1',
+                    'volume_imbalance_5', 
+                    'absolute_volume_1', 
+                    'absolute_volume_5', 
+                    'spread', 
+                    'order_sign_imbalance_256', 
+                    'order_sign_imbalance_128', 
+                    'returns_1', 
+                    'returns_50']
+                '''
+                noise = torch.randn(1, 1, self.model.generator_lstm_hidden_state_dim).to(cst.DEVICE, torch.float32)
+                generated = self.model.sample(noise=noise, cond_market_features=cond_market_features)
+                generated = self.model.post_process_order(generated)
+                # generated = ['event_type', 'size', 'direction', 'depth', 'cancel_depth', 'quantity_100', 'quantity_type']
+                generated = generated[0, 0, :]
+                generated = self._postprocess_generated_gan(generated)
+                if generated is not None:
+                    post_processed_orders = [generated]
+                    # generated = [offset, order_type, order_id, size, price, direction]
+        return post_processed_orders
+
+
+    def placeLimitOrder(self, symbol, quantity, is_buy_order, limit_price, order_id=None, ignore_risk=True, tag=None):
+        order = LimitOrder(self.id, self.currentTime, symbol, quantity, is_buy_order, limit_price, order_id, tag)
+        self.sendMessage(self.exchangeID, Message({"msg": "LIMIT_ORDER", "sender": self.id, "order": order}))
+        # Log this activity.
+        if self.log_orders: self.logEvent('ORDER_SUBMITTED', order.to_dict())
+
+    def placeMarketOrder(self, symbol, quantity, is_buy_order, order_id=None, ignore_risk=True, tag=None):
+        """
+          The market order is created as multiple limit orders crossing the spread walking the book until all the quantities are matched.
+        """
+        order = MarketOrder(self.id, self.currentTime, symbol, quantity, is_buy_order, order_id)
+        self.sendMessage(self.exchangeID, Message({"msg": "MARKET_ORDER", "sender": self.id, "order": order}))
+        if self.log_orders: self.logEvent('ORDER_SUBMITTED', order.to_dict())
+
+    def cancelOrder(self, order):
+        """Used by any Trading Agent subclass to cancel any order.
+        The order must currently appear in the agent's open orders list."""
+        if isinstance(order, LimitOrder):
+            self.sendMessage(self.exchangeID, Message({"msg": "CANCEL_ORDER", "sender": self.id,
+                                                       "order": order}))
+            # Log this activity.
+            if self.log_orders: self.logEvent('CANCEL_SUBMITTED', order.to_dict())
+        else:
+            log_print("order {} of type, {} cannot be cancelled", order, type(order))
+
+    def modifyOrder(self, order, newOrder):
+        """ Used by any Trading Agent subclass to modify any existing limit order.  The order must currently
+            appear in the agent's open orders list.  Some additional tests might be useful here
+            to ensure the old and new orders are the same in some way."""
+        self.sendMessage(self.exchangeID, Message({"msg": "MODIFY_ORDER", "sender": self.id,
+                                                   "order": order, "new_order": newOrder}))
+        # Log this activity.
+        if self.log_orders: self.logEvent('MODIFY_ORDER', order.to_dict())
+
+    def _postprocess_generated_gan(self, generated):
+        ''' we need to go from the output of the cgan model to an actual order '''
+        generated = generated.cpu().detach().numpy()
+        # firstly we generate the offset 
+        offset = stats.gamma.rvs(self.shape_temp_distance, self.loc_temp_distance, self.scale_temp_distance)
+        
+        direction = generated[2]
+        quantity_type = generated[6]
+        order_type = generated[0]
+        # order type == -1 -> limit order
+        # order type == 0 -> cancel order
+        # order type == 1 -> market order
+        order_type += 2
+        if order_type == 3 or order_type == 2:
+            order_type += 1
+        # order type == 1 -> limit order
+        # order type == 3 -> cancel order
+        # order type == 4 -> market order
+        
+        # we return the depth, the cancel depth, the size and the quantity100 to the original scale
+        mean_depth = self.normalization_terms["lob"][12]
+        std_depth = self.normalization_terms["lob"][13]
+        mean_cancel_depth = self.normalization_terms["lob"][8]
+        std_cancel_depth = self.normalization_terms["lob"][9]
+        mean_size_100 = self.normalization_terms["lob"][10]
+        std_size_100 = self.normalization_terms["lob"][11]
+        mean_size = self.normalization_terms["lob"][14]
+        std_size = self.normalization_terms["lob"][15]
+        depth = int(generated[3] * std_depth + mean_depth)
+        cancel_depth = int(generated[4] * std_cancel_depth + mean_cancel_depth)
+        # we are considering only the first 10 levels of the order book so we need to check if the cancel depth is greater than 9
+        if cancel_depth > 9:
+            return None
+        size_100 = generated[5] * std_size_100 + mean_size_100
+        size = int(generated[1] * std_size + mean_size)
+        
+        if quantity_type == -1:
+            size = int(size_100)*100
+            
+        if order_type == 1:
+            order_id = self.unused_order_ids[0]
+            self.unused_order_ids = self.unused_order_ids[1:]
+            if direction == 1:
+                bid_side = self.lob_snapshots[-1][2::4]
+                bid_price = bid_side[0]
+                if bid_price == 0:
+                    bid_price = self.last_bid_price
+                else:
+                    self.last_bid_price = bid_price
+                last_price = bid_side[-1] 
+                price = bid_price - depth*100
+                # if the first 10 levels are full and the price is less than the last price we generate another order
+                # because we consider only the first 10 levels
+                if price < last_price and last_price > 0:
+                    self.generated_orders_out_of_depth += 1
+                    return None
+                self.diff_limit_order_placed += 1
+            else:
+                ask_side = self.lob_snapshots[-1][0::4]
+                ask_price = ask_side[0]
+                if ask_price == 0:
+                    ask_price = self.last_ask_price
+                else:
+                    self.last_ask_price = ask_price
+                last_price = ask_side[-1]
+                price = ask_price + depth*100
+                if price > last_price and last_price > 0:
+                    self.generated_orders_out_of_depth += 1
+                    return None
+                self.diff_limit_order_placed += 1
+
+        elif order_type == 3:
+            if direction == 1:
+                bid_side = self.lob_snapshots[-1][2::4]
+                bid_price = bid_side[0]
+                if bid_price == 0:
+                    return None
+                else:
+                    self.last_bid_price = bid_price
+                #select the price at depth = cancel_depth
+                price = bid_side[cancel_depth]
+                # search all the active limit orders with the same price
+                orders_with_same_price = [order for order in self.active_limit_orders.values() if order.limit_price == price]
+                # if there are no orders with the same price then we generate another order
+                if len(orders_with_same_price) == 0:
+                    self.generated_cancel_orders_empty_depth += 1
+                    #chech if there are buy limit orders active
+                    if len([order for order in self.active_limit_orders.values() if order.is_buy_order]) == 0:
+                        return None
+                    # find the order with the closest price and quantity
+                    order_id = min(self.active_limit_orders.values(), key=lambda x: (abs(x.limit_price - price), abs(x.quantity - size))).order_id
+                else:
+                    # we select the order with the quantity closer to the quantity generated
+                    order_id = min(orders_with_same_price, key=lambda x: abs(x.quantity - size)).order_id
+                    self.diff_cancel_order_placed += 1
+
+            else:
+                ask_side = self.lob_snapshots[-1][0::4]
+                ask_price = ask_side[0]
+                if ask_price == 0:
+                    return None
+                else:
+                    self.last_ask_price = ask_price
+                price = ask_side[cancel_depth]
+                # search all the active limit orders in the same level
+                orders_with_same_price = [order for order in self.active_limit_orders.values() if order.limit_price == price]
+                # if there are no orders with the same price then we generate another order
+                if len(orders_with_same_price) == 0:
+                    self.generated_cancel_orders_empty_depth += 1
+                    #chech if there are sell limit orders active
+                    if len([order for order in self.active_limit_orders.values() if not order.is_buy_order]) == 0:
+                        return None
+                    order_id = min(self.active_limit_orders.values(), key=lambda x: (abs(x.limit_price - price), abs(x.quantity - size))).order_id
+                else:
+                    # we select the order with the quantity near to the quantity generated
+                    order_id = min(orders_with_same_price, key=lambda x: abs(x.quantity - size)).order_id
+                    self.diff_cancel_order_placed += 1
+
+        elif order_type == 4:
+            self.diff_market_order_placed += 1
+            if direction == 1:
+                price = self.lob_snapshots[-1][0]
+            else:
+                price = self.lob_snapshots[-1][2]
+            order_id = 0
+            # the diffusion gives in output market order and not execution of limit order,
+            # so we transform market orders in execution orders of the opposite side as the original message files
+            direction = -direction
+        self.count_diff_placed_orders += 1
+        return np.array([offset, order_type, order_id, size, price, direction])
+        
+        
+
+    def _postprocess_generated_TRADES(self, generated):
+        ''' we need to go from the output of the diffusion model to an actual order '''
+        direction = generated[self.size_type_emb+3]
+        if direction < 0:
+            direction = -1
+        else:
+            direction = 1
+        
+        #order_type = torch.argmax(generated[1:self.size_type_emb+1]).item() + 1
+        order_type = torch.argmin(torch.sum(torch.abs(self.model.type_embedder.weight.data - generated[1:self.size_type_emb+1]), dim=1)).item()+1
+        #print(order_type)
+
+        if order_type == 3 or order_type == 2:
+            order_type += 1
+        # order type == 1 -> limit order
+        # order type == 3 -> cancel order
+        # order type == 4 -> market order
+
+        # we return the size and the time to the original scale
+        size = round(generated[self.size_type_emb+1].item() * self.normalization_terms["event"][1] + self.normalization_terms["event"][0], ndigits=0)
+        depth = round(generated[-1].item() * self.normalization_terms["event"][7] + self.normalization_terms["event"][6], ndigits=0)
+        time = generated[0].item() * self.normalization_terms["event"][5] + self.normalization_terms["event"][4]
+
+        # if the price or the size are negative we return None and we generate another order
+        if size < 0 or size > 1000:
+            self.count_neg_size += 1
+            return None
+        
+        # if the time is negative we approximate to 1 microsecond
+        if time <= 0:
+            time = 0.0000001
+
+        if order_type == 1:
+            order_id = self.unused_order_ids[0]
+            self.unused_order_ids = self.unused_order_ids[1:]
+            if direction == 1:
+                bid_side = self.lob_snapshots[-1][2::4]
+                bid_price = bid_side[0]
+                if bid_price == 0:
+                    bid_price = self.last_bid_price
+                else:
+                    self.last_bid_price = bid_price
+                last_price = bid_side[-1] 
+                price = bid_price - depth*100
+                # if the first 10 levels are full and the price is less than the last price we generate another order
+                # because we consider only the first 10 levels
+                if price < last_price and last_price > 0:
+                    self.generated_orders_out_of_depth += 1
+                    return None
+                self.diff_limit_order_placed += 1
+            else:
+                ask_side = self.lob_snapshots[-1][0::4]
+                ask_price = ask_side[0]
+                if ask_price == 0:
+                    ask_price = self.last_ask_price
+                else:
+                    self.last_ask_price = ask_price
+                last_price = ask_side[-1]
+                price = ask_price + depth*100
+                if price > last_price and last_price > 0:
+                    self.generated_orders_out_of_depth += 1
+                    return None
+                self.diff_limit_order_placed += 1
+
+        elif order_type == 3:
+            if direction == 1:
+                bid_side = self.lob_snapshots[-1][2::4]
+                bid_price = bid_side[0]
+                if bid_price == 0:
+                    return None
+                else:
+                    self.last_bid_price = bid_price
+                price = bid_price - depth*100
+                # search all the active limit orders with the same price
+                orders_with_same_price = [order for order in self.active_limit_orders.values() if order.limit_price == price]
+                # if there are no orders with the same price then we generate another order
+                if len(orders_with_same_price) == 0:
+                    self.generated_cancel_orders_empty_depth += 1
+                    #chech if there are buy limit orders active
+                    if len([order for order in self.active_limit_orders.values() if order.is_buy_order]) == 0:
+                        return None
+                    # find the order with the closest price and quantity
+                    order_id = min(self.active_limit_orders.values(), key=lambda x: (abs(x.limit_price - price), abs(x.quantity - size))).order_id
+                else:
+                    # we select the order with the quantity closer to the quantity generated
+                    order_id = min(orders_with_same_price, key=lambda x: abs(x.quantity - size)).order_id
+                    self.diff_cancel_order_placed += 1
+
+            else:
+                ask_side = self.lob_snapshots[-1][0::4]
+                ask_price = ask_side[0]
+                if ask_price == 0:
+                    return None
+                else:
+                    self.last_ask_price = ask_price
+                price = ask_price + depth*100
+                # search all the active limit orders in the same level
+                orders_with_same_price = [order for order in self.active_limit_orders.values() if order.limit_price == price]
+                # if there are no orders with the same price then we generate another order
+                if len(orders_with_same_price) == 0:
+                    self.generated_cancel_orders_empty_depth += 1
+                    #chech if there are sell limit orders active
+                    if len([order for order in self.active_limit_orders.values() if not order.is_buy_order]) == 0:
+                        return None
+                    order_id = min(self.active_limit_orders.values(), key=lambda x: (abs(x.limit_price - price), abs(x.quantity - size))).order_id
+                else:
+                    # we select the order with the quantity near to the quantity generated
+                    order_id = min(orders_with_same_price, key=lambda x: abs(x.quantity - size)).order_id
+                    self.diff_cancel_order_placed += 1
+
+        elif order_type == 4:
+            self.diff_market_order_placed += 1
+            if direction == 1:
+                price = self.lob_snapshots[-1][0]
+            else:
+                price = self.lob_snapshots[-1][2]
+            order_id = 0
+            # the diffusion gives in output market order and not execution of limit order,
+            # so we transform market orders in execution orders of the opposite side as the original message files
+            direction = -direction
+        self.count_diff_placed_orders += 1
+        return np.array([time, order_type, order_id, size, price, direction])
+
+
+    def _update_active_limit_orders(self):
+        asks = self.kernel.agents[0].order_books[self.symbol].asks
+        bids = self.kernel.agents[0].order_books[self.symbol].bids
+        self.active_limit_orders = {}
+        for level in asks:
+            for order in level:
+                self.active_limit_orders[order.order_id] = order
+        for level in bids:
+            for order in level:
+                self.active_limit_orders[order.order_id] = order
+
+
+    def _z_score_orderbook(self, orderbook):
+        orderbook[:, 0::2] = orderbook[:, 0::2] / 100
+        orderbook[:, 0::2] = (orderbook[:, 0::2] - self.normalization_terms["lob"][2]) / self.normalization_terms["lob"][3]
+        orderbook[:, 1::2] = (orderbook[:, 1::2] - self.normalization_terms["lob"][0]) / self.normalization_terms["lob"][1]
+        return orderbook
+
+
+    def _preprocess_orders_for_diff_cond(self, orders, lob_snapshots):
+        COLUMNS_NAMES = {"orderbook": ["sell1", "vsell1", "buy1", "vbuy1",
+                                       "sell2", "vsell2", "buy2", "vbuy2",
+                                       "sell3", "vsell3", "buy3", "vbuy3",
+                                       "sell4", "vsell4", "buy4", "vbuy4",
+                                       "sell5", "vsell5", "buy5", "vbuy5",
+                                       "sell6", "vsell6", "buy6", "vbuy6",
+                                       "sell7", "vsell7", "buy7", "vbuy7",
+                                       "sell8", "vsell8", "buy8", "vbuy8",
+                                       "sell9", "vsell9", "buy9", "vbuy9",
+                                       "sell10", "vsell10", "buy10", "vbuy10"],
+                         "message": ["time", "event_type", "order_id", "size", "price", "direction"]}
+        orders_dataframe = pd.DataFrame(orders, columns=COLUMNS_NAMES["message"])
+        lob_dataframe = pd.DataFrame(lob_snapshots, columns=COLUMNS_NAMES["orderbook"])
+
+        # we compute the depth of the orders with respect to the orderbook
+        orders_dataframe["depth"] = 0
+        for j in range(0, orders_dataframe.shape[0]):
+            order_price = orders_dataframe["price"].iloc[j]
+            direction = orders_dataframe["direction"].iloc[j]
+            type = orders_dataframe["event_type"].iloc[j]
+            if type == 1:
+                index = j + 1
+            else:
+                index = j
+            if direction == 1:
+                bid_side = lob_dataframe.iloc[index, 2::4]
+                bid_price = bid_side[0]
+                depth = (bid_price - order_price) // 100
+                if depth < 0:
+                    depth = 0
+            else:
+                ask_side = lob_dataframe.iloc[index, 0::4]
+                ask_price = ask_side[0]
+                depth = (order_price - ask_price) // 100
+                if depth < 0:
+                    depth = 0
+            orders_dataframe.loc[j, "depth"] = depth
+
+        # if order type is 4, then we transform the execution of a sell limit order in a buy market order
+        orders_dataframe["direction"] = orders_dataframe["direction"] * orders_dataframe["event_type"].apply(
+            lambda x: -1 if x == 4 else 1)
+
+        # drop the order_id column
+        orders_dataframe = orders_dataframe.drop(columns=["order_id"])
+
+        # divide all the price, both of lob and messages, by 100
+        orders_dataframe["price"] = orders_dataframe["price"] / 100
+
+        # apply z score to orders
+        orders_dataframe, _, _, _, _, _, _, _, _ = normalize_messages(orders_dataframe,
+                                                                    mean_size=self.normalization_terms["event"][0],
+                                                                    mean_prices=self.normalization_terms["event"][2],
+                                                                    std_size=self.normalization_terms["event"][1],
+                                                                    std_prices=self.normalization_terms["event"][3],
+                                                                    mean_time=self.normalization_terms["event"][4],
+                                                                    std_time=self.normalization_terms["event"][5],
+                                                                    mean_depth=self.normalization_terms["event"][6],
+                                                                    std_depth=self.normalization_terms["event"][7]
+                                                                    )
+        
+
+        return torch.from_numpy(orders_dataframe.to_numpy()).to(cst.DEVICE, torch.float32)
+
+
+    def _load_orders_lob(self, symbol, data_dir, date, date_trading_days):
+        path = "{}/{}/{}_{}_{}".format(
+            data_dir,
+            symbol,
+            symbol,
+            date_trading_days[0],
+            date_trading_days[1],
+        )
+        COLUMNS_NAMES = {"orderbook": ["sell1", "vsell1", "buy1", "vbuy1",
+                                       "sell2", "vsell2", "buy2", "vbuy2",
+                                       "sell3", "vsell3", "buy3", "vbuy3",
+                                       "sell4", "vsell4", "buy4", "vbuy4",
+                                       "sell5", "vsell5", "buy5", "vbuy5",
+                                       "sell6", "vsell6", "buy6", "vbuy6",
+                                       "sell7", "vsell7", "buy7", "vbuy7",
+                                       "sell8", "vsell8", "buy8", "vbuy8",
+                                       "sell9", "vsell9", "buy9", "vbuy9",
+                                       "sell10", "vsell10", "buy10", "vbuy10"],
+                         "message": ["time", "event_type", "order_id", "size", "price", "direction"]}
+        for i, filename in enumerate(os.listdir(path)):
+            f = os.path.join(path, filename)
+            filename_splitted = filename.split('_')
+            file_date = filename_splitted[1]
+            if os.path.isfile(f) and file_date == date:
+                if filename_splitted[4] == "message":
+                    events = pd.read_csv(f, header=None, names=COLUMNS_NAMES["message"])
+                elif filename_splitted[4] == "orderbook":
+                    lob = pd.read_csv(f, header=None, names=COLUMNS_NAMES["orderbook"])
+                else:
+                    raise ValueError("File name not recognized")
+
+        events, lob = self._preprocess_events_for_market_replay(events, lob)
+        # transform to numpy
+        lob = lob.to_numpy()
+        events = events.to_numpy()
+        return events, lob
+
+
+    def _preprocess_events_for_market_replay(self, events, lob):
+
+        # drop the rows with event_type = 5, 6, 7
+        indexes = events[events["event_type"].isin([5, 6, 7])].index
+        events = events.drop(indexes)
+        lob = lob.drop(indexes)
+
+        # do the difference of time row per row in messages and subsitute the values with the differences
+        first = events["time"].iloc[0]
+        events["time"] = events["time"].diff()
+        events["time"].iloc[0] = first - 34200
+
+        dataframes = reset_indexes([events, lob])
+        events = dataframes[0]
+        lob = dataframes[1]
+        # get the order ids of the rows with order_type=1
+        order_ids = events.loc[events['event_type'] == 1, 'order_id']
+
+        # filter out the rows that have order_type != 1 and have an order id that is not in order_ids
+        filtered_df = events.loc[((events['event_type'] != 1) & ~(events['order_id'].isin(order_ids)))].index
+
+        events = events.drop(filtered_df)
+        lob = lob.drop(filtered_df)
+        dataframes = reset_indexes([events, lob])
+        return dataframes[0], dataframes[1]
+
+
+    def _update_lob_snapshot(self, msg):
+        last_lob_snapshot = []
+        min_actual_lob_level = min(len(msg.body['asks']), len(msg.body['bids']))
+        # we take the first 10 levels of the lob and update the list of lob snapshots
+        # to use for the conditioning of the diffusion model
+        for i in range(0, 10):
+            if i < min_actual_lob_level:
+                last_lob_snapshot.append(msg.body['asks'][i][0])
+                last_lob_snapshot.append(msg.body['asks'][i][1])
+                last_lob_snapshot.append(msg.body['bids'][i][0])
+                last_lob_snapshot.append(msg.body['bids'][i][1])
+            #we need the else in case the actual lob has less than 10 levels
+            else:
+                if len(msg.body['asks']) > len(msg.body['bids']) and i < len(msg.body['asks']):
+                    last_lob_snapshot.append(msg.body['asks'][i][0])
+                    last_lob_snapshot.append(msg.body['asks'][i][1])
+                    last_lob_snapshot.append(0)
+                    last_lob_snapshot.append(0)
+                elif len(msg.body['bids']) > len(msg.body['asks']) and i < len(msg.body['bids']):
+                    last_lob_snapshot.append(0)
+                    last_lob_snapshot.append(0)
+                    last_lob_snapshot.append(msg.body['bids'][i][0])
+                    last_lob_snapshot.append(msg.body['bids'][i][1])
+                else:
+                    for _ in range(4): last_lob_snapshot.append(0)
+        self.last_lob_snapshot = last_lob_snapshot
+        self.lob_snapshots.append(last_lob_snapshot)
+        self.sparse_lob_snapshots.append(to_sparse_representation(last_lob_snapshot, 100))
+        
+        
+    def _preprocess_market_features_for_cgan(self, lob_snapshots):
+        lob_snapshots = np.array(lob_snapshots)
+        COLUMNS_NAMES = {"orderbook": ["sell1", "vsell1", "buy1", "vbuy1",
+                                       "sell2", "vsell2", "buy2", "vbuy2",
+                                       "sell3", "vsell3", "buy3", "vbuy3",
+                                       "sell4", "vsell4", "buy4", "vbuy4",
+                                       "sell5", "vsell5", "buy5", "vbuy5",
+                                       "sell6", "vsell6", "buy6", "vbuy6",
+                                       "sell7", "vsell7", "buy7", "vbuy7",
+                                       "sell8", "vsell8", "buy8", "vbuy8",
+                                       "sell9", "vsell9", "buy9", "vbuy9",
+                                       "sell10", "vsell10", "buy10", "vbuy10"],
+                        }
+        lob_dataframe = pd.DataFrame(lob_snapshots, columns=COLUMNS_NAMES["orderbook"])
+        orders = np.array(self.placed_orders[-self.seq_len*2 +1:])
+        orders_dataframe = pd.DataFrame(orders, columns=["time", "type", "order_id", "quantity", "price", "direction"])
+        dataframes = [[orders_dataframe, lob_dataframe]]
+        mean_spread = self.normalization_terms["lob"][0]
+        std_spread = self.normalization_terms["lob"][1]
+        mean_return = self.normalization_terms["lob"][2]
+        std_return = self.normalization_terms["lob"][3]
+        mean_vol_imb = self.normalization_terms["lob"][4]
+        std_vol_imb = self.normalization_terms["lob"][5]
+        mean_abs_vol = self.normalization_terms["lob"][6]
+        std_abs_vol = self.normalization_terms["lob"][7]
+        for i in range(len(dataframes)):
+            lob_sizes = dataframes[i][1].iloc[:, 1::2]
+            lob_prices = dataframes[i][1].iloc[:, 0::2]
+            dataframes[i][1]["volume_imbalance_1"] = lob_sizes.iloc[:, 1] / (lob_sizes.iloc[:, 1] + lob_sizes.iloc[:, 0])
+            dataframes[i][1]["volume_imbalance_5"] = (lob_sizes.iloc[:, 1] + lob_sizes.iloc[:, 3] + lob_sizes.iloc[:, 5] + lob_sizes.iloc[:, 7] + lob_sizes.iloc[:, 9]) / (lob_sizes.iloc[:, :10].sum(axis=1))
+            dataframes[i][1]["absolute_volume_1"] = lob_sizes.iloc[:, 1] + lob_sizes.iloc[:, 0]
+            dataframes[i][1]["absolute_volume_5"] = lob_sizes.iloc[:, :10].sum(axis=1)
+            dataframes[i][1]["spread"] = lob_prices.iloc[:, 0] - lob_prices.iloc[:, 1]
+
+        for i in range(len(dataframes)):
+            order_sign_imbalance_256 = pd.Series(0, index=dataframes[i][1].index)
+            order_sign_imbalance_128 = pd.Series(0, index=dataframes[i][1].index)
+            returns_50 = pd.Series(0, index=dataframes[i][1].index)
+            returns_1 = pd.Series(0, index=dataframes[i][1].index)
+            lob_prices = dataframes[i][1].iloc[:, 0::2]
+            mid_prices = (lob_prices.iloc[:, 0] + lob_prices.iloc[:, 1]) / 2
+            for j in range(len(dataframes[i][1])-256):
+                order_sign_imbalance_256.iloc[j] = dataframes[i][0]["direction"].iloc[j:j+256].sum()
+                order_sign_imbalance_128.iloc[j] = dataframes[i][0]["direction"].iloc[j+128:j+256].sum()
+                returns_1.iloc[j] = mid_prices[j+255] / mid_prices[j+254] - 1
+                returns_50.iloc[j] = mid_prices[j+255] / mid_prices[j+205] - 1
+            dataframes[i][1] = dataframes[i][1].iloc[255:]
+            dataframes[i][1].loc[:, "order_sign_imbalance_256"] = order_sign_imbalance_256.iloc[:-255] / 256
+            dataframes[i][1].loc[:, "order_sign_imbalance_128"] = order_sign_imbalance_128.iloc[:-255] / 128
+            dataframes[i][1].loc[:, "returns_1"] = returns_1.iloc[:-255]
+            dataframes[i][1].loc[:, "returns_50"] = returns_50.iloc[:-255]
+            dataframes[i][1] = dataframes[i][1][["volume_imbalance_1", "volume_imbalance_5", "absolute_volume_1", "absolute_volume_5", "spread", "order_sign_imbalance_256", "order_sign_imbalance_128", "returns_1", "returns_50"]]
+        
+        for i in range(len(dataframes)):
+            dataframes[i][1] = dataframes[i][1].reset_index(drop=True)
+        
+        for i in range(len(dataframes)):
+            #transform nan values in 0
+            dataframes[i][1] = dataframes[i][1].fillna(0)
+
+        market_features = dataframes[0][1]
+        market_features["returns_1"] = (market_features["returns_1"] - mean_return) / std_return
+        market_features["returns_50"] = (market_features["returns_50"] - mean_return) / std_return
+        market_features["volume_imbalance_1"] = (market_features["volume_imbalance_1"] - mean_vol_imb) / std_vol_imb
+        market_features["volume_imbalance_5"] = (market_features["volume_imbalance_5"] - mean_vol_imb) / std_vol_imb
+        market_features["absolute_volume_1"] = (market_features["absolute_volume_1"] - mean_abs_vol) / std_abs_vol
+        market_features["absolute_volume_5"] = (market_features["absolute_volume_5"] - mean_abs_vol) / std_abs_vol
+        market_features["spread"] = (market_features["spread"] - mean_spread) / std_spread
+        market_features = market_features.to_numpy()
+        market_features = torch.from_numpy(market_features).to(cst.DEVICE, torch.float32)
+        market_features = market_features.unsqueeze(0)
+        return market_features
+
+
+
+
+
+
+
+
+
+
+
+

ABIDES/agent/ZeroIntelligenceAgent.py

@@ -0,0 +1,320 @@
+from agent.TradingAgent import TradingAgent
+from util.util import log_print
+
+from math import sqrt
+import numpy as np
+import pandas as pd
+
+
+class ZeroIntelligenceAgent(TradingAgent):
+
+    def __init__(self, id, name, type, symbol='IBM', starting_cash=100000, sigma_n=1000,
+                 r_bar=100000, kappa=0.05, sigma_s=100000, q_max=10,
+                 sigma_pv=5000000, R_min=0, R_max=250, eta=1.0,
+                 lambda_a=0.005, log_orders=False, random_state=None):
+
+        # Base class init.
+        super().__init__(id, name, type, starting_cash=starting_cash, log_orders=log_orders, random_state=random_state)
+
+        # Store important parameters particular to the ZI agent.
+        self.symbol = symbol  # symbol to trade
+        self.sigma_n = sigma_n  # observation noise variance
+        self.r_bar = r_bar  # true mean fundamental value
+        self.kappa = kappa  # mean reversion parameter
+        self.sigma_s = sigma_s  # shock variance
+        self.q_max = q_max  # max unit holdings
+        self.sigma_pv = sigma_pv  # private value variance
+        self.R_min = R_min  # min requested surplus
+        self.R_max = R_max  # max requested surplus
+        self.eta = eta  # strategic threshold
+        self.lambda_a = lambda_a  # mean arrival rate of ZI agents
+
+        # The agent uses this to track whether it has begun its strategy or is still
+        # handling pre-market tasks.
+        self.trading = False
+
+        # The agent begins in its "complete" state, not waiting for
+        # any special event or condition.
+        self.state = 'AWAITING_WAKEUP'
+
+        # The agent maintains two priors: r_t and sigma_t (value and error estimates).
+        self.r_t = r_bar
+        self.sigma_t = 0
+
+        # The agent must track its previous wake time, so it knows how many time
+        # units have passed.
+        self.prev_wake_time = None
+
+        # The agent has a private value for each incremental unit.
+        self.theta = [int(x) for x in sorted(
+            np.round(self.random_state.normal(loc=0, scale=sqrt(sigma_pv), size=(q_max * 2))).tolist(),
+            reverse=True)]
+
+    def kernelStarting(self, startTime):
+        # self.kernel is set in Agent.kernelInitializing()
+        # self.exchangeID is set in TradingAgent.kernelStarting()
+
+        super().kernelStarting(startTime)
+
+        self.oracle = self.kernel.oracle
+
+    def kernelStopping(self):
+        # Always call parent method to be safe.
+        super().kernelStopping()
+
+        # Print end of day valuation.
+        H = int(round(self.getHoldings(self.symbol), -2) / 100)
+        # May request real fundamental value from oracle as part of final cleanup/stats.
+        if self.symbol != 'ETF':
+            rT = self.oracle.observePrice(self.symbol, self.currentTime, sigma_n=0, random_state=self.random_state)
+        else:
+            portfolio_rT, rT = self.oracle.observePortfolioPrice(self.symbol, self.portfolio, self.currentTime,
+                                                                 sigma_n=0,
+                                                                 random_state=self.random_state)
+
+        # Start with surplus as private valuation of shares held.
+        if H > 0:
+            surplus = sum([self.theta[x + self.q_max - 1] for x in range(1, H + 1)])
+        elif H < 0:
+            surplus = -sum([self.theta[x + self.q_max - 1] for x in range(H + 1, 1)])
+        else:
+            surplus = 0
+
+        log_print("surplus init: {}", surplus)
+
+        # Add final (real) fundamental value times shares held.
+        surplus += rT * H
+
+        log_print("surplus after holdings: {}", surplus)
+
+        # Add ending cash value and subtract starting cash value.
+        surplus += self.holdings['CASH'] - self.starting_cash
+
+        self.logEvent('FINAL_VALUATION', surplus, True)
+
+        log_print(
+            "{} final report.  Holdings {}, end cash {}, start cash {}, final fundamental {}, preferences {}, surplus {}",
+            self.name, H, self.holdings['CASH'], self.starting_cash, rT, self.theta, surplus)
+
+    def wakeup(self, currentTime):
+        # Parent class handles discovery of exchange times and market_open wakeup call.
+        super().wakeup(currentTime)
+
+        self.state = 'INACTIVE'
+
+        if not self.mkt_open or not self.mkt_close:
+            # TradingAgent handles discovery of exchange times.
+            return
+        else:
+            if not self.trading:
+                self.trading = True
+
+                # Time to start trading!
+                log_print("{} is ready to start trading now.", self.name)
+
+        # Steady state wakeup behavior starts here.
+
+        # If we've been told the market has closed for the day, we will only request
+        # final price information, then stop.
+        if self.mkt_closed and (self.symbol in self.daily_close_price):
+            # Market is closed and we already got the daily close price.
+            return
+
+        # Schedule a wakeup for the next time this agent should arrive at the market
+        # (following the conclusion of its current activity cycle).
+        # We do this early in case some of our expected message responses don't arrive.
+
+        # Agents should arrive according to a Poisson process.  This is equivalent to
+        # each agent independently sampling its next arrival time from an exponential
+        # distribution in alternate Beta formation with Beta = 1 / lambda, where lambda
+        # is the mean arrival rate of the Poisson process.
+        delta_time = self.random_state.exponential(scale=1.0 / self.lambda_a)
+        self.setWakeup(currentTime + pd.Timedelta('{}ns'.format(int(round(delta_time)))))
+
+        # If the market has closed and we haven't obtained the daily close price yet,
+        # do that before we cease activity for the day.  Don't do any other behavior
+        # after market close.
+        if self.mkt_closed and (not self.symbol in self.daily_close_price):
+            self.getCurrentSpread(self.symbol)
+            self.state = 'AWAITING_SPREAD'
+            return
+
+        # Issue cancel requests for any open orders.  Don't wait for confirmation, as presently
+        # the only reason it could fail is that the order already executed.  (But requests won't
+        # be generated for those, anyway, unless something strange has happened.)
+        self.cancelOrders()
+
+        # The ZI agent doesn't try to maintain a zero position, so there is no need to exit positions
+        # as some "active trading" agents might.  It might exit a position based on its order logic,
+        # but this will be as a natural consequence of its beliefs.
+
+        # In order to use the "strategic threshold" parameter (eta), the ZI agent needs the current
+        # spread (inside bid/ask quote).  It would not otherwise need any trade/quote information.
+
+        # If the calling agent is a subclass, don't initiate the strategy section of wakeup(), as it
+        # may want to do something different.
+
+        if type(self) == ZeroIntelligenceAgent:
+            self.getCurrentSpread(self.symbol)
+            self.state = 'AWAITING_SPREAD'
+        else:
+            self.state = 'ACTIVE'
+
+    def updateEstimates(self):
+        # Called by a background agent that wishes to obtain a new fundamental observation,
+        # update its internal estimation parameters, and compute a new total valuation for the
+        # action it is considering.
+
+        # The agent obtains a new noisy observation of the current fundamental value
+        # and uses this to update its internal estimates in a Bayesian manner.
+        obs_t = self.oracle.observePrice(self.symbol, self.currentTime, sigma_n=self.sigma_n,
+                                         random_state=self.random_state)
+
+        log_print("{} observed {} at {}", self.name, obs_t, self.currentTime)
+
+        # Flip a coin to decide if we will buy or sell a unit at this time.
+        q = int(self.getHoldings(self.symbol) / 100) # q now represents an index to how many 100 lots are held
+
+        if q >= self.q_max:
+            buy = False
+            log_print("Long holdings limit: agent will SELL")
+        elif q <= -self.q_max:
+            buy = True
+            log_print("Short holdings limit: agent will BUY")
+        else:
+            buy = bool(self.random_state.randint(0, 2))
+            log_print("Coin flip: agent will {}", "BUY" if buy else "SELL")
+
+        # Update internal estimates of the current fundamental value and our error of same.
+
+        # If this is our first estimate, treat the previous wake time as "market open".
+        if self.prev_wake_time is None: self.prev_wake_time = self.mkt_open
+
+        # First, obtain an intermediate estimate of the fundamental value by advancing
+        # time from the previous wake time to the current time, performing mean
+        # reversion at each time step.
+
+        # delta must be integer time steps since last wake
+        delta = (self.currentTime - self.prev_wake_time) / np.timedelta64(1, 'ns')
+
+        # Update r estimate for time advancement.
+        r_tprime = (1 - (1 - self.kappa) ** delta) * self.r_bar
+        r_tprime += ((1 - self.kappa) ** delta) * self.r_t
+
+        # Update sigma estimate for time advancement.
+        sigma_tprime = ((1 - self.kappa) ** (2 * delta)) * self.sigma_t
+        sigma_tprime += ((1 - (1 - self.kappa) ** (2 * delta)) / (1 - (1 - self.kappa) ** 2)) * self.sigma_s
+
+        # Apply the new observation, with "confidence" in the observation inversely proportional
+        # to the observation noise, and "confidence" in the previous estimate inversely proportional
+        # to the shock variance.
+        self.r_t = (self.sigma_n / (self.sigma_n + sigma_tprime)) * r_tprime
+        self.r_t += (sigma_tprime / (self.sigma_n + sigma_tprime)) * obs_t
+
+        self.sigma_t = (self.sigma_n * self.sigma_t) / (self.sigma_n + self.sigma_t)
+
+        # Now having a best estimate of the fundamental at time t, we can make our best estimate
+        # of the final fundamental (for time T) as of current time t.  Delta is now the number
+        # of time steps remaining until the simulated exchange closes.
+        delta = max(0, (self.mkt_close - self.currentTime) / np.timedelta64(1, 'ns'))
+
+        # IDEA: instead of letting agent "imagine time forward" to the end of the day,
+        #       impose a maximum forward delta, like ten minutes or so.  This could make
+        #       them think more like traders and less like long-term investors.  Add
+        #       this line of code (keeping the max() line above) to try it.
+        # delta = min(delta, 1000000000 * 60 * 10)
+
+        r_T = (1 - (1 - self.kappa) ** delta) * self.r_bar
+        r_T += ((1 - self.kappa) ** delta) * self.r_t
+
+        # Our final fundamental estimate should be quantized to whole units of value.
+        r_T = int(round(r_T))
+
+        # Finally (for the final fundamental estimation section) remember the current
+        # time as the previous wake time.
+        self.prev_wake_time = self.currentTime
+
+        log_print("{} estimates r_T = {} as of {}", self.name, r_T, self.currentTime)
+
+        # Determine the agent's total valuation.
+        q += (self.q_max - 1)
+        theta = self.theta[q + 1 if buy else q]
+        v = r_T + theta
+
+        log_print("{} total unit valuation is {} (theta = {})", self.name, v, theta)
+
+        # Return values needed to implement strategy and select limit price.
+        return v, buy
+
+    def placeOrder(self):
+        # Called when it is time for the agent to determine a limit price and place an order.
+        # updateEstimates() returns the agent's current total valuation for the share it
+        # is considering to trade and whether it will buy or sell that share.
+        v, buy = self.updateEstimates()
+
+        # Select a requested surplus for this trade.
+        R = self.random_state.randint(self.R_min, self.R_max + 1)
+
+        # Determine the limit price.
+        p = v - R if buy else v + R
+
+        # Either place the constructed order, or if the agent could secure (eta * R) surplus
+        # immediately by taking the inside bid/ask, do that instead.
+        bid, bid_vol, ask, ask_vol = self.getKnownBidAsk(self.symbol)
+        if buy and ask_vol > 0:
+            R_ask = v - ask
+            if R_ask >= (self.eta * R):
+                log_print("{} desired R = {}, but took R = {} at ask = {} due to eta", self.name, R, R_ask, ask)
+                p = ask
+            else:
+                log_print("{} demands R = {}, limit price {}", self.name, R, p)
+        elif (not buy) and bid_vol > 0:
+            R_bid = bid - v
+            if R_bid >= (self.eta * R):
+                log_print("{} desired R = {}, but took R = {} at bid = {} due to eta", self.name, R, R_bid, bid)
+                p = bid
+            else:
+                log_print("{} demands R = {}, limit price {}", self.name, R, p)
+
+        # Place the order.
+        size = 100
+        self.placeLimitOrder(self.symbol, size, buy, p)
+
+    def receiveMessage(self, currentTime, msg):
+        # Parent class schedules market open wakeup call once market open/close times are known.
+        super().receiveMessage(currentTime, msg)
+
+        # We have been awakened by something other than our scheduled wakeup.
+        # If our internal state indicates we were waiting for a particular event,
+        # check if we can transition to a new state.
+
+        if self.state == 'AWAITING_SPREAD':
+            # We were waiting to receive the current spread/book.  Since we don't currently
+            # track timestamps on retained information, we rely on actually seeing a
+            # QUERY_SPREAD response message.
+
+            if msg.body['msg'] == 'QUERY_SPREAD':
+                # This is what we were waiting for.
+
+                # But if the market is now closed, don't advance to placing orders.
+                if self.mkt_closed: return
+
+                # We now have the information needed to place a limit order with the eta
+                # strategic threshold parameter.
+                self.placeOrder()
+                self.state = 'AWAITING_WAKEUP'
+
+    # Internal state and logic specific to this agent subclass.
+
+    # Cancel all open orders.
+    # Return value: did we issue any cancellation requests?
+    def cancelOrders(self):
+        if not self.orders: return False
+
+        for id, order in self.orders.items():
+            self.cancelOrder(order)
+
+        return True
+
+    def getWakeFrequency(self):
+        return pd.Timedelta(self.random_state.randint(low=0, high=100), unit='ns')

ABIDES/agent/etf/EtfArbAgent.py

@@ -0,0 +1,197 @@
+from agent.TradingAgent import TradingAgent
+from util.util import log_print
+
+import numpy as np
+import pandas as pd
+
+
+class EtfArbAgent(TradingAgent):
+
+  def __init__(self, id, name, type, portfolio = {}, gamma = 0, starting_cash=100000, lambda_a = 0.005,
+                                                    log_orders = False, random_state = None):
+
+    # Base class init.
+    super().__init__(id, name, type, starting_cash=starting_cash, log_orders=log_orders, random_state = random_state)
+
+    # Store important parameters particular to the ETF arbitrage agent.
+    self.inPrime = False                         # Determines if the agent also participates in the Primary ETF market
+    self.portfolio = portfolio                   # ETF portfolio
+    self.gamma = gamma                           # Threshold for difference between ETF and index to trade
+    self.messageCount = len(self.portfolio) + 1  # Tracks the number of messages sent so all limit orders are sent after
+                                                 # are sent after all mid prices are calculated
+    #self.q_max = q_max                          # max unit holdings
+    self.lambda_a = lambda_a                     # mean arrival rate of ETF arb agents (eventually change to a subscription)
+    
+    # NEED TO TEST IF THERE ARE SYMBOLS IN PORTFOLIO
+
+    # The agent uses this to track whether it has begun its strategy or is still
+    # handling pre-market tasks.
+    self.trading = False
+
+    # The agent begins in its "complete" state, not waiting for
+    # any special event or condition.
+    self.state = 'AWAITING_WAKEUP'
+    
+  def kernelStarting(self, startTime):
+    # self.kernel is set in Agent.kernelInitializing()
+    # self.exchangeID is set in TradingAgent.kernelStarting()
+
+    super().kernelStarting(startTime)
+
+    self.oracle = self.kernel.oracle
+
+
+  def kernelStopping (self):
+    # Always call parent method to be safe.
+    super().kernelStopping()
+
+    # Print end of day valuation.
+    H = {}
+    H['ETF'] = self.getHoldings('ETF')
+    for i,s in enumerate(self.portfolio):
+      H[s] = self.getHoldings(s)
+    print(H)
+    print(self.daily_close_price)
+
+
+  def wakeup (self, currentTime):
+    # Parent class handles discovery of exchange times and market_open wakeup call.
+    super().wakeup(currentTime)
+
+    self.state = 'INACTIVE'
+    
+    if not self.mkt_open or not self.mkt_close:
+      return
+    else:
+      if not self.trading:
+        self.trading = True
+        # Time to start trading!
+        log_print ("{} is ready to start trading now.", self.name)
+
+
+    # Steady state wakeup behavior starts here.
+    # If we've been told the market has closed for the day, we will only request
+    # final price information, then stop.
+    # If the market has closed and we haven't obtained the daily close price yet,
+    # do that before we cease activity for the day.  Don't do any other behavior
+    # after market close.
+    # If the calling agent is a subclass, don't initiate the strategy section of wakeup(), as it
+    # may want to do something different.
+    if self.mkt_closed and not self.inPrime:
+      for i,s in enumerate(self.portfolio):
+        if s not in self.daily_close_price:
+          self.getLastTrade(s)
+          self.state = 'AWAITING_LAST_TRADE'
+      if 'ETF' not in self.daily_close_price:
+        self.getLastTrade('ETF')
+        self.state = 'AWAITING_LAST_TRADE'
+      return
+
+    # Schedule a wakeup for the next time this agent should arrive at the market
+    # (following the conclusion of its current activity cycle).
+    # We do this early in case some of our expected message responses don't arrive.
+
+    # Agents should arrive according to a Poisson process.  This is equivalent to
+    # each agent independently sampling its next arrival time from an exponential
+    # distribution in alternate Beta formation with Beta = 1 / lambda, where lambda
+    # is the mean arrival rate of the Poisson process.
+    elif not self.inPrime:
+      delta_time = self.random_state.exponential(scale = 1.0 / self.lambda_a)
+      self.setWakeup(currentTime + pd.Timedelta('{}ns'.format(int(round(delta_time)))))
+
+      # Issue cancel requests for any open orders.  Don't wait for confirmation, as presently
+      # the only reason it could fail is that the order already executed.  (But requests won't
+      # be generated for those, anyway, unless something strange has happened.)
+      self.cancelOrders()
+
+
+      # The ETF arb agent DOES try to maintain a zero position, so there IS need to exit positions
+      # as some "active trading" agents might.  It might exit a position based on its order logic,
+      # but this will be as a natural consequence of its beliefs... but it submits marketable orders so...
+      for i,s in enumerate(self.portfolio):
+        self.getCurrentSpread(s)
+      self.getCurrentSpread('ETF')
+      self.state = 'AWAITING_SPREAD'
+
+    else:
+      self.state = 'ACTIVE'
+  
+  def getPriceEstimates(self):
+    index_mids = np.empty(len(self.portfolio))
+    index_p = {}
+    empty_mid = False
+    for i,s in enumerate(self.portfolio):
+      bid, bid_vol, ask, ask_vol = self.getKnownBidAsk(s)
+      if bid != None and ask != None:
+        index_p[s] = {'bid': bid, 'ask': ask}
+        mid = 0.5 * (int(bid) + int(ask))
+      else:
+        mid = float()
+        index_p[s] = {'bid': float(), 'ask': float()}
+        empty_mid = True
+      index_mids[i] = mid
+    bid, bid_vol, ask, ask_vol = self.getKnownBidAsk('ETF')
+    etf_p = {'bid': bid, 'ask': ask}
+    if bid != None and ask != None:
+      etf_mid = 0.5 * (int(bid) + int(ask))
+    else:
+      etf_mid = float()
+      empty_mid = True
+    index_mid = np.sum(index_mids)
+    return etf_mid, index_mid, etf_p, index_p, empty_mid
+
+  def placeOrder(self):
+    etf_mid, index_mid, etf_p, index_p, empty_mid  = self.getPriceEstimates()
+    if empty_mid:
+      #print('no move because index or ETF was missing part of NBBO')
+      pass
+    elif (index_mid - etf_mid) > self.gamma:
+      self.placeLimitOrder('ETF', 1, True, etf_p['ask'])
+    elif (etf_mid - index_mid) > self.gamma:
+      self.placeLimitOrder('ETF', 1, False, etf_p['bid'])
+    else:
+      pass
+      #print('no move because abs(index - ETF mid) < gamma')   
+    
+  def receiveMessage(self, currentTime, msg):
+    # Parent class schedules market open wakeup call once market open/close times are known.
+    super().receiveMessage(currentTime, msg)
+
+    # We have been awakened by something other than our scheduled wakeup.
+    # If our internal state indicates we were waiting for a particular event,
+    # check if we can transition to a new state.
+    
+    if self.state == 'AWAITING_SPREAD':
+      # We were waiting to receive the current spread/book.  Since we don't currently
+      # track timestamps on retained information, we rely on actually seeing a
+      # QUERY_SPREAD response message.
+
+      if msg.body['msg'] == 'QUERY_SPREAD':
+        # This is what we were waiting for.
+        self.messageCount -= 1
+
+        # But if the market is now closed, don't advance to placing orders.
+        if self.mkt_closed: return
+
+        # We now have the information needed to place a limit order with the eta
+        # strategic threshold parameter.
+        if self.messageCount == 0:
+          self.placeOrder()
+          self.messageCount = len(self.portfolio) + 1
+          self.state = 'AWAITING_WAKEUP'
+
+
+  # Internal state and logic specific to this agent subclass.
+
+  # Cancel all open orders.
+  # Return value: did we issue any cancellation requests?
+  def cancelOrders (self):
+    if not self.orders: return False
+
+    for id, order in self.orders.items():
+      self.cancelOrder(order)
+
+    return True
+    
+  def getWakeFrequency (self):
+    return pd.Timedelta(self.random_state.randint(low = 0, high = 100), unit='ns')

ABIDES/agent/etf/EtfMarketMakerAgent.py

@@ -0,0 +1,241 @@
+from agent.etf.EtfArbAgent import EtfArbAgent
+from agent.etf.EtfPrimaryAgent import EtfPrimaryAgent
+from message.Message import Message
+from util.order.etf.BasketOrder import BasketOrder
+from util.order.BasketOrder import BasketOrder
+from util.util import log_print
+
+import pandas as pd
+import sys
+
+class EtfMarketMakerAgent(EtfArbAgent):
+
+  def __init__(self, id, name, type, portfolio = {}, gamma = 0, starting_cash=100000, lambda_a = 0.005,
+                                                    log_orders = False, random_state = None):
+
+    # Base class init.
+    super().__init__(id, name, type, portfolio = portfolio, gamma = gamma, starting_cash=starting_cash,
+                     lambda_a = lambda_a, log_orders=log_orders, random_state = random_state)
+    
+    # NEED TO TEST IF THERE ARE SYMBOLS IN PORTFOLIO
+    
+    # Store important parameters particular to the ETF arbitrage agent.
+    self.inPrime = True                          # Determines if the agent also participates in the Primary ETF market
+    
+    # We don't yet know when the primary opens or closes.
+    self.prime_open = None
+    self.prime_close = None
+    
+    # Remember whether we have already passed the primary close time, as far
+    # as we know.
+    self.prime_closed = False
+    self.switched_mkt = False
+    
+  def kernelStarting(self, startTime):
+    # self.kernel is set in Agent.kernelInitializing()
+    # self.exchangeID is set in TradingAgent.kernelStarting()
+    
+    self.primeID = self.kernel.findAgentByType(EtfPrimaryAgent)
+
+    log_print ("Agent {} requested agent of type Agent.EtfPrimaryAgent.  Given Agent ID: {}",
+               self.id, self.primeID)
+
+    super().kernelStarting(startTime)
+    
+
+  def wakeup (self, currentTime):
+    # Parent class handles discovery of exchange times and market_open wakeup call.
+    super().wakeup(currentTime)
+    
+    # Only if the superclass leaves the state as ACTIVE should we proceed with our
+    # trading strategy.
+    if self.state != 'ACTIVE': return
+    
+    if not self.prime_open:
+      # Ask our primary when it opens and closes, exchange is handled in TradingAgent
+      self.sendMessage(self.primeID, Message({ "msg" : "WHEN_PRIME_OPEN", "sender": self.id }))
+      self.sendMessage(self.primeID, Message({ "msg" : "WHEN_PRIME_CLOSE", "sender": self.id }))
+
+
+    # Steady state wakeup behavior starts here.
+    if not self.mkt_closed and self.prime_closed:
+      print('The prime closed before the exchange')
+      sys.exit()
+    
+    elif self.mkt_closed and self.prime_closed:
+      return
+
+    # If we've been told the market has closed for the day, we will only request
+    # final price information, then stop.
+    # If the market has closed and we haven't obtained the daily close price yet,
+    # do that before we cease activity for the day.  Don't do any other behavior
+    # after market close.
+    elif self.mkt_closed and not self.prime_closed:
+      if self.switched_mkt and self.currentTime >= self.prime_open:
+        self.getEtfNav()
+        self.state = 'AWAITING_NAV'
+      elif not self.switched_mkt:
+        for i,s in enumerate(self.portfolio):
+          if s not in self.daily_close_price:
+            self.getLastTrade(s)
+            self.state = 'AWAITING_LAST_TRADE'
+        if 'ETF' not in self.daily_close_price:
+          self.getLastTrade('ETF')
+          self.state = 'AWAITING_LAST_TRADE'
+            
+        print('holdings before primary: ' + str(self.holdings))
+      
+        self.setWakeup(self.prime_open)
+        self.switched_mkt = True
+      else:
+        self.setWakeup(self.prime_open)
+      return
+
+    # Schedule a wakeup for the next time this agent should arrive at the market
+    # (following the conclusion of its current activity cycle).
+    # We do this early in case some of our expected message responses don't arrive.
+
+    # Agents should arrive according to a Poisson process.  This is equivalent to
+    # each agent independently sampling its next arrival time from an exponential
+    # distribution in alternate Beta formation with Beta = 1 / lambda, where lambda
+    # is the mean arrival rate of the Poisson process.
+    else:
+      delta_time = self.random_state.exponential(scale = 1.0 / self.lambda_a)
+      self.setWakeup(currentTime + pd.Timedelta('{}ns'.format(int(round(delta_time)))))
+
+      # Issue cancel requests for any open orders.  Don't wait for confirmation, as presently
+      # the only reason it could fail is that the order already executed.  (But requests won't
+      # be generated for those, anyway, unless something strange has happened.)
+      self.cancelOrders()
+
+
+      # The ETF arb agent DOES try to maintain a zero position, so there IS need to exit positions
+      # as some "active trading" agents might.  It might exit a position based on its order logic,
+      # but this will be as a natural consequence of its beliefs... but it submits marketable orders so...
+
+
+      # If the calling agent is a subclass, don't initiate the strategy section of wakeup(), as it
+      # may want to do something different.
+      # FIGURE OUT WHAT TO DO WITH MULTIPLE SPREADS...
+      for i,s in enumerate(self.portfolio):
+        self.getCurrentSpread(s)
+      self.getCurrentSpread('ETF')
+      self.state = 'AWAITING_SPREAD'
+
+  def placeOrder(self):
+    etf_mid, index_mid, etf_p, index_p, empty_mid  = self.getPriceEstimates()
+    if empty_mid:
+      #print('no move because index or ETF was missing part of NBBO')
+      pass
+    elif (index_mid - etf_mid) > self.gamma:
+      #print('buy ETF')
+      for i,s in enumerate(self.portfolio):
+        self.placeLimitOrder(s, 1, False, index_p[s]['bid'])
+      self.placeLimitOrder('ETF', 1, True, etf_p['ask'])
+    elif (etf_mid - index_mid) > self.gamma:
+      #print('sell ETF')
+      for i,s in enumerate(self.portfolio):
+        self.placeLimitOrder(s, 1, True, index_p[s]['ask'])
+      self.placeLimitOrder('ETF', 1, False, etf_p['bid'])
+    else:
+      pass
+      #print('no move because abs(index - ETF mid) < gamma') 
+    
+  def decideBasket(self):
+    print(self.portfolio)
+    index_est = 0
+    for i,s in enumerate(self.portfolio):
+      index_est += self.daily_close_price[s]
+    
+    H = {}
+    for i,s in enumerate(self.portfolio):
+      H[s] = self.getHoldings(s)
+    etf_h = self.getHoldings('ETF')
+    
+    self.nav_diff = self.nav - index_est
+    if self.nav_diff > 0:
+      if min(H.values()) > 0 and etf_h < 0:
+        print("send creation basket")
+        self.placeBasketOrder(min(H.values()), True)
+      else: print('wrong side for basket')
+    elif self.nav_diff < 0:
+      if etf_h > 0 and max(H.values()) < 0:
+        print("submit redemption basket")
+        self.placeBasketOrder(etf_h, False)
+      else: print('wrong side for basket')
+    else:
+      if min(H.values()) > 0 and etf_h < 0:
+        print("send creation basket")
+        self.placeBasketOrder(min(H.values()), True)
+      elif etf_h > 0 and max(H.values()) < 0:
+        print("submit redemption basket")
+        self.placeBasketOrder(etf_h, False)
+      
+    
+  def receiveMessage(self, currentTime, msg):
+    # Parent class schedules market open wakeup call once market open/close times are known.
+    super().receiveMessage(currentTime, msg)
+
+    # We have been awakened by something other than our scheduled wakeup.
+    # If our internal state indicates we were waiting for a particular event,
+    # check if we can transition to a new state.
+    
+    # Record market open or close times.
+    if msg.body['msg'] == "WHEN_PRIME_OPEN":
+      self.prime_open = msg.body['data']
+
+      log_print ("Recorded primary open: {}", self.kernel.fmtTime(self.prime_open))
+
+    elif msg.body['msg'] == "WHEN_PRIME_CLOSE":
+      self.prime_close = msg.body['data']
+
+      log_print ("Recorded primary close: {}", self.kernel.fmtTime(self.prime_close))
+
+    if self.state == 'AWAITING_NAV':
+      if msg.body['msg'] == 'QUERY_NAV':
+        if msg.body['prime_closed']: self.prime_closed = True
+        self.queryEtfNav(msg.body['nav'])
+
+        # But if the market is now closed, don't advance to placing orders.
+        if self.prime_closed: return
+
+        # We now have the information needed to place a C/R basket.
+        self.decideBasket()
+    
+    elif self.state == 'AWAITING_BASKET':
+      if msg.body['msg'] == 'BASKET_EXECUTED':
+        order = msg.body['order']
+        # We now have the information needed to place a C/R basket.
+        for i,s in enumerate(self.portfolio):
+          if order.is_buy_order: self.holdings[s] -= order.quantity
+          else: self.holdings[s] += order.quantity
+        if order.is_buy_order:
+          self.holdings['ETF'] += order.quantity
+          self.basket_size = order.quantity
+        else:
+          self.holdings['ETF'] -= order.quantity
+          self.basket_size = -1 * order.quantity
+      
+        self.state = 'INACTIVE'
+
+
+  # Internal state and logic specific to this agent subclass.
+
+  # Used by any ETF Arb Agent subclass to query the Net Assest Value (NAV) of the ETF.
+  # This activity is not logged.
+  def getEtfNav (self):
+    self.sendMessage(self.primeID, Message({ "msg" : "QUERY_NAV", "sender": self.id })) 
+    
+  # Used by ETF Arb Agent subclass to place a basket order.
+  # This activity is not logged.
+  def placeBasketOrder (self, quantity, is_create_order):
+    order = BasketOrder(self.id, self.currentTime, 'ETF', quantity, is_create_order)
+    print('BASKET ORDER PLACED: ' + str(order))
+    self.sendMessage(self.primeID, Message({ "msg" : "BASKET_ORDER", "sender": self.id,
+                                                  "order" : order })) 
+    self.state = 'AWAITING_BASKET'
+  
+  # Handles QUERY NAV messages from primary
+  def queryEtfNav(self, nav):
+    self.nav = nav
+    log_print ("Received NAV of ETF.")

ABIDES/agent/etf/EtfPrimaryAgent.py

@@ -0,0 +1,166 @@
+# The ExchangeAgent expects a numeric agent id, printable name, agent type, timestamp to open and close trading,
+# a list of equity symbols for which it should create order books, a frequency at which to archive snapshots
+# of its order books, a pipeline delay (in ns) for order activity, the exchange computation delay (in ns),
+# the levels of order stream history to maintain per symbol (maintains all orders that led to the last N trades),
+# whether to log all order activity to the agent log, and a random state object (already seeded) to use
+# for stochasticity.
+from agent.FinancialAgent import FinancialAgent
+from agent.ExchangeAgent import ExchangeAgent
+from message.Message import Message
+from util.util import log_print
+
+import pandas as pd
+pd.set_option('display.max_rows', 500)
+
+
+class EtfPrimaryAgent(FinancialAgent):
+
+  def __init__(self, id, name, type, prime_open, prime_close, symbol, pipeline_delay = 40000,
+               computation_delay = 1, random_state = None):
+
+    super().__init__(id, name, type, random_state)
+
+    # Do not request repeated wakeup calls.
+    self.reschedule = False
+
+    # Store this exchange's open and close times.
+    self.prime_open = prime_open
+    self.prime_close = prime_close
+    
+    self.mkt_close = None
+    
+    self.nav = 0
+    self.create = 0
+    self.redeem = 0
+    
+    self.symbol = symbol
+
+    # Right now, only the exchange agent has a parallel processing pipeline delay.  This is an additional
+    # delay added only to order activity (placing orders, etc) and not simple inquiries (market operating
+    # hours, etc).
+    self.pipeline_delay = pipeline_delay
+
+    # Computation delay is applied on every wakeup call or message received.
+    self.computation_delay = computation_delay
+   
+  def kernelStarting(self, startTime):
+    # Find an exchange with which we can place orders.  It is guaranteed
+    # to exist by now (if there is one).
+    self.exchangeID = self.kernel.findAgentByType(ExchangeAgent)
+
+    log_print ("Agent {} requested agent of type Agent.ExchangeAgent.  Given Agent ID: {}",
+               self.id, self.exchangeID)
+
+    # Request a wake-up call as in the base Agent.
+    super().kernelStarting(startTime)
+
+
+  def kernelStopping (self):
+    # Always call parent method to be safe.
+    super().kernelStopping()
+
+    print ("Final C/R baskets for {}: {} creation baskets. {} redemption baskets".format(self.name,
+                                                                                         self.create, self.redeem))
+
+
+  # Simulation participation messages.
+
+  def wakeup (self, currentTime):
+    super().wakeup(currentTime)
+
+    if self.mkt_close is None:
+      # Ask our exchange when it opens and closes.
+      self.sendMessage(self.exchangeID, Message({ "msg" : "WHEN_MKT_CLOSE", "sender": self.id }))
+        
+    else:
+      # Get close price of ETF/nav
+      self.getLastTrade(self.symbol)
+
+  def receiveMessage (self, currentTime, msg):
+    super().receiveMessage(currentTime, msg)
+
+    # Unless the intent of an experiment is to examine computational issues within an Exchange,
+    # it will typically have either 1 ns delay (near instant but cannot process multiple orders
+    # in the same atomic time unit) or 0 ns delay (can process any number of orders, always in
+    # the atomic time unit in which they are received).  This is separate from, and additional
+    # to, any parallel pipeline delay imposed for order book activity.
+
+    # Note that computation delay MUST be updated before any calls to sendMessage.
+    self.setComputationDelay(self.computation_delay)
+
+    # Is the exchange closed?  (This block only affects post-close, not pre-open.)
+    if currentTime > self.prime_close:
+      # Most messages after close will receive a 'PRIME_CLOSED' message in response.
+      log_print ("{} received {}, discarded: prime is closed.", self.name, msg.body['msg'])
+      self.sendMessage(msg.body['sender'], Message({ "msg": "PRIME_CLOSED" }))
+      # Don't do any further processing on these messages!
+      return
+
+    
+    if msg.body['msg'] == "WHEN_MKT_CLOSE":
+      self.mkt_close = msg.body['data']
+      log_print ("Recorded market close: {}", self.kernel.fmtTime(self.mkt_close))
+      self.setWakeup(self.mkt_close)
+      return
+    
+    elif msg.body['msg'] == 'QUERY_LAST_TRADE':
+      # Call the queryLastTrade method.
+      self.queryLastTrade(msg.body['symbol'], msg.body['data'])
+      return
+
+    self.logEvent(msg.body['msg'], msg.body['sender'])
+
+    # Handle all message types understood by this exchange.
+    if msg.body['msg'] == "WHEN_PRIME_OPEN":
+      log_print ("{} received WHEN_PRIME_OPEN request from agent {}", self.name, msg.body['sender'])
+
+      # The exchange is permitted to respond to requests for simple immutable data (like "what are your
+      # hours?") instantly.  This does NOT include anything that queries mutable data, like equity
+      # quotes or trades.
+      self.setComputationDelay(0)
+
+      self.sendMessage(msg.body['sender'], Message({ "msg": "WHEN_PRIME_OPEN", "data": self.prime_open }))
+        
+    elif msg.body['msg'] == "WHEN_PRIME_CLOSE":
+      log_print ("{} received WHEN_PRIME_CLOSE request from agent {}", self.name, msg.body['sender'])
+
+      # The exchange is permitted to respond to requests for simple immutable data (like "what are your
+      # hours?") instantly.  This does NOT include anything that queries mutable data, like equity
+      # quotes or trades.
+      self.setComputationDelay(0)
+
+      self.sendMessage(msg.body['sender'], Message({ "msg": "WHEN_PRIME_CLOSE", "data": self.prime_close }))
+        
+    elif msg.body['msg'] == "QUERY_NAV":
+      log_print ("{} received QUERY_NAV ({}) request from agent {}", self.name, msg.body['sender'])
+
+      # Return the NAV for the requested symbol.
+      self.sendMessage(msg.body['sender'], Message({ "msg": "QUERY_NAV",
+           "nav": self.nav, "prime_closed": True if currentTime > self.prime_close else False }))
+        
+    elif msg.body['msg'] == "BASKET_ORDER":
+      order = msg.body['order']
+      log_print ("{} received BASKET_ORDER: {}", self.name, order)
+      if order.is_buy_order: self.create += 1
+      else: self.redeem += 1
+      order.fill_price = self.nav
+      self.sendMessage(msg.body['sender'], Message({ "msg": "BASKET_EXECUTED", "order": order}))
+  
+
+  # Handles QUERY_LAST_TRADE messages from an exchange agent.
+  def queryLastTrade (self, symbol, price):
+    self.nav = price
+    log_print ("Received daily close price or nav of {} for {}.", price, symbol)
+                       
+  # Used by any Trading Agent subclass to query the last trade price for a symbol.
+  # This activity is not logged.
+  def getLastTrade (self, symbol):
+    self.sendMessage(self.exchangeID, Message({ "msg" : "QUERY_LAST_TRADE", "sender": self.id,
+                                                "symbol" : symbol })) 
+
+  # Simple accessor methods for the market open and close times.
+  def getPrimeOpen(self):
+    return self.__prime_open
+
+  def getPrimeClose(self):
+    return self.__prime_close

ABIDES/agent/examples/ExampleExperimentalAgent.py

@@ -0,0 +1,146 @@
+from agent.examples.SubscriptionAgent import SubscriptionAgent
+import pandas as pd
+from copy import deepcopy
+
+
+class ExampleExperimentalAgentTemplate(SubscriptionAgent):
+    """ Minimal working template for an experimental trading agent
+    """
+    def __init__(self, id, name, type, symbol, starting_cash, levels, subscription_freq, log_orders=False, random_state=None):
+        """  Constructor for ExampleExperimentalAgentTemplate.
+
+        :param id: Agent's ID as set in config
+        :param name: Agent's human-readable name as set in config
+        :param type: Agent's human-readable type as set in config, useful for grouping agents semantically
+        :param symbol: Name of asset being traded
+        :param starting_cash: Dollar amount of cash agent starts with.
+        :param levels: Number of levels of orderbook to subscribe to
+        :param subscription_freq: Frequency of orderbook updates subscribed to (in nanoseconds)
+        :param log_orders: bool to decide if agent's individual actions logged to file.
+        :param random_state: numpy RandomState object from which agent derives randomness
+        """
+        super().__init__(id, name, type, symbol, starting_cash, levels, subscription_freq, log_orders=log_orders, random_state=random_state)
+
+        self.current_bids = None  # subscription to market data populates this list
+        self.current_asks = None  # subscription to market data populates this list
+
+    def wakeup(self, currentTime):
+        """ Action to be taken by agent at each wakeup.
+
+            :param currentTime: pd.Timestamp for current simulation time
+        """
+        super().wakeup(currentTime)
+        self.setWakeup(currentTime + self.getWakeFrequency())
+
+    def receiveMessage(self, currentTime, msg):
+        """ Action taken when agent receives a message from the exchange
+
+        :param currentTime: pd.Timestamp for current simulation time
+        :param msg: message from exchange
+        :return:
+        """
+        super().receiveMessage(currentTime, msg)  # receives subscription market data
+
+    def getWakeFrequency(self):
+        """ Set next wakeup time for agent. """
+        return pd.Timedelta("1min")
+
+    def placeLimitOrder(self, quantity, is_buy_order, limit_price):
+        """ Place a limit order at the exchange.
+          :param quantity (int):      order quantity
+          :param is_buy_order (bool): True if Buy else False
+          :param limit_price: price level at which to place a limit order
+          :return:
+        """
+        super().placeLimitOrder(self.symbol, quantity, is_buy_order, limit_price)
+
+    def placeMarketOrder(self, quantity, is_buy_order):
+        """ Place a market order at the exchange.
+          :param quantity (int):      order quantity
+          :param is_buy_order (bool): True if Buy else False
+          :return:
+        """
+        super().placeMarketOrder(self.symbol, quantity, is_buy_order)
+
+    def cancelAllOrders(self):
+        """ Cancels all resting limit orders placed by the experimental agent.
+        """
+        for _, order in self.orders.items():
+            self.cancelOrder(order)
+
+
+class ExampleExperimentalAgent(ExampleExperimentalAgentTemplate):
+
+    def __init__(self, *args, wake_freq, order_size, short_window, long_window, **kwargs):
+        """
+        :param args: superclass args
+        :param wake_freq: Frequency of wakeup -- str to be parsed by pd.Timedelta
+        :param order_size: size of orders to place
+        :param short_window: length of mid price short moving average window -- str to be parsed by pd.Timedelta
+        :param long_window: length of mid price long moving average window -- str to be parsed by pd.Timedelta
+        :param kwargs: superclass kwargs
+        """
+        super().__init__(*args, **kwargs)
+        self.wake_freq = wake_freq
+        self.order_size = order_size
+        self.short_window = short_window
+        self.long_window = long_window
+        self.mid_price_history = pd.DataFrame(columns=['mid_price'], index=pd.to_datetime([]))
+
+    def getCurrentMidPrice(self):
+        """ Retrieve mid price from most recent subscription data.
+
+        :return:
+        """
+
+        try:
+            best_bid = self.current_bids[0][0]
+            best_ask = self.current_asks[0][0]
+            return round((best_ask + best_bid) / 2)
+        except (TypeError, IndexError):
+            return None
+
+    def receiveMessage(self, currentTime, msg):
+        """ Action taken when agent receives a message from the exchange -- action here is for agent to update internal
+            log of most recently observed mid-price.
+
+        :param currentTime: pd.Timestamp for current simulation time
+        :param msg: message from exchange
+        :return:
+        """
+        super().receiveMessage(currentTime, msg)  # receives subscription market data
+        self.mid_price_history = self.mid_price_history.append(
+            pd.Series({'mid_price': self.getCurrentMidPrice()}, name=currentTime))
+        self.mid_price_history.dropna(inplace=True)
+
+    def computeMidPriceMovingAverages(self):
+        """ Returns the short-window and long-window moving averages of mid price.
+        :return:
+        """
+        try:
+            short_moving_avg = self.mid_price_history.rolling(self.short_window).mean().iloc[-1]['mid_price']
+            long_moving_avg = self.mid_price_history.rolling(self.long_window).mean().iloc[-1]['mid_price']
+            return short_moving_avg, long_moving_avg
+        except IndexError:
+            return None, None
+
+    def wakeup(self, currentTime):
+        """ Action to be taken by agent at each wakeup.
+
+            :param currentTime: pd.Timestamp for current simulation time
+        """
+        super().wakeup(currentTime)
+        short_moving_avg, long_moving_avg = self.computeMidPriceMovingAverages()
+        if short_moving_avg is not None and long_moving_avg is not None:
+            if short_moving_avg > long_moving_avg:
+                self.placeMarketOrder(self.order_size, 0)
+            elif short_moving_avg < long_moving_avg:
+                self.placeMarketOrder(self.order_size, 1)
+
+    def getWakeFrequency(self):
+        """ Set next wakeup time for agent. """
+        return pd.Timedelta(self.wake_freq)
+
+
+
+

ABIDES/agent/examples/ImpactAgent.py

@@ -0,0 +1,160 @@
+from agent.TradingAgent import TradingAgent
+
+import pandas as pd
+
+
+class ImpactAgent(TradingAgent):
+
+  def __init__(self, id, name, type, symbol = None, starting_cash = None, greed = None, within = 0.01,
+               impact = True, impact_time = None, random_state = None):
+    # Base class init.
+    super().__init__(id, name, type, starting_cash = starting_cash, random_state = random_state)
+
+    self.symbol = symbol    # symbol to trade
+    self.trading = False    # ready to trade
+    self.traded = False     # has made its one trade
+
+    # The amount of available "nearby" liquidity to consume when placing its order.
+    self.greed = greed      # trade this proportion of liquidity
+    self.within = within    # within this range of the inside price
+
+    # When should we make the impact trade?
+    self.impact_time = impact_time
+
+    # The agent begins in its "complete" state, not waiting for
+    # any special event or condition.
+    self.state = 'AWAITING_WAKEUP'
+
+    # Controls whether the impact trade is actually placed.
+    self.impact = impact
+
+
+  def wakeup (self, currentTime):
+    # Parent class handles discovery of exchange times and market_open wakeup call.
+    super().wakeup(currentTime)
+
+    if not self.mkt_open or not self.mkt_close:
+      # TradingAgent handles discovery of exchange times.
+      return
+    else:
+      if not self.trading:
+        self.trading = True
+
+        # Time to start trading!
+        print ("{} is ready to start trading now.".format(self.name))
+
+
+    # Steady state wakeup behavior starts here.
+
+    # First, see if we have received a MKT_CLOSED message for the day.  If so,
+    # there's nothing to do except clean-up.
+    if self.mkt_closed and (self.symbol in self.daily_close_price):
+      # Market is closed and we already got the daily close price.
+      return
+
+
+    ### Impact agent operates at a specific time.
+    if currentTime < self.impact_time:
+      print ("Impact agent waiting for impact_time {}".format(self.impact_time))
+      self.setWakeup(self.impact_time)
+      return
+
+
+    ### The impact agent only trades once, but we will monitor prices for
+    ### the sake of performance.
+    self.setWakeup(currentTime + pd.Timedelta('30m'))
+
+
+    # If the market is closed and we haven't obtained the daily close price yet,
+    # do that before we cease activity for the day.  Don't do any other behavior
+    # after market close.
+    #
+    # Also, if we already made our one trade, do nothing except monitor prices.
+    if self.traded or (self.mkt_closed and (not self.symbol in self.daily_close_price)):
+      self.getLastTrade()
+      self.state = 'AWAITING_LAST_TRADE'
+      return
+
+
+    # The impact agent will place one order based on the current spread.
+    self.getCurrentSpread()
+    self.state = 'AWAITING_SPREAD'
+
+
+  def receiveMessage (self, currentTime, msg):
+    # Parent class schedules market open wakeup call once market open/close times are known.
+    super().receiveMessage(currentTime, msg)
+
+    # We have been awakened by something other than our scheduled wakeup.
+    # If our internal state indicates we were waiting for a particular event,
+    # check if we can transition to a new state.
+
+    if self.state == 'AWAITING_SPREAD':
+      # We were waiting for current spread information to make our trade.
+      # If the message we just received is QUERY_SPREAD, that means we just got it.
+      if msg.body['msg'] == 'QUERY_SPREAD':
+        # Place our one trade.
+        bid, bid_vol, ask, ask_vol = self.getKnownBidAsk(self.symbol)
+        bid_liq, ask_liq = self.getKnownLiquidity(self.symbol, within=self.within)
+
+        # Buy order.
+        direction, shares, price = True, int(round(ask_liq * self.greed)), ask
+
+        # Sell order.  This should be a parameter, but isn't yet.
+        #direction, shares, price = False, int(round(bid_liq * self.greed)), bid
+
+        # Compute the limit price we must offer to ensure our order executes immediately.
+        # This is essentially a workaround for the lack of true market orders in our
+        # current simulation.
+        price = self.computeRequiredPrice(direction, shares)
+
+        # Actually place the order only if self.impact is true.
+        if self.impact: 
+          print ("Impact agent firing: {} {} @ {}".format('BUY' if direction else 'SELL', shares, self.dollarize(price)))
+          self.placeLimitOrder (self.symbol, shares, direction, price)
+        else:
+          print ("Impact agent would fire: {} {} @ {} (but self.impact = False)".format('BUY' if direction else 'SELL', shares, self.dollarize(price)))
+
+        self.traded = True
+        self.state = 'AWAITING_WAKEUP'
+
+
+  # Internal state and logic specific to this agent.
+
+  def placeLimitOrder (self, symbol, quantity, is_buy_order, limit_price):
+    super().placeLimitOrder(symbol, quantity, is_buy_order, limit_price, ignore_risk = True)
+
+  # Computes required limit price to immediately execute a trade for the specified quantity
+  # of shares.
+  def computeRequiredPrice (self, direction, shares):
+    book = self.known_asks[self.symbol] if direction else self.known_bids[self.symbol]
+
+    # Start at the inside and add up the shares.
+    t = 0
+
+    for i in range(len(book)):
+      p,v = book[i]
+      t += v
+
+      # If we have accumulated enough shares, return this price.
+      if t >= shares: return p
+
+    # Not enough shares.  Just return worst price (highest ask, lowest bid).
+    return book[-1][0]
+
+
+  # Request the last trade price for our symbol.
+  def getLastTrade (self):
+    super().getLastTrade(self.symbol)
+
+
+  # Request the spread for our symbol.
+  def getCurrentSpread (self):
+    # Impact agent gets depth 10000 on each side (probably everything).
+    super().getCurrentSpread(self.symbol, 10000)
+
+
+  def getWakeFrequency (self):
+    return (pd.Timedelta('1ns'))
+
+

ABIDES/agent/examples/MarketReplayAgent.py

@@ -0,0 +1,125 @@
+import pickle
+import os.path
+from datetime import datetime
+import pandas as pd
+#from joblib import Memory
+
+from agent.TradingAgent import TradingAgent
+from util.order.LimitOrder import LimitOrder
+from util.util import log_print
+
+
+class MarketReplayAgent(TradingAgent):
+
+    def __init__(self, id, name, type, symbol, date, start_time, end_time,
+                 orders_file_path, processed_orders_folder_path,
+                 starting_cash, log_orders=False, random_state=None):
+        super().__init__(id, name, type, starting_cash=starting_cash, log_orders=log_orders, random_state=random_state)
+        self.symbol = symbol
+        self.date = date
+        self.log_orders = log_orders
+        self.executed_trades = dict()
+        self.state = 'AWAITING_WAKEUP'
+
+        self.historical_orders = L3OrdersProcessor(self.symbol,
+                                                   self.date, start_time, end_time,
+                                                   orders_file_path, processed_orders_folder_path)
+        self.wakeup_times = self.historical_orders.wakeup_times
+
+    def wakeup(self, currentTime):
+        super().wakeup(currentTime)
+        if not self.mkt_open or not self.mkt_close:
+            return
+        try:
+            self.setWakeup(self.wakeup_times[0])
+            self.wakeup_times.pop(0)
+            self.placeOrder(currentTime, self.historical_orders.orders_dict[currentTime])
+        except IndexError:
+            log_print(f"Market Replay Agent submitted all orders - last order @ {currentTime}")
+
+    def receiveMessage(self, currentTime, msg):
+        super().receiveMessage(currentTime, msg)
+        if msg.body['msg'] == 'ORDER_EXECUTED':
+            order = msg.body['order']
+            self.executed_trades[currentTime] = [order.fill_price, order.quantity]
+            self.last_trade[self.symbol] = order.fill_price
+
+    def placeOrder(self, currentTime, order):
+        if len(order) == 1:
+            order = order[0]
+            order_id = order['ORDER_ID']
+            existing_order = self.orders.get(order_id)
+            if not existing_order and order['SIZE'] > 0:
+                self.placeLimitOrder(self.symbol, order['SIZE'], order['BUY_SELL_FLAG'] == 'BUY', order['PRICE'],
+                                     order_id=order_id)
+            elif existing_order and order['SIZE'] == 0:
+                self.cancelOrder(existing_order)
+            elif existing_order:
+                self.modifyOrder(existing_order, LimitOrder(self.id, currentTime, self.symbol, order['SIZE'],
+                                                            order['BUY_SELL_FLAG'] == 'BUY', order['PRICE'],
+                                                            order_id=order_id))
+        else:
+            for ind_order in order:
+                self.placeOrder(currentTime, order=[ind_order])
+
+    def getWakeFrequency(self):
+        log_print(f"Market Replay Agent first wake up: {self.historical_orders.first_wakeup}")
+        return self.historical_orders.first_wakeup - self.mkt_open
+
+
+#mem = Memory(cachedir='./cache', verbose=0)
+
+
+class L3OrdersProcessor:
+    COLUMNS = ['TIMESTAMP', 'ORDER_ID', 'PRICE', 'SIZE', 'BUY_SELL_FLAG']
+    DIRECTION = {0: 'BUY', 1: 'SELL'}
+
+    # Class for reading historical exchange orders stream
+    def __init__(self, symbol, date, start_time, end_time, orders_file_path, processed_orders_folder_path):
+        self.symbol = symbol
+        self.date = date
+        self.start_time = start_time
+        self.end_time = end_time
+        self.orders_file_path = orders_file_path
+        self.processed_orders_folder_path = processed_orders_folder_path
+
+        self.orders_dict = self.processOrders()
+        self.wakeup_times = [*self.orders_dict]
+        self.first_wakeup = self.wakeup_times[0]
+
+    def processOrders(self):
+        def convertDate(date_str):
+            try:
+                return datetime.strptime(date_str, '%Y%m%d%H%M%S.%f')
+            except ValueError:
+                return convertDate(date_str[:-1])
+
+        #@mem.cache
+        def read_processed_orders_file(processed_orders_file):
+            with open(processed_orders_file, 'rb') as handle:
+                return pickle.load(handle)
+
+        processed_orders_file = f'{self.processed_orders_folder_path}marketreplay_{self.symbol}_{self.date.date()}.pkl'
+        if os.path.isfile(processed_orders_file):
+            print(f'Processed file exists for {self.symbol} and {self.date.date()}: {processed_orders_file}')
+            return read_processed_orders_file(processed_orders_file)
+        else:
+            print(f'Processed file does not exist for {self.symbol} and {self.date.date()}, processing...')
+            orders_df = pd.read_csv(self.orders_file_path).iloc[1:]
+            all_columns = orders_df.columns[0].split('|')
+            orders_df = orders_df[orders_df.columns[0]].str.split('|', 16, expand=True)
+            orders_df.columns = all_columns
+            orders_df = orders_df[L3OrdersProcessor.COLUMNS]
+            orders_df['BUY_SELL_FLAG'] = orders_df['BUY_SELL_FLAG'].astype(int).replace(L3OrdersProcessor.DIRECTION)
+            orders_df['TIMESTAMP'] = orders_df['TIMESTAMP'].astype(str).apply(convertDate)
+            orders_df['SIZE'] = orders_df['SIZE'].astype(int)
+            orders_df['PRICE'] = orders_df['PRICE'].astype(float) * 100
+            orders_df['PRICE'] = orders_df['PRICE'].astype(int)
+            orders_df = orders_df.loc[(orders_df.TIMESTAMP >= self.start_time) & (orders_df.TIMESTAMP < self.end_time)]
+            orders_df.set_index('TIMESTAMP', inplace=True)
+            log_print(f"Number of Orders: {len(orders_df)}")
+            orders_dict = {k: g.to_dict(orient='records') for k, g in orders_df.groupby(level=0)}
+            with open(processed_orders_file, 'wb') as handle:
+                pickle.dump(orders_dict, handle, protocol=pickle.HIGHEST_PROTOCOL)
+                print(f'processed file created as {processed_orders_file}')
+            return orders_dict

ABIDES/agent/examples/MomentumAgent.py

@@ -0,0 +1,80 @@
+from agent.TradingAgent import TradingAgent
+import pandas as pd
+import numpy as np
+
+
+class MomentumAgent(TradingAgent):
+    """
+    Simple Trading Agent that compares the 20 past mid-price observations with the 50 past observations and places a
+    buy limit order if the 20 mid-price average >= 50 mid-price average or a
+    sell limit order if the 20 mid-price average < 50 mid-price average
+    """
+
+    def __init__(self, id, name, type, symbol, starting_cash,
+                 min_size, max_size, wake_up_freq='60s',
+                 subscribe=False, log_orders=False, random_state=None, wakeup_time=None):
+
+        super().__init__(id, name, type, starting_cash=starting_cash, log_orders=log_orders, random_state=random_state)
+        self.symbol = symbol
+        self.wakeup_time = wakeup_time
+        self.min_size = min_size  # Minimum order size
+        self.max_size = max_size  # Maximum order size
+        self.size = self.random_state.randint(self.min_size, self.max_size)
+        self.wake_up_freq = wake_up_freq
+        self.subscribe = subscribe  # Flag to determine whether to subscribe to data or use polling mechanism
+        self.subscription_requested = False
+        self.mid_list, self.avg_20_list, self.avg_50_list = [], [], []
+        self.log_orders = log_orders
+        self.state = "AWAITING_WAKEUP"
+
+    def kernelStarting(self, startTime):
+        super().kernelStarting(startTime)
+
+    def wakeup(self, currentTime):
+        """ Agent wakeup is determined by self.wake_up_freq """
+        can_trade = super().wakeup(currentTime)
+        if self.subscribe and not self.subscription_requested:
+            super().requestDataSubscription(self.symbol, levels=1, freq=10e9)
+            self.subscription_requested = True
+            self.state = 'AWAITING_MARKET_DATA'
+        elif can_trade and not self.subscribe:
+            self.getCurrentSpread(self.symbol)
+            self.state = 'AWAITING_SPREAD'
+
+    def receiveMessage(self, currentTime, msg):
+        """ Momentum agent actions are determined after obtaining the best bid and ask in the LOB """
+        super().receiveMessage(currentTime, msg)
+        if not self.subscribe and self.state == 'AWAITING_SPREAD' and msg.body['msg'] == 'QUERY_SPREAD':
+            bid, _, ask, _ = self.getKnownBidAsk(self.symbol)
+            self.placeOrders(currentTime, bid, ask)
+            self.setWakeup(currentTime + self.getWakeFrequency())
+            self.state = 'AWAITING_WAKEUP'
+        elif currentTime < self.wakeup_time:
+            return
+        elif self.subscribe and self.state == 'AWAITING_MARKET_DATA' and msg.body['msg'] == 'MARKET_DATA':
+            bids, asks = self.known_bids[self.symbol], self.known_asks[self.symbol]
+            if bids and asks: self.placeOrders(currentTime, bids[0][0], asks[0][0])
+            self.state = 'AWAITING_MARKET_DATA'
+
+    def placeOrders(self, currentTime, bid, ask):
+        """ Momentum Agent actions logic """
+        #if currentTime < self.wakeup_time:
+        #    return
+        if bid and ask:
+            self.mid_list.append((bid + ask) / 2)
+            if len(self.mid_list) > 20: self.avg_20_list.append(MomentumAgent.ma(self.mid_list, n=20)[-1].round(2))
+            if len(self.mid_list) > 50: self.avg_50_list.append(MomentumAgent.ma(self.mid_list, n=50)[-1].round(2))
+            if len(self.avg_20_list) > 0 and len(self.avg_50_list) > 0:
+                if self.avg_20_list[-1] >= self.avg_50_list[-1]:
+                    self.placeLimitOrder(self.symbol, quantity=self.size, is_buy_order=True, limit_price=ask)
+                else:
+                    self.placeLimitOrder(self.symbol, quantity=self.size, is_buy_order=False, limit_price=bid)
+
+    def getWakeFrequency(self):
+        return pd.Timedelta(self.wake_up_freq)
+
+    @staticmethod
+    def ma(a, n=20):
+        ret = np.cumsum(a, dtype=float)
+        ret[n:] = ret[n:] - ret[:-n]
+        return ret[n - 1:] / n

ABIDES/agent/examples/QLearningAgent.py

@@ -0,0 +1,213 @@
+from agent.TradingAgent import TradingAgent
+from message.Message import Message
+from util.util import log_print
+
+import numpy as np
+import pandas as pd
+import sys
+
+class QLearningAgent(TradingAgent):
+
+  def __init__(self, id, name, type, symbol='IBM', starting_cash=100000,
+                     qtable = None, log_orders = False, random_state = None):
+
+    # Base class init.
+    super().__init__(id, name, type, starting_cash=starting_cash, log_orders=log_orders, random_state = random_state)
+
+    # Store important parameters particular to the QLearning agent.
+    self.symbol = symbol
+    self.qtable = qtable
+
+    # The agent uses this to track whether it has begun its strategy or is still
+    # handling pre-market tasks.
+    self.trading = False
+
+    # The agent begins in its "complete" state, not waiting for
+    # any special event or condition.
+    self.state = 'AWAITING_WAKEUP'
+
+    # The agent tracks an experience history to sample and learn from over time.
+    # Tuples of (s,a,s',r).  This is not currently used (nor part of the saved state).
+    self.experience = []
+
+    # Remember prior state, action, and portfolio value (marked to market).
+    self.s = None
+    self.a = None
+    self.v = None
+
+
+
+  # During kernelStopping, give the Kernel our saved state for potential
+  # subsequent simulations during the same experiment.
+  def kernelStopping (self):
+    super().kernelStopping()
+    self.updateAgentState(self.qtable)
+
+
+  def wakeup (self, currentTime):
+    # Parent class handles discovery of exchange times and market_open wakeup call.
+    super().wakeup(currentTime)
+
+    self.state = 'INACTIVE'
+
+    if not self.mkt_open or not self.mkt_close:
+      # TradingAgent handles discovery of exchange times.
+      return
+    else:
+      if not self.trading:
+        self.trading = True
+
+        # Time to start trading!
+        log_print ("{} is ready to start trading now.", self.name)
+
+
+    # Steady state wakeup behavior starts here.
+
+    # If we've been told the market has closed for the day, we will only request
+    # final price information, then stop.
+    if self.mkt_closed and (self.symbol in self.daily_close_price):
+      # Market is closed and we already got the daily close price.
+      return
+
+
+    # Schedule a wakeup for the next time this agent should arrive at the market
+    # (following the conclusion of its current activity cycle).
+    # We do this early in case some of our expected message responses don't arrive.
+
+    # The QLearning agent is not a background agent, so it should select strategically
+    # appropriate times.  (Maybe we should LEARN the best times or frequencies at which
+    # to trade, someday.)  Presently it just trades once a minute.
+    self.setWakeup(currentTime + pd.Timedelta('1min'))
+ 
+    # If the market has closed and we haven't obtained the daily close price yet,
+    # do that before we cease activity for the day.  Don't do any other behavior
+    # after market close.
+    if self.mkt_closed and (not self.symbol in self.daily_close_price):
+      self.getCurrentSpread(self.symbol)
+      self.state = 'AWAITING_SPREAD'
+      return
+
+    # Cancel unfilled orders (but don't exit positions).
+    self.cancelOrders()
+
+    # Get the order book or whatever else we need for the state.
+    self.getCurrentSpread(self.symbol, depth=1000)
+    self.state = 'AWAITING_SPREAD'
+
+
+
+  def placeOrder (self):
+    # Called when it is time for the agent to determine a limit price and place an order.
+
+    # Compute the order imbalance feature.
+    bid_vol = sum([ v[1] for v in self.known_bids[self.symbol] ])
+    ask_vol = sum([ v[1] for v in self.known_asks[self.symbol] ])
+    imba = bid_vol - ask_vol
+
+    # A unit of stock is now 100 shares instead of one.
+    imba = int(imba / 100)
+
+    # Get our current holdings in the stock of interest.
+    h = self.getHoldings(self.symbol)
+    
+    # The new state will be called s_prime.  This agent simply uses current
+    # holdings (limit: one share long or short) and offer volume imbalance.
+    # State: 1000s digit is 0 (short), 1 (neutral), 2 (long).  Remaining digits
+    #        are 000 (-100 imba) to 200 (+100 imba).
+    s_prime = ((h + 1) * 1000) + (imba + 100)
+
+    log_print ("h: {}, imba: {}, s_prime: {}", h, imba, s_prime)
+
+    # Compute our reward from last time.  We estimate the change in the value
+    # of our portfolio by marking it to market and comparing against the last
+    # time we were contemplating an action.
+    v = self.markToMarket(self.holdings, use_midpoint=True)
+    r = v - self.v if self.v is not None else 0
+
+    # Store our experience tuple.
+    self.experience.append((self.s, self.a, s_prime, r))
+
+    # Update our q table.
+    old_q = self.qtable.q[self.s, self.a]
+    old_weighted = (1 - self.qtable.alpha) * old_q
+
+    a_prime = np.argmax(self.qtable.q[s_prime,:])
+    new_q = r + (self.qtable.gamma * self.qtable.q[s_prime, a_prime])
+    new_weighted = self.qtable.alpha * new_q
+
+    self.qtable.q[self.s, self.a] = old_weighted + new_weighted
+
+
+    # Decay alpha.
+    self.qtable.alpha *= self.qtable.alpha_decay
+    self.qtable.alpha = max(self.qtable.alpha, self.qtable.alpha_min)
+
+
+    # Compute our next action.  0 = sell one, 1 == do nothing, 2 == buy one.
+    if self.random_state.rand() < self.qtable.epsilon:
+      # Random action, and decay epsilon.
+      a = self.random_state.randint(0,3)
+      self.qtable.epsilon *= self.qtable.epsilon_decay
+      self.qtable.epsilon = max(self.qtable.epsilon, self.qtable.epsilon_min)
+    else:
+      # Expected best action.
+      a = a_prime
+
+    # Respect holding limit.
+    if a == 0 and h == -1:  a = 1
+    elif a == 2 and h == 1: a = 1
+
+
+    # Remember s, a, and v for next time.
+    self.s = s_prime
+    self.a = a
+    self.v = v
+
+
+    # Place the order.  We probably want this to be a market order, once supported,
+    # or use a "compute required price for guaranteed execution" function like the
+    # impact agent, but that requires fetching quite a bit of book depth.
+    if a == 0:   self.placeLimitOrder(self.symbol, 1, False, 50000)
+    elif a == 2: self.placeLimitOrder(self.symbol, 1, True, 200000)
+
+
+  def receiveMessage (self, currentTime, msg):
+    # Parent class schedules market open wakeup call once market open/close times are known.
+    super().receiveMessage(currentTime, msg)
+
+    # We have been awakened by something other than our scheduled wakeup.
+    # If our internal state indicates we were waiting for a particular event,
+    # check if we can transition to a new state.
+
+    if self.state == 'AWAITING_SPREAD':
+      # We were waiting to receive the current spread/book.  Since we don't currently
+      # track timestamps on retained information, we rely on actually seeing a
+      # QUERY_SPREAD response message.
+
+      if msg.body['msg'] == 'QUERY_SPREAD':
+        # This is what we were waiting for.
+
+        # But if the market is now closed, don't advance to placing orders.
+        if self.mkt_closed: return
+
+        # We now have the information needed to place a limit order with the eta
+        # strategic threshold parameter.
+        self.placeOrder()
+        self.state = 'AWAITING_WAKEUP'
+
+
+  # Internal state and logic specific to this agent subclass.
+
+  # Cancel all open orders.
+  # Return value: did we issue any cancellation requests?
+  def cancelOrders (self):
+    if not self.orders: return False
+
+    for id, order in self.orders.items():
+      self.cancelOrder(order)
+
+    return True
+
+  def getWakeFrequency (self):
+    return pd.Timedelta(self.random_state.randint(low = 0, high = 100), unit='ns')
+

ABIDES/agent/examples/ShockAgent.py

@@ -0,0 +1,171 @@
+from agent.TradingAgent import TradingAgent
+
+import pandas as pd
+
+
+# Extends Impact agent to fire large order evenly over a predetermined time period
+# Need to add: (1) duration, (2) number of wakeups, (3) desired execution size
+class ImpactAgent(TradingAgent):
+
+  def __init__(self, id, name, type, symbol = None, starting_cash = None, within = 0.01,
+               impact = True, impact_time = None, impact_duration = 0, impact_trades = 0,
+               impact_vol = None, random_state = None):
+    # Base class init.
+    super().__init__(id, name, type, starting_cash = starting_cash, random_state = random_state)
+
+    self.symbol = symbol    # symbol to trade
+    self.trading = False    # ready to trade
+    self.traded = False     # has made its t trade
+
+    # The amount of available "nearby" liquidity to consume when placing its order.
+    self.within = within    # within this range of the inside price
+
+    self.impact_time = impact_time          # When should we make the impact trade?
+    self.impact_duration = impact_duration  # How long the agent should wait to submit the next trade
+    self.impact_trades = impact_trades      # The number of trades to execute across
+    self.impact_vol = impact_vol            # The total volume to execute across all trades
+
+    # The agent begins in its "complete" state, not waiting for
+    # any special event or condition.
+    self.state = 'AWAITING_WAKEUP'
+
+    # Controls whether the impact trade is actually placed.
+    self.impact = impact
+
+
+  def wakeup (self, currentTime):
+    # Parent class handles discovery of exchange times and market_open wakeup call.
+    super().wakeup(currentTime)
+
+    if not self.mkt_open or not self.mkt_close:
+      # TradingAgent handles discovery of exchange times.
+      return
+    else:
+      if not self.trading:
+        self.trading = True
+
+        # Time to start trading!
+        print ("{} is ready to start trading now.".format(self.name))
+
+
+    # Steady state wakeup behavior starts here.
+
+    # First, see if we have received a MKT_CLOSED message for the day.  If so,
+    # there's nothing to do except clean-up.
+    if self.mkt_closed and (self.symbol in self.daily_close_price):
+      # Market is closed and we already got the daily close price.
+      return
+
+
+    ### Impact agent operates at a specific time.
+    if currentTime < self.impact_time:
+      print ("Impact agent waiting for impact_time {}".format(self.impact_time))
+      self.setWakeup(self.impact_time)
+      return
+
+
+    ### The impact agent only trades once, but we will monitor prices for
+    ### the sake of performance.
+    self.setWakeup(currentTime + pd.Timedelta('30m'))
+
+
+    # If the market is closed and we haven't obtained the daily close price yet,
+    # do that before we cease activity for the day.  Don't do any other behavior
+    # after market close.
+    #
+    # Also, if we already made our one trade, do nothing except monitor prices.
+    #if self.traded >= self.impact_trades or (self.mkt_closed and (not self.symbol in self.daily_close_price)):
+    if self.traded or (self.mkt_closed and (not self.symbol in self.daily_close_price)):
+      self.getLastTrade()
+      self.state = 'AWAITING_LAST_TRADE'
+      return
+
+    #if self.traded < self.impact_trades:
+      #self.setWakeup(currentTime + impact_duration)
+
+    # The impact agent will place one order based on the current spread.
+    self.getCurrentSpread()
+    self.state = 'AWAITING_SPREAD'
+
+
+  def receiveMessage (self, currentTime, msg):
+    # Parent class schedules market open wakeup call once market open/close times are known.
+    super().receiveMessage(currentTime, msg)
+
+    # We have been awakened by something other than our scheduled wakeup.
+    # If our internal state indicates we were waiting for a particular event,
+    # check if we can transition to a new state.
+
+    if self.state == 'AWAITING_SPREAD':
+      # We were waiting for current spread information to make our trade.
+      # If the message we just received is QUERY_SPREAD, that means we just got it.
+      if msg.body['msg'] == 'QUERY_SPREAD':
+        # Place our one trade.
+        bid, bid_vol, ask, ask_vol = self.getKnownBidAsk(self.symbol)
+        #bid_liq, ask_liq = self.getKnownLiquidity(self.symbol, within=self.within)
+        print('within: ' + str(self.within))
+        bid_liq, ask_liq = self.getKnownLiquidity(self.symbol, within=0.75)
+
+        # Buy order.
+        #direction, shares, price = True, int(round(ask_liq * self.greed)), ask
+
+        # Sell order.  This should be a parameter, but isn't yet.
+        #direction, shares = False, int(round(bid_liq * self.greed))
+        direction, shares = False, int(round(bid_liq * 0.5))
+
+        # Compute the limit price we must offer to ensure our order executes immediately.
+        # This is essentially a workaround for the lack of true market orders in our
+        # current simulation.
+        price = self.computeRequiredPrice(direction, shares)
+
+        # Actually place the order only if self.impact is true.
+        if self.impact: 
+          print ("Impact agent firing: {} {} @ {} @ {}".format('BUY' if direction else 'SELL', shares, self.dollarize(price), currentTime))
+          self.placeLimitOrder (self.symbol, shares, direction, price)
+        else:
+          print ("Impact agent would fire: {} {} @ {} (but self.impact = False)".format('BUY' if direction else 'SELL', shares, self.dollarize(price)))
+
+        self.traded = True
+        self.state = 'AWAITING_WAKEUP'
+
+
+  # Internal state and logic specific to this agent.
+
+  def placeLimitOrder (self, symbol, quantity, is_buy_order, limit_price):
+    super().placeLimitOrder(symbol, quantity, is_buy_order, limit_price, ignore_risk = True)
+
+  # Computes required limit price to immediately execute a trade for the specified quantity
+  # of shares.
+  def computeRequiredPrice (self, direction, shares):
+    book = self.known_asks[self.symbol] if direction else self.known_bids[self.symbol]
+
+    # Start at the inside and add up the shares.
+    t = 0
+
+    for i in range(len(book)):
+      p,v = book[i]
+      t += v
+
+      # If we have accumulated enough shares, return this price.
+      # Need to also return if greater than the number of desired shares
+      if t >= shares: return p
+
+    # Not enough shares.  Just return worst price (highest ask, lowest bid).
+    return book[-1][0]
+
+
+  # Request the last trade price for our symbol.
+  def getLastTrade (self):
+    super().getLastTrade(self.symbol)
+
+
+  # Request the spread for our symbol.
+  def getCurrentSpread (self):
+    # Impact agent gets depth 10000 on each side (probably everything).
+    super().getCurrentSpread(self.symbol, 10000)
+
+
+  def getWakeFrequency (self):
+    return (pd.Timedelta('1ns'))
+
+

ABIDES/agent/examples/SubscriptionAgent.py

@@ -0,0 +1,52 @@
+from agent.TradingAgent import TradingAgent
+from util.util import log_print
+
+import pandas as pd
+
+
+class SubscriptionAgent(TradingAgent):
+    """
+    Simple agent to demonstrate subscription to order book market data.
+    """
+
+    def __init__(self, id, name, type, symbol, starting_cash, levels, freq, log_orders=False, random_state=None):
+        super().__init__(id, name, type, starting_cash=starting_cash, log_orders=log_orders, random_state=random_state)
+        self.symbol = symbol  # symbol traded
+        self.levels = levels  # number of price levels to subscribe to/recieve updates for
+        self.freq = freq  # minimum number of nanoseconds between market data messages
+        self.subscribe = True  # Flag to determine whether to subscribe to data or use polling mechanism
+        self.subscription_requested = False
+        self.last_update_ts = None  # timestamp of the last agent update.
+                                    # This is NOT required but only used to demonstrate how subscription works
+        self.state = 'AWAITING_MARKET_DATA'
+        self.current_bids = None
+        self.current_asks = None
+
+    def kernelStarting(self, startTime):
+        super().kernelStarting(startTime)
+
+    def wakeup(self, currentTime):
+        super().wakeup(currentTime)
+        if self.subscribe and not self.subscription_requested:
+            super().requestDataSubscription(self.symbol, levels=self.levels, freq=self.freq)
+            self.subscription_requested = True
+            self.last_update_ts = currentTime
+
+    def receiveMessage(self, currentTime, msg):
+        super().receiveMessage(currentTime, msg)
+        if self.subscribe and self.state == 'AWAITING_MARKET_DATA' and msg.body['msg'] == 'MARKET_DATA':
+            bids, asks = msg.body['bids'], msg.body['asks']
+            log_print("--------------------")
+            log_print("seconds elapsed since last update: {}", (currentTime - self.last_update_ts).delta / 1e9)
+            log_print("number of bid levels: {}", len(bids))
+            log_print("number of ask levels: {}", len(asks))
+            log_print("bids: {}, asks: {}", bids, asks)
+            log_print("Current Agent Timestamp: {}", currentTime)
+            log_print("Exchange Timestamp: {}", self.exchange_ts[self.symbol])
+            log_print("--------------------")
+            self.last_update_ts = currentTime
+            self.current_bids = bids
+            self.current_asks = asks
+
+    def getWakeFrequency(self):
+        return pd.Timedelta('1s')

ABIDES/agent/examples/SumClientAgent.py

@@ -0,0 +1,107 @@
+from agent.Agent import Agent
+from agent.examples.SumServiceAgent import SumServiceAgent
+from message.Message import Message
+from util.util import log_print
+
+import pandas as pd
+
+
+# The SumClientAgent class inherits from the base Agent class.  It is intended
+# to serve as an example in which a service agent performs some aggregated
+# computation for multiple clients and returns the result to all clients.
+
+class SumClientAgent(Agent):
+
+  def __init__(self, id, name, type, peer_list=None, random_state=None):
+    # Base class init.
+    super().__init__(id, name, type, random_state)
+
+    self.peer_list = peer_list
+    self.peer_exchange_complete = False
+
+    self.peers_received = {}
+    self.peer_sum = 0
+
+
+  ### Simulation lifecycle messages.
+
+  def kernelStarting(self, startTime):
+    # self.kernel is set in Agent.kernelInitializing()
+
+    # Find an SumServiceAgent which can answer our queries.  It is guaranteed
+    # to exist by now (if there is one).
+    self.serviceAgentID = self.kernel.findAgentByType(SumServiceAgent)
+
+    log_print ("Agent {} requested agent of type Agent.SumServiceAgent.  Given Agent ID: {}",
+               self.id, self.serviceAgentID)
+
+    # Request a wake-up call as in the base Agent (spread across five seconds).
+    super().kernelStarting(startTime + pd.Timedelta(self.random_state.randint(low = 0, high = 5000000000), unit='ns'))
+
+
+  ### Simulation participation messages.
+
+  def wakeup (self, currentTime):
+    # Allow the base Agent to do whatever it needs to.
+    super().wakeup(currentTime)
+
+    # This agent only needs one wakeup call at simulation start.  At this time,
+    # each client agent will send a number to each agent in its peer list.
+    # Each number will be sampled independently.  That is, client agent 1 will
+    # send n2 to agent 2, n3 to agent 3, and so forth.
+
+    # Once a client agent has received these initial random numbers from all
+    # agents in the peer list, it will make its first request from the sum
+    # service.  Afterwards, it will simply request new sums when answers are
+    # delivered to previous queries.
+
+    # At the first wakeup, initiate peer exchange.
+    if not self.peer_exchange_complete:
+      n = [self.random_state.randint(low = 0, high = 100) for i in range(len(self.peer_list))]
+      log_print ("agent {} peer list: {}", self.id, self.peer_list)
+      log_print ("agent {} numbers to exchange: {}", self.id, n)
+
+      for idx, peer in enumerate(self.peer_list):
+        self.sendMessage(peer, Message({ "msg" : "PEER_EXCHANGE", "sender": self.id, "n" : n[idx] }))
+
+    else:
+      # For subsequent (self-induced) wakeups, place a sum query.
+      n1, n2 = [self.random_state.randint(low = 0, high = 100) for i in range(2)]
+
+      log_print ("agent {} transmitting numbers {} and {} with peer sum {}", self.id, n1, n2, self.peer_sum)
+
+      # Add the sum of the peer exchange values to both numbers.
+      n1 += self.peer_sum
+      n2 += self.peer_sum
+
+      self.sendMessage(self.serviceAgentID, Message({ "msg" : "SUM_QUERY", "sender": self.id,
+                                                      "n1" : n1, "n2" : n2 })) 
+
+    return
+
+
+  def receiveMessage (self, currentTime, msg):
+    # Allow the base Agent to do whatever it needs to.
+    super().receiveMessage(currentTime, msg)
+
+    if msg.body['msg'] == "PEER_EXCHANGE":
+
+      # Ensure we don't somehow record the same peer twice.
+      if msg.body['sender'] not in self.peers_received:
+        self.peers_received[msg.body['sender']] = True
+        self.peer_sum += msg.body['n']
+
+        if len(self.peers_received) == len(self.peer_list):
+          # We just heard from the final peer.  Initiate our first sum request.
+          log_print ("agent {} heard from final peer.  peers_received = {}, peer_sum = {}",
+                     self.id, self.peers_received, self.peer_sum)
+
+          self.peer_exchange_complete = True
+          self.setWakeup(currentTime + pd.Timedelta('1ns'))
+
+    elif msg.body['msg'] == "SUM_QUERY_RESPONSE":
+      log_print("Agent {} received sum query response: {}", self.id, msg)
+
+      # Now schedule a new query.
+      self.setWakeup(currentTime + pd.Timedelta('1m'))
+

ABIDES/agent/examples/SumServiceAgent.py

@@ -0,0 +1,77 @@
+from agent.Agent import Agent
+from message.Message import Message
+from util.util import log_print
+
+
+# The SumServiceAgent class inherits from the base Agent class.  It is intended
+# to serve as an example in which a service agent performs some aggregated
+# computation for multiple clients and returns the result to all clients.
+
+class SumServiceAgent(Agent):
+
+  def __init__(self, id, name, type, random_state=None, num_clients=10):
+    # Base class init.
+    super().__init__(id, name, type, random_state)
+
+    # How many clients should we wait for?
+    self.num_clients = num_clients
+
+    # A list of the numbers to sum: dictionary keyed by agentID.
+    self.numbers = {}
+
+    # We track the total sum for the entire day to print at the end.
+    self.total = 0
+
+
+  ### Simulation lifecycle messages.
+  def kernelStarting(self, startTime):
+    # self.kernel is set in Agent.kernelInitializing()
+
+    # This agent should have negligible computation delay.
+    self.setComputationDelay(1000000)    # 1 ms
+
+    # Request a wake-up call as in the base Agent.
+    super().kernelStarting(startTime)
+
+
+  def kernelStopping(self):
+    # Print the total sum for the day, only for completed sum requests.
+    print("Agent {} reports total sum: {}".format(self.id, self.total))
+
+    # Allow the base class to perform stopping activities.
+    super().kernelStopping()
+
+
+  ### Simulation participation messages.
+
+  # The service agent does not require wakeup calls.
+
+  def receiveMessage (self, currentTime, msg):
+    # Allow the base Agent to do whatever it needs to.
+    super().receiveMessage(currentTime, msg)
+
+    if msg.body['msg'] == "SUM_QUERY":
+      log_print("Agent {} received sum query: {}", self.id, msg)
+      self.numbers[msg.body['sender']] = (msg.body['n1'], msg.body['n2'])
+
+    if len(self.numbers.keys()) >= self.num_clients:
+      # It is time to sum the numbers.
+      self.processSum()
+
+      # Then clear the pending queries.
+      self.numbers = {}
+
+
+  ### Sum client numbers and respond to each client.
+  def processSum (self):
+
+    current_sum = sum([ x[0] + x[1] for x in self.numbers.values() ])
+    self.total += current_sum
+
+    log_print("Agent {} computed sum: {}", self.id, current_sum)
+
+    for sender in self.numbers.keys():
+      self.sendMessage(sender, Message({ "msg" : "SUM_QUERY_RESPONSE", "sender": self.id,
+                                         "sum" : current_sum }))
+
+

ABIDES/agent/examples/crypto/PPFL_ClientAgent.py

@@ -0,0 +1,380 @@
+from agent.Agent import Agent
+from agent.examples.crypto.PPFL_ServiceAgent import PPFL_ServiceAgent
+from message.Message import Message
+from util.util import log_print
+
+from util.crypto.logReg import getWeights, reportStats
+import util.crypto.diffieHellman as dh
+
+import numpy as np
+from os.path import exists
+import pandas as pd
+import random
+
+
+# The PPFL_ClientAgent class inherits from the base Agent class.  It implements
+# a secure federated learning protocol with basic differential privacy plus
+# secure multiparty communication.
+
+class PPFL_ClientAgent(Agent):
+
+  def __init__(self, id, name, type, peer_list=None, iterations=4, multiplier=10000, secret_scale = 100000,
+               X_train = None, y_train = None, X_test = None, y_test = None, split_size = None,
+               learning_rate = None, clear_learning = None, num_clients = None, num_subgraphs = None,
+               epsilon = None, max_logreg_iterations = None, collusion = False, random_state=None):
+
+    # Base class init.
+    super().__init__(id, name, type, random_state)
+
+
+    # Store the client's peer list (subgraph, neighborhood) with which it should communicate.
+    self.peer_list = peer_list
+
+    # Initialize a tracking attribute for the initial peer exchange and record the subgraph size.
+    self.peer_exchange_complete = False
+    self.num_peers = len(self.peer_list)
+
+    # Record the total number of clients participating in the protocol and the number of subgraphs.
+    # Neither of these are part of the protocol, or necessary for real-world implementation, but do
+    # allow for convenient logging of progress and results in simulation.
+    self.num_clients = num_clients
+    self.num_subgraphs = num_subgraphs
+
+    # Record whether the clients should be recording information about the potential accuracy of
+    # peer data reconstruction via collusion among the clients.
+    self.collusion = collusion
+
+    # Record the number of protocol (federated learning) iterations the clients will perform.
+    self.no_of_iterations = iterations
+
+    # Record the multiplier that will be used to protect against floating point accuracy loss and
+    # the scale of the client shared secrets.
+    self.multiplier = multiplier
+    self.secret_scale = secret_scale
+
+    # Record the number of local iterations of logistic regression each client will run during
+    # each protocol iteration and what local learning rate will be used.
+    self.max_logreg_iterations = max_logreg_iterations
+    self.learning_rate = learning_rate
+
+    # Record whether clients will do federated learning in the clear (no privacy, no encryption)
+    # and, if needed, the epsilon value for differential privacy.
+    self.clear_learning = clear_learning
+    self.epsilon = epsilon
+    
+    # Record the training and testing splits for the data set to be learned.
+    self.X_train = X_train
+    self.y_train = y_train
+
+    self.X_test = X_test
+    self.y_test = y_test
+
+    # Record the number of features in the data set.
+    self.no_of_weights = X_train.shape[1]
+    
+    # Initialize an attribute to remember the shared weights returned from the server.
+    self.prevWeight = None
+
+    # Each client receives only a portion of the training data each protocol iteration.
+    self.split_size = split_size
+
+    # Initialize a dictionary to remember which peers we have heard from during peer exchange.
+    self.peers_received = {}
+
+    # Initialize a dictionary to accumulate this client's timing information by task.
+    self.elapsed_time = { 'DH_OFFLINE' : pd.Timedelta(0), 'DH_ONLINE' : pd.Timedelta(0),
+                          'TRAINING' : pd.Timedelta(0), 'ENCRYPTION' : pd.Timedelta(0) }
+
+
+    # Pre-generate this client's local training data for each iteration (for the sake of simulation speed).
+    self.trainX = []
+    self.trainY = []
+
+    # This is a faster PRNG than the default, for times when we must select a large quantity of randomness.
+    self.prng = np.random.Generator(np.random.SFC64())
+
+    ### Data randomly selected from total training set each iteration, simulating online behavior.
+    for i in range(iterations):
+      slice = self.prng.choice(range(self.X_train.shape[0]), size = split_size, replace = False)
+
+      # Pull together the current local training set.
+      self.trainX.append(self.X_train[slice].copy())
+      self.trainY.append(self.y_train[slice].copy())
+
+
+    # Create dictionaries to hold the public and secure keys for this client, and the public keys shared
+    # by its peers.
+    self.pubkeys = {}
+    self.seckeys = {}
+    self.peer_public_keys = {}
+
+    # Create dictionaries to hold the shared key for each peer each iteration and the seed for the
+    # following iteration.
+    self.r = {}
+    self.R = {}
+
+
+    # Specify the parameters used for generation of randomness.
+    self.px_reg = 1
+    self.px_epsilon = epsilon
+    self.px_min_rows = self.split_size
+
+    self.px_shape = 1 / ( self.num_peers + 1)
+    self.px_scale = 2 / (( self.num_peers + 1 ) * self.px_min_rows * self.px_reg * self.px_epsilon )
+
+    if self.id == 1: print (f"px_shape is {self.px_shape}")
+    if self.id == 1: print (f"px_scale is {self.px_scale}")
+
+    # Specify the required shape for vectorized generation of randomness.
+    self.px_dims = ( self.num_peers, self.no_of_iterations, self.no_of_weights )
+
+
+    # Iteration counter.
+    self.current_iteration = 0
+
+
+
+
+  ### Simulation lifecycle messages.
+
+  def kernelStarting(self, startTime):
+
+    # Initialize custom state properties into which we will later accumulate results.
+    # To avoid redundancy, we allow only the first client to handle initialization.
+    if self.id == 1:
+      self.kernel.custom_state['dh_offline'] = pd.Timedelta(0)
+      self.kernel.custom_state['dh_online'] = pd.Timedelta(0)
+      self.kernel.custom_state['training'] = pd.Timedelta(0)
+      self.kernel.custom_state['encryption'] = pd.Timedelta(0)
+
+    # Find the PPFL service agent, so messages can be directed there.
+    self.serviceAgentID = self.kernel.findAgentByType(PPFL_ServiceAgent)
+
+    # Request a wake-up call as in the base Agent.  Noise is kept small because
+    # the overall protocol duration is so short right now.  (up to one microsecond)
+    super().kernelStarting(startTime + pd.Timedelta(self.random_state.randint(low = 0, high = 1000), unit='ns'))
+
+
+  def kernelStopping(self):
+
+    # Accumulate into the Kernel's "custom state" this client's elapsed times per category.
+    # Note that times which should be reported in the mean per iteration are already so computed.
+    # These will be output to the config (experiment) file at the end of the simulation.
+
+    self.kernel.custom_state['dh_offline'] += self.elapsed_time['DH_OFFLINE']
+    self.kernel.custom_state['dh_online'] += (self.elapsed_time['DH_ONLINE'] / self.no_of_iterations)
+    self.kernel.custom_state['training'] += (self.elapsed_time['TRAINING'] / self.no_of_iterations)
+    self.kernel.custom_state['encryption'] += (self.elapsed_time['ENCRYPTION'] / self.no_of_iterations)
+
+    super().kernelStopping()
+
+
+  ### Simulation participation messages.
+
+  def wakeup (self, currentTime):
+    super().wakeup(currentTime)
+
+    # Record start of wakeup for real-time computation delay..
+    dt_wake_start = pd.Timestamp('now')
+
+    # Check if the clients are still performing the one-time peer exchange.
+    if not self.peer_exchange_complete:    
+
+      # Generate DH keys.
+      if not self.clear_learning: self.pubkeys, self.seckeys = dh.dict_keygeneration( self.peer_list )
+
+      # Record elapsed wallclock for Diffie Hellman offline.
+      dt_wake_end = pd.Timestamp('now')
+      self.elapsed_time['DH_OFFLINE'] += dt_wake_end - dt_wake_start
+
+      # Set computation delay to elapsed wallclock time.
+      self.setComputationDelay(int((dt_wake_end - dt_wake_start).to_timedelta64()))
+
+      # Send generated values to peers.
+      if not self.clear_learning:
+        for idx, peer in enumerate(self.peer_list):
+          # We assume a star network configuration where all messages between peers must be forwarded
+          # through the server.
+          self.sendMessage(self.serviceAgentID, Message({ "msg" : "FWD_MSG", "msgToForward" : "PEER_EXCHANGE",
+                          "sender": self.id, "recipient": peer, "pubkey" : self.pubkeys[peer] }))
+
+      if self.clear_learning:
+        self.peer_exchange_complete = True
+        self.setWakeup(currentTime + pd.Timedelta('1ns'))
+      
+    else: 
+       
+      # We are waking up to start a new iteration of the protocol.
+      # (Peer exchange is done before all this.)
+
+      if (self.current_iteration == 0):
+        # During iteration 0 (only) we complete the key exchange and prepare the
+        # common key list, because at this point we know we have received keys
+        # from all peers.
+
+        # R is the common key dictionary (by peer agent id).
+        if not self.clear_learning: self.R = dh.dict_keyexchange(self.peer_list, self.id, self.pubkeys,
+                                                                 self.seckeys, self.peer_public_keys)
+
+        # Pre-generate all of this client's local differential privacy noise (for simulation speed).
+        # We will need one per weight per protocol iteration.
+        self.my_noise = np.random.laplace(scale = self.px_scale, size = (self.no_of_iterations, self.no_of_weights))
+
+
+      # Diffie Hellman is done in every iteration.
+      if not self.clear_learning:
+        for peer_id, common_key in self.R.items():
+
+          random.seed(common_key)
+          rand = random.getrandbits(512)
+
+          rand_b_raw  = format(rand, '0512b')
+          rand_b_rawr = rand_b_raw[:256]
+          rand_b_rawR = rand_b_raw[256:]
+
+
+          # Negate offsets below this agent's id.  This ensures each offset will be
+          # added once and subtracted once.
+          r = int(rand_b_rawr,2) % (2**32)
+
+          log_print ("SELECTED r: {}", r)
+
+          # Update dictionary of shared secrets for this iteration.
+          self.r[peer_id] = r if peer_id < self.id else -r
+
+          # Store the shared seeds for the next iteration.
+          self.R[peer_id] = int(rand_b_rawR,2)
+
+
+      # Record elapsed wallclock for Diffie Hellman online.
+      dt_online_complete = pd.Timestamp('now')
+
+      # For convenience of things indexed by iteration...
+      i = self.current_iteration
+
+      # Perform the local training for this client, using only its local (private) data.  The configured learning
+      # rate might need to be increased if there are very many clients, each with very little data, otherwise
+      # convergence may take a really long time.
+      #
+      # max_iter controls how many iterations of gradient descent to perform on the logistic
+      # regression model.  previous_weight should be passed as None for the first iteration.
+      weight = getWeights(previous_weight = self.prevWeight, max_iter = self.max_logreg_iterations, lr = self.learning_rate,
+                          trainX = self.trainX[i], trainY = self.trainY[i], self_id = self.id)
+
+      # If in collusion analysis mode, write out the weights we will need to evaluate reconstruction.
+      if self.collusion:
+        with open('results/collusion_weights.csv', 'a') as results_file:
+          results_file.write(f"{self.id},{self.current_iteration},{','.join([str(x) for x in weight])}\n")
+
+      # Record elapsed wallclock for training model.
+      dt_training_complete = pd.Timestamp('now')
+
+      if not self.clear_learning:
+        # Add a random sample from Laplace to each of the weights.
+        noise = self.my_noise[i]
+
+        if self.collusion:
+          with open('results/collusion_selected_noise.csv', 'a') as results_file:
+            # Write out the noise added to each weight by this client.
+            results_file.write(f"{self.id},{self.current_iteration},{','.join([str(x) for x in noise])}\n")
+
+        log_print ("weight {}", weight)
+        log_print ("noise {}", noise)
+
+      if self.clear_learning: n = np.array(weight) * self.multiplier
+      else: n = (np.array(weight) + noise) * self.multiplier
+
+      log_print ("n {}", n)
+      log_print ("r {}", self.r)
+
+      weights_to_send = n + sum(self.r.values())
+
+      log_print ("weights_to_send {}", weights_to_send)
+
+      
+      # Record elapsed wallclock for encryption.
+      dt_encryption_complete = pd.Timestamp('now')
+
+      # Set computation delay to elapsed wallclock time.
+      self.setComputationDelay(int((dt_encryption_complete - dt_wake_start).to_timedelta64()))
+
+      # Send the message to the server.
+      self.sendMessage(self.serviceAgentID, Message({ "msg" : "CLIENT_WEIGHTS", "sender": self.id,
+                                                      "weights" : weights_to_send }))
+    
+      self.current_iteration += 1
+
+      # Store elapsed times by category.
+      self.elapsed_time['DH_ONLINE'] += dt_online_complete - dt_wake_start
+      self.elapsed_time['TRAINING'] += dt_training_complete - dt_online_complete
+      self.elapsed_time['ENCRYPTION'] += dt_encryption_complete - dt_training_complete
+
+
+
+  def receiveMessage (self, currentTime, msg):
+    super().receiveMessage(currentTime, msg)
+
+    if msg.body['msg'] == "PEER_EXCHANGE":
+
+      # Record start of message processing.
+      dt_rcv_start = pd.Timestamp('now')
+
+      # Ensure we don't somehow record the same peer twice.  These all come from the
+      # service provider, relayed from other clients, but are "fixed up" to appear
+      # as if they come straight from the relevant peer.
+      if msg.body['sender'] not in self.peers_received:
+
+        # Record the content of the message and that we received it.
+        self.peers_received[msg.body['sender']] = True
+        self.peer_public_keys[msg.body['sender']] = msg.body['pubkey']
+
+        # Record end of message processing.
+        dt_rcv_end = pd.Timestamp('now')
+
+        # Store elapsed times by category.
+        self.elapsed_time['DH_OFFLINE'] += dt_rcv_end - dt_rcv_start
+
+        # Set computation delay to elapsed wallclock time.
+        self.setComputationDelay(int((dt_rcv_end - dt_rcv_start).to_timedelta64()))
+
+        # If this is the last peer from whom we expect to hear, move on with the protocol.
+        if len(self.peers_received) == self.num_peers:
+          self.peer_exchange_complete = True
+          self.setWakeup(currentTime + pd.Timedelta('1ns'))
+
+    elif msg.body['msg'] == "SHARED_WEIGHTS":
+      # Reset computation delay.
+      self.setComputationDelay(0)
+
+      # Extract the shared weights from the message.
+      self.prevWeight = msg.body['weights']
+
+      # Remove the multiplier that was helping guard against floating point error.
+      self.prevWeight /= self.multiplier
+
+      log_print ("Client weights received for iteration {} by {}: {}", self.current_iteration, self.id, self.prevWeight)
+
+      # Client number 1 (arbitrary choice) records the shared learning progress each iteration
+      # for later visualization and analysis.
+      if self.id == 1:
+        is_acc, is_mcc, is_f1, is_mse, is_auprc, oos_acc, oos_mcc, oos_f1, oos_mse, oos_auprc = reportStats(self.prevWeight, self.current_iteration, self.X_train, self.y_train, self.X_test, self.y_test)
+
+        if not exists("results/all_results.csv"):
+          with open('results/all_results.csv', 'a') as results_file:
+            # Write out the header.
+            results_file.write(f"Clients,Peers,Subgraphs,Iterations,Train Rows,Learning Rate,In The Clear?,Local Iterations,Epsilon,Iteration,IS ACC,OOS ACC,IS MCC,OOS MCC,IS MSE,OOS MSE,IS F1,OOS F1,IS AUPRC,OOS AUPRC\n")
+
+        with open('results/all_results.csv', 'a') as results_file:
+          # Write out the current protocol iteration weights and metadata.
+          results_file.write(f"{self.num_clients},{self.num_peers},{self.num_subgraphs},{self.no_of_iterations},{self.split_size},{self.learning_rate},{self.clear_learning},{self.max_logreg_iterations},{self.epsilon},{self.current_iteration},{is_acc},{oos_acc},{is_mcc},{oos_mcc},{is_mse},{oos_mse},{is_f1},{oos_f1},{is_auprc},{oos_auprc}\n")
+
+        if self.collusion:
+          with open('results/collusion_consensus.csv', 'a') as results_file:
+            # Agent 1 also writes out the consensus weights each iteration (for collusion analysis).
+            results_file.write(f"{self.current_iteration},{','.join([str(x) for x in self.prevWeight])}\n")
+
+
+      # Start a new iteration if we are not at the end of the protocol.
+      if self.current_iteration < self.no_of_iterations:
+        self.setWakeup(currentTime + pd.Timedelta('1ns'))
+

ABIDES/agent/examples/crypto/PPFL_ServiceAgent.py

@@ -0,0 +1,155 @@
+from agent.Agent import Agent
+from message.Message import Message
+from util.util import log_print
+from util.crypto.logReg import getWeights
+
+from copy import deepcopy
+import numpy as np
+import pandas as pd
+
+### NEW MESSAGES: CLIENT_WEIGHTS : weights, SHARED_WEIGHTS : weights
+
+# The PPFL_ServiceAgent class inherits from the base Agent class.  It provides
+# the simple shared service necessary for model combination under secure
+# federated learning.
+
+class PPFL_ServiceAgent(Agent):
+
+  def __init__(self, id, name, type, random_state=None, msg_fwd_delay=1000000,
+               iterations=4, num_clients=10):
+
+    # Base class init.
+    super().__init__(id, name, type, random_state)
+
+    # From how many clients do we expect to hear in each protocol iteration?
+    self.num_clients = num_clients
+
+    # How long does it take us to forward a peer-to-peer client relay message?
+    self.msg_fwd_delay = msg_fwd_delay
+    
+    # Agent accumulation of elapsed times by category of task.
+    self.elapsed_time = { 'STORE_MODEL' : pd.Timedelta(0), 'COMBINE_MODEL' : pd.Timedelta(0) }
+
+    # How many iterations of the protocol should be run?
+    self.no_of_iterations = iterations
+
+    # Create a dictionary keyed by agentID to record which clients we have
+    # already heard from during the current protocol iteration.  This can
+    # also guard against double accumulation from duplicate messages.
+    self.received = {}
+
+    # Create a list to accumulate received values.  We don't need to know which came from which
+    # client, what the values mean, or indeed anything about them.
+    self.total = []
+
+    # Track the current iteration of the protocol.
+    self.current_iteration = 0
+
+
+  ### Simulation lifecycle messages.
+  def kernelStarting(self, startTime):
+    # self.kernel is set in Agent.kernelInitializing()
+
+    # Initialize custom state properties into which we will accumulate results later.
+    self.kernel.custom_state['srv_store_model'] = pd.Timedelta(0)
+    self.kernel.custom_state['srv_combine_model'] = pd.Timedelta(0)
+
+    # This agent should have negligible (or no) computation delay until otherwise specified.
+    self.setComputationDelay(0)
+
+    # Request a wake-up call as in the base Agent.
+    super().kernelStarting(startTime)
+
+
+  def kernelStopping(self):
+    # Add the server time components to the custom state in the Kernel, for output to the config.
+    # Note that times which should be reported in the mean per iteration are already so computed.
+    self.kernel.custom_state['srv_store_model'] += (self.elapsed_time['STORE_MODEL'] / self.no_of_iterations)
+    self.kernel.custom_state['srv_combine_model'] += (self.elapsed_time['COMBINE_MODEL'] / self.no_of_iterations)
+
+    # Allow the base class to perform stopping activities.
+    super().kernelStopping()
+    
+
+  ### Simulation participation messages.
+
+  # The service agent does not require wakeup calls.
+
+  def receiveMessage (self, currentTime, msg):
+    # Allow the base Agent to do whatever it needs to.
+    super().receiveMessage(currentTime, msg)
+
+    # Logic for receiving weights from client agents.  The weights are almost certainly
+    # noisy and encrypted, but that doesn't matter to us.
+    if msg.body['msg'] == "CLIENT_WEIGHTS":
+      
+      # Start wallclock timing for message handling.
+      dt_combine_complete = None
+      dt_start_rcv = pd.Timestamp('now')
+
+      sender = msg.body['sender']
+      if sender in self.received: return
+
+      self.received[sender] = True
+      self.total.append(msg.body['weights'].tolist())
+
+      # Capture elapsed wallclock for model storage.
+      dt_store_complete = pd.Timestamp('now')
+
+      log_print ("Server received {} from {}.", msg.body['weights'], msg.body['sender'])
+
+      if len(self.received.keys()) >= self.num_clients:
+        # This is the last client on whom we were waiting.
+        self.combineWeights()
+
+        # Capture elapsed wallclock for model combination.
+        dt_combine_complete = pd.Timestamp('now')
+
+        # Then clear the protocol attributes for the next round.
+        self.received = {}
+        self.total = []
+
+      # Capture elapsed wallclock at end of CLIENT_WEIGHTS.
+      dt_end_rcv = pd.Timestamp('now')
+
+      # Compute time deltas only after all elapsed times are captured.
+      if dt_combine_complete is not None: self.elapsed_time['COMBINE_MODEL'] += dt_combine_complete - dt_store_complete
+      self.elapsed_time['STORE_MODEL'] += dt_store_complete - dt_start_rcv
+      elapsed_total = int((dt_end_rcv - dt_start_rcv).to_timedelta64())
+
+      # Use total elapsed wallclock as computation delay.
+      self.setComputationDelay(elapsed_total)
+
+    elif msg.body['msg'] == "FWD_MSG":
+      # In our star topology, all client messages are forwarded securely through the server.
+      sender = msg.body['sender']
+      recipient = msg.body['recipient']
+      msg.body['msg'] = msg.body['msgToForward']
+
+      self.setComputationDelay(self.msg_fwd_delay)
+
+      # Normally not advisable, but here we need to fix up the sender so the
+      # server can be a silent proxy.
+      self.kernel.sendMessage(sender, recipient, msg)
+
+
+  ### Combine client weights and respond to each client.
+  def combineWeights (self):
+
+    log_print ("total: {}", self.total)
+
+    # Don't respond after the final iteration.
+    if (self.current_iteration < self.no_of_iterations):
+
+      # Take the mean weights across the clients.
+      self.total = np.array(self.total)
+      totals = np.mean(self.total, axis=0)
+
+      # Send the combined weights back to each client who participated.
+      for sender in self.received.keys():
+        log_print ("Sending {} to {}", totals, sender)
+        self.sendMessage(sender, Message({ "msg" : "SHARED_WEIGHTS", "sender": self.id, "weights" : deepcopy(totals) }))
+
+      # This is the end of one round of the protocol.
+      self.current_iteration += 1
+

ABIDES/agent/examples/crypto/PPFL_TemplateClientAgent.py

@@ -0,0 +1,311 @@
+from agent.Agent import Agent
+from agent.examples.crypto.PPFL_ServiceAgent import PPFL_ServiceAgent
+from message.Message import Message
+from util.util import log_print
+
+from util.crypto.logReg import getWeights, reportStats
+import util.crypto.diffieHellman as dh
+
+import numpy as np
+from os.path import exists
+import pandas as pd
+import random
+
+
+# The PPFL_TemplateClientAgent class inherits from the base Agent class.  It has the
+# structure of a secure federated learning protocol with secure multiparty communication,
+# but without any particular learning or noise methods.  That is, this is a template in
+# which the client parties simply pass around arbitrary data.  Sections that would need
+# to be completed are clearly marked.
+
+class PPFL_TemplateClientAgent(Agent):
+
+  def __init__(self, id, name, type, peer_list=None, iterations=4, multiplier=10000, secret_scale = 100000,
+               X_train = None, y_train = None, X_test = None, y_test = None, split_size = None,
+               num_clients = None, num_subgraphs = None, random_state=None):
+
+    # Base class init.
+    super().__init__(id, name, type, random_state)
+
+
+    # Store the client's peer list (subgraph, neighborhood) with which it should communicate.
+    self.peer_list = peer_list
+
+    # Initialize a tracking attribute for the initial peer exchange and record the subgraph size.
+    self.peer_exchange_complete = False
+    self.num_peers = len(self.peer_list)
+
+    # Record the total number of clients participating in the protocol and the number of subgraphs.
+    # Neither of these are part of the protocol, or necessary for real-world implementation, but do
+    # allow for convenient logging of progress and results in simulation.
+    self.num_clients = num_clients
+    self.num_subgraphs = num_subgraphs
+
+    # Record the number of protocol (federated learning) iterations the clients will perform.
+    self.no_of_iterations = iterations
+
+    # Record the multiplier that will be used to protect against floating point accuracy loss and
+    # the scale of the client shared secrets.
+    self.multiplier = multiplier
+    self.secret_scale = secret_scale
+
+    # Record the training and testing splits for the data set to be learned.
+    self.X_train = X_train
+    self.y_train = y_train
+
+    self.X_test = X_test
+    self.y_test = y_test
+
+    # Record the number of features in the data set.
+    self.no_of_weights = X_train.shape[1]
+    
+    # Initialize an attribute to remember the shared weights returned from the server.
+    self.prevWeight = np.zeros(self.no_of_weights)
+
+    # Each client receives only a portion of the training data each protocol iteration.
+    self.split_size = split_size
+
+    # Initialize a dictionary to remember which peers we have heard from during peer exchange.
+    self.peers_received = {}
+
+    # Initialize a dictionary to accumulate this client's timing information by task.
+    self.elapsed_time = { 'DH_OFFLINE' : pd.Timedelta(0), 'DH_ONLINE' : pd.Timedelta(0),
+                          'TRAINING' : pd.Timedelta(0), 'ENCRYPTION' : pd.Timedelta(0) }
+
+
+    # Pre-generate this client's local training data for each iteration (for the sake of simulation speed).
+    self.trainX = []
+    self.trainY = []
+
+    # This is a faster PRNG than the default, for times when we must select a large quantity of randomness.
+    self.prng = np.random.Generator(np.random.SFC64())
+
+    ### Data randomly selected from total training set each iteration, simulating online behavior.
+    for i in range(iterations):
+      slice = self.prng.choice(range(self.X_train.shape[0]), size = split_size, replace = False)
+
+      # Pull together the current local training set.
+      self.trainX.append(self.X_train[slice].copy())
+      self.trainY.append(self.y_train[slice].copy())
+
+
+    # Create dictionaries to hold the public and secure keys for this client, and the public keys shared
+    # by its peers.
+    self.pubkeys = {}
+    self.seckeys = {}
+    self.peer_public_keys = {}
+
+    # Create dictionaries to hold the shared key for each peer each iteration and the seed for the
+    # following iteration.
+    self.r = {}
+    self.R = {}
+
+
+    ### ADD DIFFERENTIAL PRIVACY CONSTANTS AND CONFIGURATION HERE, IF NEEDED.
+    #
+    #
+
+
+    # Iteration counter.
+    self.current_iteration = 0
+
+
+
+
+  ### Simulation lifecycle messages.
+
+  def kernelStarting(self, startTime):
+
+    # Initialize custom state properties into which we will later accumulate results.
+    # To avoid redundancy, we allow only the first client to handle initialization.
+    if self.id == 1:
+      self.kernel.custom_state['dh_offline'] = pd.Timedelta(0)
+      self.kernel.custom_state['dh_online'] = pd.Timedelta(0)
+      self.kernel.custom_state['training'] = pd.Timedelta(0)
+      self.kernel.custom_state['encryption'] = pd.Timedelta(0)
+
+    # Find the PPFL service agent, so messages can be directed there.
+    self.serviceAgentID = self.kernel.findAgentByType(PPFL_ServiceAgent)
+
+    # Request a wake-up call as in the base Agent.  Noise is kept small because
+    # the overall protocol duration is so short right now.  (up to one microsecond)
+    super().kernelStarting(startTime + pd.Timedelta(self.random_state.randint(low = 0, high = 1000), unit='ns'))
+
+
+  def kernelStopping(self):
+
+    # Accumulate into the Kernel's "custom state" this client's elapsed times per category.
+    # Note that times which should be reported in the mean per iteration are already so computed.
+    # These will be output to the config (experiment) file at the end of the simulation.
+
+    self.kernel.custom_state['dh_offline'] += self.elapsed_time['DH_OFFLINE']
+    self.kernel.custom_state['dh_online'] += (self.elapsed_time['DH_ONLINE'] / self.no_of_iterations)
+    self.kernel.custom_state['training'] += (self.elapsed_time['TRAINING'] / self.no_of_iterations)
+    self.kernel.custom_state['encryption'] += (self.elapsed_time['ENCRYPTION'] / self.no_of_iterations)
+
+    super().kernelStopping()
+
+
+  ### Simulation participation messages.
+
+  def wakeup (self, currentTime):
+    super().wakeup(currentTime)
+
+    # Record start of wakeup for real-time computation delay..
+    dt_wake_start = pd.Timestamp('now')
+
+    # Check if the clients are still performing the one-time peer exchange.
+    if not self.peer_exchange_complete:    
+
+      # Generate DH keys.
+      self.pubkeys, self.seckeys = dh.dict_keygeneration( self.peer_list )
+
+      # Record elapsed wallclock for Diffie Hellman offline.
+      dt_wake_end = pd.Timestamp('now')
+      self.elapsed_time['DH_OFFLINE'] += dt_wake_end - dt_wake_start
+
+      # Set computation delay to elapsed wallclock time.
+      self.setComputationDelay(int((dt_wake_end - dt_wake_start).to_timedelta64()))
+
+      # Send generated values to peers.
+      for idx, peer in enumerate(self.peer_list):
+        # We assume a star network configuration where all messages between peers must be forwarded
+        # through the server.
+        self.sendMessage(self.serviceAgentID, Message({ "msg" : "FWD_MSG", "msgToForward" : "PEER_EXCHANGE",
+                        "sender": self.id, "recipient": peer, "pubkey" : self.pubkeys[peer] }))
+
+    else: 
+       
+      # We are waking up to start a new iteration of the protocol.
+      # (Peer exchange is done before all this.)
+
+      if (self.current_iteration == 0):
+        # During iteration 0 (only) we complete the key exchange and prepare the
+        # common key list, because at this point we know we have received keys
+        # from all peers.
+
+        # R is the common key dictionary (by peer agent id).
+        dh.dict_keyexchange(self.peer_list, self.id, self.pubkeys, self.seckeys, self.peer_public_keys)
+
+
+        # CREATE AND CACHE LOCAL DIFFERENTIAL PRIVACY NOISE HERE, IF NEEDED.
+        #
+        #
+
+
+      # Diffie Hellman is done in every iteration.
+      for peer_id, common_key in self.R.items():
+
+        random.seed(common_key)
+        rand = random.getrandbits(512)
+
+        rand_b_raw  = format(rand, '0512b')
+        rand_b_rawr = rand_b_raw[:256]
+        rand_b_rawR = rand_b_raw[256:]
+
+
+        # Negate offsets below this agent's id.  This ensures each offset will be
+        # added once and subtracted once.
+        r = int(rand_b_rawr,2) % (2**32)
+
+        # Update dictionary of shared secrets for this iteration.
+        self.r[peer_id] = r if peer_id < self.id else -r
+
+        # Store the shared seeds for the next iteration.
+        self.R[peer_id] = int(rand_b_rawR,2)
+
+
+      # Record elapsed wallclock for Diffie Hellman online.
+      dt_online_complete = pd.Timestamp('now')
+
+      # For convenience of things indexed by iteration...
+      i = self.current_iteration
+
+
+      ### ADD LOCAL LEARNING METHOD HERE, IF NEEDED.
+      #
+      #
+
+      weight = np.random.normal (loc = self.prevWeight, scale = self.prevWeight / 10, size = self.prevWeight.shape)
+
+
+      # Record elapsed wallclock for training model.
+      dt_training_complete = pd.Timestamp('now')
+
+
+      ### ADD NOISE TO THE WEIGHTS HERE, IF NEEDED.
+      #
+      #
+
+      n = np.array(weight) * self.multiplier
+      weights_to_send = n + sum(self.r.values())
+
+      
+      # Record elapsed wallclock for encryption.
+      dt_encryption_complete = pd.Timestamp('now')
+
+      # Set computation delay to elapsed wallclock time.
+      self.setComputationDelay(int((dt_encryption_complete - dt_wake_start).to_timedelta64()))
+
+      # Send the message to the server.
+      self.sendMessage(self.serviceAgentID, Message({ "msg" : "CLIENT_WEIGHTS", "sender": self.id,
+                                                      "weights" : weights_to_send }))
+    
+      self.current_iteration += 1
+
+      # Store elapsed times by category.
+      self.elapsed_time['DH_ONLINE'] += dt_online_complete - dt_wake_start
+      self.elapsed_time['TRAINING'] += dt_training_complete - dt_online_complete
+      self.elapsed_time['ENCRYPTION'] += dt_encryption_complete - dt_training_complete
+
+
+
+  def receiveMessage (self, currentTime, msg):
+    super().receiveMessage(currentTime, msg)
+
+    if msg.body['msg'] == "PEER_EXCHANGE":
+
+      # Record start of message processing.
+      dt_rcv_start = pd.Timestamp('now')
+
+      # Ensure we don't somehow record the same peer twice.  These all come from the
+      # service provider, relayed from other clients, but are "fixed up" to appear
+      # as if they come straight from the relevant peer.
+      if msg.body['sender'] not in self.peers_received:
+
+        # Record the content of the message and that we received it.
+        self.peers_received[msg.body['sender']] = True
+        self.peer_public_keys[msg.body['sender']] = msg.body['pubkey']
+
+        # Record end of message processing.
+        dt_rcv_end = pd.Timestamp('now')
+
+        # Store elapsed times by category.
+        self.elapsed_time['DH_OFFLINE'] += dt_rcv_end - dt_rcv_start
+
+        # Set computation delay to elapsed wallclock time.
+        self.setComputationDelay(int((dt_rcv_end - dt_rcv_start).to_timedelta64()))
+
+        # If this is the last peer from whom we expect to hear, move on with the protocol.
+        if len(self.peers_received) == self.num_peers:
+          self.peer_exchange_complete = True
+          self.setWakeup(currentTime + pd.Timedelta('1ns'))
+
+    elif msg.body['msg'] == "SHARED_WEIGHTS":
+      # Reset computation delay.
+      self.setComputationDelay(0)
+
+      # Extract the shared weights from the message.
+      self.prevWeight = msg.body['weights']
+
+      # Remove the multiplier that was helping guard against floating point error.
+      self.prevWeight /= self.multiplier
+
+      log_print ("Client weights received for iteration {} by {}: {}", self.current_iteration, self.id, self.prevWeight)
+
+      if self.id == 1: print (f"Protocol iteration {self.current_iteration} complete.")
+
+      # Start a new iteration if we are not at the end of the protocol.
+      if self.current_iteration < self.no_of_iterations:
+        self.setWakeup(currentTime + pd.Timedelta('1ns'))
+

ABIDES/agent/execution/ExecutionAgent.py

@@ -0,0 +1,106 @@
+import pandas as pd
+import datetime
+
+from agent.TradingAgent import TradingAgent
+from util.util import log_print
+
+
+class ExecutionAgent(TradingAgent):
+
+    def __init__(self, id, name, type, symbol, starting_cash,
+                 direction, quantity, execution_time_horizon,
+                 trade=True, log_orders=False, random_state=None):
+        super().__init__(id, name, type, starting_cash=starting_cash, log_orders=log_orders, random_state=random_state)
+        self.symbol = symbol
+        self.direction = direction
+        self.quantity = quantity
+        self.execution_time_horizon = execution_time_horizon
+
+        self.start_time = self.execution_time_horizon[0]
+        self.end_time = self.execution_time_horizon[-1]
+        self.schedule = None
+
+        self.rem_quantity = quantity
+        self.arrival_price = None
+
+        self.accepted_orders = []
+        self.trade = trade
+        self.log_orders = log_orders
+
+        self.state = 'AWAITING_WAKEUP'
+
+    def kernelStopping(self):
+        super().kernelStopping()
+        if self.trade:
+            slippage = self.get_average_transaction_price() - self.arrival_price if self.direction == 'BUY' else \
+                       self.arrival_price - self.get_average_transaction_price()
+            self.logEvent('DIRECTION', self.direction, True)
+            self.logEvent('TOTAL_QTY', self.quantity, True)
+            self.logEvent('REM_QTY', self.rem_quantity, True)
+            self.logEvent('ARRIVAL_MID', self.arrival_price, True)
+            self.logEvent('AVG_TXN_PRICE', self.get_average_transaction_price(), True)
+            self.logEvent('SLIPPAGE', slippage, True)
+
+    def wakeup(self, currentTime):
+        can_trade = super().wakeup(currentTime)
+        if not can_trade: return
+        if self.trade:
+            try:
+                self.setWakeup([time for time in self.execution_time_horizon if time > currentTime][0])
+            except IndexError:
+                pass
+
+            self.getCurrentSpread(self.symbol, depth=1000)
+            self.state = 'AWAITING_SPREAD'
+
+    def receiveMessage(self, currentTime, msg):
+        super().receiveMessage(currentTime, msg)
+        if msg.body['msg'] == 'ORDER_EXECUTED': self.handleOrderExecution(currentTime, msg)
+        elif msg.body['msg'] == 'ORDER_ACCEPTED': self.handleOrderAcceptance(currentTime, msg)
+        if self.rem_quantity > 0 and self.state == 'AWAITING_SPREAD' and msg.body['msg'] == 'QUERY_SPREAD':
+            self.cancelOrders()
+            self.placeOrders(currentTime)
+
+    def handleOrderExecution(self, currentTime, msg):
+        executed_order = msg.body['order']
+        self.executed_orders.append(executed_order)
+        executed_qty = sum(executed_order.quantity for executed_order in self.executed_orders)
+        self.rem_quantity = self.quantity - executed_qty
+        log_print('[---- {} - {} ----]: LIMIT ORDER EXECUTED - {} @ {}'.format(self.name, currentTime,
+                                                                               executed_order.quantity,
+                                                                               executed_order.fill_price))
+        log_print('[---- {} - {} ----]: EXECUTED QUANTITY: {}'.format(self.name, currentTime, executed_qty))
+        log_print('[---- {} - {} ----]: REMAINING QUANTITY: {}'.format(self.name, currentTime, self.rem_quantity))
+        log_print('[---- {} - {} ----]: % EXECUTED: {} \n'.format(self.name, currentTime,
+                                                                   round((1 - self.rem_quantity / self.quantity) * 100, 2)))
+
+    def handleOrderAcceptance(self, currentTime, msg):
+        accepted_order = msg.body['order']
+        self.accepted_orders.append(accepted_order)
+        accepted_qty = sum(accepted_order.quantity for accepted_order in self.accepted_orders)
+        log_print('[---- {} - {} ----]: ACCEPTED QUANTITY : {}'.format(self.name, currentTime, accepted_qty))
+
+    def placeOrders(self, currentTime):
+        if currentTime.floor('1s') == self.execution_time_horizon[-2]:
+            self.placeMarketOrder(symbol=self.symbol, quantity=self.rem_quantity, is_buy_order=self.direction == 'BUY')
+        elif currentTime.floor('1s') in self.execution_time_horizon[:-2]:
+            bid, _, ask, _ = self.getKnownBidAsk(self.symbol)
+
+            if currentTime.floor('1s') == self.start_time:
+                self.arrival_price = (bid + ask) / 2
+                log_print("[---- {}  - {} ----]: Arrival Mid Price {}".format(self.name, currentTime,
+                                                                               self.arrival_price))
+
+            qty = self.schedule[pd.Interval(currentTime.floor('1s'),
+                                            currentTime.floor('1s')+datetime.timedelta(minutes=1))]
+            price = ask if self.direction == 'BUY' else bid
+            self.placeLimitOrder(symbol=self.symbol, quantity=qty,
+                                 is_buy_order=self.direction == 'BUY', limit_price=price)
+            log_print('[---- {} - {} ----]: LIMIT ORDER PLACED - {} @ {}'.format(self.name, currentTime, qty, price))
+
+    def cancelOrders(self):
+        for _, order in self.orders.items():
+            self.cancelOrder(order)
+
+    def getWakeFrequency(self):
+        return self.execution_time_horizon[0] - self.mkt_open

ABIDES/agent/execution/POVExecutionAgent.py

@@ -0,0 +1,93 @@
+import sys
+import warnings
+import pandas as pd
+
+from agent.TradingAgent import TradingAgent
+from util.util import log_print
+
+POVExecutionWarning_msg = "Running a configuration using POVExecutionAgent requires an ExchangeAgent with " \
+                              "attribute `stream_history` set to a large value, recommended at sys.maxsize."
+
+
+class POVExecutionAgent(TradingAgent):
+
+    def __init__(self, id, name, type, symbol, starting_cash,
+                 direction, quantity, pov, start_time, freq, lookback_period, end_time=None,
+                 trade=True, log_orders=False, random_state=None):
+        super().__init__(id, name, type, starting_cash=starting_cash, log_orders=log_orders, random_state=random_state)
+        self.log_events = True  # save events for plotting
+        self.symbol = symbol
+        self.direction = direction
+        self.quantity = quantity
+        self.rem_quantity = quantity
+        self.pov = pov
+        self.start_time = start_time
+        self.end_time = end_time
+        self.freq = freq
+        self.look_back_period = lookback_period
+        self.trade = trade
+        self.accepted_orders = []
+        self.state = 'AWAITING_WAKEUP'
+
+        warnings.warn(POVExecutionWarning_msg, UserWarning, stacklevel=1)
+        self.processEndTime()
+
+    def processEndTime(self):
+        """ Make end time of POV order sensible, i.e. if a time is given leave it alone; else, add 24 hours to start."""
+        if self.end_time is None:
+            self.end_time = self.start_time + pd.to_timedelta('24 hours')
+
+    def wakeup(self, currentTime):
+        can_trade = super().wakeup(currentTime)
+        self.setWakeup(currentTime + self.getWakeFrequency())
+        if not can_trade: return
+        if self.trade and self.rem_quantity > 0 and self.start_time < currentTime < self.end_time:
+            self.cancelOrders()
+            self.getCurrentSpread(self.symbol, depth=sys.maxsize)
+            self.get_transacted_volume(self.symbol, lookback_period=self.look_back_period)
+            self.state = 'AWAITING_TRANSACTED_VOLUME'
+
+    def getWakeFrequency(self):
+        return pd.Timedelta(self.freq)
+
+    def receiveMessage(self, currentTime, msg):
+        super().receiveMessage(currentTime, msg)
+        if msg.body['msg'] == 'ORDER_EXECUTED': self.handleOrderExecution(currentTime, msg)
+        elif msg.body['msg'] == 'ORDER_ACCEPTED': self.handleOrderAcceptance(currentTime, msg)
+
+        if currentTime > self.end_time:
+            log_print(
+                f'[---- {self.name} - {currentTime} ----]: current time {currentTime} is after specified end time of POV order '
+                f'{self.end_time}. TRADING CONCLUDED. ')
+            return
+
+        if self.rem_quantity > 0 and \
+                self.state == 'AWAITING_TRANSACTED_VOLUME' \
+                and msg.body['msg'] == 'QUERY_TRANSACTED_VOLUME' \
+                and self.transacted_volume[self.symbol] is not None\
+                and currentTime > self.start_time:
+            qty = round(self.pov * self.transacted_volume[self.symbol])
+            self.cancelOrders()
+            self.placeMarketOrder(self.symbol, qty, self.direction == 'BUY')
+            log_print(f'[---- {self.name} - {currentTime} ----]: TOTAL TRANSACTED VOLUME IN THE LAST {self.look_back_period} = {self.transacted_volume[self.symbol]}')
+            log_print(f'[---- {self.name} - {currentTime} ----]: MARKET ORDER PLACED - {qty}')
+
+    def handleOrderAcceptance(self, currentTime, msg):
+        accepted_order = msg.body['order']
+        self.accepted_orders.append(accepted_order)
+        accepted_qty = sum(accepted_order.quantity for accepted_order in self.accepted_orders)
+        log_print(f'[---- {self.name} - {currentTime} ----]: ACCEPTED QUANTITY : {accepted_qty}')
+
+    def handleOrderExecution(self, currentTime, msg):
+        executed_order = msg.body['order']
+        self.executed_orders.append(executed_order)
+        executed_qty = sum(executed_order.quantity for executed_order in self.executed_orders)
+        self.rem_quantity = self.quantity - executed_qty
+        log_print(f'[---- {self.name} - {currentTime} ----]: LIMIT ORDER EXECUTED - {executed_order.quantity} @ {executed_order.fill_price}')
+        log_print(f'[---- {self.name} - {currentTime} ----]: EXECUTED QUANTITY: {executed_qty}')
+        log_print(f'[---- {self.name} - {currentTime} ----]: REMAINING QUANTITY (NOT EXECUTED): {self.rem_quantity}')
+        log_print(f'[---- {self.name} - {currentTime} ----]: % EXECUTED: {round((1 - self.rem_quantity / self.quantity) * 100, 2)} \n')
+
+    def cancelOrders(self):
+        for _, order in self.orders.items():
+            self.cancelOrder(order)

ABIDES/agent/execution/TWAPExecutionAgent.py

@@ -0,0 +1,38 @@
+import pandas as pd
+from agent.execution.ExecutionAgent import ExecutionAgent
+from util.util import log_print
+
+
+class TWAPExecutionAgent(ExecutionAgent):
+    """
+    TWAP (Time Weighted Average Price) Execution Agent:
+        - Aims to execute the parent order as close as possible to the TWAP average price
+        - breaks up the parent order and releases dynamically smaller chunks of the order to the market using
+        evenly divided time slots during the execution time horizon.
+        -
+        e.g. 18,000 shares - to be executed between 09:32:00 and 09:35:00
+        - > 18,000 shares over 3 minutes = 100 shares per second
+    """
+
+    def __init__(self, id, name, type, symbol, starting_cash,
+                 direction, quantity, execution_time_horizon, freq,
+                 trade=True, log_orders=False, random_state=None):
+        super().__init__(id, name, type, symbol, starting_cash,
+                         direction=direction, quantity=quantity, execution_time_horizon=execution_time_horizon,
+                         trade=trade, log_orders=log_orders, random_state=random_state)
+
+        self.freq = freq
+        self.schedule = self.generate_schedule()
+
+    def generate_schedule(self):
+
+        schedule = {}
+        bins = pd.interval_range(start=self.start_time, end=self.end_time, freq=self.freq)
+        child_quantity = int(self.quantity / len(self.execution_time_horizon))
+        for b in bins:
+            schedule[b] = child_quantity
+        log_print('[---- {} {} - Schedule ----]:'.format(self.name, self.currentTime))
+        log_print('[---- {} {} - Total Number of Orders ----]: {}'.format(self.name, self.currentTime, len(schedule)))
+        for t, q in schedule.items():
+            log_print("From: {}, To: {}, Quantity: {}".format(t.left.time(), t.right.time(), q))
+        return schedule

ABIDES/agent/execution/VWAPExecutionAgent.py

@@ -0,0 +1,55 @@
+import pandas as pd
+
+from agent.execution.ExecutionAgent import ExecutionAgent
+from util.util import log_print
+
+
+class VWAPExecutionAgent(ExecutionAgent):
+    """
+    VWAP (Volume Weighted Average Price) Execution Agent:
+        breaks up the parent order and releases dynamically smaller chunks of the order to the market using
+        stock specific historical volume profiles. Aims to execute the parent order as close as possible to the
+        VWAP average price
+    """
+
+    def __init__(self, id, name, type, symbol, starting_cash,
+                 direction, quantity, execution_time_horizon, freq, volume_profile_path,
+                 trade=True, log_orders=False, random_state=None):
+        super().__init__(id, name, type, symbol, starting_cash,
+                         direction=direction, quantity=quantity, execution_time_horizon=execution_time_horizon,
+                         trade=trade, log_orders=log_orders, random_state=random_state)
+        self.freq = freq
+        self.volume_profile_path = volume_profile_path
+        self.schedule = self.generate_schedule()
+
+    def generate_schedule(self):
+
+        if self.volume_profile_path is None:
+            volume_profile = VWAPExecutionAgent.synthetic_volume_profile(self.start_time, self.freq)
+        else:
+            volume_profile = pd.read_pickle(self.volume_profile_path).to_dict()
+
+        schedule = {}
+        bins = pd.interval_range(start=self.start_time, end=self.end_time, freq=self.freq)
+        for b in bins:
+            schedule[b] = round(volume_profile[b.left] * self.quantity)
+        log_print('[---- {} {} - Schedule ----]:'.format(self.name, self.currentTime))
+        log_print('[---- {} {} - Total Number of Orders ----]: {}'.format(self.name, self.currentTime, len(schedule)))
+        for t, q in schedule.items():
+            log_print("From: {}, To: {}, Quantity: {}".format(t.left.time(), t.right.time(), q))
+        return schedule
+
+    @staticmethod
+    def synthetic_volume_profile(date, freq):
+        mkt_open = pd.to_datetime(date.date()) + pd.to_timedelta('09:30:00')
+        mkt_close = pd.to_datetime(date.date()) + pd.to_timedelta('16:00:00')
+        day_range = pd.date_range(mkt_open, mkt_close, freq=freq)
+
+        vol_profile = {}
+        for t, x in zip(day_range, range(int(-len(day_range) / 2), int(len(day_range) / 2), 1)):
+            vol_profile[t] = x ** 2 + 2 * x + 2
+
+        factor = 1.0 / sum(vol_profile.values())
+        vol_profile = {k: v * factor for k, v in vol_profile.items()}
+
+        return vol_profile

ABIDES/agent/market_makers/AdaptiveMarketMakerAgent.py

@@ -0,0 +1,298 @@
+from agent.TradingAgent import TradingAgent
+import pandas as pd
+from util.util import log_print
+from collections import namedtuple, deque
+from util.util import ignored, sigmoid
+from math import floor, ceil
+
+
+ANCHOR_TOP_STR = 'top'
+ANCHOR_BOTTOM_STR = 'bottom'
+ANCHOR_MIDDLE_STR = 'middle'
+
+ADAPTIVE_SPREAD_STR = 'adaptive'
+INITIAL_SPREAD_VALUE = 50
+
+
+class AdaptiveMarketMakerAgent(TradingAgent):
+    """ This class implements a modification of the Chakraborty-Kearns `ladder` market-making strategy, wherein the
+        the size of order placed at each level is set as a fraction of measured transacted volume in the previous time
+        period.
+
+        Can skew orders to size of current inventory using beta parameter, whence beta == 0 represents inventory being
+        ignored and beta == infinity represents all liquidity placed on one side of book.
+
+        ADAPTIVE SPREAD: the market maker's spread can be set either as a fixed or value or can be adaptive,
+
+    """
+
+    def __init__(self, id, name, type, symbol, starting_cash, pov=0.05, min_order_size=20, window_size=5, anchor=ANCHOR_MIDDLE_STR,
+                 num_ticks=20, level_spacing=0.5, wake_up_freq='1s', subscribe=False, subscribe_freq=10e9, subscribe_num_levels=1, cancel_limit_delay=50,
+                 skew_beta=0, spread_alpha=0.85, backstop_quantity=None, log_orders=False, random_state=None, wakeup_time=None):
+
+        super().__init__(id, name, type, starting_cash=starting_cash, log_orders=log_orders, random_state=random_state)
+        self.is_adaptive = False
+        self.symbol = symbol      # Symbol traded
+        self.pov = pov  # fraction of transacted volume placed at each price level
+        self.min_order_size = min_order_size  # minimum size order to place at each level, if pov <= min
+        self.anchor = self.validateAnchor(anchor)  # anchor either top of window or bottom of window to mid-price
+        self.window_size = self.validateWindowSize(window_size)  # Size in ticks (cents) of how wide the window around mid price is. If equal to
+                                                                # string 'adaptive' then ladder starts at best bid and ask
+        self.num_ticks = num_ticks  # number of ticks on each side of window in which to place liquidity
+        self.level_spacing = level_spacing  #  level spacing as a fraction of the spread
+        self.wake_up_freq = wake_up_freq  # Frequency of agent wake up
+        self.subscribe = subscribe  # Flag to determine whether to subscribe to data or use polling mechanism
+        self.subscribe_freq = subscribe_freq  # Frequency in nanoseconds^-1 at which to receive market updates
+                                              # in subscribe mode
+        self.subscribe_num_levels = subscribe_num_levels  # Number of orderbook levels in subscription mode
+        self.cancel_limit_delay  = cancel_limit_delay  # delay in nanoseconds between order cancellations and new limit order placements
+
+        self.skew_beta = skew_beta  # parameter for determining order placement imbalance
+        self.spread_alpha = spread_alpha  # parameter for exponentially weighted moving average of spread. 1 corresponds to ignoring old values, 0 corresponds to no updates
+        self.backstop_quantity = backstop_quantity  # how many orders to place at outside order level, to prevent liquidity dropouts. If None then place same as at other levels.
+        self.log_orders = log_orders
+
+        ## Internal variables
+
+        self.subscription_requested = False
+        self.state = self.initialiseState()
+        self.buy_order_size = self.min_order_size
+        self.sell_order_size = self.min_order_size
+
+        self.last_mid = None  # last observed mid price
+        self.last_spread = INITIAL_SPREAD_VALUE  # last observed spread moving average
+        self.tick_size = None if self.is_adaptive else ceil(self.last_spread * self.level_spacing)
+        self.LIQUIDITY_DROPOUT_WARNING = f"Liquidity dropout for agent {self.name}."
+        self.wakeup_time = wakeup_time
+
+
+    def initialiseState(self):
+        """ Returns variables that keep track of whether spread and transacted volume have been observed. """
+        if not self.subscribe:
+            return {
+                "AWAITING_SPREAD": True,
+                "AWAITING_TRANSACTED_VOLUME": True
+            }
+        else:
+            return {
+                "AWAITING_MARKET_DATA": True,
+                "AWAITING_TRANSACTED_VOLUME": True
+            }
+
+    def validateAnchor(self, anchor):
+        """ Checks that input parameter anchor takes allowed value, raises ValueError if not.
+
+        :param anchor: str
+        :return:
+        """
+        if anchor not in [ANCHOR_TOP_STR, ANCHOR_BOTTOM_STR, ANCHOR_MIDDLE_STR]:
+            raise ValueError(f"Variable anchor must take the value `{ANCHOR_BOTTOM_STR}`, `{ANCHOR_MIDDLE_STR}` or "
+                             f"`{ANCHOR_TOP_STR}`")
+        else:
+            return anchor
+
+    def validateWindowSize(self, window_size):
+        """ Checks that input parameter window_size takes allowed value, raises ValueError if not
+
+        :param window_size:
+        :return:
+        """
+        try:  # fixed window size specified
+            return int(window_size)
+        except:
+            if window_size.lower() == 'adaptive':
+                self.is_adaptive = True
+                self.anchor = ANCHOR_MIDDLE_STR
+                return None
+            else:
+                raise ValueError(f"Variable window_size must be of type int or string {ADAPTIVE_SPREAD_STR}.")
+
+    def kernelStarting(self, startTime):
+        super().kernelStarting(startTime)
+
+    def wakeup(self, currentTime):
+        """ Agent wakeup is determined by self.wake_up_freq """
+        can_trade = super().wakeup(currentTime)
+        if self.subscribe and not self.subscription_requested:
+            super().requestDataSubscription(self.symbol, levels=self.subscribe_num_levels,
+                                            freq=pd.Timedelta(self.subscribe_freq, unit='ns'))
+            self.subscription_requested = True
+            self.get_transacted_volume(self.symbol, lookback_period=self.subscribe_freq)
+            self.state = self.initialiseState()
+
+        elif currentTime <= self.wakeup_time:
+            self.setWakeup(currentTime + self.getWakeFrequency())
+
+        elif can_trade and not self.subscribe:
+            self.cancelAllOrders()
+            self.delay(self.cancel_limit_delay)
+            self.getCurrentSpread(self.symbol, depth=self.subscribe_num_levels)
+            self.get_transacted_volume(self.symbol, lookback_period=self.wake_up_freq)
+            self.initialiseState()
+
+    def receiveMessage(self, currentTime, msg):
+        """ Processes message from exchange. Main function is to update orders in orderbook relative to mid-price.
+
+        :param simulation current time
+        :param message received by self from ExchangeAgent
+
+        :type currentTime: pd.Timestamp
+        :type msg: str
+
+        :return:
+        """
+
+        super().receiveMessage(currentTime, msg)
+        if self.last_mid is not None:
+            mid = self.last_mid
+
+        if self.last_spread is not None and self.is_adaptive:
+            self._adaptive_update_window_and_tick_size()
+
+        if msg.body['msg'] == 'QUERY_TRANSACTED_VOLUME' and self.state['AWAITING_TRANSACTED_VOLUME'] is True:
+            self.updateOrderSize()
+            self.state['AWAITING_TRANSACTED_VOLUME'] = False
+
+        if not self.subscribe:
+            if msg.body['msg'] == 'QUERY_SPREAD' and self.state['AWAITING_SPREAD'] is True:
+                bid, _, ask, _ = self.getKnownBidAsk(self.symbol)
+                if bid and ask:
+                    mid = int((ask + bid) / 2)
+                    self.last_mid = mid
+                    if self.is_adaptive:
+                        spread = int(ask - bid)
+                        self._adaptive_update_spread(spread)
+
+                    self.state['AWAITING_SPREAD'] = False
+                else:
+                    log_print("SPREAD MISSING at time {}", currentTime)
+                    self.state['AWAITING_SPREAD'] = False  # use last mid price and spread
+
+            if self.state['AWAITING_SPREAD'] is False and self.state['AWAITING_TRANSACTED_VOLUME'] is False:
+                if self.last_mid is None:
+                    self.state = self.initialiseState()
+                    self.setWakeup(currentTime + self.getWakeFrequency())
+                    return 
+                self.placeOrders(mid)
+                self.state = self.initialiseState()
+                self.setWakeup(currentTime + self.getWakeFrequency())
+
+        else:  # subscription mode
+            if msg.body['msg'] == 'MARKET_DATA' and self.state['AWAITING_MARKET_DATA'] is True:
+                bid = self.known_bids[self.symbol][0][0] if self.known_bids[self.symbol] else None
+                ask = self.known_asks[self.symbol][0][0] if self.known_asks[self.symbol] else None
+                if bid and ask:
+                    
+                    mid = int((ask + bid) / 2)
+                    self.last_mid = mid
+                    if self.is_adaptive:
+                        spread = int(ask - bid)
+                        self._adaptive_update_spread(spread)
+
+                    self.state['AWAITING_MARKET_DATA'] = False
+                else:
+                    log_print("SPREAD MISSING at time {}", currentTime)
+                    self.state['AWAITING_MARKET_DATA'] = False
+
+            if self.state['MARKET_DATA'] is False and self.state['AWAITING_TRANSACTED_VOLUME'] is False:
+                self.placeOrders(mid)
+                self.state = self.initialiseState()
+
+    def _adaptive_update_spread(self, spread):
+        """ Update internal spread estimate with exponentially weighted moving average
+        :param spread:
+        :return:
+        """
+        spread_ewma = self.spread_alpha * spread + (1 - self.spread_alpha) * self.last_spread
+        self.window_size = spread_ewma
+        self.last_spread = spread_ewma
+
+    def _adaptive_update_window_and_tick_size(self):
+        """ Update window size and tick size relative to internal spread estimate.
+
+        :return:
+        """
+        self.window_size = self.last_spread
+        self.tick_size = round(self.level_spacing * self.window_size)
+        if self.tick_size == 0:
+            self.tick_size = 1
+
+    def updateOrderSize(self):
+        """ Updates size of order to be placed. """
+        qty = round(self.pov * self.transacted_volume[self.symbol])
+        if self.skew_beta == 0:  # ignore inventory
+            self.buy_order_size = qty if qty >= self.min_order_size else self.min_order_size
+            self.sell_order_size = qty if qty >= self.min_order_size else self.min_order_size
+        else:
+            holdings = self.getHoldings(self.symbol)
+            proportion_sell = sigmoid(holdings, self.skew_beta)
+            sell_size = ceil(proportion_sell * qty)
+            buy_size = floor((1 - proportion_sell) * qty)
+
+            self.buy_order_size = buy_size if buy_size >= self.min_order_size else self.min_order_size
+            self.sell_order_size = sell_size if sell_size >= self.min_order_size else self.min_order_size
+
+    def computeOrdersToPlace(self, mid):
+        """ Given a mid price, computes the orders that need to be removed from orderbook, and adds these orders to
+            bid and ask deques.
+
+        :param mid: mid-price
+        :type mid: int
+
+        :return:
+        """
+
+        if self.anchor == ANCHOR_MIDDLE_STR:
+            highest_bid = int(mid) - floor(0.5 * self.window_size)
+            lowest_ask = int(mid) + ceil(0.5 * self.window_size)
+        elif self.anchor == ANCHOR_BOTTOM_STR:
+            highest_bid = int(mid - 1)
+            lowest_ask = int(mid + self.window_size)
+        elif self.anchor == ANCHOR_TOP_STR:
+            highest_bid = int(mid - self.window_size)
+            lowest_ask = int(mid + 1)
+
+        lowest_bid = highest_bid - ((self.num_ticks - 1) * self.tick_size)
+        highest_ask = lowest_ask + ((self.num_ticks - 1) * self.tick_size)
+
+        bids_to_place = [price for price in range(lowest_bid, highest_bid + self.tick_size, self.tick_size)]
+        asks_to_place = [price for price in range(lowest_ask, highest_ask + self.tick_size, self.tick_size)]
+
+        return bids_to_place, asks_to_place
+
+    def placeOrders(self, mid):
+        """ Given a mid-price, compute new orders that need to be placed, then send the orders to the Exchange.
+
+            :param mid: mid-price
+            :type mid: int
+
+        """
+        bid_orders, ask_orders = self.computeOrdersToPlace(mid)
+
+        if self.backstop_quantity is not None:
+            bid_price = bid_orders[0]
+            log_print('{}: Placing BUY limit order of size {} @ price {}', self.name, self.backstop_quantity, bid_price)
+            self.placeLimitOrder(self.symbol, self.backstop_quantity, True, bid_price)
+            bid_orders = bid_orders[1:]
+
+            ask_price = ask_orders[-1]
+            log_print('{}: Placing SELL limit order of size {} @ price {}', self.name, self.backstop_quantity, ask_price)
+            self.placeLimitOrder(self.symbol, self.backstop_quantity, False, ask_price)
+            ask_orders = ask_orders[:-1]
+
+        for bid_price in bid_orders:
+            log_print('{}: Placing BUY limit order of size {} @ price {}', self.name, self.buy_order_size, bid_price)
+            self.placeLimitOrder(self.symbol, self.buy_order_size, True, bid_price)
+
+        for ask_price in ask_orders:
+            log_print('{}: Placing SELL limit order of size {} @ price {}', self.name, self.sell_order_size, ask_price)
+            self.placeLimitOrder(self.symbol, self.sell_order_size, False, ask_price)
+
+    def getWakeFrequency(self):
+        """ Get time increment corresponding to wakeup period. """
+        return pd.Timedelta(self.wake_up_freq)
+
+    def cancelAllOrders(self):
+        """ Cancels all resting limit orders placed by the market maker """
+        for _, order in self.orders.items():
+            self.cancelOrder(order)

ABIDES/agent/market_makers/MarketMakerAgent.py

@@ -0,0 +1,130 @@
+from agent.TradingAgent import TradingAgent
+import pandas as pd
+from util.util import log_print
+
+
+DEFAULT_LEVELS_QUOTE_DICT = {1: [1, 0, 0, 0, 0],
+                             2: [.5, .5, 0, 0, 0],
+                             3: [.34, .33, .33, 0, 0],
+                             4: [.25, .25, .25, .25, 0],
+                             5: [.20, .20, .20, .20, .20]}
+
+
+class MarketMakerAgent(TradingAgent):
+    """
+    Simple market maker agent that attempts to provide liquidity in the orderbook by placing orders on both sides every
+    time it wakes up. The agent starts off by cancelling any existing orders, it then queries the current spread to
+    determine the trades to be placed. The order size is chosen at random between min_size and max_size which are parameters
+    of the agent.
+
+    If subscribe == True
+        The agent places orders in 1-5 price levels randomly with sizes determined by the levels_quote_dict.
+
+    Else if subscribe == False:
+        The agent places an order of size / 2 at both the best bid and best ask price levels
+
+    """
+
+    def __init__(self, id, name, type, symbol, starting_cash, min_size, max_size , wake_up_freq='1s',
+                 subscribe=False, subscribe_freq=10e9, subscribe_num_levels=5, log_orders=False, random_state=None):
+
+        super().__init__(id, name, type, starting_cash=starting_cash, log_orders=log_orders, random_state=random_state)
+        self.symbol = symbol      # Symbol traded
+        self.min_size = min_size  # Minimum order size
+        self.max_size = max_size  # Maximum order size
+        self.size = round(self.random_state.randint(self.min_size, self.max_size) / 2) # order size per LOB side
+        self.wake_up_freq = wake_up_freq  # Frequency of agent wake up
+        self.subscribe = subscribe  # Flag to determine whether to subscribe to data or use polling mechanism
+        self.subscribe_freq = subscribe_freq  # Frequency in nanoseconds^-1 at which to receive market updates
+                                              # in subscribe mode
+        self.subscribe_num_levels = subscribe_num_levels  # Number of orderbook levels in subscription mode
+        self.subscription_requested = False
+        self.log_orders = log_orders
+        self.state = "AWAITING_WAKEUP"
+        # Percentage of the order size to be placed at different levels is determined by levels_quote_dict
+        self.levels_quote_dict = DEFAULT_LEVELS_QUOTE_DICT
+        self.num_levels = None
+        self.size_split = None
+        self.last_spread = 10
+
+    def kernelStarting(self, startTime):
+        super().kernelStarting(startTime)
+
+    def wakeup(self, currentTime):
+        """ Agent wakeup is determined by self.wake_up_freq """
+        can_trade = super().wakeup(currentTime)
+        if self.subscribe and not self.subscription_requested:
+            super().requestDataSubscription(self.symbol, levels=self.subscribe_num_levels, freq=self.subscribe_freq)
+            self.subscription_requested = True
+            self.state = 'AWAITING_MARKET_DATA'
+        elif can_trade and not self.subscribe:
+            self.cancelOrders()
+            self.getCurrentSpread(self.symbol, depth=self.subscribe_num_levels)
+            self.state = 'AWAITING_SPREAD'
+
+    def receiveMessage(self, currentTime, msg):
+        """ Market Maker actions are determined after obtaining the bids and asks in the LOB """
+        super().receiveMessage(currentTime, msg)
+        if not self.subscribe and self.state == 'AWAITING_SPREAD' and msg.body['msg'] == 'QUERY_SPREAD':
+            self.cancelOrders()
+            mid = self.last_trade[self.symbol]
+
+            self.num_levels = 2 * self.subscribe_num_levels   # Number of price levels to place the trades in
+
+            bid, bid_vol, ask, ask_vol = self.getKnownBidAsk(self.symbol)
+
+            if bid and ask:
+                mid = int((ask + bid) / 2)
+                spread = int(abs(ask - bid)/2)
+            else:
+                log_print(f"SPREAD MISSING at time {currentTime}")
+                spread = self.last_spread
+
+            for i in range(self.num_levels):
+                self.size = round(self.random_state.randint(self.min_size, self.max_size) / 2)
+                #bids
+                self.placeLimitOrder(self.symbol, self.size, True, mid - spread - i)
+                #asks
+                self.placeLimitOrder(self.symbol, self.size, False, mid + spread + i)
+
+            self.setWakeup(currentTime + self.getWakeFrequency())
+            self.state = 'AWAITING_WAKEUP'
+
+        elif self.subscribe and self.state == 'AWAITING_MARKET_DATA' and msg.body['msg'] == 'MARKET_DATA':
+            self.cancelOrders()
+            num_levels_place = len(self.levels_quote_dict.keys())
+            self.num_levels = self.random_state.randint(1, num_levels_place)  # Number of price levels to place the trades in
+            self.size_split = self.levels_quote_dict.get(self.num_levels)  # % of the order size to be placed at different levels
+            self.placeOrders(self.known_bids[self.symbol], self.known_asks[self.symbol])
+            self.state = 'AWAITING_MARKET_DATA'
+
+    def placeOrders(self, bids, asks):
+        if bids and asks:
+            buy_quotes, sell_quotes = {}, {}
+            self.size = round(self.random_state.randint(self.min_size, self.max_size) / 2)
+            for i in range(self.num_levels):
+                vol = round(self.size_split[i] * self.size)
+                try:
+                    buy_quotes[bids[i][0]] = vol
+                except IndexError:
+                    # Orderbook price level i empty so create a new price level with bid price 1 CENT below
+                    buy_quotes[bids[-1][0] - 1] = vol
+                try:
+                    sell_quotes[asks[i][0]] = vol
+                except IndexError:
+                    # Orderbook price level i empty so create a new price level with bid price 1 CENT above
+                    sell_quotes[asks[-1][0] + 1] = vol
+
+            for price, vol in buy_quotes.items():
+                self.placeLimitOrder(self.symbol, vol, True, price)
+            for price, vol in sell_quotes.items():
+                self.placeLimitOrder(self.symbol, vol, False, price)
+
+
+    def cancelOrders(self):
+        """ cancels all resting limit orders placed by the market maker """
+        for _, order in self.orders.items():
+            self.cancelOrder(order)
+
+    def getWakeFrequency(self):
+        return pd.Timedelta(self.wake_up_freq)

ABIDES/agent/market_makers/POVMarketMakerAgent.py

@@ -0,0 +1,195 @@
+from agent.TradingAgent import TradingAgent
+import pandas as pd
+from util.util import log_print
+from collections import namedtuple, deque
+from util.util import ignored
+
+
+ANCHOR_TOP_STR = 'top'
+ANCHOR_BOTTOM_STR = 'bottom'
+
+
+class POVMarketMakerAgent(TradingAgent):
+    """ This class implements a modification of the Chakraborty-Kearns `ladder` market-making strategy, wherein the
+        the size of order placed at each level is set as a fraction of measured transacted volume in the previous time
+        period.
+    """
+
+    def __init__(self, id, name, type, symbol, starting_cash, pov=0.05, min_order_size=20, window_size=5, anchor=ANCHOR_BOTTOM_STR,
+                 num_ticks=20, wake_up_freq='1s', subscribe=False, subscribe_freq=10e9, subscribe_num_levels=1,
+                 log_orders=False, random_state=None):
+
+        super().__init__(id, name, type, starting_cash=starting_cash, log_orders=log_orders, random_state=random_state)
+        self.symbol = symbol      # Symbol traded
+        self.pov = pov  # fraction of transacted volume placed at each price level
+        self.min_order_size = min_order_size  # minimum size order to place at each level, if pov <= min
+        self.window_size = window_size  # Size in ticks (cents) of how wide the window around mid price is
+        self.anchor = self.validateAnchor(anchor)  # anchor either top of window or bottom of window to mid-price
+        self.num_ticks = num_ticks  # number of ticks on each side of window in which to place liquidity
+
+        self.wake_up_freq = wake_up_freq  # Frequency of agent wake up
+        self.subscribe = subscribe  # Flag to determine whether to subscribe to data or use polling mechanism
+        self.subscribe_freq = subscribe_freq  # Frequency in nanoseconds^-1 at which to receive market updates
+                                              # in subscribe mode
+        self.subscribe_num_levels = subscribe_num_levels  # Number of orderbook levels in subscription mode
+        self.log_orders = log_orders
+
+        ## Internal variables
+
+        self.subscription_requested = False
+        self.state = self.initialiseState()
+        self.order_size = self.min_order_size
+
+        self.last_mid = None  # last observed mid price
+        self.LIQUIDITY_DROPOUT_WARNING = f"Liquidity dropout for agent {self.name}."
+
+    def initialiseState(self):
+        """ Returns variables that keep track of whether spread and transacted volume have been observed. """
+        if not self.subscribe:
+            return {
+                "AWAITING_SPREAD": True,
+                "AWAITING_TRANSACTED_VOLUME": True
+            }
+        else:
+            return {
+                "AWAITING_MARKET_DATA": True,
+                "AWAITING_TRANSACTED_VOLUME": True
+            }
+
+    def validateAnchor(self, anchor):
+        """ Checks that input parameter anchor takes allowed value, raises ValueError if not.
+
+        :param anchor: str
+        :return:
+        """
+        if anchor not in [ANCHOR_TOP_STR, ANCHOR_BOTTOM_STR]:
+            raise ValueError(f"Variable anchor must take the value `{ANCHOR_BOTTOM_STR}` or `{ANCHOR_TOP_STR}`")
+        else:
+            return anchor
+
+    def kernelStarting(self, startTime):
+        super().kernelStarting(startTime)
+
+    def wakeup(self, currentTime):
+        """ Agent wakeup is determined by self.wake_up_freq """
+        can_trade = super().wakeup(currentTime)
+        if self.subscribe and not self.subscription_requested:
+            super().requestDataSubscription(self.symbol, levels=self.subscribe_num_levels,
+                                            freq=pd.Timedelta(self.subscribe_freq, unit='ns'))
+            self.subscription_requested = True
+            self.get_transacted_volume(self.symbol, lookback_period=self.subscribe_freq)
+            self.state = self.initialiseState()
+
+        elif can_trade and not self.subscribe:
+            self.getCurrentSpread(self.symbol, depth=self.subscribe_num_levels)
+            self.get_transacted_volume(self.symbol, lookback_period=self.wake_up_freq)
+            self.initialiseState()
+
+    def receiveMessage(self, currentTime, msg):
+        """ Processes message from exchange. Main function is to update orders in orderbook relative to mid-price.
+
+        :param simulation current time
+        :param message received by self from ExchangeAgent
+
+        :type currentTime: pd.Timestamp
+        :type msg: str
+
+        :return:
+        """
+
+        super().receiveMessage(currentTime, msg)
+
+        if self.last_mid is not None:
+            mid = self.last_mid
+
+        if msg.body['msg'] == 'QUERY_TRANSACTED_VOLUME' and self.state['AWAITING_TRANSACTED_VOLUME'] is True:
+            self.updateOrderSize()
+            self.state['AWAITING_TRANSACTED_VOLUME'] = False
+
+        if not self.subscribe:
+            if msg.body['msg'] == 'QUERY_SPREAD' and self.state['AWAITING_SPREAD'] is True:
+                bid, _, ask, _ = self.getKnownBidAsk(self.symbol)
+                if bid and ask:
+                    mid = int((ask + bid) / 2)
+                    self.last_mid = mid
+                    self.state['AWAITING_SPREAD'] = False
+                else:
+                    log_print(f"SPREAD MISSING at time {currentTime}")
+
+            if self.state['AWAITING_SPREAD'] is False and self.state['AWAITING_TRANSACTED_VOLUME'] is False:
+                self.cancelAllOrders()
+                self.placeOrders(mid)
+                self.state = self.initialiseState()
+                self.setWakeup(currentTime + self.getWakeFrequency())
+
+        else:  # subscription mode
+            if msg.body['msg'] == 'MARKET_DATA' and self.state['AWAITING_MARKET_DATA'] is True:
+                bid = self.known_bids[self.symbol][0][0] if self.known_bids[self.symbol] else None
+                ask = self.known_asks[self.symbol][0][0] if self.known_asks[self.symbol] else None
+                if bid and ask:
+                    mid = int((ask + bid) / 2)
+                    self.last_mid = mid
+                    self.state['AWAITING_MARKET_DATA'] = False
+                else:
+                    log_print(f"SPREAD MISSING at time {currentTime}")
+                    self.state['AWAITING_MARKET_DATA'] = False
+
+            if self.state['MARKET_DATA'] is False and self.state['AWAITING_TRANSACTED_VOLUME'] is False:
+                self.placeOrders(mid)
+                self.state = self.initialiseState()
+
+    def updateOrderSize(self):
+        """ Updates size of order to be placed. """
+        qty = round(self.pov * self.transacted_volume[self.symbol])
+        self.order_size = qty if qty >= self.min_order_size else self.min_order_size
+
+    def computeOrdersToPlace(self, mid):
+        """ Given a mid price, computes the orders that need to be removed from orderbook, and adds these orders to
+            bid and ask deques.
+
+        :param mid: mid-price
+        :type mid: int
+
+        :return:
+        """
+
+        if self.anchor == ANCHOR_BOTTOM_STR:
+            highest_bid = int(mid - 1)
+            lowest_ask = int(mid + self.window_size)
+        elif self.anchor == ANCHOR_TOP_STR:
+            highest_bid = int(mid - self.window_size)
+            lowest_ask = int(mid + 1)
+
+        lowest_bid = highest_bid - self.num_ticks
+        highest_ask = lowest_ask + self.num_ticks
+
+        bids_to_place = [price for price in range(lowest_bid, highest_bid + 1)]
+        asks_to_place = [price for price in range(lowest_ask, highest_ask + 1)]
+
+        return bids_to_place, asks_to_place
+
+    def placeOrders(self, mid):
+        """ Given a mid-price, compute new orders that need to be placed, then send the orders to the Exchange.
+
+            :param mid: mid-price
+            :type mid: int
+
+        """
+
+        bid_orders, ask_orders = self.computeOrdersToPlace(mid)
+        for bid_price in bid_orders:
+            log_print(f'{self.name}: Placing BUY limit order of size {self.order_size} @ price {bid_price}')
+            self.placeLimitOrder(self.symbol, self.order_size, True, bid_price)
+
+        for ask_price in ask_orders:
+            log_print(f'{self.name}: Placing SELL limit order of size {self.order_size} @ price {ask_price}')
+            self.placeLimitOrder(self.symbol, self.order_size, False, ask_price)
+
+    def getWakeFrequency(self):
+        """ Get time increment corresponding to wakeup period. """
+        return pd.Timedelta(self.wake_up_freq)
+
+    def cancelAllOrders(self):
+        """ Cancels all resting limit orders placed by the market maker """
+        for _, order in self.orders.items():
+            self.cancelOrder(order)

ABIDES/agent/market_makers/SpreadBasedMarketMakerAgent.py

@@ -0,0 +1,282 @@
+from agent.TradingAgent import TradingAgent
+import pandas as pd
+from util.util import log_print
+from collections import namedtuple, deque
+from util.util import ignored
+
+
+ANCHOR_TOP_STR = 'top'
+ANCHOR_BOTTOM_STR = 'bottom'
+
+
+class SpreadBasedMarketMakerAgent(TradingAgent):
+    """ This class implements the Chakraborty-Kearns `ladder` market-making strategy. """
+
+    _Order = namedtuple('_Order', ['price', 'id'])  # Internal data structure used to describe a placed order
+
+    def __init__(self, id, name, type, symbol, starting_cash, order_size=1, window_size=5, anchor=ANCHOR_BOTTOM_STR,
+                 num_ticks=20, wake_up_freq='1s', subscribe=True, subscribe_freq=10e9, subscribe_num_levels=1,
+                 log_orders=False, random_state=None):
+
+        super().__init__(id, name, type, starting_cash=starting_cash, log_orders=log_orders, random_state=random_state)
+        self.symbol = symbol      # Symbol traded
+        self.order_size = order_size  # order size per price level
+        self.window_size = window_size  # Size in ticks (cents) of how wide the window around mid price is
+        self.anchor = self.validateAnchor(anchor)  # anchor either top of window or bottom of window to mid-price
+        self.num_ticks = num_ticks  # number of ticks on each side of window in which to place liquidity
+
+        self.wake_up_freq = wake_up_freq  # Frequency of agent wake up
+        self.subscribe = subscribe  # Flag to determine whether to subscribe to data or use polling mechanism
+        self.subscribe_freq = subscribe_freq  # Frequency in nanoseconds^-1 at which to receive market updates
+                                              # in subscribe mode
+        self.subscribe_num_levels = subscribe_num_levels  # Number of orderbook levels in subscription mode
+        self.log_orders = log_orders
+
+        ## Internal variables
+
+        self.subscription_requested = False
+        self.state = "AWAITING_WAKEUP"
+
+        self.current_bids = None  # double-ended queue holding bid orders in the book
+        self.current_asks = None  # double-ended queue holding ask orders in the book
+        self.last_mid = None  # last observed mid price
+        self.order_id_counter = 0  # counter for bookkeeping orders made by self
+        self.LIQUIDITY_DROPOUT_WARNING = f"Liquidity dropout for agent {self.name}."
+
+    def validateAnchor(self, anchor):
+        """ Checks that input parameter anchor takes allowed value, raises ValueError if not.
+
+        :param anchor: str
+        :return:
+        """
+        if anchor not in [ANCHOR_TOP_STR, ANCHOR_BOTTOM_STR]:
+            raise ValueError(f"Variable anchor must take the value `{ANCHOR_BOTTOM_STR}` or `{ANCHOR_TOP_STR}`")
+        else:
+            return anchor
+
+    def kernelStarting(self, startTime):
+        super().kernelStarting(startTime)
+
+    def wakeup(self, currentTime):
+        """ Agent wakeup is determined by self.wake_up_freq """
+        can_trade = super().wakeup(currentTime)
+        if self.subscribe and not self.subscription_requested:
+            super().requestDataSubscription(self.symbol, levels=self.subscribe_num_levels, freq=self.subscribe_freq)
+            self.subscription_requested = True
+            self.state = 'AWAITING_MARKET_DATA'
+        elif can_trade and not self.subscribe:
+            self.getCurrentSpread(self.symbol, depth=self.subscribe_num_levels)
+            self.state = 'AWAITING_SPREAD'
+
+    def receiveMessage(self, currentTime, msg):
+        """ Processes message from exchange. Main function is to update orders in orderbook relative to mid-price.
+
+        :param simulation current time
+        :param message received by self from ExchangeAgent
+
+        :type currentTime: pd.Timestamp
+        :type msg: str
+
+        :return:
+        """
+
+        super().receiveMessage(currentTime, msg)
+
+        if self.last_mid is not None:
+            mid = self.last_mid
+
+        if not self.subscribe and self.state == 'AWAITING_SPREAD' and msg.body['msg'] == 'QUERY_SPREAD':
+
+            bid, _, ask, _ = self.getKnownBidAsk(self.symbol)
+            if bid and ask:
+                mid = int((ask + bid) / 2)
+            else:
+                log_print(f"SPREAD MISSING at time {currentTime}")
+
+            orders_to_cancel = self.computeOrdersToCancel(mid)
+            self.cancelOrders(orders_to_cancel)
+            self.placeOrders(mid)
+            self.setWakeup(currentTime + self.getWakeFrequency())
+            self.state = 'AWAITING_WAKEUP'
+            self.last_mid = mid
+
+        elif self.subscribe and self.state == 'AWAITING_MARKET_DATA' and msg.body['msg'] == 'MARKET_DATA':
+
+            bid = self.known_bids[self.symbol][0][0] if self.known_bids[self.symbol] else None
+            ask = self.known_asks[self.symbol][0][0] if self.known_asks[self.symbol] else None
+            if bid and ask:
+                mid = int((ask + bid) / 2)
+            else:
+                log_print(f"SPREAD MISSING at time {currentTime}")
+                return
+
+            orders_to_cancel = self.computeOrdersToCancel(mid)
+            self.cancelOrders(orders_to_cancel)
+            self.placeOrders(mid)
+            self.state = 'AWAITING_MARKET_DATA'
+            self.last_mid = mid
+
+    def computeOrdersToCancel(self, mid):
+        """ Given a mid price, computes the orders that need to be removed from orderbook, and pops these orders from
+            bid and ask deques.
+
+        :param mid: mid-price
+        :type mid: int
+
+        :return:
+        """
+
+        orders_to_cancel = []
+
+        if (self.current_asks is None) or (self.current_bids is None):
+            return orders_to_cancel
+
+        num_ticks_to_increase = int(mid - self.last_mid)
+
+        if num_ticks_to_increase > 0:
+            for _ in range(num_ticks_to_increase):
+                with ignored(self.LIQUIDITY_DROPOUT_WARNING, IndexError):
+                    orders_to_cancel.append(self.current_bids.popleft())
+                with ignored(self.LIQUIDITY_DROPOUT_WARNING, IndexError):
+                    orders_to_cancel.append(self.current_asks.popleft())
+        elif num_ticks_to_increase < 0:
+            for _ in range(- num_ticks_to_increase):
+                with ignored(self.LIQUIDITY_DROPOUT_WARNING, IndexError):
+                    orders_to_cancel.append(self.current_bids.pop())
+                with ignored(self.LIQUIDITY_DROPOUT_WARNING, IndexError):
+                    orders_to_cancel.append(self.current_asks.pop())
+
+        return orders_to_cancel
+
+    def cancelOrders(self, orders_to_cancel):
+        """ Given a list of _Order objects, remove the corresponding orders from ExchangeAgent's orderbook
+
+        :param orders_to_cancel: orders to remove from orderbook
+        :type orders_to_cancel: list(_Order)
+        :return:
+        """
+        for order_tuple in orders_to_cancel:
+            order_id = order_tuple.id
+            try:
+                order = self.orders[order_id]
+                self.cancelOrder(order)
+            except KeyError:
+                continue
+
+    def computeOrdersToPlace(self, mid):
+        """ Given a mid price, computes the orders that need to be removed from orderbook, and adds these orders to
+            bid and ask deques.
+
+        :param mid: mid-price
+        :type mid: int
+
+        :return:
+        """
+
+        bids_to_place = []
+        asks_to_place = []
+
+        if (not self.current_asks) or (not self.current_bids):
+            self.cancelAllOrders()
+            self.initialiseBidsAsksDeques(mid)
+            bids_to_place.extend([order for order in self.current_bids])
+            asks_to_place.extend([order for order in self.current_asks])
+            return bids_to_place, asks_to_place
+
+        if self.last_mid is not None:
+            num_ticks_to_increase = int(mid - self.last_mid)
+        else:
+            num_ticks_to_increase = 0
+
+        if num_ticks_to_increase > 0:
+
+            base_bid_price = self.current_bids[-1].price
+            base_ask_price = self.current_asks[-1].price
+
+            for price_increment in range(1, num_ticks_to_increase + 1):
+                bid_price = base_bid_price + price_increment
+                new_bid_order = self.generateNewOrderId(bid_price)
+                bids_to_place.append(new_bid_order)
+                self.current_bids.append(new_bid_order)
+
+                ask_price = base_ask_price + price_increment
+                new_ask_order = self.generateNewOrderId(ask_price)
+                asks_to_place.append(new_ask_order)
+                self.current_asks.append(new_ask_order)
+
+        elif num_ticks_to_increase < 0:
+
+            base_bid_price = self.current_bids[0].price
+            base_ask_price = self.current_asks[0].price
+
+            for price_increment in range(1, 1 - num_ticks_to_increase):
+                bid_price = base_bid_price - price_increment
+                new_bid_order = self.generateNewOrderId(bid_price)
+                bids_to_place.append(new_bid_order)
+                self.current_bids.appendleft(new_bid_order)
+
+                ask_price = base_ask_price - price_increment
+                new_ask_order = self.generateNewOrderId(ask_price)
+                asks_to_place.append(new_ask_order)
+                self.current_asks.appendleft(new_ask_order)
+
+        return bids_to_place, asks_to_place
+
+    def placeOrders(self, mid):
+        """ Given a mid-price, compute new orders that need to be placed, then send the orders to the Exchange.
+
+            :param mid: mid-price
+            :type mid: int
+
+        """
+
+        bid_orders, ask_orders = self.computeOrdersToPlace(mid)
+        for bid_order in bid_orders:
+            log_print(f'{self.name}: Placing BUY limit order of size {self.order_size} @ price {bid_order.price}')
+            self.placeLimitOrder(self.symbol, self.order_size, True, bid_order.price, order_id=bid_order.id)
+
+        for ask_order in ask_orders:
+            log_print(f'{self.name}: Placing SELL limit order of size {self.order_size} @ price {ask_order.price}')
+            self.placeLimitOrder(self.symbol, self.order_size, False, ask_order.price, order_id=ask_order.id)
+
+    def initialiseBidsAsksDeques(self, mid):
+        """ Initialise the current_bids and current_asks object attributes, which internally keep track of the limit
+            orders sent to the Exchange.
+
+            :param mid: mid-price
+            :type mid: int
+
+        """
+
+        if self.anchor == ANCHOR_BOTTOM_STR:
+            highest_bid = int(mid - 1)
+            lowest_ask = int(mid + self.window_size)
+        elif self.anchor == ANCHOR_TOP_STR:
+            highest_bid = int(mid - self.window_size)
+            lowest_ask = int(mid + 1)
+
+        lowest_bid = highest_bid - self.num_ticks
+        highest_ask = lowest_ask + self.num_ticks
+
+        self.current_bids = deque([self.generateNewOrderId(price) for price in range(lowest_bid, highest_bid + 1)])
+        self.current_asks = deque([self.generateNewOrderId(price) for price in range(lowest_ask, highest_ask + 1)])
+
+    def generateNewOrderId(self, price):
+        """ Generate a _Order object for a particular price level
+
+        :param price:
+        :type price: int
+
+        """
+        self.order_id_counter += 1
+        order_id = f"{self.name}_{self.id}_{self.order_id_counter}"
+        return self._Order(price, order_id)
+
+    def getWakeFrequency(self):
+        """ Get time increment corresponding to wakeup period. """
+        return pd.Timedelta(self.wake_up_freq)
+
+    def cancelAllOrders(self):
+        """ Cancels all resting limit orders placed by the market maker """
+        for _, order in self.orders.items():
+            self.cancelOrder(order)

ABIDES/cli/book_plot.py

@@ -0,0 +1,259 @@
+import copy
+from mpl_toolkits.mplot3d import Axes3D
+import matplotlib
+matplotlib.use('TkAgg')
+import matplotlib.pyplot as plt
+import seaborn as sns
+import numpy as np
+import pandas as pd
+import sys
+
+from matplotlib.colors import LogNorm
+
+from joblib import Memory
+
+# Auto-detect terminal width.
+pd.options.display.width = None
+pd.options.display.max_rows = 1000
+pd.options.display.max_colwidth = 200
+
+# Initialize a persistent memcache.
+mem = Memory(cachedir='./.cached_plot_book', verbose=0)
+mem_hist = Memory(cachedir='./.cached_plot_book_historical', verbose=0)
+mem_hist_plot = Memory(cachedir='./.cached_plot_book_historical_heatmap', verbose=0)
+
+
+# Turn these into command line parameters.
+SHOW_BEST = False
+TIME_STEPS = False
+PLOT_HISTORICAL = False
+
+
+# Used to read and cache simulated quotes (best bid/ask).
+# Doesn't actually pay attention to symbols yet.
+#@mem.cache
+def read_book_quotes (file):
+  print ("Simulated quotes were not cached.  This will take a minute.")
+  df = pd.read_pickle(file, compression='bz2')
+
+  if len(df) <= 0:
+    print ("There appear to be no simulated quotes.")
+    sys.exit()
+
+  print ("Cached simulated quotes.")
+  return df
+
+
+# Used to read historical national best bid/ask spread.
+@mem_hist.cache
+def read_historical_quotes (file, symbol):
+  print ("Historical quotes were not cached.  This will take a minute.")
+  df = pd.read_pickle(file, compression='bz2')
+
+  if len(df) <= 0:
+    print ("There appear to be no historical quotes.")
+    sys.exit()
+
+  df = df.loc[symbol]
+
+  return df
+
+
+# Used to cache the transformed historical dataframe for a symbol.
+@mem_hist_plot.cache
+def prepare_histogram (df_hist):
+  print ("Historical dataframe transformation was not cached.  This will take a minute.")
+
+  min_quote = df_hist['BEST_BID'].min()
+  max_quote = df_hist['BEST_ASK'].max()
+
+  quote_range = pd.Series(np.arange(min_quote, max_quote + 0.01, 0.01)).round(2).map(str)
+  quote_range = quote_range.str.pad(6, side='right', fillchar='0')
+
+  df = pd.DataFrame(index=df_hist.index, columns=quote_range)
+  df[:] = 0
+
+  i = 0
+
+  for idx in df.index:
+    if i % 1000 == 0: print ("Caching {}".format(idx))
+
+    col = '{:0.2f}'.format(round(df_hist.loc[idx].BEST_BID, 2))
+    val = -df_hist.loc[idx].BEST_BIDSIZ
+    df.loc[idx,col] = val
+
+    col = '{:0.2f}'.format(round(df_hist.loc[idx].BEST_ASK, 2))
+    val = df_hist.loc[idx].BEST_ASKSIZ
+    df.loc[idx,col] = val
+
+    i += 1
+
+  return df
+
+
+# Main program starts here.
+
+if len(sys.argv) < 2:
+  print ("Usage: python book_plot.py <Simulator Order Book DataFrame file>")
+  sys.exit()
+
+book_file = sys.argv[1]
+
+print ("Visualizing order book from {}".format(book_file))
+
+sns.set()
+
+df_book = read_book_quotes(book_file)
+#df_hist = read_historical_quotes('./data/nbbo/nbbo_2018/nbbom_20180518.bgz', 'IBM')
+
+fig = plt.figure(dpi=300,figsize=(12,9))
+
+# Use this to make all volume positive (ASK volume is negative in the dataframe).
+#df_book.Volume = df_book.Volume.abs()
+
+# Use this to swap the sign of BID vs ASK volume (to better fit a colormap, perhaps).
+#df_book.Volume = df_book.Volume * -1
+
+# Use this to clip volume to an upper limit.
+#df_book.Volume = df_book.Volume.clip(lower=-400,upper=400)
+
+# Use this to turn zero volume into np.nan (useful for some plot types).
+#df_book.Volume[df_book.Volume == 0] = np.nan
+
+# This section colors the best bid, best ask, and bid/ask midpoint
+# differently from the rest of the heatmap below, by substituting
+# special values at those indices.  It is important to do this while
+# the price index is still numeric.  We use a value outside the
+# range of actual order book volumes (selected dynamically).
+min_volume = df_book.Volume.min()
+max_volume = df_book.Volume.max()
+
+best_bid_value = min_volume - 1000
+best_ask_value = min_volume - 1001
+midpoint_value = min_volume - 1002
+
+# This converts the DateTimeIndex to integer nanoseconds since market open.  We use
+# these as our time steps for discrete time simulations (e.g. SRG config).
+if TIME_STEPS:
+  df_book = df_book.unstack(1)
+  t = df_book.index.get_level_values(0) - df_book.index.get_level_values(0)[0]
+  df_book.index = (t / np.timedelta64(1, 'ns')).astype(np.int64)
+  df_book = df_book.stack()
+
+
+# Use this to restrict plotting to a certain time of day.  Depending on quote frequency,
+# plotting could be very slow without this.
+#df_book = df_book.unstack(1)
+#df_book = df_book.between_time('11:50:00', '12:10:00')
+#df_book = df_book.stack()
+
+
+
+if SHOW_BEST:
+
+  df_book = df_book.unstack(1)
+  df_book.columns = df_book.columns.droplevel(0)
+
+  # Now row (single) index is time.  Column (single) index is quote price.
+
+  # In temporary data frame, find best bid per (time) row.
+  # Copy bids only.
+  best_bid = df_book[df_book < 0].copy()
+
+  # Replace every non-zero bid volume with the column header (quote price) instead.
+  for col in best_bid.columns:
+    c = best_bid[col]
+    c[c < 0] = col
+
+  # Copy asks only.
+  best_ask = df_book[df_book > 0].copy()
+
+  # Replace every non-zero ask volume with the column header (quote price) instead.
+  for col in best_ask.columns:
+    c = best_ask[col]
+    c[c > 0] = col
+
+  # In a new column in each temporary data frame, compute the best bid or ask.
+  best_bid['best'] = best_bid.idxmax(axis=1)
+  best_ask['best'] = best_ask.idxmin(axis=1)
+
+  # Iterate over the index (all three DF have the same index) and set the special
+  # best bid/ask value in the correct column(s) per row.  Also compute and include
+  # the midpoint where possible.
+  for idx in df_book.index:
+    bb = best_bid.loc[idx,'best']
+    #if bb: df_book.loc[idx,bb] = best_bid_value
+
+    ba = best_ask.loc[idx,'best']
+    #if ba: df_book.loc[idx,ba] = best_ask_value
+
+    if ba and bb: df_book.loc[idx,round((ba+bb)/2)] = midpoint_value
+
+
+  # Put the data frame indices back the way they were and ensure it is a DataFrame,
+  # not a Series.
+  df_book = df_book.stack()
+  df_book = pd.DataFrame(data=df_book)
+  df_book.columns = ['Volume']
+
+
+# Change the MultiIndex to time and dollars.
+df_book['Time'] = df_book.index.get_level_values(0)
+df_book['Price'] = df_book.index.get_level_values(1)
+
+# Use this to restrict plotting to a certain range of prices.
+#df_book = df_book.loc[(df_book.Price > 98500) & (df_book.Price < 101500)]
+
+# Use this to pad price strings for appearance.
+#df_book.Price = df_book.Price.map(str)
+#df_book.Price = df_book.Price.str.pad(6, side='right', fillchar='0')
+
+df_book.set_index(['Time', 'Price'], inplace=True)
+
+# This section makes a 2-D histogram (time vs price, color == volume)
+unstacked = df_book.unstack(1)
+if not TIME_STEPS: unstacked.index = unstacked.index.time
+unstacked.columns = unstacked.columns.droplevel(0)
+
+with sns.axes_style("white"):
+  ax = sns.heatmap(unstacked, cmap='seismic', mask=unstacked < min_volume, vmin=min_volume, cbar_kws={'label': 'Shares Available'}, center=0, antialiased = False)
+
+ax.set(xlabel='Quoted Price', ylabel='Quote Time')
+
+# Plot layers of best bid, best ask, and midpoint in special colors.
+#best_bids = unstacked[unstacked == best_bid_value].copy().notnull()
+midpoints = unstacked[unstacked == midpoint_value].copy().notnull()
+#best_asks = unstacked[unstacked == best_ask_value].copy().notnull()
+
+if SHOW_BEST:
+  #sns.heatmap(best_bids, cmap=['xkcd:hot purple'], mask=~best_bids, cbar=False, ax=ax)
+  #sns.heatmap(midpoints, cmap=['xkcd:hot green'], mask=~midpoints, cbar=False, ax=ax)
+  sns.heatmap(midpoints, cmap=['black'], mask=~midpoints, cbar=False, ax=ax)
+  #sns.heatmap(best_asks, cmap=['xkcd:hot pink'], mask=~best_asks, cbar=False, ax=ax)
+
+plt.tight_layout()
+
+# This section plots the historical order book (no depth available).
+if PLOT_HISTORICAL:
+  fig = plt.figure(dpi=300,figsize=(12,9))
+
+  df_hist = df_hist.between_time('9:30', '16:00')
+  #df_hist = df_hist.between_time('10:00', '10:05')
+  df_hist = df_hist.resample('1S').last().ffill()
+
+  df = prepare_histogram(df_hist)
+  df.index = df.index.time
+
+  # There's no order book depth anyway, so make all bids the same volume
+  # and all asks the same volume, so they're easy to see.
+  df[df > 0] = 1
+  df[df < 0] = -1
+
+  ax = sns.heatmap(df, cmap=sns.color_palette("coolwarm", 7), cbar_kws={'label': 'Shares Available'}, center=0)
+  ax.set(xlabel='Quoted Price', ylabel='Quote Time')
+
+  plt.tight_layout()
+
+# Show all the plots.
+#plt.show()
+

ABIDES/cli/dump.py

@@ -0,0 +1,23 @@
+import pandas as pd
+import sys
+
+# Auto-detect terminal width.
+pd.options.display.width = None
+pd.options.display.max_rows = 500000
+pd.options.display.max_colwidth = 200
+
+if len(sys.argv) < 2:
+  print ("Usage: python dump.py <DataFrame file> [List of Event Types]")
+  sys.exit()
+
+file = sys.argv[1]
+
+df = pd.read_pickle(file, compression='bz2')
+
+if len(sys.argv) > 2:
+  events = sys.argv[2:]
+  event = "|".join(events)
+  df = df[df['EventType'].str.contains(event)]
+
+print(df)
+

ABIDES/cli/event_midpoint.py

@@ -0,0 +1,208 @@
+import ast
+import matplotlib
+matplotlib.use('TkAgg')
+import matplotlib.pyplot as plt
+import pandas as pd
+import os
+import re
+import sys
+
+from joblib import Memory
+
+# Auto-detect terminal width.
+pd.options.display.width = None
+pd.options.display.max_rows = 1000
+pd.options.display.max_colwidth = 200
+
+# Initialize a persistent memcache.
+#mem_sim = Memory(cachedir='./.cached_plot_sim', verbose=0)
+
+
+# Linewidth for plots.
+LW = 2
+
+# Rolling window for smoothing.
+#SIM_WINDOW = 250
+SIM_WINDOW = 1
+
+
+# Used to read and cache simulated quotes.
+# Doesn't actually pay attention to symbols yet.
+#@mem_sim.cache
+def read_simulated_quotes (file, symbol):
+  print ("Simulated quotes were not cached.  This will take a minute.")
+  df = pd.read_pickle(file, compression='bz2')
+  df['Timestamp'] = df.index
+
+  # Keep only the last bid and last ask event at each timestamp.
+  df = df.drop_duplicates(subset=['Timestamp','EventType'], keep='last')
+
+  del df['Timestamp']
+
+  df_bid = df[df['EventType'] == 'BEST_BID'].copy()
+  df_ask = df[df['EventType'] == 'BEST_ASK'].copy()
+
+  if len(df) <= 0:
+    print ("There appear to be no simulated quotes.")
+    sys.exit()
+
+  df_bid['BEST_BID'] = [b for s,b,bv in df_bid['Event'].str.split(',')]
+  df_bid['BEST_BID_VOL'] = [bv for s,b,bv in df_bid['Event'].str.split(',')]
+  df_ask['BEST_ASK'] = [a for s,a,av in df_ask['Event'].str.split(',')]
+  df_ask['BEST_ASK_VOL'] = [av for s,a,av in df_ask['Event'].str.split(',')]
+
+  df_bid['BEST_BID'] = df_bid['BEST_BID'].str.replace('$','').astype('float64')
+  df_ask['BEST_ASK'] = df_ask['BEST_ASK'].str.replace('$','').astype('float64')
+
+  df_bid['BEST_BID_VOL'] = df_bid['BEST_BID_VOL'].astype('float64')
+  df_ask['BEST_ASK_VOL'] = df_ask['BEST_ASK_VOL'].astype('float64')
+
+  df = df_bid.join(df_ask, how='outer', lsuffix='.bid', rsuffix='.ask')
+  df['BEST_BID'] = df['BEST_BID'].ffill().bfill()
+  df['BEST_ASK'] = df['BEST_ASK'].ffill().bfill()
+  df['BEST_BID_VOL'] = df['BEST_BID_VOL'].ffill().bfill()
+  df['BEST_ASK_VOL'] = df['BEST_ASK_VOL'].ffill().bfill()
+
+  df['MIDPOINT'] = (df['BEST_BID'] + df['BEST_ASK']) / 2.0
+
+  return df
+
+
+
+# Main program starts here.
+
+if len(sys.argv) < 3:
+  print ("Usage: python event_midpoint.py <Ticker symbol> <Simulator DataFrame file(s)>")
+  sys.exit()
+
+# TODO: only really works for one symbol right now.
+
+symbol = sys.argv[1]
+sim_files = sys.argv[2:]
+
+fig,ax = plt.subplots(figsize=(12,9), nrows=1, ncols=1)
+
+
+
+# Plot each impact simulation with the baseline subtracted (i.e. residual effect).
+i = 1
+legend = []
+#legend = ['baseline']
+
+# Events is now a dictionary of event lists (key == greed parameter).
+events = {}
+
+first_date = None
+impact_time = 200
+
+for sim_file in sim_files:
+
+  # Skip baseline files.
+  if 'baseline' in sim_file: continue
+
+  if 'greed' in os.path.dirname(sim_file):
+    # Group plots by greed parameter.
+    m = re.search("greed(\d\d\d)_", sim_file)
+    g = m.group(1)
+  else:
+    g = 'greed'
+
+  baseline_file = os.path.join(os.path.dirname(sim_file) + '_baseline', os.path.basename(sim_file))
+  print ("Visualizing simulation baseline from {}".format(baseline_file))
+
+  df_baseline = read_simulated_quotes(baseline_file, symbol)
+
+  # Read the event file.
+  print ("Visualizing simulated {} from {}".format(symbol, sim_file))
+
+  df_sim = read_simulated_quotes(sim_file, symbol)
+
+  plt.rcParams.update({'font.size': 12})
+
+  # Given nanosecond ("time step") data, we can just force everything to
+  # fill out an integer index of nanoseconds.
+  rng = pd.date_range(start=df_sim.index[0], end=df_sim.index[-1], freq='1N')
+
+  df_baseline = df_baseline[~df_baseline.index.duplicated(keep='last')]
+  df_baseline = df_baseline.reindex(rng,method='ffill')
+  df_baseline = df_baseline.reset_index(drop=True)
+
+  df_sim = df_sim[~df_sim.index.duplicated(keep='last')]
+  df_sim = df_sim.reindex(rng,method='ffill')
+  df_sim = df_sim.reset_index(drop=True)
+
+  # Absolute price difference.
+  #s = df_sim['MIDPOINT'] - df_baseline['MIDPOINT']
+
+  # Relative price difference.
+  s = (df_sim['MIDPOINT'] / df_baseline['MIDPOINT']) - 1.0
+
+  s = s.rolling(window=SIM_WINDOW).mean()
+  s.name = sim_file
+
+  if g not in events: events[g] = []
+
+  events[g].append(s.copy())
+
+  i += 1
+
+
+# Now have a list of series (each an event) that are time-aligned.  BUT the data is
+# still aperiodic, so they may not have the exact same index timestamps.
+
+legend = []
+
+for g in events:
+  df = pd.DataFrame()
+  legend.append("greed = " + str(g))
+  
+  for s in events[g]:
+    print ("Joining {}".format(s.name))
+    df = df.join(s, how='outer')
+  
+  df.dropna(how='all', inplace=True)
+  df = df.ffill().bfill()
+  
+  # Smooth after combining means at each instant-of-trade.
+  #df.mean(axis=1).rolling(window=250).mean().plot(grid=True, linewidth=LW, ax=ax)
+  
+  # No additional smoothing.
+  m = df.mean(axis=1)
+  s = df.std(axis=1)
+  
+  # Plot mean and std.
+  m.plot(grid=True, linewidth=LW, ax=ax, fontsize=12, label="Relative mean mid-price")
+
+  # Fill std region?
+  #ax.fill_between(m.index, m-s, m+s, alpha=0.2)
+  
+
+# Do the rest a single time for the whole plot.
+
+# If we need a vertical "time of event" line...
+ax.axvline(x=200, color='0.5', linestyle='--', linewidth=2, label="Order placement time")
+  
+# Absolute or relative time labels...
+ax.set_xticklabels(['0','10000','20000','30000','40000','50000','60000','70000'])
+#ax.set_xticklabels(['T-30', 'T-20', 'T-10', 'T', 'T+10', 'T+20', 'T+30'])
+
+ax.legend(legend)
+#ax.legend()
+  
+# Force y axis limits to make multiple plots line up exactly...
+#ax.set_ylim(-0.0065,0.0010)
+#ax.set_ylim(-0.0010,0.0065)
+
+# If an in-figure super title is required...
+#plt.suptitle('Impact Event Study: {}'.format(symbol))
+  
+ax.set_xlabel('Relative Time (ms)', fontsize=12, fontweight='bold')
+ax.set_ylabel('Baseline-Relative Price', fontsize=12, fontweight='bold')
+  
+#plt.savefig('IABS_SELL_100_multi_size.png')
+#plt.savefig('abides_impact_sell.png')
+#plt.savefig('abides_multi_buy.png')
+#plt.savefig('abides_multi_sell.png')
+  
+#plt.show()
+  

ABIDES/cli/event_ticker.py

@@ -0,0 +1,152 @@
+import ast
+import matplotlib
+matplotlib.use('TkAgg')
+import matplotlib.pyplot as plt
+import pandas as pd
+import os
+import re
+import sys
+
+from joblib import Memory
+
+# Auto-detect terminal width.
+pd.options.display.width = None
+pd.options.display.max_rows = 1000
+pd.options.display.max_colwidth = 200
+
+# Initialize a persistent memcache.
+mem_sim = Memory(cachedir='./.cached_plot_sim', verbose=0)
+
+
+# Linewidth for plots.
+LW = 2
+
+# Rolling window for smoothing.
+#SIM_WINDOW = 250
+SIM_WINDOW = 1
+
+
+# Used to read and cache simulated trades.
+# Doesn't actually pay attention to symbols yet.
+#@mem_sim.cache
+def read_simulated_trades (file, symbol):
+  #print ("Simulated trades were not cached.  This will take a minute.")
+  df = pd.read_pickle(file, compression='bz2')
+  df = df[df['EventType'] == 'LAST_TRADE']
+
+  if len(df) <= 0:
+    print ("There appear to be no simulated trades.")
+    sys.exit()
+
+  df['PRICE'] = [y for x,y in df['Event'].str.split(',')]
+  df['SIZE'] = [x for x,y in df['Event'].str.split(',')]
+
+  df['PRICE'] = df['PRICE'].str.replace('$','').astype('float64')
+  df['SIZE'] = df['SIZE'].astype('float64')
+
+  return df
+
+
+# Main program starts here.
+
+if len(sys.argv) < 3:
+  print ("Usage: python mean_std_event.py <Ticker symbol> <Simulator DataFrame file(s)>")
+  sys.exit()
+
+# TODO: only really works for one symbol right now.
+
+symbol = sys.argv[1]
+sim_files = sys.argv[2:]
+
+fig,ax = plt.subplots(figsize=(12,9), nrows=1, ncols=1)
+
+
+
+# Plot each impact simulation with the baseline subtracted (i.e. residual effect).
+i = 1
+legend = []
+#legend = ['baseline']
+
+events = []
+
+first_date = None
+impact_time = 200
+
+for sim_file in sim_files:
+
+  # Skip baseline files.
+  if 'baseline' in sim_file: continue
+
+  baseline_file = os.path.join(os.path.dirname(sim_file) + '_baseline', os.path.basename(sim_file))
+  print ("Visualizing simulation baseline from {}".format(baseline_file))
+
+  df_baseline = read_simulated_trades(baseline_file, symbol)
+
+  # Read the event file.
+  print ("Visualizing simulated {} from {}".format(symbol, sim_file))
+
+  df_sim = read_simulated_trades(sim_file, symbol)
+
+  plt.rcParams.update({'font.size': 12})
+
+  # Given nanosecond ("time step") data, we can just force everything to
+  # fill out an integer index of nanoseconds.
+  rng = pd.date_range(start=df_sim.index[0], end=df_sim.index[-1], freq='1N')
+
+  df_baseline = df_baseline[~df_baseline.index.duplicated(keep='last')]
+  df_baseline = df_baseline.reindex(rng,method='ffill')
+  df_baseline = df_baseline.reset_index(drop=True)
+
+  df_sim = df_sim[~df_sim.index.duplicated(keep='last')]
+  df_sim = df_sim.reindex(rng,method='ffill')
+  df_sim = df_sim.reset_index(drop=True)
+
+  s = df_sim['PRICE'] - df_baseline['PRICE']
+  s = s.rolling(window=SIM_WINDOW).mean()
+
+  s.name = sim_file
+  events.append(s.copy())
+
+  i += 1
+
+
+# Now have a list of series (each an event) that are time-aligned.
+df = pd.DataFrame()
+
+for s in events:
+  print ("Joining {}".format(s.name))
+  df = df.join(s, how='outer')
+
+df.dropna(how='all', inplace=True)
+df = df.ffill().bfill()
+
+# Smooth after combining means at each instant-of-trade.
+#df.mean(axis=1).rolling(window=250).mean().plot(grid=True, linewidth=LW, ax=ax)
+
+# No additional smoothing.
+m = df.mean(axis=1)
+s = df.std(axis=1)
+
+# Plot mean and std.
+m.plot(grid=True, linewidth=LW, ax=ax)
+
+# Shade the stdev region?
+ax.fill_between(m.index, m-s, m+s, alpha=0.2)
+
+# Override prettier axis ticks...
+#ax.set_xticklabels(['T-30', 'T-20', 'T-10', 'T', 'T+10', 'T+20', 'T+30'])
+
+# Force y axis limits to match some other plot.
+#ax.set_ylim(-0.1, 0.5)
+
+# Set a super title if required.
+plt.suptitle('Impact Event Study: {}'.format(symbol))
+
+ax.set_xlabel('Relative Time')
+ax.set_ylabel('Baseline-Relative Price')
+
+#plt.savefig('background_{}.png'.format(b))
+
+#plt.show()
+
+

ABIDES/cli/intraday_index.py

@@ -0,0 +1,255 @@
+# This file calculates the intraday index in a similar method to the Dow,
+# after the conclusion of a simulation run. It takes the average price
+# of the symbols in the index at each timestep, and graphs it. The
+# price refers to the mid.
+# Also graphs the mid of the underlying symbols
+
+import ast
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+import pandas as pd
+import os
+import sys
+import numpy as np
+
+from joblib import Memory
+
+# Auto-detect terminal width.
+pd.options.display.width = None
+pd.options.display.max_rows = 1000
+pd.options.display.max_colwidth = 200
+
+# Initialize a persistent memcache.
+mem_hist = Memory(cachedir='./.cached_plot_hist', verbose=0)
+mem_sim = Memory(cachedir='./.cached_plot_sim', verbose=0)
+
+
+PRINT_BASELINE = False
+PRINT_DELTA_ONLY = False
+
+BETWEEN_START = pd.to_datetime('09:30').time()
+BETWEEN_END = pd.to_datetime('09:30:00.000001').time()
+
+# Linewidth for plots.
+LW = 2
+
+# Used to read and cache simulated quotes.
+# Doesn't actually pay attention to symbols yet.
+#@mem_sim.cache
+def read_simulated_quotes (file):
+  print ("Simulated quotes were not cached.  This will take a minute.")
+  df = pd.read_pickle(file, compression='bz2')
+  df['Timestamp'] = df.index
+
+  df_bid = df[df['EventType'] == 'BEST_BID'].copy()
+  df_ask = df[df['EventType'] == 'BEST_ASK'].copy()
+
+  if len(df) <= 0:
+    print ("There appear to be no simulated quotes.")
+    sys.exit()
+
+  df_bid['SYM'] = [s for s,b,bv in df_bid['Event'].str.split(',')]
+  df_bid['BEST_BID'] = [b for s,b,bv in df_bid['Event'].str.split(',')]
+  df_bid['BEST_BID_VOL'] = [bv for s,b,bv in df_bid['Event'].str.split(',')]
+  df_ask['SYM'] = [s for s,a,av in df_ask['Event'].str.split(',')]
+  df_ask['BEST_ASK'] = [a for s,a,av in df_ask['Event'].str.split(',')]
+  df_ask['BEST_ASK_VOL'] = [av for s,a,av in df_ask['Event'].str.split(',')]
+
+  df_bid['BEST_BID'] = df_bid['BEST_BID'].str.replace('$','').astype('float64')
+  df_ask['BEST_ASK'] = df_ask['BEST_ASK'].str.replace('$','').astype('float64')
+
+  df_bid['BEST_BID_VOL'] = df_bid['BEST_BID_VOL'].astype('float64')
+  df_ask['BEST_ASK_VOL'] = df_ask['BEST_ASK_VOL'].astype('float64')
+    
+
+  # Keep only the last bid and last ask event at each timestamp.
+  df_bid = df_bid.drop_duplicates(subset=['Timestamp', 'SYM'], keep='last')
+  df_ask = df_ask.drop_duplicates(subset=['Timestamp', 'SYM'], keep='last')
+
+  #df = df_bid.join(df_ask, how='outer', lsuffix='.bid', rsuffix='.ask')
+    
+  # THIS ISN'T TRUE, YOU CAN'T GET THE MID FROM FUTURE ORDERS!!!
+  #df['BEST_BID'] = df['BEST_BID'].ffill().bfill()
+  #df['BEST_ASK'] = df['BEST_ASK'].ffill().bfill()
+  #df['BEST_BID_VOL'] = df['BEST_BID_VOL'].ffill().bfill()
+  #df['BEST_ASK_VOL'] = df['BEST_ASK_VOL'].ffill().bfill()
+  df = pd.merge(df_bid, df_ask,  how='left', left_on=['Timestamp','SYM'], right_on = ['Timestamp','SYM'])
+
+  df['MIDPOINT'] = (df['BEST_BID'] + df['BEST_ASK']) / 2.0
+
+  #ts = df['Timestamp.bid']
+  ts = df['Timestamp']
+  #print(df)
+  df['INTRADAY_INDEX'] = 0
+  #df['Timestamp.bid'] = df.index.to_series()
+  #df['Timestamp'] = df.index.to_series()
+  #df['SYM.bid'] = df['SYM.bid'].fillna(df['SYM.ask'])
+  #symbols = df['SYM.bid'].unique()
+  symbols = df['SYM'].unique()
+  #print(df)
+  for i,x in enumerate(symbols):
+      #df_one_sym = df[df['SYM.bid']==x]
+      df_one_sym = df[df['SYM']==x]
+      #df_one_sym = df_one_sym[['Timestamp.bid','MIDPOINT','BEST_BID','BEST_ASK']]
+      df_one_sym = df_one_sym[['Timestamp','MIDPOINT','BEST_BID','BEST_ASK']]
+      #md = pd.merge_asof(ts, df_one_sym, on='Timestamp.bid')
+      #print(ts)
+      #print(df_one_sym)
+      md = pd.merge_asof(ts, df_one_sym, on='Timestamp')
+      md = md.set_index(df.index)
+      df['MIDPOINT.' + x] = md['MIDPOINT']
+      df['BID.' + x] = md['BEST_BID']
+      df['ASK.' + x] = md['BEST_ASK']
+      if x != 'ETF':
+        df['INTRADAY_INDEX'] = df['INTRADAY_INDEX'] + md['MIDPOINT']
+  df['MSE'] = (df['INTRADAY_INDEX'] - df['MIDPOINT.ETF'])**2
+
+  #del df['Timestamp.bid']
+  #del df['Timestamp.ask']
+  df = df.set_index(df['Timestamp'])
+  del df['Timestamp']
+    
+  return df
+
+
+
+# Main program starts here.
+
+if len(sys.argv) < 2:
+  print ("Usage: python midpoint_plot.py <Ticker symbol> <Simulator DataFrame file>")
+  sys.exit()
+
+# TODO: only really works for one symbol right now.
+
+#symbols = sys.argv[1]
+sim_file = sys.argv[1]
+
+print ("Visualizing simulated {} from {}".format(12,sim_file))
+df_sim = read_simulated_quotes(sim_file)
+
+if PRINT_BASELINE:
+  baseline_file = os.path.join(os.path.dirname(sim_file) + '_baseline', os.path.basename(sim_file))
+  print (baseline_file)
+  df_baseline = read_simulated_quotes(baseline_file)
+
+plt.rcParams.update({'font.size': 12})
+
+
+# Use to restrict time to plot.
+df_sim = df_sim.between_time(BETWEEN_START, BETWEEN_END)
+
+if PRINT_BASELINE:
+  df_baseline = df_baseline.between_time(BETWEEN_START, BETWEEN_END)
+
+fig,ax = plt.subplots(figsize=(12,9), nrows=1, ncols=1)
+axes = [ax]
+
+# For smoothing...
+#hist_window = 100
+#sim_window = 100
+
+hist_window = 1
+sim_window = 1
+
+if PRINT_BASELINE:
+  # For nanosecond experiments, turn it into int index.  Pandas gets weird if all
+  # the times vary only by a few nanoseconds.
+  rng = pd.date_range(start=df_sim.index[0], end=df_sim.index[-1], freq='1N')
+
+  df_baseline = df_baseline[~df_baseline.index.duplicated(keep='last')]
+  df_baseline = df_baseline.reindex(rng,method='ffill')
+  df_baseline = df_baseline.reset_index(drop=True)
+
+  df_sim = df_sim[~df_sim.index.duplicated(keep='last')]
+  df_sim = df_sim.reindex(rng,method='ffill')
+  df_sim = df_sim.reset_index(drop=True)
+
+  # Print both separately.
+  if PRINT_DELTA_ONLY:
+    # Print the difference as a single series.
+    df_diff = df_sim['MIDPOINT'] - df_baseline['MIDPOINT']
+
+    # Smoothing.
+    df_diff = df_diff.rolling(window=10).mean()
+
+    df_diff.plot(color='C0', grid=True, linewidth=LW, ax=axes[0])
+
+    axes[0].legend(['Bid-ask Midpoint Delta'])
+  else:
+    df_baseline['MIDPOINT'].plot(color='C0', grid=True, linewidth=LW, ax=axes[0])
+    df_sim['MIDPOINT'].plot(color='C1', grid=True, linewidth=LW, alpha=0.9, ax=axes[0])
+
+    axes[0].legend(['Baseline', 'With Impact'])
+
+else:
+  #df_sim['PRICE'] = df_sim['PRICE'].rolling(window=sim_window).mean()
+
+  # For nanosecond experiments, turn it into int index.  Pandas gets weird if all
+  # the times vary only by a few nanoseconds.
+  rng = pd.date_range(start=df_sim.index[0], end=df_sim.index[-1], freq='1N')
+  df_sim = df_sim[~df_sim.index.duplicated(keep='last')]
+  df_sim = df_sim.reindex(rng,method='ffill')
+  df_time = df_sim.copy()
+  df_sim = df_sim.reset_index(drop=True)
+    
+  #symbols = df_sim['SYM.bid'].unique()
+  symbols = df_sim['SYM'].unique()
+  for i,x in enumerate(symbols):
+      #df_sim[df_sim['SYM.bid']==x]['MIDPOINT.' + x].plot(color='C1', grid=True, linewidth=LW, alpha=0.9, ax=axes[0])
+      df_sim['MIDPOINT.' + x].plot(color='C1', grid=True, linewidth=LW, alpha=0.9, ax=axes[0])
+      #df_sim['BID.' + x].plot(color='C2', grid=True, linewidth=LW, alpha=0.9, ax=axes[0])
+      #df_sim['ASK.' + x].plot(color='C3', grid=True, linewidth=LW, alpha=0.9, ax=axes[0])
+      if x != 'ETF':
+        axes[0].legend(['Simulated'])
+
+      plt.suptitle('Bid-Ask Midpoint: {}'.format(x))
+
+      axes[0].set_ylabel('Quote Price')
+      axes[0].set_xlabel('Quote Time')
+
+      plt.savefig('graphs/background_' + str(x) + '_{}.png'.format('png'))
+      plt.cla()
+    
+      if x == 'ETF':
+        df_sim['MIDPOINT.' + x].plot(color='C1', grid=True, linewidth=LW, alpha=0.9, ax=axes[0], label = 'ETF Mid')
+        i = np.argwhere(symbols=='ETF')
+        symbols_portfolio = np.delete(symbols, i)
+        df_sim['INTRADAY_INDEX'].plot(color='C4', grid=True, linewidth=LW, alpha=0.9, ax=axes[0], label = 'Index')
+        #axes[0].legend(['Simulated'])
+        plt.suptitle('65 ZI, 0 ETF Arb, gamma = 500: {}'.format(symbols_portfolio))
+        
+        axes[0].set_ylabel('Quote Price')
+        axes[0].set_xlabel('Quote Time')
+        axes[0].legend()
+        ymin = 249000
+        ymax = 251000
+        axes[0].set_ylim([ymin,ymax])
+
+        plt.savefig('graphs/index_vs_etf_ten_arb_gamma_500'.format('png'))
+        plt.cla()
+    
+  i = np.argwhere(symbols=='ETF')
+  symbols_portfolio = np.delete(symbols, i)
+  df_sim['INTRADAY_INDEX'].plot(color='C4', grid=True, linewidth=LW, alpha=0.9, ax=axes[0])
+  axes[0].legend(['Simulated'])
+  plt.suptitle('Intraday Index: {}'.format(symbols_portfolio))
+
+  plt.savefig('graphs/intraday_index_' + str(symbols_portfolio) + '_{}.png'.format('png'))
+  plt.cla()
+
+  df_sim['MSE'].plot(color='C5', grid=True, linewidth=LW, alpha=0.9, ax=axes[0])
+  #axes[0].legend(['Simulated'])
+  plt.suptitle('65 ZI, 10 ETF Arb, gamma = 500')
+  axes[0].set_ylabel('Mean Squared Error')
+  axes[0].set_xlabel('Quote Time')
+  ymin = -1000
+  ymax = 700000
+  axes[0].set_ylim([ymin,ymax])
+
+  plt.savefig('graphs/mse_index_etf_ten_arb_gamma_500'.format('png'))
+  plt.close()
+  #df_time.to_csv('test.csv')
+
+##plt.show()
+