zipline_polygon_bundle 0.1.7__py3-none-any.whl → 0.1.8__py3-none-any.whl

zipline_polygon_bundle/__init__.py

@@ -7,7 +7,14 @@ from .bundle import (
 
 from .config import PolygonConfig
 from .concat_all_aggs import concat_all_aggs_from_csv, generate_csv_agg_tables
-from .adjustments import load_splits, load_dividends
+from .adjustments import load_splits, load_dividends, load_conditions
+from .trades import trades_schema, trades_dataset, cast_trades, date_to_path
+from .trades import custom_aggs_partitioning, custom_aggs_schema, trades_to_custom_aggs, convert_all_to_custom_aggs
+from .trades import get_custom_aggs_dates, generate_csv_trades_tables, compute_signals_for_all_custom_aggs
+from .quotes import quotes_schema, quotes_dataset, cast_quotes
+# from .tickers_and_names import load_all_tickers, merge_tickers, ticker_names_from_merged_tickers, get_ticker_universe
+from .tickers_and_names import PolygonAssets, get_ticker_universe
+
 
 __all__ = [
     "register_polygon_equities_bundle",
@@ -19,4 +26,24 @@ __all__ = [
     "generate_csv_agg_tables",
     "load_splits",
     "load_dividends",
+    "load_conditions",
+    "trades_schema",
+    "trades_dataset",
+    "cast_trades",
+    "date_to_path",
+    "get_custom_aggs_dates",
+    "generate_csv_trades_tables",
+    "custom_aggs_partitioning",
+    "custom_aggs_schema",
+    "trades_to_custom_aggs",
+    "convert_all_to_custom_aggs",
+    "compute_signals_for_all_custom_aggs",
+    "quotes_schema",
+    "quotes_dataset",
+    "cast_quotes",
+    # "load_all_tickers", 
+    # "merge_tickers",
+    # "ticker_names_from_merged_tickers",
+    "PolygonAssets",
+    "get_ticker_universe",
 ]

zipline_polygon_bundle/adjustments.py

@@ -153,3 +153,37 @@ def load_dividends(
     return dividends[
         ["sid", "ex_date", "declared_date", "record_date", "pay_date", "amount"]
     ]
+
+
+def load_conditions(config: PolygonConfig) -> pd.DataFrame:
+    # The API doesn't use dates for the condition codes but this is a way to provide control over caching.
+    # Main thing is to get the current conditions list but we don't want to call more than once a day.
+    conditions_path = config.api_cache_path(
+        start_date=config.start_timestamp.date(), end_date=config.end_timestamp.date(), filename="conditions"
+    )
+    expected_conditions_count = 100
+    if not os.path.exists(conditions_path):
+        client = polygon.RESTClient(api_key=config.api_key)
+        conditions_response = client.list_conditions(
+            limit=1000,
+        )
+        if conditions_response is HTTPResponse:
+            raise ValueError(f"Polygon.list_splits bad HTTPResponse: {conditions_response}")
+        conditions = pd.DataFrame(conditions_response)
+        print(f"Got {len(conditions)=} from Polygon list_conditions.")
+        os.makedirs(os.path.dirname(conditions_path), exist_ok=True)
+        conditions.to_parquet(conditions_path)
+        if len(conditions) < expected_conditions_count:
+            logging.warning(
+                f"Only got {len(conditions)=} from Polygon list_splits (expected {expected_conditions_count=}).  "
+            )
+        # We will always load from the file to avoid any chance of weird errors.
+    if os.path.exists(conditions_path):
+        conditions = pd.read_parquet(conditions_path)
+        print(f"Loaded {len(conditions)=} from {conditions_path}")
+        if len(conditions) < expected_conditions_count:
+            logging.warning(
+                f"Only got {len(conditions)=} from cached conditions (expected {expected_conditions_count=}).  "
+            )
+        return conditions
+    raise ValueError(f"Failed to load splits from {conditions_path}")

zipline_polygon_bundle/bundle.py

@@ -1,18 +1,21 @@
+import os
 from zipline.data.bundles import register
 from zipline.data.resample import minute_frame_to_session_frame
 
+from exchange_calendars.calendar_helpers import parse_date
+from zipline.utils.calendar_utils import get_calendar
+
 from .config import PolygonConfig
 from .concat_all_aggs import concat_all_aggs_from_csv, generate_csv_agg_tables
 from .adjustments import load_splits, load_dividends
 
 import pyarrow
 import pyarrow.compute
+import pyarrow.dataset
 
 import pandas as pd
 import logging
 
-import concurrent.futures
-
 
 # TODO: Change warnings to be relative to number of days in the range.
 
@@ -175,8 +178,8 @@ def polygon_equities_bundle_day(
     daily_bar_writer,
     adjustment_writer,
     calendar,
-    start_session,
-    end_session,
+    start_date,
+    end_date,
     cache,
     show_progress,
     output_dir,
@@ -184,8 +187,8 @@ def polygon_equities_bundle_day(
     config = PolygonConfig(
         environ=environ,
         calendar_name=calendar.name,
-        start_session=start_session,
-        end_session=end_session,
+        start_date=start_date,
+        end_date=end_date,
         agg_time="day",
     )
 
@@ -219,7 +222,7 @@ def polygon_equities_bundle_day(
     daily_bar_writer.write(
         process_day_aggregates(
             table=table,
-            sessions=calendar.sessions_in_range(start_session, end_session),
+            sessions=calendar.sessions_in_range(start_date, end_date),
             metadata=metadata,
             calendar=calendar,
             symbol_to_sid=symbol_to_sid,
@@ -400,8 +403,8 @@ def polygon_equities_bundle_minute(
     daily_bar_writer,
     adjustment_writer,
     calendar,
-    start_session,
-    end_session,
+    start_date,
+    end_date,
     cache,
     show_progress,
     output_dir,
@@ -409,8 +412,8 @@ def polygon_equities_bundle_minute(
     config = PolygonConfig(
         environ=environ,
         calendar_name=calendar.name,
-        start_session=start_session,
-        end_session=end_session,
+        start_date=start_date,
+        end_date=end_date,
         agg_time="minute",
     )
 
@@ -444,8 +447,8 @@ def polygon_equities_bundle_minute(
     daily_bar_writer.write(
         process_minute_aggregates(
             fragments=aggregates.get_fragments(),
-            sessions=calendar.sessions_in_range(start_session, end_session),
-            minutes=calendar.sessions_minutes(start_session, end_session),
+            sessions=calendar.sessions_in_range(start_date, end_date),
+            minutes=calendar.sessions_minutes(start_date, end_date),
             metadata=metadata,
             calendar=calendar,
             symbol_to_sid=symbol_to_sid,
@@ -459,8 +462,8 @@ def polygon_equities_bundle_minute(
     minute_bar_writer.write(
         process_minute_aggregates(
             fragments=aggregates.get_fragments(),
-            sessions=calendar.sessions_in_range(start_session, end_session),
-            minutes=calendar.sessions_minutes(start_session, end_session),
+            sessions=calendar.sessions_in_range(start_date, end_date),
+            minutes=calendar.sessions_minutes(start_date, end_date),
             metadata=metadata,
             calendar=calendar,
             symbol_to_sid=symbol_to_sid,
@@ -485,8 +488,8 @@ def polygon_equities_bundle_minute(
 
 def register_polygon_equities_bundle(
     bundlename,
-    start_session=None,
-    end_session=None,
+    start_date=None,
+    end_date=None,
     calendar_name="XNYS",
     agg_time="day",
     # ticker_list=None,
@@ -495,6 +498,25 @@ def register_polygon_equities_bundle(
 ):
     if agg_time not in ["day", "minute"]:
         raise ValueError(f"agg_time must be 'day' or 'minute', not '{agg_time}'")
+    # We need to know the start and end dates of the session before the bundle is
+    # registered because even though we only need it for ingest, the metadata in 
+    # the writer is initialized and written before our ingest function is called.
+    if start_date is None or end_date is None:
+        config = PolygonConfig(
+            environ=os.environ,
+            calendar_name=calendar_name,
+            start_date=start_date,
+            end_date=end_date,
+            agg_time=agg_time,
+        )
+        first_aggs_date, last_aggs_date = config.find_first_and_last_aggs()
+        if start_date is None:
+            start_date = first_aggs_date
+        if end_date is None:
+            end_date = last_aggs_date
+
+    calendar = get_calendar(calendar_name)
+
     register(
         bundlename,
         (
@@ -502,8 +524,8 @@ def register_polygon_equities_bundle(
             if agg_time == "minute"
             else polygon_equities_bundle_day
         ),
-        start_session=start_session,
-        end_session=end_session,
+        start_session=parse_date(start_date, calendar=calendar),
+        end_session=parse_date(end_date, calendar=calendar),
         calendar_name=calendar_name,
         # minutes_per_day=390,
         # create_writers=True,
@@ -517,12 +539,12 @@ def register_polygon_equities_bundle(
 #     config = PolygonConfig(
 #         environ=os.environ,
 #         calendar_name="XNYS",
-#         # start_session="2003-10-01",
-#         # start_session="2018-01-01",
-#         start_session="2023-01-01",
-#         # end_session="2023-01-12",
-#         end_session="2023-12-31",
-#         # end_session="2024-06-30",
+#         # start_date="2003-10-01",
+#         # start_date="2018-01-01",
+#         start_date="2023-01-01",
+#         # end_date="2023-01-12",
+#         end_date="2023-12-31",
+#         # end_date="2024-06-30",
 #     )
 #     splits = load_polygon_splits(config)
 #     splits.info()

zipline_polygon_bundle/concat_all_aggs.py

@@ -1,7 +1,7 @@
 from .config import PolygonConfig
 
 import shutil
-from typing import Iterator, Tuple
+from typing import Iterator, Tuple, List, Union
 
 import argparse
 import glob
@@ -10,6 +10,7 @@ import os
 import pyarrow as pa
 from pyarrow import dataset as pa_ds
 from pyarrow import csv as pa_csv
+from pyarrow import compute as pa_compute
 
 import pandas as pd
 
@@ -34,7 +35,7 @@ def to_partition_key(s: str) -> str:
 
 
 def generate_tables_from_csv_files(
-    paths: list,
+    paths: Iterator[Union[str, os.PathLike]],
     schema: pa.Schema,
     start_timestamp: pd.Timestamp,
     limit_timestamp: pd.Timestamp,
@@ -57,7 +58,7 @@ def generate_tables_from_csv_files(
             quoted_strings_can_be_null=False,
         )
 
-        table = pa.csv.read_csv(path, convert_options=convert_options)
+        table = pa_csv.read_csv(path, convert_options=convert_options)
         tables_read_count += 1
         table = table.set_column(
             table.column_names.index("window_start"),
@@ -75,10 +76,10 @@ def generate_tables_from_csv_files(
                 ),
             )
         expr = (
-            pa.compute.field("window_start")
+            pa_compute.field("window_start")
             >= pa.scalar(start_timestamp, type=schema.field("window_start").type)
         ) & (
-            pa.compute.field("window_start")
+            pa_compute.field("window_start")
             < pa.scalar(
                 limit_timestamp,
                 type=schema.field("window_start").type,
@@ -101,22 +102,8 @@ def generate_tables_from_csv_files(
 
 def generate_csv_agg_tables(
     config: PolygonConfig,
-) -> Tuple[list[str], pa.Schema, Iterator[pa.Table]]:
+) -> Tuple[pa.Schema, Iterator[pa.Table]]:
     """zipline does bundle ingestion one ticker at a time."""
-    # We sort by path because they have the year and month in the dir names and the date in the filename.
-    paths = sorted(
-        list(
-            glob.glob(
-                os.path.join(config.aggs_dir, config.csv_paths_pattern),
-                recursive="**" in config.csv_paths_pattern,
-            )
-        )
-    )
-
-    print(f"{len(paths)=}")
-    if len(paths) > 0:
-        print(f"{paths[0]=}")
-        print(f"{paths[-1]=}")
 
     # Polygon Aggregate flatfile timestamps are in nanoseconds (like trades), not milliseconds as the docs say.
     # I make the timestamp timezone-aware because that's how Unix timestamps work and it may help avoid mistakes.
@@ -154,11 +141,11 @@ def generate_csv_agg_tables(
             pa.field(PARTITION_COLUMN_NAME, pa.string(), nullable=False)
         )
 
+    # TODO: Use generator like os.walk for paths.
     return (
-        paths,
         polygon_aggs_schema,
         generate_tables_from_csv_files(
-            paths=paths,
+            paths=config.csv_paths(),
             schema=polygon_aggs_schema,
             start_timestamp=config.start_timestamp,
             limit_timestamp=config.end_timestamp + pd.to_timedelta(1, unit="day"),
@@ -176,11 +163,9 @@ def concat_all_aggs_from_csv(
     config: PolygonConfig,
     overwrite: bool = False,
 ) -> str:
-    paths, schema, tables = generate_csv_agg_tables(config)
+    schema, tables = generate_csv_agg_tables(config)
 
-    if len(paths) < 1:
-        raise ValueError(f"No Polygon CSV flat files found in {config.aggs_dir=}")
-    by_ticker_aggs_arrow_dir = config.by_ticker_aggs_arrow_dir(paths[0], paths[-1])
+    by_ticker_aggs_arrow_dir = config.by_ticker_aggs_arrow_dir
     if os.path.exists(by_ticker_aggs_arrow_dir):
         if overwrite:
             print(f"Removing {by_ticker_aggs_arrow_dir=}")
@@ -212,10 +197,10 @@ if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("--calendar_name", default="XNYS")
 
-    parser.add_argument("--start_session", default="2014-06-16")
-    parser.add_argument("--end_session", default="2024-09-06")
-    # parser.add_argument("--start_session", default="2020-01-01")
-    # parser.add_argument("--end_session", default="2020-12-31")
+    parser.add_argument("--start_date", default="2014-06-16")
+    parser.add_argument("--end_date", default="2024-09-06")
+    # parser.add_argument("--start_date", default="2020-01-01")
+    # parser.add_argument("--end_date", default="2020-12-31")
 
     parser.add_argument("--agg_time", default="day")
 
@@ -235,8 +220,8 @@ if __name__ == "__main__":
     config = PolygonConfig(
         environ=os.environ,
         calendar_name=args.calendar_name,
-        start_session=args.start_session,
-        end_session=args.end_session,
+        start_date=args.start_date,
+        end_date=args.end_date,
         agg_time=args.agg_time,
     )
 

zipline_polygon_bundle/concat_all_aggs_partitioned.py

@@ -138,10 +138,10 @@ if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("--calendar_name", default="XNYS")
 
-    parser.add_argument("--start_session", default="2014-06-16")
-    parser.add_argument("--end_session", default="2024-09-06")
-    # parser.add_argument("--start_session", default="2020-10-07")
-    # parser.add_argument("--end_session", default="2020-10-15")
+    parser.add_argument("--start_date", default="2014-06-16")
+    parser.add_argument("--end_date", default="2024-09-06")
+    # parser.add_argument("--start_date", default="2020-10-07")
+    # parser.add_argument("--end_date", default="2020-10-15")
     # parser.add_argument("--aggs_pattern", default="2020/10/**/*.csv.gz")
     parser.add_argument("--aggs_pattern", default="**/*.csv.gz")
 
@@ -163,8 +163,8 @@ if __name__ == "__main__":
     config = PolygonConfig(
         environ=os.environ,
         calendar_name=args.calendar_name,
-        start_session=args.start_session,
-        end_session=args.end_session,
+        start_date=args.start_date,
+        end_date=args.end_date,
     )
 
     concat_all_aggs_from_csv(

zipline_polygon_bundle/config.py

@@ -1,8 +1,13 @@
 from exchange_calendars.calendar_helpers import Date, parse_date, parse_timestamp
 from zipline.utils.calendar_utils import get_calendar
 
-import os
+from typing import Iterator, Tuple, List
+
 import pandas as pd
+from pyarrow.fs import LocalFileSystem
+import os
+import re
+import fnmatch
 
 
 class PolygonConfig:
@@ -10,33 +15,35 @@ class PolygonConfig:
         self,
         environ: dict,
         calendar_name: str,
-        start_session: Date,
-        end_session: Date,
+        start_date: Date,
+        end_date: Date,
         agg_time: str = "day",
+        custom_aggs_format: str = "{config.agg_timedelta.seconds}sec_aggs",
     ):
-        if agg_time not in ["minute", "day"]:
-            raise ValueError(f"agg_time must be 'minute' or 'day', got '{agg_time}'")
         self.calendar_name = calendar_name
+        self.start_date = start_date
+        self.end_date = end_date
         self.start_timestamp = (
-            parse_date(start_session, calendar=self.calendar)
-            if start_session
+            parse_date(start_date, calendar=self.calendar)
+            if start_date
             else self.calendar.first_session
         )
         self.end_timestamp = (
-            parse_date(end_session, calendar=self.calendar)
-            if end_session
+            parse_date(end_date, calendar=self.calendar)
+            if end_date
             else self.calendar.last_session
         )
         self.max_workers = None
         if environ.get("POLYGON_MAX_WORKERS", "").strip() != "":
             self.max_workers = int(environ.get("POLYGON_MAX_WORKERS"))
         self.api_key = environ.get("POLYGON_API_KEY")
+        self.filesystem = LocalFileSystem()
         self.data_dir = environ.get("POLYGON_DATA_DIR", "data/files.polygon.io")
         self.cik_cusip_mapping_csv_path = environ.get(
             "CIK_CUSIP_MAPS_CSV", os.path.join(self.data_dir, "cik-cusip-maps.csv")
         )
-        self.asset_subdir = environ.get("POLYGON_ASSET_SUBDIR", "us_stocks_sip")
         self.market = environ.get("POLYGON_MARKET", "stocks")
+        self.asset_subdir = environ.get("POLYGON_ASSET_SUBDIR", "us_stocks_sip")
         self.tickers_dir = environ.get(
             "POLYGON_TICKERS_DIR",
             os.path.join(os.path.join(self.data_dir, "tickers"), self.asset_subdir),
@@ -51,25 +58,54 @@ class PolygonConfig:
         self.flat_files_dir = environ.get(
             "POLYGON_FLAT_FILES_DIR", os.path.join(self.data_dir, "flatfiles")
         )
-        self.csv_paths_pattern = environ.get("POLYGON_FLAT_FILES_CSV_PATTERN", "**/*.csv.gz")
-        self.agg_time = agg_time
+        # TODO: Restore non-recusive option.  Always recursive for now.
+        self.csv_paths_pattern = environ.get(
+            # "POLYGON_FLAT_FILES_CSV_PATTERN", "**/*.csv.gz"
+            "POLYGON_FLAT_FILES_CSV_PATTERN", "*.csv.gz"
+        )
         self.asset_files_dir = os.path.join(self.flat_files_dir, self.asset_subdir)
         self.minute_aggs_dir = os.path.join(self.asset_files_dir, "minute_aggs_v1")
         self.day_aggs_dir = os.path.join(self.asset_files_dir, "day_aggs_v1")
-        self.aggs_dir = (
-            self.minute_aggs_dir if self.agg_time == "minute" else self.day_aggs_dir
-        )
+        self.trades_dir = os.path.join(self.asset_files_dir, "trades_v1")
+        self.quotes_dir = os.path.join(self.asset_files_dir, "quotes_v1")
+
         # TODO: The "by ticker" files are temporary/intermediate and should/could be in the zipline data dir.
         self.minute_by_ticker_dir = os.path.join(
             self.asset_files_dir, "minute_by_ticker_v1"
         )
         self.day_by_ticker_dir = os.path.join(self.asset_files_dir, "day_by_ticker_v1")
-        self.by_ticker_dir = (
-            self.minute_by_ticker_dir
-            if self.agg_time == "minute"
-            else self.day_by_ticker_dir
+
+        if bool(re.match(r"^\d", agg_time)):
+            self.agg_timedelta = pd.to_timedelta(agg_time)
+            self.custom_asset_files_dir = environ.get(
+                "CUSTOM_ASSET_FILES_DIR", self.asset_files_dir
+            )
+            self.custom_aggs_dir = os.path.join(
+                self.custom_asset_files_dir, custom_aggs_format.format(config=self)
+            )
+            self.custom_aggs_by_ticker_dir = os.path.join(
+                self.custom_asset_files_dir,
+                (custom_aggs_format + "_by_ticker").format(config=self),
+            )
+            self.aggs_dir = self.custom_aggs_dir
+            self.by_ticker_dir = self.custom_aggs_by_ticker_dir
+        elif agg_time == "minute":
+            self.agg_timedelta = pd.to_timedelta("1minute")
+            self.aggs_dir = self.minute_aggs_dir
+            self.by_ticker_dir = self.minute_by_ticker_dir
+        elif agg_time == "day":
+            self.agg_timedelta = pd.to_timedelta("1day")
+            self.aggs_dir = self.day_aggs_dir
+            self.by_ticker_dir = self.day_by_ticker_dir
+        else:
+            raise ValueError(
+                f"agg_time must be 'minute', 'day', or a timedelta string; got '{agg_time=}'"
+            )
+        self.agg_time = agg_time
+
+        self.arrow_format = environ.get(
+            "POLYGON_ARROW_FORMAT", "parquet" if self.agg_time == "day" else "hive"
         )
-        self.arrow_format = environ.get("POLYGON_ARROW_FORMAT", "parquet" if self.agg_time == "day" else "hive")
         # self.by_ticker_hive_dir = os.path.join(
         #     self.by_ticker_dir,
         #     f"{self.agg_time}_{self.start_timestamp.date().isoformat()}_{self.end_timestamp.date().isoformat()}.hive",
@@ -88,15 +124,15 @@ class PolygonConfig:
         return os.path.join(
             ticker_year_dir, f"tickers_{date.date().isoformat()}.parquet"
         )
-    
+
     def file_path_to_name(self, path: str):
+        # TODO: Use csv_paths_pattern to remove the suffixes
         return os.path.basename(path).removesuffix(".gz").removesuffix(".csv")
 
-    def by_ticker_aggs_arrow_dir(self, first_path: str, last_path: str):
-        return os.path.join(
-            self.by_ticker_dir,
-            f"{self.file_path_to_name(first_path)}_{self.file_path_to_name(last_path)}.arrow",
-        )
+    @property
+    def by_ticker_aggs_arrow_dir(self):
+        return os.path.join(self.by_ticker_dir,
+                            f"{self.start_timestamp.date().isoformat()}_{self.end_timestamp.date().isoformat()}.arrow")
 
     def api_cache_path(
         self, start_date: Date, end_date: Date, filename: str, extension=".parquet"
@@ -107,6 +143,43 @@ class PolygonConfig:
             self.cache_dir, f"{start_str}_{end_str}/{filename}{extension}"
         )
 
+    def csv_paths(self) -> Iterator[str]:
+        for root, dirnames, filenames in os.walk(self.aggs_dir, topdown=True):
+            if dirnames:
+                dirnames[:] = sorted(dirnames)
+            # Filter out filenames that don't match the pattern.
+            filenames = fnmatch.filter(filenames, self.csv_paths_pattern)
+            if filenames:
+                for filename in sorted(filenames):
+                    yield os.path.join(root, filename)
+
+    def find_first_and_last_aggs(self) -> Tuple[str, str]:
+        # Find the path to the lexically first and last paths in aggs_dir that matches csv_paths_pattern.
+        # Would like to use Path.walk(top_down=True) but it is only availble in Python 3.12+.
+        # This needs to be efficient because it is called on every init, even though we only need it for ingest.
+        # But we can't call it in ingest because the writer initializes and writes the metadata before it is called.
+        paths = []
+        for root, dirnames, filenames in os.walk(self.aggs_dir, topdown=True):
+            if dirnames:
+                # We only want first and last in each directory.
+                sorted_dirs = sorted(dirnames)
+                dirnames[:] = (
+                    [sorted_dirs[0], sorted_dirs[-1]]
+                    if len(sorted_dirs) > 1
+                    else sorted_dirs
+                )
+            # Filter out filenames that don't match the pattern.
+            filenames = fnmatch.filter(filenames, self.csv_paths_pattern)
+            if filenames:
+                filenames = sorted(filenames)
+                paths.append(os.path.join(root, filenames[0]))
+                if len(filenames) > 1:
+                    paths.append(os.path.join(root, filenames[-1]))
+        paths = sorted(paths)
+        if len(paths) < 2:
+            raise ValueError(f"Need more than one aggs file but found {len(paths)} paths in {self.aggs_dir}")
+        return self.file_path_to_name(paths[0]), self.file_path_to_name(paths[-1])
+
 
 if __name__ == "__main__":
     config = PolygonConfig(os.environ, "XNYS", "2003-10-01", "2023-01-01")

zipline_polygon_bundle/polygon_file_reader.py

@@ -99,6 +99,6 @@ def process_all_csv_to_parquet(
 if __name__ == "__main__":
     # os.environ["POLYGON_DATA_DIR"] = "/Volumes/Oahu/Mirror/files.polygon.io"
     config = PolygonConfig(
-        environ=os.environ, calendar_name="XNYS", start_session=None, end_session=None
+        environ=os.environ, calendar_name="XNYS", start_date=None, end_date=None
     )
     process_all_csv_to_parquet(config.aggs_dir)

zipline_polygon_bundle/process_all_aggs.py

@@ -74,8 +74,8 @@ if __name__ == "__main__":
     config = PolygonConfig(
         environ=os.environ,
         calendar_name="XNYS",
-        start_session="2020-10-07",
-        end_session="2020-10-15",
+        start_date="2020-10-07",
+        end_date="2020-10-15",
     )
     print(f"{config.aggs_dir=}")
     max_ticker_lens = apply_to_all_aggs(