vlrdevapi 2.0.0__tar.gz → 2.1.0__tar.gz

{vlrdevapi-2.0.0 → vlrdevapi-2.1.0}/CHANGELOG.md

@@ -5,6 +5,65 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/),
 and this project adheres to [Semantic Versioning](https://semver.org/).
 
+## [Unreleased]
+
+### Changed
+
+- **Events list dates without a year** — `event.list()` dates are rendered
+  on vlr.gg without a year (e.g. `"Jul 9 – Aug 23"`). These now use a
+  sentinel year of `2019` instead of the current year. Any parsed date with
+  `year < 2020` means the source omitted the year, so guard with
+  `event.start_date.year < 2020` before relying on it.
+
+### Fixed
+
+- **Python 3.13/3.15 date parsing deprecation** — `datetime.strptime` emits
+  a `DeprecationWarning` when parsing a day-of-month without a year (and will
+  change behavior in Python 3.15). All such parses now supply an explicit
+  year derived from context (reference date, page-header year, or the
+  sentinel above).
+
+## [2.1.0] - 2026-08-07
+
+### Added
+
+- **Event teams player rosters** — `event.teams()` now includes a `players`
+  list on each `Team`, containing each player's `name` and `id` parsed from
+  the event page. The `players` field is always present and defaults to `[]`
+  when roster data is unavailable. A new `TeamPlayer` model was added and exposed
+  from the `_event.teams` submodule.
+
+### Changed
+
+- **Documentation** — event teams reference updated with the new `players`
+  field, a `TeamPlayer` fields table, and a roster iteration example.
+
+## [2.0.1] - 2026-07-29
+
+### Fixed
+
+- **Series player stats** — overview tab HTML changed from `<table>` to
+  `<div>` on vlr.gg; updated CSS selectors to match the new structure.
+- **Player agent stats** — agent table class changed from `wf-table` to
+  `st-table.mod-agent-rows`; column count reduced from 17 to 16 (FKPR and
+  FDPR columns consolidated into a single FK:FD ratio column).
+- **Player profile** — same agent table selector fix; the profile fallback
+  to `timespan=all` now works correctly.
+- **Team fixtures** — updated stale test assertions for NRG Haven map
+  stats (games played, wins, losses, etc.) and total winnings to match
+  current vlr.gg data.
+
+### Removed
+
+- `fkpr` and `fdpr` fields from `AgentStats` model — vlr.gg no longer
+  exposes separate First Kills Per Round / First Deaths Per Round columns.
+  The `first_kills` and `first_deaths` total fields remain available.
+
+### Changed
+
+- **Documentation** — agents schema reference updated to reflect the
+  removal of `fkpr` and `fdpr`.
+
 ## [2.0.0] - 2026-07-07
 
 ### Major Rewrite
@@ -66,4 +125,6 @@ The API surface, module structure, and type system are all new.
 - `aiohttp` and `asyncio` dependencies.
 - v1.x match/event/team parsing modules.
 
+[2.1.0]: https://github.com/Vanshbordia/vlrdevapi/compare/v2.0.1...v2.1.0
+[2.0.1]: https://github.com/Vanshbordia/vlrdevapi/compare/v2.0.0...v2.0.1
 [2.0.0]: https://github.com/Vanshbordia/vlrdevapi/compare/v1.6.2...v2.0.0

{vlrdevapi-2.0.0 → vlrdevapi-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vlrdevapi
-Version: 2.0.0
+Version: 2.1.0
 Summary: A Python library to scrape data from vlr.gg
 Project-URL: Homepage, https://vlrdevapi.pages.dev/
 Project-URL: Repository, https://github.com/Vanshbordia/vlrdevapi

{vlrdevapi-2.0.0 → vlrdevapi-2.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "vlrdevapi"
-version = "2.0.0"
+version = "2.1.0"
 description = "A Python library to scrape data from vlr.gg"
 readme = "README.md"
 requires-python = ">=3.11"

{vlrdevapi-2.0.0 → vlrdevapi-2.1.0}/src/vlrdevapi/__init__.py

@@ -45,7 +45,7 @@ if TYPE_CHECKING:
     matches: MatchesNamespace
     client: type[VLRClient]
 
-__version__ = "2.0.0"
+__version__ = "2.1.0"
 
 _default_client: "VLRClient | None" = None
 

{vlrdevapi-2.0.0 → vlrdevapi-2.1.0}/src/vlrdevapi/_event/info/parser.py

@@ -288,10 +288,9 @@ def _parse_partial_date(text: str, reference_end: date) -> date | None:
     if full_attempt is not None:
         return full_attempt
 
-    for fmt in ("%b %d", "%B %d"):
+    for fmt in ("%b %d %Y", "%B %d %Y"):
         try:
-            dt = datetime.strptime(text, fmt)
-            return dt.replace(year=reference_end.year).date()
+            return datetime.strptime(f"{text} {reference_end.year}", fmt).date()
         except ValueError:
             continue
 

{vlrdevapi-2.0.0 → vlrdevapi-2.1.0}/src/vlrdevapi/_event/list/models.py

@@ -22,8 +22,16 @@ class EventListItem(BaseModel):
         default="upcoming", description="Event status",
     )
     prize: EventPrize | None = Field(default=None, description="Prize information")
-    start_date: date | None = Field(default=None, description="Event start date")
-    end_date: date | None = Field(default=None, description="Event end date")
+    start_date: date | None = Field(
+        default=None,
+        description="Event start date. Year is 2019 when the listing omitted it "
+        "(year < 2020 means the year is not present).",
+    )
+    end_date: date | None = Field(
+        default=None,
+        description="Event end date. Year is 2019 when the listing omitted it "
+        "(year < 2020 means the year is not present).",
+    )
     region: str = Field(default="", description="Country or region name from flag")
     image_url: str = Field(default="", description="URL to the event thumbnail image")
     url: str = Field(default="", description="Full URL to the event page on vlr.gg")

{vlrdevapi-2.0.0 → vlrdevapi-2.1.0}/src/vlrdevapi/_event/namespace.py

@@ -99,8 +99,10 @@ class EventMatchNamespace:
                 If ``None``, returns teams for all stages.
 
         Returns:
-            EventTeams: Teams grouped by stage, with team ``name``, ``tag``,
-            ``logo_url``, and roster info where available.
+            EventTeams: Teams grouped by stage, with team ``name``, ``id``,
+            optional ``note``, and a ``players`` list (each with ``name``
+            and ``id``). ``players`` is always present and may be an empty
+            list when roster data is unavailable.
 
         Raises:
             NotFoundError: If the event page does not exist (HTTP 404).
@@ -241,6 +243,8 @@ class EventNamespace:
         Returns:
             An ``EventTeamsNamespace`` instance. Call with an ``event_id``
             and optional ``stage`` to return an ``EventTeams`` model.
+            Each ``Team`` includes a ``players`` roster list that is always
+            present and may be empty when roster data is unavailable.
 
         """
         return self._teams

{vlrdevapi-2.0.0 → vlrdevapi-2.1.0}/src/vlrdevapi/_event/stages/parser.py

@@ -189,10 +189,9 @@ def _parse_subnav_single_date(text: str, year: int | None) -> date | None:
         return None
 
     if year is not None:
-        for fmt in ("%b %d", "%B %d"):
+        for fmt in ("%b %d %Y", "%B %d %Y"):
             try:
-                dt = datetime.strptime(text, fmt)
-                return dt.replace(year=year).date()
+                return datetime.strptime(f"{text} {year}", fmt).date()
             except ValueError:
                 continue
 
@@ -220,10 +219,9 @@ def _parse_subnav_partial_date(text: str, year: int) -> date | None:
     if full is not None:
         return full
 
-    for fmt in ("%b %d", "%B %d"):
+    for fmt in ("%b %d %Y", "%B %d %Y"):
         try:
-            dt = datetime.strptime(text, fmt)
-            return dt.replace(year=year).date()
+            return datetime.strptime(f"{text} {year}", fmt).date()
         except ValueError:
             continue
 

{vlrdevapi-2.0.0 → vlrdevapi-2.1.0}/src/vlrdevapi/_event/teams/__init__.py

@@ -1,8 +1,9 @@
-from vlrdevapi._event.teams.models import EventStageTeams, EventTeams
+from vlrdevapi._event.teams.models import EventStageTeams, EventTeams, TeamPlayer
 from vlrdevapi._event.teams.namespace import EventTeamsNamespace
 
 __all__ = [
     "EventStageTeams",
     "EventTeams",
+    "TeamPlayer",
     "EventTeamsNamespace",
 ]

{vlrdevapi-2.0.0 → vlrdevapi-2.1.0}/src/vlrdevapi/_event/teams/models.py

@@ -1,6 +1,23 @@
 from pydantic import BaseModel, ConfigDict, Field
 
 
+class TeamPlayer(BaseModel):
+    """Player information for a team at an event."""
+
+    model_config = ConfigDict(
+        json_schema_extra={"description": "Player information for a team at an event."},
+    )
+
+    id: int = Field(
+        default=0,
+        description="Player identifier from vlr.gg (e.g., 1311)",
+    )
+    name: str = Field(
+        default="",
+        description="Player in-game name (e.g., 'Melser')",
+    )
+
+
 class Team(BaseModel):
     """Team information for an event from vlr.gg."""
 
@@ -20,6 +37,10 @@ class Team(BaseModel):
         default=None,
         description="Optional note (e.g., 'Partner Team')",
     )
+    players: list[TeamPlayer] = Field(
+        default_factory=list,
+        description="List of players on the team (name and id). Always present; empty when roster data is unavailable.",
+    )
 
 
 class EventStageTeams(BaseModel):
@@ -60,4 +81,4 @@ class EventTeams(BaseModel):
         return iter(self.stages)
 
     def __getitem__(self, index):
-        return self.stages[index]
+        return self.stages[index]

{vlrdevapi-2.0.0 → vlrdevapi-2.1.0}/src/vlrdevapi/_event/teams/namespace.py

@@ -43,8 +43,10 @@ class EventTeamsNamespace:
             stage: Optional stage name or path to filter by (e.g. 'playoffs').
 
         Returns:
-            EventTeams: Teams grouped by stage, with team ``name``, ``tag``,
-            ``logo_url``, and roster info where available.
+            EventTeams: Teams grouped by stage, with team ``name``, ``id``,
+            optional ``note``, and a ``players`` list (each with ``name``
+            and ``id``). ``players`` is always present and may be an empty
+            list when roster data is unavailable.
 
         Raises:
             ValidationError: If ``event_id`` is not a valid positive integer.

{vlrdevapi-2.0.0 → vlrdevapi-2.1.0}/src/vlrdevapi/_event/teams/parser.py

@@ -1,7 +1,6 @@
-
 from selectolax.parser import HTMLParser, Node
 
-from vlrdevapi._event.teams.models import Team
+from vlrdevapi._event.teams.models import Team, TeamPlayer
 
 
 def parse_subnav(html: HTMLParser) -> list[tuple[str, str]]:
@@ -70,4 +69,32 @@ def _parse_team_card(card: Node) -> Team | None:
     note_el = card.css_first(".event-team-note")
     note = note_el.text(strip=True) if note_el else None
 
-    return Team(name=name, id=team_id, note=note)
+    players = _parse_players(card)
+
+    return Team(name=name, id=team_id, note=note, players=players)
+
+
+def _parse_players(card: Node) -> list[TeamPlayer]:
+    """Parse the players listed on a team card."""
+    players = []
+    for item in card.css(".event-team-players-item"):
+        player = _parse_player_item(item)
+        if player:
+            players.append(player)
+    return players
+
+
+def _parse_player_item(item: Node) -> TeamPlayer | None:
+    """Parse a single player anchor (e.g. /player/1311/melser)."""
+    href = item.attributes.get("href", "")
+    if not href or "/player/" not in href:
+        return None
+
+    try:
+        id_str = href.split("/player/")[1].split("/")[0]
+        player_id = int(id_str)
+    except (ValueError, IndexError):
+        return None
+
+    name = item.text(strip=True)
+    return TeamPlayer(id=player_id, name=name)

{vlrdevapi-2.0.0 → vlrdevapi-2.1.0}/src/vlrdevapi/_player/_common_parsing.py

@@ -139,7 +139,7 @@ def _parse_agent_row(tr: Node) -> AgentStats:
     stats = AgentStats()
     tds = tr.css("td")
 
-    if len(tds) < 17:
+    if len(tds) < 16:
         return stats
 
     img_el = tds[0].css_first("img")
@@ -160,12 +160,10 @@ def _parse_agent_row(tr: Node) -> AgentStats:
     stats.kast = tds[7].text(strip=True)
     stats.kpr = _parse_float(tds[8].text(strip=True))
     stats.apr = _parse_float(tds[9].text(strip=True))
-    stats.fkpr = _parse_float(tds[10].text(strip=True))
-    stats.fdpr = _parse_float(tds[11].text(strip=True))
-    stats.kills = _parse_int(tds[12].text(strip=True))
-    stats.deaths = _parse_int(tds[13].text(strip=True))
-    stats.assists = _parse_int(tds[14].text(strip=True))
-    stats.first_kills = _parse_int(tds[15].text(strip=True))
-    stats.first_deaths = _parse_int(tds[16].text(strip=True))
+    stats.kills = _parse_int(tds[11].text(strip=True))
+    stats.deaths = _parse_int(tds[12].text(strip=True))
+    stats.assists = _parse_int(tds[13].text(strip=True))
+    stats.first_kills = _parse_int(tds[14].text(strip=True))
+    stats.first_deaths = _parse_int(tds[15].text(strip=True))
 
     return stats

{vlrdevapi-2.0.0 → vlrdevapi-2.1.0}/src/vlrdevapi/_player/agents/models.py

@@ -18,8 +18,6 @@ class AgentStats(BaseModel):
     kast: str = Field(default="", description="Kill, Assist, Survive, Trade %")
     kpr: float | None = Field(default=None, description="Kills Per Round")
     apr: float | None = Field(default=None, description="Assists Per Round")
-    fkpr: float | None = Field(default=None, description="First Kills Per Round")
-    fdpr: float | None = Field(default=None, description="First Deaths Per Round")
     kills: int | None = Field(default=None, description="Total kills")
     deaths: int | None = Field(default=None, description="Total deaths")
     assists: int | None = Field(default=None, description="Total assists")

{vlrdevapi-2.0.0 → vlrdevapi-2.1.0}/src/vlrdevapi/_player/agents/parser.py

@@ -16,7 +16,7 @@ def parse_agent_stats(html: HTMLParser, timespan: str = "all") -> AgentStatsPage
             card = _next_sibling_card(search_from)
             if card is None:
                 break
-            table = card.css_first("table.wf-table")
+            table = card.css_first("table.st-table.mod-agent-rows")
             if table is None:
                 break
             tbody = table.css_first("tbody")

{vlrdevapi-2.0.0 → vlrdevapi-2.1.0}/src/vlrdevapi/_player/profile/parser.py

@@ -69,7 +69,7 @@ def _parse_agents(html: HTMLParser, profile: PlayerProfile) -> None:
             card = _next_sibling_card(search_from)
             if card is None:
                 break
-            table = card.css_first("table.wf-table")
+            table = card.css_first("table.st-table.mod-agent-rows")
             if table is None:
                 break
             tbody = table.css_first("tbody")

{vlrdevapi-2.0.0 → vlrdevapi-2.1.0}/src/vlrdevapi/_series/players/parser.py

@@ -138,119 +138,137 @@ def _parse_stat_cell(td: Node) -> tuple:
     return overall, attack, defend
 
 
-def _parse_player_row(tr: Node) -> PlayerGameStats:
-    """Parse a player row from the stats table.
+def _parse_player_row(cell: Node) -> PlayerGameStats:
+    player = PlayerGameStats()
 
-    Args:
-        tr: The table row Node containing player data.
+    a = cell.css_first("a")
+    if a:
+        href = a.attributes.get("href", "") or ""
+        parts = href.strip("/").split("/")
+        if len(parts) >= 2:
+            with contextlib.suppress(ValueError):
+                player.player_id = int(parts[1])
 
-    Returns:
-        PlayerGameStats: Parsed player info including name, ID, team,
-        and agents.
-
-    """
-    player = PlayerGameStats()
-    tds = tr.css("td")
-
-    td_player = tds[0] if len(tds) > 0 else None
-    td_agents = tds[1] if len(tds) > 1 else None
-
-    if td_player:
-        a = td_player.css_first("a")
-        if a:
-            href = a.attributes.get("href", "") or ""
-            parts = href.strip("/").split("/")
-            if len(parts) >= 2:
-                with contextlib.suppress(ValueError):
-                    player.player_id = int(parts[1])
-
-        name_el = td_player.css_first(".text-of")
-        if name_el:
-            player.name = name_el.text(strip=True)
+    name_el = cell.css_first(".ovw-player-name")
+    if name_el:
+        player.name = name_el.text(strip=True)
+    else:
+        bold_el = cell.css_first("div[style*='font-weight: 700']")
+        if bold_el:
+            player.name = bold_el.text(strip=True)
         else:
-            bold_el = td_player.css_first("div[style*='font-weight: 700']")
-            if bold_el:
-                player.name = bold_el.text(strip=True)
-            else:
-                for div in td_player.css("div"):
-                    text = div.text(strip=True)
-                    if text and len(text) <= 20 and not div.css("div"):
-                        player.name = text
-                        break
-
-        team_el = td_player.css_first(".ge-text-light")
-        if team_el:
-            player.team_short = team_el.text(strip=True)
-
-        flag_el = td_player.css_first("i.flag")
-        if flag_el:
-            for cls in (flag_el.attributes.get("class") or "").split():
-                if cls.startswith("mod-") and cls != "mod-none":
-                    player.country_code = cls[4:]
-                    player.country = get_country_name(player.country_code)
+            for div in cell.css("div"):
+                text = div.text(strip=True)
+                if text and len(text) <= 20 and not div.css("div"):
+                    player.name = text
                     break
 
-    if td_agents:
-        for img in td_agents.css("img"):
-            alt = img.attributes.get("alt", "") or ""
-            if alt:
-                player.agents.append(alt.title())
+    team_el = cell.css_first(".ovw-player-tag")
+    if team_el:
+        player.team_short = team_el.text(strip=True)
 
-    return player
+    flag_el = cell.css_first("i.flag")
+    if flag_el:
+        for cls in (flag_el.attributes.get("class") or "").split():
+            if cls.startswith("mod-") and cls != "mod-none":
+                player.country_code = cls[4:]
+                player.country = get_country_name(player.country_code)
+                break
 
+    for img in cell.css(".ovw-agents img"):
+        alt = img.attributes.get("alt", "") or ""
+        if alt:
+            player.agents.append(alt.title())
 
-def _parse_table(table: Node) -> list[PlayerGameStats]:
-    """Parse an entire player stats table into PlayerGameStats list.
+    return player
 
-    Args:
-        table: The table Node containing player stat rows.
 
-    Returns:
-        list[PlayerGameStats]: Parsed player stats with side-specific
-        breakdowns.
+def _parse_kda_cell(cell: Node) -> tuple:
+    kills_o = kills_a = kills_d = None
+    deaths_o = deaths_a = deaths_d = None
+    assists_o = assists_a = assists_d = None
 
-    """
-    players: list[PlayerGameStats] = []
-    rows = table.css("tbody tr")
-    for tr in rows:
-        tds = tr.css("td")
-        if len(tds) < 14:
-            continue
+    for stat_span in cell.css("span.ovw-kda-stat"):
+        col = stat_span.attributes.get("data-col", "")
+        both_el = stat_span.css_first("span.mod-both")
+        t_el = stat_span.css_first("span.mod-t")
+        ct_el = stat_span.css_first("span.mod-ct")
+        both = _parse_int(both_el.text(strip=True)) if both_el is not None else None
+        t = _parse_int(t_el.text(strip=True)) if t_el is not None else None
+        ct = _parse_int(ct_el.text(strip=True)) if ct_el is not None else None
+        if col == "kills":
+            kills_o, kills_a, kills_d = both, t, ct
+        elif col == "deaths":
+            deaths_o, deaths_a, deaths_d = both, t, ct
+        elif col == "assists":
+            assists_o, assists_a, assists_d = both, t, ct
 
-        player = _parse_player_row(tr)
+    return (kills_o, kills_a, kills_d, deaths_o, deaths_a, deaths_d, assists_o, assists_a, assists_d)
 
-        stat_tds = tds[2:14]
 
-        overall_vals = []
-        attack_vals = []
-        defend_vals = []
+def _parse_table(table: Node) -> list[PlayerGameStats]:
+    players: list[PlayerGameStats] = []
+    rows = table.css("div.ovw-row")
+    for row in rows:
+        cls = row.attributes.get("class", "") or ""
+        if "mod-head" in cls:
+            continue
 
-        for td in stat_tds:
-            o, a, d = _parse_stat_cell(td)
-            overall_vals.append(o)
-            attack_vals.append(a)
-            defend_vals.append(d)
+        cells = row.css("div.ovw-cell")
+        if len(cells) < 11:
+            continue
 
-        def _build_side(vals) -> SideStats:
+        player = _parse_player_row(cells[0])
+
+        rating_vals = _parse_stat_cell(cells[1])
+        acs_vals = _parse_stat_cell(cells[2])
+        kills_vals, deaths_vals, assists_vals = None, None, None
+        kda_vals = _parse_kda_cell(cells[3])
+        kills_vals = (kda_vals[0], kda_vals[1], kda_vals[2])
+        deaths_vals = (kda_vals[3], kda_vals[4], kda_vals[5])
+        assists_vals = (kda_vals[6], kda_vals[7], kda_vals[8])
+        kd_diff_vals = _parse_stat_cell(cells[4])
+        kast_vals = _parse_stat_cell(cells[5])
+        adr_vals = _parse_stat_cell(cells[6])
+        hs_percent_vals = _parse_stat_cell(cells[7])
+        first_kills_vals = _parse_stat_cell(cells[8])
+        first_deaths_vals = _parse_stat_cell(cells[9])
+        fk_fd_diff_vals = _parse_stat_cell(cells[10])
+
+        def _build_side(
+            rating_t, acs_t, kills_t, deaths_t, assists_t, kd_diff_t, kast_t, adr_t, hs_percent_t, first_kills_t, first_deaths_t, fk_fd_diff_t,
+        ) -> SideStats:
             return SideStats(
-                rating=vals[0],
-                acs=vals[1],
-                kills=vals[2],
-                deaths=vals[3],
-                assists=vals[4],
-                kd_diff=vals[5],
-                kast=vals[6],
-                adr=vals[7],
-                hs_percent=vals[8],
-                first_kills=vals[9],
-                first_deaths=vals[10],
-                fk_fd_diff=vals[11],
+                rating=rating_t,
+                acs=acs_t,
+                kills=kills_t,
+                deaths=deaths_t,
+                assists=assists_t,
+                kd_diff=kd_diff_t,
+                kast=kast_t,
+                adr=adr_t,
+                hs_percent=hs_percent_t,
+                first_kills=first_kills_t,
+                first_deaths=first_deaths_t,
+                fk_fd_diff=fk_fd_diff_t,
             )
 
         player.stats = PlayerStats(
-            overall=_build_side(overall_vals),
-            attack=_build_side(attack_vals),
-            defend=_build_side(defend_vals),
+            overall=_build_side(
+                rating_vals[0], acs_vals[0], kills_vals[0], deaths_vals[0], assists_vals[0],
+                kd_diff_vals[0], kast_vals[0], adr_vals[0], hs_percent_vals[0],
+                first_kills_vals[0], first_deaths_vals[0], fk_fd_diff_vals[0],
+            ),
+            attack=_build_side(
+                rating_vals[1], acs_vals[1], kills_vals[1], deaths_vals[1], assists_vals[1],
+                kd_diff_vals[1], kast_vals[1], adr_vals[1], hs_percent_vals[1],
+                first_kills_vals[1], first_deaths_vals[1], fk_fd_diff_vals[1],
+            ),
+            defend=_build_side(
+                rating_vals[2], acs_vals[2], kills_vals[2], deaths_vals[2], assists_vals[2],
+                kd_diff_vals[2], kast_vals[2], adr_vals[2], hs_percent_vals[2],
+                first_kills_vals[2], first_deaths_vals[2], fk_fd_diff_vals[2],
+            ),
         )
 
         players.append(player)
@@ -319,7 +337,7 @@ def parse_players_stats(html: HTMLParser, game_id: str = "all") -> PlayersStats:
             if not result.map_name:
                 result.map_name = map_div.text(strip=True)
 
-    tables = game_div.css("table.wf-table-inset.mod-overview")
+    tables = game_div.css("div.ovw-table")
     if len(tables) < 2:
         return result