sportsball 0.3.109__tar.gz → 0.3.111__tar.gz

{sportsball-0.3.109/sportsball.egg-info → sportsball-0.3.111}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: sportsball
-Version: 0.3.109
+Version: 0.3.111
 Summary: A library for pulling in and normalising sports stats.
 Home-page: https://github.com/8W9aG/sportsball
 Author: Will Sackfield

{sportsball-0.3.109 → sportsball-0.3.111}/setup.py

@@ -26,7 +26,7 @@ def install_requires() -> typing.List[str]:
 
 setup(
     name='sportsball',
-    version='0.3.109',
+    version='0.3.111',
     description='A library for pulling in and normalising sports stats.',
     long_description=long_description,
     long_description_content_type='text/markdown',

{sportsball-0.3.109 → sportsball-0.3.111}/sportsball/__init__.py

@@ -4,4 +4,4 @@
 import cchardet  # type: ignore
 import lxml  # noqa: ignore
 
-__VERSION__ = "0.3.109"
+__VERSION__ = "0.3.111"

{sportsball-0.3.109 → sportsball-0.3.111}/sportsball/__main__.py

@@ -21,7 +21,7 @@ def main() -> None:
     logging.info("--- sportsball %s ---", __VERSION__)
 
     ball = SportsBall()
-    league = ball.league(league_from_str(args.league))
+    league = ball.league(league_from_str(args.league), args.leaguemodel)
     df = league.to_frame()
     handle = io.BytesIO()
     df.to_parquet(handle, compression="gzip")

{sportsball-0.3.109 → sportsball-0.3.111}/sportsball/args.py

@@ -23,6 +23,11 @@ def parse_args() -> argparse.Namespace:
         help="The loglevel to display logs at..",
         required=False,
     )
+    parser.add_argument(
+        "--leaguemodel",
+        required=False,
+        help="The league model to use.",
+    )
     parser.add_argument(
         "file",
         default=STDOUT_FILE,

{sportsball-0.3.109 → sportsball-0.3.111}/sportsball/data/afl/afl/afl_afl_league_model.py

@@ -8,6 +8,7 @@ from typing import Iterator
 
 import requests_cache
 from bs4 import BeautifulSoup
+from dateutil.parser import parse
 from playwright.sync_api import sync_playwright
 
 from ....playwright import ensure_install
@@ -73,6 +74,11 @@ def _parse_game_info(
             "time", {"class": re.compile(".*match-list-alt__header-time.*")}
         ):
             dt = datetime.datetime.fromtimestamp(float(time.get("data-date")) / 1000.0)
+        for span_tz in div.find_all(
+            "span", {"class": re.compile(".*match-list-alt__header-timezone.*")}
+        ):
+            tz_text = span_tz.get_text().strip().replace("(", "").replace(")", "")
+            dt = parse(" ".join([str(dt), tz_text]))
         venue_name: str | None = None
         for span in div.find_all(
             "span", {"class": re.compile(".*match-list-alt__header-venue.*")}
@@ -95,6 +101,10 @@ class AFLAFLLeagueModel(LeagueModel):
     ) -> None:
         super().__init__(League.AFL, session)
 
+    @classmethod
+    def name(cls) -> str:
+        return "afl-afl-league-model"
+
     @property
     def _ladder(self) -> list[str]:
         ladder = []

{sportsball-0.3.109 → sportsball-0.3.111}/sportsball/data/afl/afltables/afl_afltables_league_model.py

@@ -47,6 +47,10 @@ class AFLAFLTablesLeagueModel(LeagueModel):
     ) -> None:
         super().__init__(League.AFL, session)
 
+    @classmethod
+    def name(cls) -> str:
+        return "afl-afltables-league-model"
+
     def _produce_games(
         self, season_url: str, season_type: SeasonType, pbar: tqdm.tqdm
     ) -> Iterator[GameModel]:

{sportsball-0.3.109 → sportsball-0.3.111}/sportsball/data/afl/aussportsbetting/afl_aussportsbetting_league_model.py

@@ -14,3 +14,7 @@ class AFLAusSportsBettingLeagueModel(AusSportsBettingLeagueModel):
         self, session: requests_cache.CachedSession, position: int | None = None
     ) -> None:
         super().__init__(League.AFL, session, position=position)
+
+    @classmethod
+    def name(cls) -> str:
+        return "afl-aussportsbetting-league-model"

{sportsball-0.3.109 → sportsball-0.3.111}/sportsball/data/afl/combined/afl_combined_league_model.py

@@ -251,7 +251,9 @@ AFL_VENUE_IDENTITY_MAP = {
 class AFLCombinedLeagueModel(CombinedLeagueModel):
     """AFL combined implementation of the league model."""
 
-    def __init__(self, session: requests_cache.CachedSession) -> None:
+    def __init__(
+        self, session: requests_cache.CachedSession, league_filter: str | None
+    ) -> None:
         super().__init__(
             session,
             League.AFL,
@@ -262,6 +264,7 @@ class AFLCombinedLeagueModel(CombinedLeagueModel):
                 AFLOddsPortalLeagueModel(session, position=3),
                 AFLAFLLeagueModel(session, position=4),
             ],
+            league_filter,
         )
 
     @classmethod
@@ -271,3 +274,7 @@ class AFLCombinedLeagueModel(CombinedLeagueModel):
     @classmethod
     def venue_identity_map(cls) -> dict[str, str]:
         return AFL_VENUE_IDENTITY_MAP
+
+    @classmethod
+    def name(cls) -> str:
+        return "afl-combined-league-model"

{sportsball-0.3.109 → sportsball-0.3.111}/sportsball/data/afl/oddsportal/afl_oddsportal_league_model.py

@@ -15,3 +15,7 @@ class AFLOddsPortalLeagueModel(OddsPortalLeagueModel):
         self, session: requests_cache.CachedSession, position: int | None = None
     ) -> None:
         super().__init__(League.AFL, session, position=position)
+
+    @classmethod
+    def name(cls) -> str:
+        return "afl-oddsportal-league-model"

{sportsball-0.3.109 → sportsball-0.3.111}/sportsball/data/aussportsbetting/aussportsbetting_league_model.py

@@ -39,6 +39,10 @@ class AusSportsBettingLeagueModel(LeagueModel):
                     f"League {league} not supported by aus sports betting."
                 )
 
+    @classmethod
+    def name(cls) -> str:
+        return "aussportsbetting-league-model"
+
     def _row_to_game(self, row: Any) -> GameModel | None:
         current_cell_idx = 0
         date_cell = str(row[0].value)

{sportsball-0.3.109 → sportsball-0.3.111}/sportsball/data/combined/combined_address_model.py

@@ -2,6 +2,7 @@
 
 from ..address_model import AddressModel
 from .combined_weather_model import create_combined_weather_model
+from .null_check import is_null
 
 
 def create_combined_address_model(
@@ -16,16 +17,16 @@ def create_combined_address_model(
     weather_models = []
     for address_model in address_models:
         address_model_latitude = address_model.latitude
-        if address_model_latitude is not None:
+        if not is_null(address_model_latitude):
             latitude = address_model_latitude
         address_model_longitude = address_model.longitude
-        if address_model_longitude is not None:
+        if not is_null(address_model_longitude):
             longitude = address_model_longitude
         address_model_housenumber = address_model.housenumber
-        if address_model_housenumber is not None:
+        if not is_null(address_model_housenumber):
             housenumber = address_model_housenumber
         address_model_weather = address_model.weather
-        if address_model_weather is not None:
+        if not is_null(address_model_weather):
             weather_models.append(address_model_weather)
     return AddressModel(
         city=address_models[0].city,
@@ -34,7 +35,7 @@ def create_combined_address_model(
         latitude=latitude,
         longitude=longitude,
         housenumber=housenumber,
-        weather=create_combined_weather_model(weather_models),  # pyright: ignore
+        weather=create_combined_weather_model(weather_models),  # type: ignore
         timezone=address_models[0].timezone,
         country=address_models[0].country,
     )

{sportsball-0.3.109 → sportsball-0.3.111}/sportsball/data/combined/combined_game_model.py

@@ -1,6 +1,6 @@
 """Combined game model."""
 
-# pylint: disable=too-many-locals,line-too-long,too-many-arguments
+# pylint: disable=too-many-locals,line-too-long,too-many-arguments,too-many-branches
 import logging
 
 import requests
@@ -10,6 +10,7 @@ from ..team_model import TeamModel
 from ..venue_model import VenueModel
 from .combined_team_model import create_combined_team_model
 from .combined_venue_model import create_combined_venue_model
+from .null_check import is_null
 
 
 def _venue_models(
@@ -78,30 +79,34 @@ def create_combined_game_model(
     game_number = None
     postponed = None
     play_off = None
+    dt = game_models[0].dt
     for game_model in game_models:
+        game_model_dt = game_model.dt
+        if game_model_dt.tzinfo is not None and dt.tzinfo is None:
+            dt = game_model_dt
         game_model_attendance = game_model.attendance
-        if game_model_attendance is not None:
+        if not is_null(game_model_attendance):
             attendance = game_model_attendance
         game_model_end_dt = game_model.end_dt
-        if game_model_end_dt is not None:
+        if not is_null(game_model_end_dt):
             end_dt = game_model_end_dt
         game_model_year = game_model.year
-        if game_model_year is not None:
+        if not is_null(game_model_year):
             year = game_model_year
         game_model_season_type = game_model.season_type
-        if game_model_season_type is not None:
+        if not is_null(game_model_season_type):
             season_type = game_model_season_type
         game_model_week = game_model.week
-        if game_model_week is not None:
+        if not is_null(game_model_week):
             week = game_model_week
         game_model_game_number = game_model.game_number
-        if game_model_game_number is not None:
+        if not is_null(game_model_game_number):
             game_number = game_model_game_number
         game_model_postponed = game_model.postponed
-        if game_model_postponed is not None:
+        if not is_null(game_model_postponed):
             postponed = game_model_postponed
         game_model_play_off = game_model.play_off
-        if game_model_play_off is not None:
+        if not is_null(game_model_play_off):
             play_off = game_model_play_off
 
     if full_venue_identity is None and venue_models:
@@ -111,7 +116,7 @@ def create_combined_game_model(
                 full_venue_identity = venue_model_identifier
 
     return GameModel(
-        dt=game_models[0].dt,
+        dt=dt,
         week=week,
         game_number=game_number,
         venue=create_combined_venue_model(venue_models, full_venue_identity, session),  # pyright: ignore

{sportsball-0.3.109 → sportsball-0.3.111}/sportsball/data/combined/combined_league_model.py

@@ -26,8 +26,13 @@ class CombinedLeagueModel(LeagueModel):
         session: requests_cache.CachedSession,
         league: League,
         league_models: list[LeagueModel],
+        league_filter: str | None,
     ) -> None:
         super().__init__(league, session)
+        if league_filter is not None:
+            league_models = [x for x in league_models if x.name() == league_filter]
+        if not league_models:
+            raise ValueError("No league models to run")
         self._league_models = league_models
 
     @classmethod

{sportsball-0.3.109 → sportsball-0.3.111}/sportsball/data/combined/combined_player_model.py

@@ -2,6 +2,7 @@
 
 # pylint: disable=too-many-locals,too-many-branches,too-many-statements,duplicate-code
 from ..player_model import PlayerModel
+from .null_check import is_null
 
 
 def create_combined_player_model(
@@ -42,100 +43,100 @@ def create_combined_player_model(
     percentage_played = None
     for player_model in player_models:
         player_model_jersey = player_model.jersey
-        if player_model_jersey is not None:
+        if not is_null(player_model_jersey):
             jersey = player_model_jersey
         player_model_kicks = player_model.kicks
-        if player_model_kicks is not None:
+        if not is_null(player_model_kicks):
             kicks = player_model_kicks
         player_model_fumbles = player_model.fumbles
-        if player_model_fumbles is not None:
+        if not is_null(player_model_fumbles):
             fumbles = player_model_fumbles
         player_model_fumbles_lost = player_model.fumbles_lost
-        if player_model_fumbles_lost is not None:
+        if not is_null(player_model_fumbles_lost):
             fumbles_lost = player_model_fumbles_lost
         player_model_field_goals = player_model.field_goals
-        if player_model_field_goals is not None:
+        if not is_null(player_model_field_goals):
             field_goals = player_model_field_goals
         player_model_field_goals_attempted = player_model.field_goals_attempted
-        if player_model_field_goals_attempted is not None:
+        if not is_null(player_model_field_goals_attempted):
             field_goals_attempted = player_model_field_goals_attempted
         player_model_offensive_rebounds = player_model.offensive_rebounds
-        if player_model_offensive_rebounds is not None:
+        if not is_null(player_model_offensive_rebounds):
             offensive_rebounds = player_model_offensive_rebounds
         player_model_assists = player_model.assists
-        if player_model_assists is not None:
+        if not is_null(player_model_assists):
             assists = player_model_assists
         player_model_turnovers = player_model.turnovers
-        if player_model_turnovers is not None:
+        if not is_null(player_model_turnovers):
             turnovers = player_model_turnovers
         player_model_name = player_model.name
-        if player_model_name is not None:
+        if not is_null(player_model_name):
             name = player_model_name
         player_model_marks = player_model.marks
-        if player_model_marks is not None:
+        if not is_null(player_model_marks):
             marks = player_model_marks
         player_model_handballs = player_model.handballs
-        if player_model_handballs is not None:
+        if not is_null(player_model_handballs):
             handballs = player_model_handballs
         player_model_disposals = player_model.disposals
-        if player_model_disposals is not None:
+        if not is_null(player_model_disposals):
             disposals = player_model_disposals
         player_model_goals = player_model.goals
-        if player_model_goals is not None:
+        if not is_null(player_model_goals):
             goals = player_model_goals
         player_model_behinds = player_model.behinds
-        if player_model_behinds is not None:
+        if not is_null(player_model_behinds):
             behinds = player_model_behinds
         player_model_hit_outs = player_model.hit_outs
-        if player_model_hit_outs is not None:
+        if not is_null(player_model_hit_outs):
             hit_outs = player_model_hit_outs
         player_model_tackles = player_model.tackles
-        if player_model_tackles is not None:
+        if not is_null(player_model_tackles):
             tackles = player_model_tackles
         player_model_rebounds = player_model.rebounds
-        if player_model_rebounds is not None:
+        if not is_null(player_model_rebounds):
             rebounds = player_model_rebounds
         player_model_insides = player_model.insides
-        if player_model_insides is not None:
+        if not is_null(player_model_insides):
             insides = player_model_insides
         player_model_clearances = player_model.clearances
-        if player_model_clearances is not None:
+        if not is_null(player_model_clearances):
             clearances = player_model_clearances
         player_model_clangers = player_model.clangers
-        if player_model_clangers is not None:
+        if not is_null(player_model_clangers):
             clangers = player_model_clangers
         player_model_free_kicks_for = player_model.free_kicks_for
-        if player_model_free_kicks_for is not None:
+        if not is_null(player_model_free_kicks_for):
             free_kicks_for = player_model_free_kicks_for
         player_model_free_kicks_against = player_model.free_kicks_against
-        if player_model_free_kicks_against is not None:
+        if not is_null(player_model_free_kicks_against):
             free_kicks_against = player_model_free_kicks_against
         player_model_brownlow_votes = player_model.brownlow_votes
-        if player_model_brownlow_votes is not None:
+        if not is_null(player_model_brownlow_votes):
             brownlow_votes = player_model_brownlow_votes
         player_model_contested_possessions = player_model.contested_possessions
-        if player_model_contested_possessions is not None:
+        if not is_null(player_model_contested_possessions):
             contested_possessions = player_model_contested_possessions
         player_model_uncontested_possessions = player_model.uncontested_possessions
-        if player_model_uncontested_possessions is not None:
+        if not is_null(player_model_uncontested_possessions):
             uncontested_possessions = player_model_uncontested_possessions
         player_model_contested_marks = player_model.contested_marks
-        if player_model_contested_marks is not None:
+        if not is_null(player_model_contested_marks):
             contested_marks = player_model_contested_marks
         player_model_marks_inside = player_model.marks_inside
-        if player_model_marks_inside is not None:
+        if not is_null(player_model_marks_inside):
             marks_inside = player_model_marks_inside
         player_model_one_percenters = player_model.one_percenters
-        if player_model_one_percenters is not None:
+        if not is_null(player_model_one_percenters):
             one_percenters = player_model_one_percenters
         player_model_bounces = player_model.bounces
-        if player_model_bounces is not None:
+        if not is_null(player_model_bounces):
             bounces = player_model_bounces
         player_model_goal_assists = player_model.goal_assists
-        if player_model_goal_assists is not None:
+        if not is_null(player_model_goal_assists):
             goal_assists = player_model_goal_assists
         player_model_percentage_played = player_model.percentage_played
-        if player_model_percentage_played is not None:
+        if not is_null(player_model_percentage_played):
             percentage_played = player_model_percentage_played
     if name is None:
         raise ValueError("name is null.")

{sportsball-0.3.109 → sportsball-0.3.111}/sportsball/data/combined/combined_team_model.py

@@ -10,6 +10,7 @@ from ..player_model import PlayerModel
 from ..social_model import SocialModel
 from ..team_model import TeamModel
 from .combined_player_model import create_combined_player_model
+from .null_check import is_null
 
 REGEX = re.compile("[^a-zA-Z]")
 
@@ -54,10 +55,10 @@ def create_combined_team_model(
             key = f"{odds_model.bookie.identifier}-{odds_model.odds}"
             odds[key] = odds.get(key, []) + [odds_model]
         team_model_points = team_model.points
-        if team_model_points is not None:
+        if not is_null(team_model_points):
             points = team_model_points
         team_model_ladder_rank = team_model.ladder_rank
-        if team_model_ladder_rank is not None:
+        if not is_null(team_model_ladder_rank):
             ladder_rank = team_model_ladder_rank
         for news_model in team_model.news:
             news_key = "-".join(
@@ -75,7 +76,7 @@ def create_combined_team_model(
             )
             social[social_key] = social_model
         team_model_field_goals = team_model.field_goals
-        if team_model_field_goals is not None:
+        if not is_null(team_model_field_goals):
             field_goals = team_model_field_goals
 
     return TeamModel(

{sportsball-0.3.109 → sportsball-0.3.111}/sportsball/data/combined/combined_venue_model.py

@@ -5,6 +5,7 @@ import requests
 from ..venue_model import VenueModel
 from ..wikipedia.wikipedia_venue_model import create_wikipedia_venue_model
 from .combined_address_model import create_combined_address_model
+from .null_check import is_null
 
 
 def create_combined_venue_model(
@@ -24,18 +25,18 @@ def create_combined_venue_model(
     is_indoor = None
     for venue_model in venue_models:
         venue_model_address = venue_model.address
-        if venue_model_address is not None:
+        if not is_null(venue_model_address):
             address_models.append(venue_model_address)
         venue_model_is_grass = venue_model.is_grass
-        if venue_model_is_grass is not None:
+        if not is_null(venue_model_is_grass):
             is_grass = venue_model_is_grass
         venue_model_is_indoor = venue_model.is_indoor
-        if venue_model_is_indoor is not None:
+        if not is_null(venue_model_is_indoor):
             is_indoor = venue_model_is_indoor
     return VenueModel(
         identifier=identifier,
         name=venue_models[0].name,
-        address=create_combined_address_model(address_models),  # pyright: ignore
+        address=create_combined_address_model(address_models),  # type: ignore
         is_grass=is_grass,
         is_indoor=is_indoor,
     )

{sportsball-0.3.109 → sportsball-0.3.111}/sportsball/data/combined/combined_weather_model.py

@@ -1,6 +1,7 @@
 """Combined weather model."""
 
 from ..weather_model import WeatherModel
+from .null_check import is_null
 
 
 def create_combined_weather_model(
@@ -13,9 +14,9 @@ def create_combined_weather_model(
     relative_humidity = None
     for weather_model in weather_models:
         weather_model_temperature = weather_model.temperature
-        if weather_model_temperature is not None:
+        if not is_null(weather_model_temperature):
             temperature = weather_model_temperature
         weather_model_relative_humidity = weather_model.relative_humidity
-        if weather_model_relative_humidity is not None:
+        if not is_null(weather_model_relative_humidity):
             relative_humidity = weather_model_relative_humidity
     return WeatherModel(temperature=temperature, relative_humidity=relative_humidity)

sportsball-0.3.111/sportsball/data/combined/null_check.py

@@ -0,0 +1,22 @@
+"""A function for checking whether an object is null."""
+
+from typing import Any
+
+import numpy as np
+
+
+def is_null(obj: Any) -> bool:
+    """Whether the object is a null type object."""
+    if obj is None:
+        return True
+    try:
+        if np.isnan(obj):
+            return True
+    except TypeError:
+        pass
+    try:
+        if np.isnat(obj):
+            return True
+    except TypeError:
+        pass
+    return False

{sportsball-0.3.109 → sportsball-0.3.111}/sportsball/data/espn/espn_league_model.py

@@ -38,6 +38,10 @@ class ESPNLeagueModel(LeagueModel):
         super().__init__(league, session, position=position)
         self._start_url = start_url
 
+    @classmethod
+    def name(cls) -> str:
+        return "espn-league-model"
+
     def _produce_games(
         self,
         week: dict[str, Any],

{sportsball-0.3.109 → sportsball-0.3.111}/sportsball/data/google/google_address_model.py

@@ -13722,6 +13722,33 @@ _CACHED_GEOCODES: dict[str, Any] = {
         country="USA",
     ),
     "Ninja Stadium": BLUNDSTONE_ARENA,
+    "Summit Arena, Rapid City, South Dakota": SportsballGeocodeTuple(
+        city="Rapid City",
+        state="SD",
+        postal="",
+        lat=44.08854,
+        lng=-103.225816,
+        housenumber="444",
+        country="USA",
+    ),
+    "Charleston, West Virginia": SportsballGeocodeTuple(
+        city="Charleston",
+        state="WV",
+        postal="",
+        lat=38.349819,
+        lng=-81.632622,
+        housenumber="",
+        country="USA",
+    ),
+    "Shreveport, Louisiana": SportsballGeocodeTuple(
+        city="Shreveport",
+        state="LA",
+        postal="",
+        lat=32.463889,
+        lng=-93.794444,
+        housenumber="",
+        country="USA",
+    ),
 }
 
 

{sportsball-0.3.109 → sportsball-0.3.111}/sportsball/data/league_model.py

@@ -1,6 +1,7 @@
 """The prototype class defining how to interface to the league."""
 
 # pylint: disable=line-too-long
+import datetime
 from typing import Iterator, get_args, get_origin
 
 import pandas as pd
@@ -35,6 +36,7 @@ def _normalize_tz(df: pd.DataFrame) -> pd.DataFrame:
     )
     if tz_column not in df.columns.values.tolist():
         return df
+    df = df.dropna(subset=tz_column)
 
     tqdm.tqdm.pandas(desc="Timezone Conversions")
 
@@ -46,18 +48,24 @@ def _normalize_tz(df: pd.DataFrame) -> pd.DataFrame:
         if pd.isnull(tz):
             return row
 
-        datetimes = {
-            col: val for col, val in row.items() if isinstance(val, pd.Timestamp)
+        datetime_cols = {
+            col for col, val in row.items() if isinstance(val, pd.Timestamp)
         }
-        for col, dt in datetimes.items():
+        datetime_cols.add(GAME_DT_COLUMN)
+        for col in datetime_cols:
+            dt = row[col]  # type: ignore
+            if isinstance(dt, datetime.datetime):
+                dt = pd.to_datetime(dt)
             if dt.tz is None:
-                row[col] = dt.tz_localize(tz, ambiguous=True)
+                row[col] = dt.tz_localize(
+                    tz, ambiguous=True, nonexistent="shift_forward"
+                )
             elif str(dt.tz) != str(tz):
                 row[col] = dt.tz_convert(tz)
 
         return row
 
-    return df.apply(apply_tz, axis=1)
+    return df.progress_apply(apply_tz, axis=1)  # type: ignore
 
 
 class LeagueModel(Model):
@@ -76,6 +84,11 @@ class LeagueModel(Model):
         self._df = None
         self.position = position
 
+    @classmethod
+    def name(cls) -> str:
+        """The name of the league model."""
+        raise NotImplementedError("name is not implemented by parent class.")
+
     @property
     def games(self) -> Iterator[GameModel]:
         """Find all the games in this league."""
@@ -180,12 +193,16 @@ class LeagueModel(Model):
             df = _normalize_tz(df)
 
             if GAME_DT_COLUMN in df.columns.values:
-                df[GAME_DT_COLUMN] = pd.to_datetime(df[GAME_DT_COLUMN], utc=True)
+                # df[GAME_DT_COLUMN] = pd.to_datetime(df[GAME_DT_COLUMN])
+                # naive_times = df[df[GAME_DT_COLUMN].dt.tz.isna()]
+                # print("naive_times:")
+                # print(naive_times)
                 df = df.sort_values(
                     by=GAME_DT_COLUMN,
                     ascending=True,
                 )
             df = _clear_column_list(df)
+            df = df.reset_index()
 
             df = df[sorted(df.columns.values.tolist())]