maxpreps-scraper 0.1.0__tar.gz

maxpreps_scraper-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Raghav Dhir
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

maxpreps_scraper-0.1.0/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: maxpreps-scraper
+Version: 0.1.0
+Summary: A Python scraper for MaxPreps high school sports data
+Home-page: https://github.com/raghavdhir03/maxpreps_scraper
+Author: Raghav Dhir
+Author-email: dhir.raghav@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: beautifulsoup4
+Requires-Dist: tqdm
+Requires-Dist: pandas
+Requires-Dist: lxml
+Requires-Dist: html5lib
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# MaxPreps Web Scraper
+
+This Python module scrapes high school sports data from [MaxPreps.com](https://www.maxpreps.com), enabling efficient extraction of team rankings and game results across states and sports.
+
+## Features
+
+- Retrieve team rankings with strength of schedule, rating, and team links.
+- Scrape team schedules, game outcomes, rankings
+- Includes address/location data for each team.
+- Multi-threaded scraping for speed and efficiency.
+- Cleans and structures game metadata (venue, game type, outcome, etc.).
+
+##  File Structure
+
+- `scraper.py`: Contains the `MaxPrepsScraper` class 
+
+## ️ Installation
+
+```bash
+pip install requests beautifulsoup4 pandas tqdm
+```
+##  Functions
+
+##### `get_rankings(state: str, sport: str, year: str, boys: bool = True)`
+
+Retrieves state rankings for a given sport and academic year.
+**Parameters:**
+- `state` (`str`): Two-letter state abbreviation (e.g., `'tx'` for Texas)
+- `sport` (`str`): Sport name (e.g., `'basketball'`)
+- `year` (`str`): Academic year of the season (e.g., `'21-22'`)
+- `boys` (`bool`, optional): Set to `True` for boys' sports and `False` for girls'. Defaults to `True`.
+
+**Returns:**  
+`pandas.DataFrame` containing:
+- School Name
+- State Rank
+- Strength of Schedule (SOS)
+- Team Rating
+- Team URL
+
+---
+
+##### `get_contests(state: str, sport: str, year: str, boys: bool = True, cities: list = None)`
+
+Scrapes all contests (games) for selected schools by state, sport, and year.
+**Parameters:**
+- `state` (`str`): Two-letter state abbreviation (e.g., `'tx'`)
+- `sport` (`str`): Sport name (e.g., `'basketball'`)
+- `year` (`str`): Academic year of the season (e.g., `'21-22'`)
+- `boys` (`bool`, optional): Set to `True` for boys' sports and `False` for girls'. Defaults to `True`.
+- `cities` (`list`, optional): A list of cities to filter for, e.g., `['austin', 'el paso']` (if omitted, full state will be scraped)
+
+**Returns:**  
+`pandas.DataFrame` containing game-level contest data, including:
+- Date, opponent, venue, scores
+- Team location details (address, city, state, zipcode)
+- URLs to the MaxPreps pages of both teams
+
+## Usage and Example Output
+```
+from scraper import MaxPrepsScraper
+scraper = MaxPrepsScraper()
+
+# Get Team Rankings
+rankings_df = scraper.get_rankings(state = 'de', sport = 'football', year = '23-24')
+
+# Get Contest Data
+contests_df = scraper.get_contests(state='tx', sport='basketball', year='21-22', boys=False, cities = ['san antonio'])
+
+#output datframes
+rankings_df.head(10)
+contests_df.head(10)
+```
+![Get Rankings](images/rankings_demo.png)
+![Get Contests](images/contests_demo.png)
+
+
+

maxpreps_scraper-0.1.0/README.md

@@ -0,0 +1,78 @@
+# MaxPreps Web Scraper
+
+This Python module scrapes high school sports data from [MaxPreps.com](https://www.maxpreps.com), enabling efficient extraction of team rankings and game results across states and sports.
+
+## Features
+
+- Retrieve team rankings with strength of schedule, rating, and team links.
+- Scrape team schedules, game outcomes, rankings
+- Includes address/location data for each team.
+- Multi-threaded scraping for speed and efficiency.
+- Cleans and structures game metadata (venue, game type, outcome, etc.).
+
+##  File Structure
+
+- `scraper.py`: Contains the `MaxPrepsScraper` class 
+
+## ️ Installation
+
+```bash
+pip install requests beautifulsoup4 pandas tqdm
+```
+##  Functions
+
+##### `get_rankings(state: str, sport: str, year: str, boys: bool = True)`
+
+Retrieves state rankings for a given sport and academic year.
+**Parameters:**
+- `state` (`str`): Two-letter state abbreviation (e.g., `'tx'` for Texas)
+- `sport` (`str`): Sport name (e.g., `'basketball'`)
+- `year` (`str`): Academic year of the season (e.g., `'21-22'`)
+- `boys` (`bool`, optional): Set to `True` for boys' sports and `False` for girls'. Defaults to `True`.
+
+**Returns:**  
+`pandas.DataFrame` containing:
+- School Name
+- State Rank
+- Strength of Schedule (SOS)
+- Team Rating
+- Team URL
+
+---
+
+##### `get_contests(state: str, sport: str, year: str, boys: bool = True, cities: list = None)`
+
+Scrapes all contests (games) for selected schools by state, sport, and year.
+**Parameters:**
+- `state` (`str`): Two-letter state abbreviation (e.g., `'tx'`)
+- `sport` (`str`): Sport name (e.g., `'basketball'`)
+- `year` (`str`): Academic year of the season (e.g., `'21-22'`)
+- `boys` (`bool`, optional): Set to `True` for boys' sports and `False` for girls'. Defaults to `True`.
+- `cities` (`list`, optional): A list of cities to filter for, e.g., `['austin', 'el paso']` (if omitted, full state will be scraped)
+
+**Returns:**  
+`pandas.DataFrame` containing game-level contest data, including:
+- Date, opponent, venue, scores
+- Team location details (address, city, state, zipcode)
+- URLs to the MaxPreps pages of both teams
+
+## Usage and Example Output
+```
+from scraper import MaxPrepsScraper
+scraper = MaxPrepsScraper()
+
+# Get Team Rankings
+rankings_df = scraper.get_rankings(state = 'de', sport = 'football', year = '23-24')
+
+# Get Contest Data
+contests_df = scraper.get_contests(state='tx', sport='basketball', year='21-22', boys=False, cities = ['san antonio'])
+
+#output datframes
+rankings_df.head(10)
+contests_df.head(10)
+```
+![Get Rankings](images/rankings_demo.png)
+![Get Contests](images/contests_demo.png)
+
+
+

maxpreps_scraper-0.1.0/maxpreps_scraper/__init__.py

@@ -0,0 +1 @@
+from .scraper import MaxPrepsScraper

maxpreps_scraper-0.1.0/maxpreps_scraper/scraper.py

@@ -0,0 +1,286 @@
+import requests
+from bs4 import BeautifulSoup
+from tqdm import tqdm
+import pandas as pd
+from io import StringIO
+import concurrent.futures
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import re
+
+class MaxPrepsScraper():
+
+    BASE_URL = 'https://www.maxpreps.com'
+
+    def __init__(self):
+        """Initialize scraper settings (headers, session, etc.)."""
+        self.session = requests.Session()
+
+    def get_rankings(self, state: str, sport: str, year: str, boys=True):
+        """
+        Get rankings for a given sport, state, and year.
+        Returns a Pandas DataFrame with:
+        - School Name
+        - State Rank
+        - Strength of Schedule (SOS)
+        - Team Rating
+        - Team URL
+        """
+
+        if sport not in ['basketball', 'football', 'baseball', 'soccer', 'volleyball', 'lacrosse', 'softball']:
+            raise ValueError(f"Sport '{sport}' is not supported. Please choose from: basketball, football, baseball, soccer, volleyball, lacrosse, softball")
+        
+        if (boys == False and sport in ['football', 'baseball']) or (boys and sport in ['softball', 'volleyball']):
+            raise ValueError(f"{'boys' if boys else 'girls'} {sport} is not supported")
+        
+        if sport == 'soccer' and state not in ['tx', 'la', 'ms', 'hi', 'ca', 'fl', 'az']:
+            raise ValueError(f"Soccer is not supported in {state}")
+        
+        state_url = f"{self.BASE_URL}/{state}/{sport}/{'' if (boys or sport in ['softball', 'volleyball']) else 'girls/'}{'winter/' if sport == 'soccer' else ''}{year}/rankings"
+       
+        page = 1
+        full_df = pd.DataFrame()
+
+        while True:
+            page_url = f'{state_url}/{page}/'
+        
+            response = requests.get(page_url)
+
+            # Stop if the page does not exist
+            if response.status_code != 200:
+                break
+
+            soup = BeautifulSoup(response.text, 'html.parser')
+
+            # You can add extra checks here to stop if there's no data
+            table = soup.find('table')
+            if not table:
+                break
+
+            # Process your table here
+            df = self._scrape_table(soup)
+
+            full_df = pd.concat([full_df, df]).reset_index(drop=True)
+
+            page += 1
+        
+        full_df['Team'] = full_df['Team'].str.replace(r'^([A-Z])\1', r'\1', regex=True) #take care of schools with no mascot. Turns AAustin into Austin
+
+        return full_df
+    
+    #sports that this function suppoprts: basketball, football, baseball, soccer, volleyball, lacrosse, softball, 
+    def get_contests(self, state: str, sport: str, year: str, boys: bool = True, cities=None):
+
+        if sport not in ['basketball', 'football', 'baseball', 'soccer', 'volleyball', 'lacrosse', 'softball']:
+            raise ValueError(f"Sport '{sport}' is not supported. Please choose from: basketball, football, baseball, soccer, volleyball, lacrosse, softball")
+        
+        if (boys == False and sport in ['football', 'baseball']) or (boys and sport in ['softball', 'volleyball']):
+            raise ValueError(f"{'boys' if boys else 'girls'} {sport} is not supported")
+        
+        if sport == 'soccer' and state not in ['tx', 'la', 'ms', 'hi', 'ca', 'fl', 'az']:
+            raise ValueError(f"Soccer is not supported in {state}")
+        
+
+        state_url = f"{self.BASE_URL}/{state}/{sport}/{'' if (boys or sport in ['softball', 'volleyball']) else 'girls/'}{'winter/' if sport == 'soccer' else ''}{year}/rankings"
+        page = 1
+        school_list = []
+
+        # Step 1: Collect all school links
+        while True:
+            page_url = f'{state_url}/{page}/'
+            #print(page_url)
+            response = requests.get(page_url)
+
+            if response.status_code != 200:
+                break
+
+            soup = BeautifulSoup(response.text, 'html.parser')
+            page_list = self._get_school_list(soup, cities)
+            #print(page_list)
+            school_list += page_list
+            #print(len(school_list))
+            page += 1
+        
+        
+
+        # Step 2: Thread-safe scrape function that still uses self._scrape_table()
+        def _fetch_and_scrape(school, url, base_url='https://www.maxpreps.com'):
+            try:
+                response = requests.get(base_url + url, timeout=10)
+                if response.status_code == 200:
+                    soup = BeautifulSoup(response.text, 'html.parser')
+                    table = self._scrape_table(soup)
+                    table['Team 2 URL'] = self._extract_opponent_urls(soup)
+                    location_info = self._extract_location_info(soup)
+                    table['Team 1'] = school
+                    table['Team 1 Address'] = location_info['address']
+                    table['Team 1 City'] = location_info['city']
+                    table['Team 1 State'] = location_info['state']
+                    table['Team 1 Zipcode'] = location_info['zipcode']
+                    table['Team 1 URL'] = url
+                    return table
+                else:
+                    print(f"Failed to fetch {url} (status code: {response.status_code})")
+            except Exception as e:
+                print(f"Error scraping {school} at {url}: {e}")
+            return None
+
+        # Step 3: Run threads
+       
+        full_df = pd.DataFrame()
+        with ThreadPoolExecutor(max_workers=10) as executor:
+            futures = [executor.submit(_fetch_and_scrape, school, url) for school, url in school_list]
+
+            with tqdm(total=len(futures), desc=f"Scraping Schools for {', '.join(city for city in cities) if cities else ''} {state}", unit=" schools") as pbar:
+                for future in as_completed(futures):
+                    result_df = future.result()
+                    if result_df is not None and not result_df.empty:
+                        full_df = pd.concat([full_df, result_df], ignore_index=True)
+                    pbar.update(1)
+        
+        
+        full_df = self._clean_contest_data(full_df)
+
+        return full_df
+
+
+    def _scrape_table(self, soup):
+        table = soup.find('table')
+        html = str(table)
+        df = pd.read_html(StringIO(html))[0]
+        return df
+
+    def _get_school_list(self, soup, cities=None, base_url='https://www.maxpreps.com'):
+        """
+        Extracts school names and links to schedule pages based on new MaxPreps HTML structure.
+        """
+        school_data = []
+
+        for td in soup.find_all('td'):
+            a_tag = td.find('a', href=True)
+            if a_tag and 'schedule' in a_tag['href']:
+                href = a_tag['href']
+                
+                # Check if cities is None (no filter), or if any city is in the href
+                if cities is None or any(city.lower().replace(" ", "-") == href.lower().split('/')[2] for city in cities):
+                    name = a_tag.get_text(strip=True)
+                    link = href
+                    school_data.append((name, link))
+
+
+        return school_data
+
+    def _extract_location_info(self, soup):
+
+        address_element = soup.select_one('address')
+        if not address_element:
+            return {
+                "address": None,
+                "city": None,
+                "state": None,
+                "zipcode": None
+            }
+
+        # Get city/state/zip from <span>
+        city_state_span = address_element.find('span')
+        if city_state_span:
+            city_state_text = city_state_span.get_text(strip=True)
+            city_state_span.decompose()  # Remove span from the address block
+        else:
+            city_state_text = ""
+
+        # Now get street address (without the span)
+        street_address = address_element.get_text(strip=True)
+
+        # Parse city, state, and zip using regex
+        city, state, zipcode = None, None, None
+        match = re.match(r'^(.*?),\s*([A-Z]{2})\s*(\d{5})(?:-\d{4})?$', city_state_text)
+        if match:
+            city, state, zipcode = match.groups()
+
+        return {
+            "address": street_address or None,
+            "city": city,
+            "state": state,
+            "zipcode": zipcode
+        }
+    
+    def _extract_opponent_urls(self, soup): #Extracts a list of opponent URLs (or None) from the 'Opponent' column in the schedule table.
+        
+        opponent_urls = []
+
+        # Find the schedule table
+        table = soup.find('table')
+        if not table:
+            return []
+
+        # Step 1: Get header row and find the column index for 'Opponent'
+        header_row = table.find('tr')
+        headers = [th.get_text(strip=True).lower() for th in header_row.find_all('th')]
+        
+        try:
+            opponent_idx = headers.index('opponent')
+        except ValueError:
+            return []
+
+        # Step 2: Go through all remaining rows and get href from the opponent column
+        for row in table.find_all('tr')[1:]:  # skip header row
+            cells = row.find_all('td')
+            if len(cells) > opponent_idx:
+                opponent_cell = cells[opponent_idx]
+                a_tag = opponent_cell.find('a', href=True)
+
+                if a_tag and a_tag['href'].endswith('/schedule/'):
+                    opponent_urls.append(a_tag['href'])
+                else:
+                    opponent_urls.append(None)
+
+        return opponent_urls
+    
+    def _clean_contest_data(self, df):
+        # --- 1. Clean 'Opponent' column ---
+        opponent_pattern = r'(?P<VenueRaw>vs\.?|@)?\s*(?P<Team2>.+?)(?P<Star>\*{0,3})$'
+
+        opponent_info = df['Opponent'].str.extract(opponent_pattern)
+
+        # Venue
+        opponent_info['Venue'] = opponent_info['VenueRaw'].map({
+            'vs': 'Home',
+            'vs.': 'Home',
+            '@': 'Away'
+        }).fillna('Neutral')
+
+        # Game Type
+        opponent_info['Game Type'] = opponent_info['Star'].map({
+            '': 'Regular Season',
+            '*': 'District',
+            '**': 'Playoff',
+            '***': 'Tournament'
+        }).fillna('Regular Season')
+
+        df['Team 2'] = opponent_info['Team2'].str.strip()
+        df['Venue'] = opponent_info['Venue']
+        df['Game Type'] = opponent_info['Game Type']
+
+        # --- 2. Clean 'Result' column ---
+        result_pattern = r'(?P<Outcome>[WL])(?: (?P<Team1_Score>\d+)-(?P<Team2_Score>\d+)|\((?P<Forfeit>FF)\))'
+
+        result_info = df['Result'].str.extract(result_pattern)
+
+        df['Outcome'] = result_info['Outcome']
+        df['Team 1 Score'] = pd.to_numeric(result_info['Team1_Score'], errors='coerce')
+        df['Team 2 Score'] = pd.to_numeric(result_info['Team2_Score'], errors='coerce')
+        df['Forfeit'] = result_info['Forfeit'].notna()
+
+        cols_to_drop = ['Opponent', 'Result', 'Game Info', 'Match Info']
+        df.drop(columns=[col for col in cols_to_drop if col in df.columns], inplace=True)
+
+        df.loc[df['Outcome'] == 'L', ['Team 1 Score', 'Team 2 Score']] = df.loc[df['Outcome'] == 'L', ['Team 2 Score', 'Team 1 Score']].values # Swap scores if team 1 lost
+
+        df['Team 1'] = df['Team 1'].str.replace(r'(^[A-Z])\1', '', regex=True) #take care of schools with no mascot. Turns AAustin into Austin
+
+        # Reorder columns
+        new_order = ['Date', 'Team 1', 'Team 2', 'Team 1 Score', 'Team 2 Score', 'Outcome', 'Forfeit', 'Venue', 'Game Type', 'Team 1 Address', 'Team 1 City', 'Team 1 State', 'Team 1 Zipcode', 'Team 1 URL', 'Team 2 URL'] 
+        df = df[new_order]
+
+        return df
+

maxpreps_scraper-0.1.0/maxpreps_scraper.egg-info/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: maxpreps-scraper
+Version: 0.1.0
+Summary: A Python scraper for MaxPreps high school sports data
+Home-page: https://github.com/raghavdhir03/maxpreps_scraper
+Author: Raghav Dhir
+Author-email: dhir.raghav@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: beautifulsoup4
+Requires-Dist: tqdm
+Requires-Dist: pandas
+Requires-Dist: lxml
+Requires-Dist: html5lib
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# MaxPreps Web Scraper
+
+This Python module scrapes high school sports data from [MaxPreps.com](https://www.maxpreps.com), enabling efficient extraction of team rankings and game results across states and sports.
+
+## Features
+
+- Retrieve team rankings with strength of schedule, rating, and team links.
+- Scrape team schedules, game outcomes, rankings
+- Includes address/location data for each team.
+- Multi-threaded scraping for speed and efficiency.
+- Cleans and structures game metadata (venue, game type, outcome, etc.).
+
+##  File Structure
+
+- `scraper.py`: Contains the `MaxPrepsScraper` class 
+
+## ️ Installation
+
+```bash
+pip install requests beautifulsoup4 pandas tqdm
+```
+##  Functions
+
+##### `get_rankings(state: str, sport: str, year: str, boys: bool = True)`
+
+Retrieves state rankings for a given sport and academic year.
+**Parameters:**
+- `state` (`str`): Two-letter state abbreviation (e.g., `'tx'` for Texas)
+- `sport` (`str`): Sport name (e.g., `'basketball'`)
+- `year` (`str`): Academic year of the season (e.g., `'21-22'`)
+- `boys` (`bool`, optional): Set to `True` for boys' sports and `False` for girls'. Defaults to `True`.
+
+**Returns:**  
+`pandas.DataFrame` containing:
+- School Name
+- State Rank
+- Strength of Schedule (SOS)
+- Team Rating
+- Team URL
+
+---
+
+##### `get_contests(state: str, sport: str, year: str, boys: bool = True, cities: list = None)`
+
+Scrapes all contests (games) for selected schools by state, sport, and year.
+**Parameters:**
+- `state` (`str`): Two-letter state abbreviation (e.g., `'tx'`)
+- `sport` (`str`): Sport name (e.g., `'basketball'`)
+- `year` (`str`): Academic year of the season (e.g., `'21-22'`)
+- `boys` (`bool`, optional): Set to `True` for boys' sports and `False` for girls'. Defaults to `True`.
+- `cities` (`list`, optional): A list of cities to filter for, e.g., `['austin', 'el paso']` (if omitted, full state will be scraped)
+
+**Returns:**  
+`pandas.DataFrame` containing game-level contest data, including:
+- Date, opponent, venue, scores
+- Team location details (address, city, state, zipcode)
+- URLs to the MaxPreps pages of both teams
+
+## Usage and Example Output
+```
+from scraper import MaxPrepsScraper
+scraper = MaxPrepsScraper()
+
+# Get Team Rankings
+rankings_df = scraper.get_rankings(state = 'de', sport = 'football', year = '23-24')
+
+# Get Contest Data
+contests_df = scraper.get_contests(state='tx', sport='basketball', year='21-22', boys=False, cities = ['san antonio'])
+
+#output datframes
+rankings_df.head(10)
+contests_df.head(10)
+```
+![Get Rankings](images/rankings_demo.png)
+![Get Contests](images/contests_demo.png)
+
+
+

maxpreps_scraper-0.1.0/maxpreps_scraper.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+setup.py
+maxpreps_scraper/__init__.py
+maxpreps_scraper/scraper.py
+maxpreps_scraper.egg-info/PKG-INFO
+maxpreps_scraper.egg-info/SOURCES.txt
+maxpreps_scraper.egg-info/dependency_links.txt
+maxpreps_scraper.egg-info/requires.txt
+maxpreps_scraper.egg-info/top_level.txt
+tests/test_scraper.py

maxpreps_scraper-0.1.0/maxpreps_scraper.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

maxpreps_scraper-0.1.0/maxpreps_scraper.egg-info/requires.txt

@@ -0,0 +1,6 @@
+requests
+beautifulsoup4
+tqdm
+pandas
+lxml
+html5lib

maxpreps_scraper-0.1.0/maxpreps_scraper.egg-info/top_level.txt

@@ -0,0 +1 @@
+maxpreps_scraper

maxpreps_scraper-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

maxpreps_scraper-0.1.0/setup.py

@@ -0,0 +1,27 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='maxpreps-scraper',                       # Package name (pip install maxpreps-scraper)
+    version='0.1.0',                               # Initial version
+    packages=find_packages(),                      # Automatically find all modules inside your package folder
+    install_requires=[
+        'requests',
+        'beautifulsoup4',
+        'tqdm',
+        'pandas',
+        'lxml',
+        'html5lib',
+    ],
+    author='Raghav Dhir',
+    author_email='dhir.raghav@gmail.com',         
+    description='A Python scraper for MaxPreps high school sports data',
+    long_description=open('README.md').read(),
+    long_description_content_type='text/markdown', # So Markdown renders on PyPI
+    url='https://github.com/raghavdhir03/maxpreps_scraper',  # Your GitHub repo
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+    ],
+    python_requires='>=3.7',
+)

maxpreps_scraper-0.1.0/tests/test_scraper.py

@@ -0,0 +1,42 @@
+import requests
+import pandas as pd
+from bs4 import BeautifulSoup
+from io import StringIO
+import sys
+import os
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+from maxpreps_scraper.scraper import MaxPrepsScraper
+from concurrent.futures import ThreadPoolExecutor
+import concurrent.futures
+import re
+
+
+## testing scraping state rankings
+'''scraper = MaxPrepsScraper()
+table = scraper.get_rankings('de', 'basketball', '21-22', boys=False)
+print(table.head())'''
+
+## testing scraping contests
+scraper = MaxPrepsScraper()
+#football_data = scraper.get_contests('de', 'football', '21-22')
+#basketball_data = scraper.get_contests('tx', 'basketball', '21-22', cities=['austin', 'san antonio'])
+baseball_data = scraper.get_contests('hi', 'baseball', '21-22')
+#lacrosse_data = scraper.get_contests('tx', 'lacrosse', '21-22', boys=False)
+#soccer_data = scraper.get_contests('la', 'soccer', '21-22')
+#softball_data = scraper.get_contests('de', 'softball', '21-22')
+#print(football_data.head())
+#print(basketball_data.head())
+print(baseball_data.head())
+#print(softball_data.head())
+#print(lacrosse_data.head())
+#print(soccer_data.head())
+
+"""baseball_rankings = scraper.get_rankings('de', 'baseball', '21-22')
+print(baseball_rankings.head())"""
+
+
+##testing roster function
+"""scraper = MaxPrepsScraper()
+roster = scraper.get_roster('https://www.maxpreps.com/tx/austin/bowie-bulldogs/basketball/21-22/roster/')
+print(roster.head())"""
+