roboquant 0.3.0__tar.gz → 0.3.2__tar.gz

{roboquant-0.3.0 → roboquant-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: roboquant
-Version: 0.3.0
+Version: 0.3.2
 Summary: A fast algo-trading platform
 Author-email: roboquant team <info@roboquant.org>
 Project-URL: Homepage, https://roboquant.org

{roboquant-0.3.0 → roboquant-0.3.2}/roboquant/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.3.0"
+__version__ = "0.3.2"
 
 from roboquant import brokers
 from roboquant import feeds
@@ -12,4 +12,4 @@ from .event import Event, PriceItem, Bar, Trade, Quote
 from .order import Order, OrderStatus
 from .run import run
 from .signal import SignalType, Signal
-from .timeframe import Timeframe
+from .timeframe import Timeframe, EMPTY_TIMEFRAME

{roboquant-0.3.0 → roboquant-0.3.2}/roboquant/account.py

@@ -19,6 +19,14 @@ class Position:
     mkt_price: float
     """latest market price denoted in the currency of the symbol"""
 
+    @property
+    def is_short(self):
+        return self.size < 0
+
+    @property
+    def is_long(self):
+        return self.size > 0
+
 
 class Converter(ABC):
     """Abstraction that enables trading symbols that are denoted in different currencies and/or contact sizes"""
@@ -126,7 +134,7 @@ class Account:
         return float(size) * price * rate
 
     def mkt_value(self) -> float:
-        """Return the sum of the market values of the open positions in the account.
+        """Return the sum market values of the open positions in the account.
 
         The returned value is denoted in the base currency of the account.
         """
@@ -142,8 +150,8 @@ class Account:
         return self.contract_value(symbol, pos.size, pos.mkt_price) if pos else 0.0
 
     def equity(self) -> float:
-        """Return the equity of the account. It calcaluates the sum of the mkt value of
-        each open position and adds the available cash.
+        """Return the equity of the account.
+        It calculates the sum mkt values of each open position and adds the available cash.
 
         The returned value is denoted in the base currency of the account.
         """

roboquant-0.3.2/roboquant/alpaca/__init__.py

@@ -0,0 +1,2 @@
+from roboquant.alpaca.feed import AlpacaLiveFeed, AlpacaHistoricCryptoFeed, AlpacaHistoricStockFeed
+from roboquant.alpaca.broker import AlpacaBroker

roboquant-0.3.0/roboquant/brokers/alpacabroker.py → roboquant-0.3.2/roboquant/alpaca/broker.py

@@ -110,23 +110,3 @@ class AlpacaBroker(LiveBroker):
     def _get_replace_request(self, order: Order):
         result = ReplaceOrderRequest(qty=int(abs(float(order.size))), limit_price=order.limit)
         return result
-
-
-if __name__ == "__main__":
-    broker = AlpacaBroker()
-    account = broker.sync()
-    print(account)
-
-    tsla_order = Order("TSLA", 10)
-    broker.place_orders([tsla_order])
-    time.sleep(5)
-    account = broker.sync()
-    print(account)
-
-    tesla_size = account.get_position_size("TSLA")
-    if tesla_size:
-        tsla_order = Order("TSLA", -tesla_size)
-        broker.place_orders([tsla_order])
-        time.sleep(5)
-        account = broker.sync()
-        print(account)

roboquant-0.3.2/roboquant/alpaca/feed.py

@@ -0,0 +1,182 @@
+from array import array
+from datetime import timedelta
+import threading
+from typing import Literal
+import numpy as np
+
+from alpaca.data import DataFeed
+from alpaca.data.enums import Adjustment
+from alpaca.data.historical.crypto import CryptoHistoricalDataClient
+from alpaca.data.historical.stock import StockHistoricalDataClient
+from alpaca.data.live.crypto import CryptoDataStream
+from alpaca.data.live.stock import StockDataStream
+from alpaca.data.live.option import OptionDataStream
+from alpaca.data.models.bars import BarSet
+from alpaca.data.models.quotes import QuoteSet
+from alpaca.data.models.trades import TradeSet
+from alpaca.data.requests import (
+    CryptoBarsRequest,
+    CryptoTradesRequest,
+    StockBarsRequest,
+    StockQuotesRequest,
+    StockTradesRequest,
+)
+from alpaca.data.timeframe import TimeFrame, TimeFrameUnit
+
+from roboquant.config import Config
+from roboquant.event import Event, Quote, Trade, Bar
+from roboquant.feeds.historic import HistoricFeed
+from roboquant.feeds.live import LiveFeed
+
+
+class AlpacaLiveFeed(LiveFeed):
+    """Subscribe to live market data for stocks, crypto currencies or options"""
+
+    __one_minute = str(timedelta(minutes=1))
+
+    def __init__(self, market: Literal["iex", "sip", "crypto", "option"] = "iex", api_key=None, secret_key=None) -> None:
+        super().__init__()
+        config = Config()
+        api_key = api_key or config.get("alpaca.public.key")
+        secret_key = secret_key or config.get("alpaca.secret.key")
+        match market:
+            case "sip":
+                self.stream = StockDataStream(api_key, secret_key, feed=DataFeed.SIP)
+            case "iex":
+                self.stream = StockDataStream(api_key, secret_key, feed=DataFeed.IEX)
+            case "crypto":
+                self.stream = CryptoDataStream(api_key, secret_key)
+            case "option":
+                self.stream = OptionDataStream(api_key, secret_key)
+            case _:
+                raise ValueError(f"unsupported value market={market}")
+
+        thread = threading.Thread(None, self.stream.run, daemon=True)
+        thread.start()
+
+    async def close(self):
+        await self.stream.close()
+
+    def __put_item(self, time, item):
+        event = Event(time, [item])
+        self.put(event)
+
+    async def __handle_trades(self, data):
+        item = Trade(data.symbol, data.price, data.size)
+        self.__put_item(data.timestamp, item)
+
+    async def __handle_bars(self, data):
+        item = Bar(data.symbol, array("f", [data.open, data.high, data.low, data.close, data.volume]), self.__one_minute)
+        self.__put_item(data.timestamp, item)
+
+    async def __handle_quotes(self, data):
+        item = Quote(data.symbol, array("f", [data.ask_price, data.ask_size, data.bid_price, data.bid_size]))
+        self.__put_item(data.timestamp, item)
+
+    def subscribe_trades(self, *symbols: str):
+        self.stream.subscribe_trades(self.__handle_trades, *symbols)
+
+    def subscribe_quotes(self, *symbols: str):
+        self.stream.subscribe_quotes(self.__handle_quotes, *symbols)
+
+    def subscribe_bars(self, *symbols: str):
+        self.stream.subscribe_bars(self.__handle_bars, *symbols)
+
+
+class _AlpacaHistoricFeed(HistoricFeed):
+
+    def _process_bars(self, bar_set, freq: str):
+        for symbol, data in bar_set.items():
+            for d in data:
+                time = d.timestamp
+                ohlcv = array("f", [d.open, d.high, d.low, d.close, d.volume])
+                item = Bar(symbol, ohlcv, freq)
+                super()._add_item(time, item)
+
+    def _process_trades(self, quote_set):
+        for symbol, data in quote_set.items():
+            for d in data:
+                time = d.timestamp
+                item = Trade(symbol, d.price, d.size)
+                super()._add_item(time, item)
+
+    def _process_quotes(self, quote_set):
+        for symbol, data in quote_set.items():
+            for d in data:
+                time = d.timestamp
+                arr = array("f", [d.ask_price, d.ask_size, d.bid_price, d.bid_size])
+
+                if np.all(arr):
+                    # on rare occasions values are missing and have 0.0 as a value
+                    item = Quote(symbol, arr)
+                    super()._add_item(time, item)
+
+
+class AlpacaHistoricStockFeed(_AlpacaHistoricFeed):
+    """Get historic stock prices from Alpaca.
+    Support for bars, trades and quotes.
+    """
+
+    def __init__(self, api_key=None, secret_key=None, data_api_url=None, feed: DataFeed | None = None):
+        super().__init__()
+        config = Config()
+        api_key = api_key or config.get("alpaca.public.key")
+        secret_key = secret_key or config.get("alpaca.secret.key")
+        self.client = StockHistoricalDataClient(api_key, secret_key, url_override=data_api_url)
+        self.feed = feed
+
+    def retrieve_bars(
+        self,
+        *symbols,
+        start=None,
+        end=None,
+        resolution: TimeFrame | None = None,
+        adjustment=Adjustment.ALL
+    ):
+        resolution = resolution or TimeFrame(amount=1, unit=TimeFrameUnit.Day)
+        req = StockBarsRequest(
+            symbol_or_symbols=list(symbols), timeframe=resolution, start=start, end=end, adjustment=adjustment, feed=self.feed
+        )
+        res = self.client.get_stock_bars(req)
+        assert isinstance(res, BarSet)
+        freq = str(resolution)
+        self._process_bars(res.data, freq)
+
+    def retrieve_trades(self, *symbols, start=None, end=None):
+        req = StockTradesRequest(symbol_or_symbols=list(symbols), start=start, end=end, feed=self.feed)
+        res = self.client.get_stock_trades(req)
+        assert isinstance(res, TradeSet)
+        self._process_trades(res.data)
+
+    def retrieve_quotes(self, *symbols, start=None, end=None):
+        req = StockQuotesRequest(symbol_or_symbols=list(symbols), start=start, end=end, feed=self.feed)
+        res = self.client.get_stock_quotes(req)
+        assert isinstance(res, QuoteSet)
+        self._process_quotes(res.data)
+
+
+class AlpacaHistoricCryptoFeed(_AlpacaHistoricFeed):
+    """Get historic crypto-currency prices from Alpaca.
+    Support for bars and trades.
+    """
+
+    def __init__(self, api_key=None, secret_key=None, data_api_url=None):
+        super().__init__()
+        config = Config()
+        api_key = api_key or config.get("alpaca.public.key")
+        secret_key = secret_key or config.get("alpaca.secret.key")
+        self.client = CryptoHistoricalDataClient(api_key, secret_key, url_override=data_api_url)
+
+    def retrieve_bars(self, *symbols, start=None, end=None, resolution: TimeFrame | None = None):
+        resolution = resolution or TimeFrame(amount=1, unit=TimeFrameUnit.Day)
+        req = CryptoBarsRequest(symbol_or_symbols=list(symbols), timeframe=resolution, start=start, end=end)
+        res = self.client.get_crypto_bars(req)
+        assert isinstance(res, BarSet)
+        freq = str(resolution)
+        self._process_bars(res.data, freq)
+
+    def retrieve_trades(self, *symbols, start=None, end=None):
+        req = CryptoTradesRequest(symbol_or_symbols=list(symbols), start=start, end=end)
+        res = self.client.get_crypto_trades(req)
+        assert isinstance(res, TradeSet)
+        self._process_trades(res.data)

{roboquant-0.3.0 → roboquant-0.3.2}/roboquant/brokers/simbroker.py

@@ -5,7 +5,7 @@ import logging
 
 from roboquant.account import Account, Position
 from roboquant.brokers.broker import Broker, _update_positions
-from roboquant.event import Event, PriceItem
+from roboquant.event import Event, PriceItem, Quote
 from roboquant.order import Order, OrderStatus
 
 logger = logging.getLogger(__name__)
@@ -86,6 +86,8 @@ class SimBroker(Broker):
 
         The default implementation is a fixed slippage percentage based on the configured price_type.
         """
+        if isinstance(item, Quote):
+            return item.ask_price if order.is_buy else item.bid_price
 
         price = item.price(self.price_type)
         correction = self.slippage if order.is_buy else -self.slippage
@@ -189,17 +191,32 @@ class SimBroker(Broker):
         item = self._last_known_prices.get(symbol)
         return item.price(self.price_type) if item else None
 
-    def calculate_buyingpower(self):
-        """Calculate buying power, based on the available cash minus the open orders"""
-        bp = self._account.cash
+    def _calculate_open_orders(self):
+        reserved = 0.0
         for order in self._account.open_orders():
             old_pos = self._account.get_position_size(order.symbol)
             remaining = order.size - order.fill
+
+            # only update reserved amount if remaining order size would increase position size
             if abs(old_pos + remaining) > abs(old_pos):
-                price = order.limit or self._get_last_known_price(order.symbol)
-                if price:
-                    reserve = self._account.contract_value(order.symbol, remaining, price)
-                    bp -= abs(reserve)
+                if price := (order.limit or self._get_last_known_price(order.symbol)):
+                    reserved += abs(self._account.contract_value(order.symbol, remaining, price))
+
+        return reserved
+
+    def _calculate_short_positions(self):
+        reserved = 0.0
+        for symbol, position in self._account.positions.items():
+            if position.is_short:
+                short_value = self._account.contract_value(symbol, position.size, position.mkt_price)
+                reserved += abs(short_value)
+        return reserved
+
+    def _calculate_buyingpower(self):
+        """Calculate buying power, based on the available cash minus the open orders and short positions"""
+        bp = self._account.cash
+        bp -= self._calculate_open_orders()
+        bp -= self._calculate_short_positions()
         return bp
 
     def sync(self, event: Event | None = None) -> Account:
@@ -223,9 +240,9 @@ class SimBroker(Broker):
         _update_positions(acc, event, self.price_type)
 
         acc.orders = list(self._create_orders.values())
-        acc.buying_power = self.calculate_buyingpower()
+        acc.buying_power = self._calculate_buyingpower()
         return acc
 
-    def __str__(self) -> str:
+    def __repr__(self) -> str:
         attrs = " ".join([f"{k}={v}" for k, v in self.__dict__.items() if not k.startswith("_")])
         return f"SimBroker({attrs})"

{roboquant-0.3.0 → roboquant-0.3.2}/roboquant/config.py

@@ -4,7 +4,10 @@ from configparser import ConfigParser
 
 
 class Config:
-    """Access to the roboquant configuration file"""
+    """Access to the roboquant configuration file.
+    This allows to share the same property file for both the Python and Kotlin
+    version of roboquant.
+    """
 
     def __init__(self, path=None):
         path = path or os.path.expanduser("~/.roboquant/.env")

{roboquant-0.3.0 → roboquant-0.3.2}/roboquant/event.py

@@ -28,7 +28,7 @@ class PriceItem:
 
 @dataclass(slots=True)
 class Quote(PriceItem):
-    data: array
+    data: array  # [ask-price, ask-volume, bid-price, bid-volume]
 
     def price(self, price_type: str = "DEFAULT") -> float:
         """Return the price, the default being the mid-point price"""
@@ -42,6 +42,14 @@ class Quote(PriceItem):
                 # Default is the mid-point price
                 return (self.data[0] + self.data[2]) / 2.0
 
+    @property
+    def ask_price(self) -> float:
+        return self.data[0]
+
+    @property
+    def bid_price(self) -> float:
+        return self.data[2]
+
     @property
     def ask_volume(self) -> float:
         return self.data[1]
@@ -82,7 +90,7 @@ class Trade(PriceItem):
 
 @dataclass(slots=True)
 class Bar(PriceItem):
-    """Represents a bar (a.k.a candlestick) with open, high, low, close and volume data.
+    """Represents a bar (a.k.a. candlestick) with open-, high-, low-, close-price and volume data.
     """
 
     ohlcv: array
@@ -130,10 +138,10 @@ class Event:
 
     def is_empty(self) -> bool:
         """return True if this is an empty event without any items, False otherwise"""
-        return len(self) == 0
+        return len(self.items) == 0
 
-    def __len__(self) -> int:
-        return len(self.items)
+    # def __len__(self) -> int:
+    #    return len(self.items)
 
     @cached_property
     def price_items(self) -> dict[str, PriceItem]:

{roboquant-0.3.0 → roboquant-0.3.2}/roboquant/feeds/__init__.py

@@ -1,5 +1,6 @@
 from roboquant.feeds import feedutil
 from .aggregate import AggregatorFeed
+from .collect import CollectorFeed
 from .csvfeed import CSVFeed
 from .eventchannel import EventChannel
 from .feed import Feed
@@ -7,12 +8,7 @@ from .historic import HistoricFeed
 from .randomwalk import RandomWalk
 from .sqllitefeed import SQLFeed
 from .tiingo import TiingoLiveFeed, TiingoHistoricFeed
-from .feedutil import get_sp500_symbols
-
-try:
-    from .alpacafeed import AlpacaLiveFeed
-except ImportError:
-    pass
+from .feedutil import get_sp500_symbols, print_feed_items, count_events
 
 try:
     from .yahoo import YahooFeed

{roboquant-0.3.0 → roboquant-0.3.2}/roboquant/feeds/aggregate.py

@@ -8,17 +8,17 @@ from .feed import Feed
 
 
 class AggregatorFeed(Feed):
-    """Aggregates Trades or Quotes of another feed into a `Bar`.
+    """Aggregates Trades or Quotes of another feed into a `Bar` prices.
 
-    When trades are used, the actual trade price and volume are used to create the aggregated bars.
-    When quotes are used, the midpoint price and no volume are used to create the aggregated bars.
+    When trades are used, the actual trade prices and volumes are used to create the aggregated bars.
+    When quotes are used, the midpoint prices and no volumes are used to create the aggregated bars.
     """
 
     def __init__(
         self,
         feed: Feed,
         frequency: timedelta,
-        item_type: Literal["trade", "quote"] = "trade",
+        price_type: Literal["trade", "quote"] = "trade",
         send_remaining=False,
         continuation=True,
     ):
@@ -27,16 +27,16 @@ class AggregatorFeed(Feed):
         self.freq = frequency
         self.send_remaining = send_remaining
         self.continuation = continuation
-        self.item_type = item_type
+        self.price_type = price_type
 
     def __aggr_trade2bar(self, evt: Event, bars: dict[str, Bar], freq: str):
 
         for item in evt.items:
 
-            if self.item_type == "trade" and isinstance(item, Trade):
+            if self.price_type == "trade" and isinstance(item, Trade):
                 price = item.trade_price
                 volume = item.trade_volume
-            elif self.item_type == "quote" and isinstance(item, Quote):
+            elif self.price_type == "quote" and isinstance(item, Quote):
                 price = item.midpoint_price
                 volume = float("nan")
             else:
@@ -59,7 +59,7 @@ class AggregatorFeed(Feed):
         result = {}
         for symbol, item in bars.items():
             p = item.price("CLOSE")
-            v = 0.0 if self.item_type == "trade" else float("nan")
+            v = 0.0 if self.price_type == "trade" else float("nan")
             b = Bar(symbol, array("f", [p, p, p, p, v]))
             result[symbol] = b
         return result

roboquant-0.3.2/roboquant/feeds/avrofeed.py

@@ -0,0 +1,120 @@
+import logging
+import os.path
+from datetime import datetime
+from array import array
+import time
+
+from fastavro import writer, reader, parse_schema
+
+from roboquant.alpaca.feed import AlpacaHistoricStockFeed
+from roboquant.event import Quote, Bar, Trade
+from roboquant.event import Event
+from roboquant.feeds.eventchannel import EventChannel
+from roboquant.feeds.feed import Feed
+from roboquant.feeds.feedutil import count_events
+
+logger = logging.getLogger(__name__)
+
+
+class AvroFeed(Feed):
+
+    _schema = {
+        "namespace": "org.roboquant.avro.schema",
+        "type": "record",
+        "name": "PriceItemV2",
+        "fields": [
+            {"name": "timestamp", "type": "string"},
+            {"name": "symbol", "type": "string"},
+            {"name": "type", "type": {"type": "enum", "name": "item_type", "symbols": ["BAR", "TRADE", "QUOTE", "BOOK"]}},
+            {"name": "values", "type": {"type": "array", "items": "double"}},
+            {"name": "meta", "type": ["null", "string"], "default": None},
+        ],
+    }
+
+    def __init__(self, avro_file) -> None:
+        super().__init__()
+        self.avro_file = avro_file
+        logger.info("avro feed file=%s", avro_file)
+
+    def exists(self):
+        return os.path.exists(self.avro_file)
+
+    def play(self, channel: EventChannel):
+        t_old = ""
+        items = []
+
+        with open(self.avro_file, "rb") as fo:
+            for row in reader(fo):
+                t = row["timestamp"]  # type: ignore
+
+                if t != t_old:
+                    if items:
+                        dt = datetime.fromisoformat(t)
+                        event = Event(dt, items)
+                        channel.put(event)
+                        items = []
+                    t_old = t
+
+                price_type = str(row["type"])  # type: ignore
+                match (price_type):
+                    case "QUOTE":
+                        item = Quote(row["symbol"], array("f", row["values"]))  # type: ignore
+                        items.append(item)
+                    case "BAR":
+                        item = Bar(row["symbol"], array("f", row["values"]), row["other"])  # type: ignore
+                        items.append(item)
+                    case "TRADE":
+                        prices = row["values"]  # type: ignore
+                        item = Trade(row["symbol"], prices[0], prices[1])  # type: ignore
+                        items.append(item)
+                    case _:
+                        raise ValueError(f"Unsupported priceItem type={price_type}")
+
+    def record(self, feed: Feed, timeframe=None):
+        schema = parse_schema(AvroFeed._schema)
+        channel = feed.play_background(timeframe)
+        records = []
+        while event := channel.get():
+            t = event.time.isoformat()
+            for item in event.items:
+
+                match item:
+                    case Quote():
+                        data = {"timestamp": t, "type": "QUOTE", "symbol": item.symbol, "values": list(item.data)}
+                        records.append(data)
+                    case Trade():
+                        data = {
+                            "timestamp": t,
+                            "type": "TRADE",
+                            "symbol": item.symbol,
+                            "values": [item.trade_price, item.trade_volume],
+                        }
+                        records.append(data)
+                    case Bar():
+                        data = {
+                            "timestamp": t,
+                            "type": "BAR",
+                            "symbol": item.symbol,
+                            "values": list(item.ohlcv),
+                            "meta": item.frequency,
+                        }
+                        records.append(data)
+
+        with open(self.avro_file, "wb") as out:
+            writer(out, schema, records)
+
+    def __repr__(self) -> str:
+        return f"AvroFeed(path={self.avro_file})"
+
+
+if __name__ == "__main__":
+
+    avroFeed = AvroFeed("/tmp/test.avro")
+    if not avroFeed.exists():
+        alpaca_feed = AlpacaHistoricStockFeed()
+        alpaca_feed.retrieve_quotes("AAPL", start="2024-05-24T00:00:00Z", end="2024-05-25T00:00:00Z")
+        avroFeed.record(alpaca_feed)
+
+    start = time.time()
+    print("events=", count_events(avroFeed), "time=", time.time() - start)
+    # print_feed_items(feed)

roboquant-0.3.2/roboquant/feeds/collect.py

@@ -0,0 +1,33 @@
+
+from roboquant.event import Event
+from .eventchannel import EventChannel
+from .feed import Feed
+
+
+class CollectorFeed(Feed):
+    """Collect events that occur close after ech other into a single new event.
+
+    Close to eachother is defined by the timeout is seconds. If there is no new
+    event in the specified timeout, all the previously collected event items will
+    be bundled together and put on the channel as a single event.
+    """
+
+    def __init__(
+        self,
+        feed: Feed,
+        timeout=5.0,
+    ):
+        super().__init__()
+        self.feed = feed
+        self.timeout = timeout
+
+    def play(self, channel: EventChannel):
+        src_channel = self.feed.play_background(channel.timeframe, channel.maxsize)
+        items = []
+        while event := src_channel.get(self.timeout):
+            if event.is_empty() and items:
+                new_event = Event(event.time, items)
+                channel.put(new_event)
+                items = []
+
+            items.extend(event.items)

{roboquant-0.3.0 → roboquant-0.3.2}/roboquant/feeds/csvfeed.py

@@ -24,7 +24,7 @@ class CSVColumn(str, Enum):
     ADJ_CLOSE = "Adj CLose"
     TIME = "Time"
 
-    def __str__(self) -> str:
+    def __repr__(self) -> str:
         return self.value
 
     @staticmethod
@@ -121,7 +121,7 @@ class CSVFeed(HistoricFeed):
 
         class StooqDailyFeed(CSVFeed):
             def __init__(self):
-                # from Python 3.11 onwards we can use the fast standard ISO parsing
+                # from Python 3.11 onwards, we can use the fast standard ISO parsing
                 if sys.version_info >= (3, 11):
                     super().__init__(path, columns=columns, time_offset="21:00:00+00:00", endswith=".txt", frequency="1d")
                 else:
@@ -147,7 +147,7 @@ class CSVFeed(HistoricFeed):
 
         class StooqIntradayFeed(CSVFeed):
             def __init__(self):
-                # from Python 3.11 onwards we can use the faster standard ISO parsing
+                # from Python 3.11 onwards, we can use the faster standard ISO parsing
                 if sys.version_info >= (3, 11):
                     super().__init__(path, columns=columns, has_time_column=True, endswith=".txt")
                 else:
@@ -171,11 +171,3 @@ class CSVFeed(HistoricFeed):
         """Parse one or more CSV files that meet the Yahoo Finance format"""
         columns = ["Date", "Open", "High", "Low", "Close", "Volume", "Adj Close"]
         return cls(path, columns=columns, adj_close=True, time_offset="21:00:00+00:00", frequency=frequency)
-
-
-if __name__ == "__main__":
-    t = datetime.strptime("210000", "%H%M%S").time()
-    print(t)
-
-    t = time.fromisoformat("210000")
-    print(t)