.github/FUNDING.yml

@@ -1 +0,0 @@
-github: Bunsly

.pre-commit-config.yaml

@@ -1,21 +0,0 @@
----
-repos:
-  - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.2.0
-    hooks:
-      - id: trailing-whitespace
-      - id: end-of-file-fixer
-      - id: check-added-large-files
-      - id: check-yaml
-  - repo: https://github.com/adrienverge/yamllint
-    rev: v1.29.0
-    hooks:
-      - id: yamllint
-        verbose: true # create awareness of linter findings
-        args: ["-d", "{extends: relaxed, rules: {line-length: {max: 120}}}"]
-  - repo: https://github.com/psf/black
-    rev: 24.2.0
-    hooks:
-    - id: black
-      language_version: python
-      args: [--line-length=120, --quiet]

HomeHarvest_Demo.ipynb

@@ -0,0 +1,118 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cb48903e-5021-49fe-9688-45cd0bc05d0f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from homeharvest import scrape_property\n",
+    "import pandas as pd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "156488ce-0d5f-43c5-87f4-c33e9c427860",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pd.set_option('display.max_columns', None)  # Show all columns\n",
+    "pd.set_option('display.max_rows', None)     # Show all rows\n",
+    "pd.set_option('display.width', None)        # Auto-adjust display width to fit console\n",
+    "pd.set_option('display.max_colwidth', 50)   # Limit max column width to 50 characters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1c8b9744-8606-4e9b-8add-b90371a249a7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# scrapes all 3 sites by default\n",
+    "scrape_property(\n",
+    "    location=\"dallas\",\n",
+    "    listing_type=\"for_sale\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "aaf86093",
+   "metadata": {
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# search a specific address\n",
+    "scrape_property(\n",
+    "    location=\"2530 Al Lipscomb Way\",\n",
+    "    site_name=\"zillow\",\n",
+    "    listing_type=\"for_sale\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ab7b4c21-da1d-4713-9df4-d7425d8ce21e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# check rentals\n",
+    "scrape_property(\n",
+    "    location=\"chicago, illinois\",\n",
+    "    site_name=[\"redfin\", \"zillow\"],\n",
+    "    listing_type=\"for_rent\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "af280cd3",
+   "metadata": {
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# check sold properties\n",
+    "scrape_property(\n",
+    "    location=\"90210\",\n",
+    "    site_name=[\"redfin\"],\n",
+    "    listing_type=\"sold\"\n",
+    ")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

README.md

@@ -1,198 +1,166 @@
 <img src="https://github.com/ZacharyHampton/HomeHarvest/assets/78247585/d1a2bf8b-09f5-4c57-b33a-0ada8a34f12d" width="400">
 
-**HomeHarvest** is a real estate scraping library that extracts and formats data in the style of MLS listings.
+**HomeHarvest** is a simple, yet comprehensive, real estate scraping library.
 
-## HomeHarvest Features
+[![Try with Replit](https://replit.com/badge?caption=Try%20with%20Replit)](https://replit.com/@ZacharyHampton/HomeHarvestDemo)
 
-- **Source**: Fetches properties directly from **Realtor.com**.
+\
-- **Data Format**: Structures data to resemble MLS listings.
+**Not technical?** Try out the web scraping tool on our site at [tryhomeharvest.com](https://tryhomeharvest.com).
-- **Export Flexibility**: Options to save as either CSV or Excel.
 
-[Video Guide for HomeHarvest](https://youtu.be/J1qgNPgmSLI) - _updated for release v0.3.4_
+*Looking to build a data-focused software product?* **[Book a call](https://calendly.com/zachary-products/15min)** *to work with us.*
+
+Check out another project we wrote: ***[JobSpy](https://github.com/cullenwatson/JobSpy)** – a Python package for job scraping*
+
+## Features
+
+- Scrapes properties from **Zillow**, **Realtor.com** & **Redfin** simultaneously
+- Aggregates the properties in a Pandas DataFrame
+
+[Video Guide for HomeHarvest](https://youtu.be/JnV7eR2Ve2o) - _updated for release v0.2.7_
 
 ![homeharvest](https://github.com/ZacharyHampton/HomeHarvest/assets/78247585/b3d5d727-e67b-4a9f-85d8-1e65fd18620a)
 
 ## Installation
 
 ```bash
-pip install -U homeharvest
+pip install homeharvest
 ```
-  _Python version >= [3.9](https://www.python.org/downloads/release/python-3100/) required_
+  _Python version >= [3.10](https://www.python.org/downloads/release/python-3100/) required_ 
 
 ## Usage
 
+### CLI 
+
+```bash
+homeharvest "San Francisco, CA" -s zillow realtor.com redfin -l for_rent -o excel -f HomeHarvest
+```
+
+This will scrape properties from the specified sites for the given location and listing type, and save the results to an Excel file named `HomeHarvest.xlsx`.
+
+By default:
+- If `-s` or `--site_name` is not provided, it will scrape from all available sites.
+- If `-l` or `--listing_type` is left blank, the default is `for_sale`. Other options are `for_rent` or `sold`.
+- The `-o` or `--output` default format is `excel`. Options are `csv` or `excel`.
+- If `-f` or `--filename` is left blank, the default is `HomeHarvest_<current_timestamp>`.
+- If `-p` or `--proxy` is not provided, the scraper uses the local IP.
+- Use `-k` or `--keep_duplicates` to keep duplicate properties based on address. If not provided, duplicates will be removed.
 ### Python 
 
 ```py
 from homeharvest import scrape_property
-from datetime import datetime
+import pandas as pd
 
-# Generate filename based on current timestamp
+properties: pd.DataFrame = scrape_property(
-current_timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    site_name=["zillow", "realtor.com", "redfin"],
-filename = f"HomeHarvest_{current_timestamp}.csv"
+    location="85281",
-
+    listing_type="for_rent" # for_sale / sold
-properties = scrape_property(
-  location="San Diego, CA",
-  listing_type="sold",  # or (for_sale, for_rent, pending)
-  past_days=30,  # sold in last 30 days - listed in last 30 days if (for_sale, for_rent)
-
-  # property_type=['single_family','multi_family'],
-  # date_from="2023-05-01", # alternative to past_days
-  # date_to="2023-05-28",
-  # foreclosure=True
-  # mls_only=True,  # only fetch MLS listings
 )
-print(f"Number of properties: {len(properties)}")
 
-# Export to csv
+#: Note, to export to CSV or Excel, use properties.to_csv() or properties.to_excel().
-properties.to_csv(filename, index=False)
+print(properties)
-print(properties.head())
 ```
 
 ## Output
-```plaintext
+```py
 >>> properties.head()
-    MLS       MLS # Status          Style  ...     COEDate LotSFApx PrcSqft Stories
+                                        property_url site_name listing_type  apt_min_price  apt_max_price   ...  
-0  SDCA   230018348   SOLD         CONDOS  ...  2023-10-03   290110     803       2
+0  https://www.redfin.com/AZ/Tempe/1003-W-Washing...    redfin     for_rent         1666.0         2750.0   ... 
-1  SDCA   230016614   SOLD      TOWNHOMES  ...  2023-10-03     None     838       3
+1  https://www.redfin.com/AZ/Tempe/VELA-at-Town-L...    redfin     for_rent         1665.0         3763.0   ...  
-2  SDCA   230016367   SOLD         CONDOS  ...  2023-10-03    30056     649       1
+2  https://www.redfin.com/AZ/Tempe/Camden-Tempe/a...    redfin     for_rent         1939.0         3109.0   ...  
-3  MRCA  NDP2306335   SOLD  SINGLE_FAMILY  ...  2023-10-03     7519     661       2
+3  https://www.redfin.com/AZ/Tempe/Emerson-Park/a...    redfin     for_rent         1185.0         1817.0   ... 
-4  SDCA   230014532   SOLD         CONDOS  ...  2023-10-03     None     752       1
+4  https://www.redfin.com/AZ/Tempe/Rio-Paradiso-A...    redfin     for_rent         1470.0         2235.0   ...   
-[5 rows x 22 columns]
+[5 rows x 41 columns]
 ```
 
-### Parameters for `scrape_property()`
+### Parameters for `scrape_properties()`
-```
+```plaintext
 Required
-├── location (str): The address in various formats - this could be just a zip code, a full address, or city/state, etc.
+├── location (str): address in various formats e.g. just zip, full address, city/state, etc.
-├── listing_type (option): Choose the type of listing.
+└── listing_type (enum): for_rent, for_sale, sold
-    - 'for_rent'
-    - 'for_sale'
-    - 'sold'
-    - 'pending' (for pending/contingent sales)
-
 Optional
-├── property_type (list): Choose the type of properties.
+├── site_name (list[enum], default=all three sites): zillow, realtor.com, redfin
-    - 'single_family'
+├── proxy (str): in format 'http://user:pass@host:port' or [https, socks]
-    - 'multi_family'
+└── keep_duplicates (bool, default=False): whether to keep or remove duplicate properties based on address
-    - 'condos'
-    - 'condo_townhome_rowhome_coop'
-    - 'condo_townhome'
-    - 'townhomes'
-    - 'duplex_triplex'
-    - 'farm'
-    - 'land'
-    - 'mobile'
-│
-├── return_type (option): Choose the return type.
-│    - 'pandas' (default)
-│    - 'pydantic'
-│    - 'raw' (json)
-│
-├── radius (decimal): Radius in miles to find comparable properties based on individual addresses.
-│    Example: 5.5 (fetches properties within a 5.5-mile radius if location is set to a specific address; otherwise, ignored)
-│
-├── past_days (integer): Number of past days to filter properties. Utilizes 'last_sold_date' for 'sold' listing types, and 'list_date' for others (for_rent, for_sale).
-│    Example: 30 (fetches properties listed/sold in the last 30 days)
-│
-├── date_from, date_to (string): Start and end dates to filter properties listed or sold, both dates are required.
-|    (use this to get properties in chunks as there's a 10k result limit)
-│    Format for both must be "YYYY-MM-DD".
-│    Example: "2023-05-01", "2023-05-15" (fetches properties listed/sold between these dates)
-│
-├── mls_only (True/False): If set, fetches only MLS listings (mainly applicable to 'sold' listings)
-│
-├── foreclosure (True/False): If set, fetches only foreclosures
-│
-├── proxy (string): In format 'http://user:pass@host:port'
-│
-├── extra_property_data (True/False): Increases requests by O(n). If set, this fetches additional property data for general searches (e.g. schools, tax appraisals etc.)
-│
-├── exclude_pending (True/False): If set, excludes 'pending' properties from the 'for_sale' results unless listing_type is 'pending'
-│
-└── limit (integer): Limit the number of properties to fetch. Max & default is 10000.
 ```
 
 ### Property Schema
 ```plaintext
 Property
 ├── Basic Information:
-│ ├── property_url
+│   ├── property_url (str)
-│ ├── property_id
+│   ├── site_name (enum): zillow, redfin, realtor.com
-│ ├── listing_id
+│   ├── listing_type (enum): for_sale, for_rent, sold
-│ ├── mls
+│   └── property_type (enum): house, apartment, condo, townhouse, single_family, multi_family, building
-│ ├── mls_id
-│ └── status
 
 ├── Address Details:
-│ ├── street
+│   ├── street_address (str)
-│ ├── unit
+│   ├── city (str)
-│ ├── city
+│   ├── state (str)
-│ ├── state
+│   ├── zip_code (str)
-│ └── zip_code
+│   ├── unit (str)
+│   └── country (str)
 
-├── Property Description:
+├── House for Sale Features:
-│ ├── style
+│   ├── tax_assessed_value (int)
-│ ├── beds
+│   ├── lot_area_value (float)
-│ ├── full_baths
+│   ├── lot_area_unit (str)
-│ ├── half_baths
+│   ├── stories (int)
-│ ├── sqft
+│   ├── year_built (int)
-│ ├── year_built
+│   └── price_per_sqft (int)
-│ ├── stories
-│ ├── garage
-│ └── lot_sqft
 
-├── Property Listing Details:
+├── Building for Sale and Apartment Details:
-│ ├── days_on_mls
+│   ├── bldg_name (str)
-│ ├── list_price
+│   ├── beds_min (int)
-│ ├── list_price_min
+│   ├── beds_max (int)
-│ ├── list_price_max
+│   ├── baths_min (float)
-│ ├── list_date
+│   ├── baths_max (float)
-│ ├── pending_date
+│   ├── sqft_min (int)
-│ ├── sold_price
+│   ├── sqft_max (int)
-│ ├── last_sold_date
+│   ├── price_min (int)
-│ ├── price_per_sqft
+│   ├── price_max (int)
-│ ├── new_construction
+│   ├── area_min (int)
-│ └── hoa_fee
+│   └── unit_count (int)
 
-├── Tax Information:
+├── Miscellaneous Details:
-│  ├── year
+│   ├── mls_id (str)
-│  ├── tax
+│   ├── agent_name (str)
-│  ├── assessment
+│   ├── img_src (str)
-│  │   ├── building
+│   ├── description (str)
-│  │   ├── land
+│   ├── status_text (str)
-│  │   └── total
+│   └── posted_time (str)
-
-├── Location Details:
-│ ├── latitude
-│ ├── longitude
-│ ├── nearby_schools
-
-├── Agent Info:
-│ ├── agent_id
-│ ├── agent_name
-│ ├── agent_email
-│ └── agent_phone
-
-├── Broker Info:
-│ ├── broker_id
-│ └── broker_name
-
-├── Builder Info:
-│ ├── builder_id
-│ └── builder_name
-
-├── Office Info:
-│ ├── office_id
-│ ├── office_name
-│ ├── office_phones
-│ └── office_email
 
+└── Location Details:
+    ├── latitude (float)
+    └── longitude (float)
 ```
+## Supported Countries for Property Scraping
+
+* **Zillow**: contains listings in the **US** & **Canada** 
+* **Realtor.com**: mainly from the **US** but also has international listings
+* **Redfin**: listings mainly in the **US**, **Canada**, & has expanded to some areas in **Mexico**
 
 ### Exceptions
 The following exceptions may be raised when using HomeHarvest:
 
-- `InvalidListingType` - valid options: `for_sale`, `for_rent`, `sold`, `pending`.
+- `InvalidSite` - valid options: `zillow`, `redfin`, `realtor.com`
-- `InvalidDate` - date_from or date_to is not in the format YYYY-MM-DD.
+- `InvalidListingType` - valid options: `for_sale`, `for_rent`, `sold`
-- `AuthenticationError` - Realtor.com token request failed.
+- `NoResultsFound` - no properties found from your input
+- `GeoCoordsNotFound` - if Zillow scraper is not able to derive geo-coordinates from the location you input
+
+## Frequently Asked Questions
+
+---
+
+**Q: Encountering issues with your queries?**  
+**A:** Try a single site and/or broaden the location. If problems persist, [submit an issue](https://github.com/ZacharyHampton/HomeHarvest/issues).
+
+---
+
+**Q: Received a Forbidden 403 response code?**  
+**A:** This indicates that you have been blocked by the real estate site for sending too many requests. Currently, **Zillow** is particularly aggressive with blocking. We recommend:
+
+- Waiting a few seconds between requests.
+- Trying a VPN to change your IP address.
+
+---
+

examples/price_of_land.py

@@ -1,104 +0,0 @@
-"""
-This script scrapes sold and pending sold land listings in past year for a list of zip codes and saves the data to individual Excel files.
-It adds two columns to the data: 'lot_acres' and 'ppa' (price per acre) for user to analyze average price of land in a zip code.
-"""
-
-import os
-import pandas as pd
-from homeharvest import scrape_property
-
-
-def get_property_details(zip: str, listing_type):
-    properties = scrape_property(location=zip, listing_type=listing_type, property_type=["land"], past_days=365)
-    if not properties.empty:
-        properties["lot_acres"] = properties["lot_sqft"].apply(lambda x: x / 43560 if pd.notnull(x) else None)
-
-        properties = properties[properties["sqft"].isnull()]
-        properties["ppa"] = properties.apply(
-            lambda row: (
-                int(
-                    (
-                        row["sold_price"]
-                        if (pd.notnull(row["sold_price"]) and row["status"] == "SOLD")
-                        else row["list_price"]
-                    )
-                    / row["lot_acres"]
-                )
-                if pd.notnull(row["lot_acres"])
-                and row["lot_acres"] > 0
-                and (pd.notnull(row["sold_price"]) or pd.notnull(row["list_price"]))
-                else None
-            ),
-            axis=1,
-        )
-        properties["ppa"] = properties["ppa"].astype("Int64")
-        selected_columns = [
-            "property_url",
-            "property_id",
-            "style",
-            "status",
-            "street",
-            "city",
-            "state",
-            "zip_code",
-            "county",
-            "list_date",
-            "last_sold_date",
-            "list_price",
-            "sold_price",
-            "lot_sqft",
-            "lot_acres",
-            "ppa",
-        ]
-        properties = properties[selected_columns]
-    return properties
-
-
-def output_to_excel(zip_code, sold_df, pending_df):
-    root_folder = os.getcwd()
-    zip_folder = os.path.join(root_folder, "zips", zip_code)
-
-    # Create zip code folder if it doesn't exist
-    os.makedirs(zip_folder, exist_ok=True)
-
-    # Define file paths
-    sold_file = os.path.join(zip_folder, f"{zip_code}_sold.xlsx")
-    pending_file = os.path.join(zip_folder, f"{zip_code}_pending.xlsx")
-
-    # Save individual sold and pending files
-    sold_df.to_excel(sold_file, index=False)
-    pending_df.to_excel(pending_file, index=False)
-
-
-zip_codes = map(
-    str,
-    [
-        22920,
-        77024,
-        78028,
-        24553,
-        22967,
-        22971,
-        22922,
-        22958,
-        22969,
-        22949,
-        22938,
-        24599,
-        24562,
-        22976,
-        24464,
-        22964,
-        24581,
-    ],
-)
-
-combined_df = pd.DataFrame()
-for zip in zip_codes:
-    sold_df = get_property_details(zip, "sold")
-    pending_df = get_property_details(zip, "pending")
-    combined_df = pd.concat([combined_df, sold_df, pending_df], ignore_index=True)
-    output_to_excel(zip, sold_df, pending_df)
-
-combined_file = os.path.join(os.getcwd(), "zips", "combined.xlsx")
-combined_df.to_excel(combined_file, index=False)

homeharvest/__init__.py

@@ -1,77 +1,171 @@
-import warnings
 import pandas as pd
+from typing import Union
+import concurrent.futures
+from concurrent.futures import ThreadPoolExecutor
+
 from .core.scrapers import ScraperInput
-from .utils import process_result, ordered_properties, validate_input, validate_dates, validate_limit
+from .core.scrapers.redfin import RedfinScraper
 from .core.scrapers.realtor import RealtorScraper
-from .core.scrapers.models import ListingType, SearchPropertyType, ReturnType, Property
+from .core.scrapers.zillow import ZillowScraper
+from .core.scrapers.models import ListingType, Property, SiteName
+from .exceptions import InvalidSite, InvalidListingType
+
+
+_scrapers = {
+    "redfin": RedfinScraper,
+    "realtor.com": RealtorScraper,
+    "zillow": ZillowScraper,
+}
+
+
+def _validate_input(site_name: str, listing_type: str) -> None:
+    if site_name.lower() not in _scrapers:
+        raise InvalidSite(f"Provided site, '{site_name}', does not exist.")
+
+    if listing_type.upper() not in ListingType.__members__:
+        raise InvalidListingType(f"Provided listing type, '{listing_type}', does not exist.")
+
+
+def _get_ordered_properties(result: Property) -> list[str]:
+    return [
+        "property_url",
+        "site_name",
+        "listing_type",
+        "property_type",
+        "status_text",
+        "baths_min",
+        "baths_max",
+        "beds_min",
+        "beds_max",
+        "sqft_min",
+        "sqft_max",
+        "price_min",
+        "price_max",
+        "unit_count",
+        "tax_assessed_value",
+        "price_per_sqft",
+        "lot_area_value",
+        "lot_area_unit",
+        "address_one",
+        "address_two",
+        "city",
+        "state",
+        "zip_code",
+        "posted_time",
+        "area_min",
+        "bldg_name",
+        "stories",
+        "year_built",
+        "agent_name",
+        "mls_id",
+        "img_src",
+        "latitude",
+        "longitude",
+        "description",
+    ]
+
+
+def _process_result(result: Property) -> pd.DataFrame:
+    prop_data = result.__dict__
+
+    prop_data["site_name"] = prop_data["site_name"].value
+    prop_data["listing_type"] = prop_data["listing_type"].value.lower()
+    if "property_type" in prop_data and prop_data["property_type"] is not None:
+        prop_data["property_type"] = prop_data["property_type"].value.lower()
+    else:
+        prop_data["property_type"] = None
+    if "address" in prop_data:
+        address_data = prop_data["address"]
+        prop_data["address_one"] = address_data.address_one
+        prop_data["address_two"] = address_data.address_two
+        prop_data["city"] = address_data.city
+        prop_data["state"] = address_data.state
+        prop_data["zip_code"] = address_data.zip_code
+
+        del prop_data["address"]
+
+    properties_df = pd.DataFrame([prop_data])
+    properties_df = properties_df[_get_ordered_properties(result)]
+
+    return properties_df
+
+
+def _scrape_single_site(location: str, site_name: str, listing_type: str, proxy: str = None) -> pd.DataFrame:
+    """
+    Helper function to scrape a single site.
+    """
+    _validate_input(site_name, listing_type)
+
+    scraper_input = ScraperInput(
+        location=location,
+        listing_type=ListingType[listing_type.upper()],
+        site_name=SiteName.get_by_value(site_name.lower()),
+        proxy=proxy,
+    )
+
+    site = _scrapers[site_name.lower()](scraper_input)
+    results = site.search()
+
+    properties_dfs = [_process_result(result) for result in results]
+    properties_dfs = [df.dropna(axis=1, how="all") for df in properties_dfs if not df.empty]
+    if not properties_dfs:
+        return pd.DataFrame()
+
+    return pd.concat(properties_dfs, ignore_index=True)
 
 
 def scrape_property(
     location: str,
+    site_name: Union[str, list[str]] = None,
     listing_type: str = "for_sale",
-    return_type: str = "pandas",
-    property_type: list[str] | None = None,
-    radius: float = None,
-    mls_only: bool = False,
-    past_days: int = None,
     proxy: str = None,
-    date_from: str = None,  #: TODO: Switch to one parameter, Date, with date_from and date_to, pydantic validation
+    keep_duplicates: bool = False
-    date_to: str = None,
+) -> pd.DataFrame:
-    foreclosure: bool = None,
-    extra_property_data: bool = True,
-    exclude_pending: bool = False,
-    limit: int = 10000
-) -> pd.DataFrame | list[dict] | list[Property]:
     """
-    Scrape properties from Realtor.com based on a given location and listing type.
+    Scrape property from various sites from a given location and listing type.
-    :param location: Location to search (e.g. "Dallas, TX", "85281", "2530 Al Lipscomb Way")
+
-    :param listing_type: Listing Type (for_sale, for_rent, sold, pending)
+    :returns: pd.DataFrame
-    :param return_type: Return type (pandas, pydantic, raw)
+    :param location: US Location (e.g. 'San Francisco, CA', 'Cook County, IL', '85281', '2530 Al Lipscomb Way')
-    :param property_type: Property Type (single_family, multi_family, condos, condo_townhome_rowhome_coop, condo_townhome, townhomes, duplex_triplex, farm, land, mobile)
+    :param site_name: Site name or list of site names (e.g. ['realtor.com', 'zillow'], 'redfin')
-    :param radius: Get properties within _ (e.g. 1.0) miles. Only applicable for individual addresses.
+    :param listing_type: Listing type (e.g. 'for_sale', 'for_rent', 'sold')
-    :param mls_only: If set, fetches only listings with MLS IDs.
+    :return: pd.DataFrame containing properties
-    :param proxy: Proxy to use for scraping
-    :param past_days: Get properties sold or listed (dependent on your listing_type) in the last _ days.
-    :param date_from, date_to: Get properties sold or listed (dependent on your listing_type) between these dates. format: 2021-01-28
-    :param foreclosure: If set, fetches only foreclosure listings.
-    :param extra_property_data: Increases requests by O(n). If set, this fetches additional property data (e.g. agent, broker, property evaluations etc.)
-    :param exclude_pending: If true, this excludes pending or contingent properties from the results, unless listing type is pending.
-    :param limit: Limit the number of results returned. Maximum is 10,000.
     """
-    validate_input(listing_type)
+    if site_name is None:
-    validate_dates(date_from, date_to)
+        site_name = list(_scrapers.keys())
-    validate_limit(limit)
 
-    scraper_input = ScraperInput(
+    if not isinstance(site_name, list):
-        location=location,
+        site_name = [site_name]
-        listing_type=ListingType(listing_type.upper()),
-        return_type=ReturnType(return_type.lower()),
-        property_type=[SearchPropertyType[prop.upper()] for prop in property_type] if property_type else None,
-        proxy=proxy,
-        radius=radius,
-        mls_only=mls_only,
-        last_x_days=past_days,
-        date_from=date_from,
-        date_to=date_to,
-        foreclosure=foreclosure,
-        extra_property_data=extra_property_data,
-        exclude_pending=exclude_pending,
-        limit=limit,
-    )
 
-    site = RealtorScraper(scraper_input)
+    results = []
-    results = site.search()
 
-    if scraper_input.return_type != ReturnType.pandas:
+    if len(site_name) == 1:
-        return results
+        final_df = _scrape_single_site(location, site_name[0], listing_type, proxy)
+        results.append(final_df)
+    else:
+        with ThreadPoolExecutor() as executor:
+            futures = {
+                executor.submit(_scrape_single_site, location, s_name, listing_type, proxy): s_name
+                for s_name in site_name
+            }
 
-    properties_dfs = [df for result in results if not (df := process_result(result)).empty]
+            for future in concurrent.futures.as_completed(futures):
-    if not properties_dfs:
+                result = future.result()
+                results.append(result)
+
+    results = [df for df in results if not df.empty and not df.isna().all().all()]
+
+    if not results:
         return pd.DataFrame()
 
-    with warnings.catch_warnings():
+    final_df = pd.concat(results, ignore_index=True)
-        warnings.simplefilter("ignore", category=FutureWarning)
 
-        return pd.concat(properties_dfs, ignore_index=True, axis=0)[ordered_properties].replace(
+    columns_to_track = ["address_one", "address_two", "city"]
-            {"None": pd.NA, None: pd.NA, "": pd.NA}
+
-        )
+    #: validate they exist, otherwise create them
+    for col in columns_to_track:
+        if col not in final_df.columns:
+            final_df[col] = None
+
+    if not keep_duplicates:
+        final_df = final_df.drop_duplicates(subset=columns_to_track, keep="first")
+    return final_df

homeharvest/cli.py

@@ -7,12 +7,21 @@ def main():
     parser = argparse.ArgumentParser(description="Home Harvest Property Scraper")
     parser.add_argument("location", type=str, help="Location to scrape (e.g., San Francisco, CA)")
 
+    parser.add_argument(
+        "-s",
+        "--site_name",
+        type=str,
+        nargs="*",
+        default=None,
+        help="Site name(s) to scrape from (e.g., realtor, zillow)",
+    )
+
     parser.add_argument(
         "-l",
         "--listing_type",
         type=str,
         default="for_sale",
-        choices=["for_sale", "for_rent", "sold", "pending"],
+        choices=["for_sale", "for_rent", "sold"],
         help="Listing type to scrape",
     )
 
@@ -33,39 +42,18 @@ def main():
         help="Name of the output file (without extension)",
     )
 
-    parser.add_argument("-p", "--proxy", type=str, default=None, help="Proxy to use for scraping")
     parser.add_argument(
-        "-d",
+        "-k",
-        "--days",
+        "--keep_duplicates",
-        type=int,
+        action="store_true",
-        default=None,
+        help="Keep duplicate properties based on address"
-        help="Sold/listed in last _ days filter.",
     )
 
-    parser.add_argument(
+    parser.add_argument("-p", "--proxy", type=str, default=None, help="Proxy to use for scraping")
-        "-r",
-        "--radius",
-        type=float,
-        default=None,
-        help="Get comparable properties within _ (eg. 0.0) miles. Only applicable for individual addresses.",
-    )
-    parser.add_argument(
-        "-m",
-        "--mls_only",
-        action="store_true",
-        help="If set, fetches only MLS listings.",
-    )
 
     args = parser.parse_args()
 
-    result = scrape_property(
+    result = scrape_property(args.location, args.site_name, args.listing_type, proxy=args.proxy, keep_duplicates=args.keep_duplicates)
-        args.location,
-        args.listing_type,
-        radius=args.radius,
-        proxy=args.proxy,
-        mls_only=args.mls_only,
-        past_days=args.days,
-    )
 
     if not args.filename:
         timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")

homeharvest/core/scrapers/__init__.py

@@ -1,128 +1,35 @@
-from __future__ import annotations
 from dataclasses import dataclass
-from typing import Union
-
 import requests
-from requests.adapters import HTTPAdapter
+from .models import Property, ListingType, SiteName
-from urllib3.util.retry import Retry
-import uuid
-from ...exceptions import AuthenticationError
-from .models import Property, ListingType, SiteName, SearchPropertyType, ReturnType
-import json
 
 
 @dataclass
 class ScraperInput:
     location: str
     listing_type: ListingType
-    property_type: list[SearchPropertyType] | None = None
+    site_name: SiteName
-    radius: float | None = None
-    mls_only: bool | None = False
     proxy: str | None = None
-    last_x_days: int | None = None
-    date_from: str | None = None
-    date_to: str | None = None
-    foreclosure: bool | None = False
-    extra_property_data: bool | None = True
-    exclude_pending: bool | None = False
-    limit: int = 10000
-    return_type: ReturnType = ReturnType.pandas
 
 
 class Scraper:
-    session = None
+    def __init__(self, scraper_input: ScraperInput):
-
-    def __init__(
-        self,
-        scraper_input: ScraperInput,
-    ):
         self.location = scraper_input.location
         self.listing_type = scraper_input.listing_type
-        self.property_type = scraper_input.property_type
-
-        if not self.session:
-            Scraper.session = requests.Session()
-            retries = Retry(
-                total=3, backoff_factor=4, status_forcelist=[429, 403], allowed_methods=frozenset(["GET", "POST"])
-            )
-
-            adapter = HTTPAdapter(max_retries=retries)
-            Scraper.session.mount("http://", adapter)
-            Scraper.session.mount("https://", adapter)
-            Scraper.session.headers.update(
-                {
-                    "accept": "application/json, text/javascript",
-                    "accept-language": "en-US,en;q=0.9",
-                    "cache-control": "no-cache",
-                    "content-type": "application/json",
-                    "origin": "https://www.realtor.com",
-                    "pragma": "no-cache",
-                    "priority": "u=1, i",
-                    "rdc-ab-tests": "commute_travel_time_variation:v1",
-                    "sec-ch-ua": '"Not)A;Brand";v="99", "Google Chrome";v="127", "Chromium";v="127"',
-                    "sec-ch-ua-mobile": "?0",
-                    "sec-ch-ua-platform": '"Windows"',
-                    "sec-fetch-dest": "empty",
-                    "sec-fetch-mode": "cors",
-                    "sec-fetch-site": "same-origin",
-                    "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36",
-                }
-            )
 
+        self.session = requests.Session()
         if scraper_input.proxy:
             proxy_url = scraper_input.proxy
             proxies = {"http": proxy_url, "https": proxy_url}
             self.session.proxies.update(proxies)
-
         self.listing_type = scraper_input.listing_type
-        self.radius = scraper_input.radius
+        self.site_name = scraper_input.site_name
-        self.last_x_days = scraper_input.last_x_days
-        self.mls_only = scraper_input.mls_only
-        self.date_from = scraper_input.date_from
-        self.date_to = scraper_input.date_to
-        self.foreclosure = scraper_input.foreclosure
-        self.extra_property_data = scraper_input.extra_property_data
-        self.exclude_pending = scraper_input.exclude_pending
-        self.limit = scraper_input.limit
-        self.return_type = scraper_input.return_type
 
-    def search(self) -> list[Union[Property | dict]]: ...
+    def search(self) -> list[Property]:
+        ...
 
     @staticmethod
-    def _parse_home(home) -> Property: ...
+    def _parse_home(home) -> Property:
+        ...
 
-    def handle_location(self): ...
+    def handle_location(self):
-
+        ...
-    @staticmethod
-    def get_access_token():
-        device_id = str(uuid.uuid4()).upper()
-
-        response = requests.post(
-            "https://graph.realtor.com/auth/token",
-            headers={
-                "Host": "graph.realtor.com",
-                "Accept": "*/*",
-                "Content-Type": "Application/json",
-                "X-Client-ID": "rdc_mobile_native,iphone",
-                "X-Visitor-ID": device_id,
-                "X-Client-Version": "24.21.23.679885",
-                "Accept-Language": "en-US,en;q=0.9",
-                "User-Agent": "Realtor.com/24.21.23.679885 CFNetwork/1494.0.7 Darwin/23.4.0",
-            },
-            data=json.dumps(
-                {
-                    "grant_type": "device_mobile",
-                    "device_id": device_id,
-                    "client_app_id": "rdc_mobile_native,24.21.23.679885,iphone",
-                }
-            ),
-        )
-
-        data = response.json()
-
-        if not (access_token := data.get("access_token")):
-            raise AuthenticationError(
-                "Failed to get access token, use a proxy/vpn or wait a moment and try again.", response=response
-            )
-
-        return access_token

homeharvest/core/scrapers/models.py

@@ -1,13 +1,6 @@
-from __future__ import annotations
 from dataclasses import dataclass
 from enum import Enum
-from typing import Optional
+from typing import Tuple
-
-
-class ReturnType(Enum):
-    pydantic = "pydantic"
-    pandas = "pandas"
-    raw = "raw"
 
 
 class SiteName(Enum):
@@ -23,172 +16,94 @@ class SiteName(Enum):
         raise ValueError(f"{value} not found in {cls}")
 
 
-class SearchPropertyType(Enum):
-    SINGLE_FAMILY = "single_family"
-    APARTMENT = "apartment"
-    CONDOS = "condos"
-    CONDO_TOWNHOME_ROWHOME_COOP = "condo_townhome_rowhome_coop"
-    CONDO_TOWNHOME = "condo_townhome"
-    TOWNHOMES = "townhomes"
-    DUPLEX_TRIPLEX = "duplex_triplex"
-    FARM = "farm"
-    LAND = "land"
-    MULTI_FAMILY = "multi_family"
-    MOBILE = "mobile"
-
-
 class ListingType(Enum):
     FOR_SALE = "FOR_SALE"
     FOR_RENT = "FOR_RENT"
-    PENDING = "PENDING"
     SOLD = "SOLD"
 
 
-@dataclass
-class Agent:
-    name: str | None = None
-    phone: str | None = None
-
-
 class PropertyType(Enum):
-    APARTMENT = "APARTMENT"
+    HOUSE = "HOUSE"
     BUILDING = "BUILDING"
-    COMMERCIAL = "COMMERCIAL"
-    GOVERNMENT = "GOVERNMENT"
-    INDUSTRIAL = "INDUSTRIAL"
-    CONDO_TOWNHOME = "CONDO_TOWNHOME"
-    CONDO_TOWNHOME_ROWHOME_COOP = "CONDO_TOWNHOME_ROWHOME_COOP"
     CONDO = "CONDO"
-    CONDOP = "CONDOP"
+    TOWNHOUSE = "TOWNHOUSE"
-    CONDOS = "CONDOS"
-    COOP = "COOP"
-    DUPLEX_TRIPLEX = "DUPLEX_TRIPLEX"
-    FARM = "FARM"
-    INVESTMENT = "INVESTMENT"
-    LAND = "LAND"
-    MOBILE = "MOBILE"
-    MULTI_FAMILY = "MULTI_FAMILY"
-    RENTAL = "RENTAL"
     SINGLE_FAMILY = "SINGLE_FAMILY"
-    TOWNHOMES = "TOWNHOMES"
+    MULTI_FAMILY = "MULTI_FAMILY"
+    MANUFACTURED = "MANUFACTURED"
+    NEW_CONSTRUCTION = "NEW_CONSTRUCTION"
+    APARTMENT = "APARTMENT"
+    APARTMENTS = "APARTMENTS"
+    LAND = "LAND"
+    LOT = "LOT"
     OTHER = "OTHER"
 
+    BLANK = "BLANK"
+
+    @classmethod
+    def from_int_code(cls, code):
+        mapping = {
+            1: cls.HOUSE,
+            2: cls.CONDO,
+            3: cls.TOWNHOUSE,
+            4: cls.MULTI_FAMILY,
+            5: cls.LAND,
+            6: cls.OTHER,
+            8: cls.SINGLE_FAMILY,
+            13: cls.SINGLE_FAMILY,
+        }
+
+        return mapping.get(code, cls.BLANK)
+
 
 @dataclass
 class Address:
-    full_line: str | None = None
+    address_one: str | None = None
-    street: str | None = None
+    address_two: str | None = "#"
-    unit: str | None = None
     city: str | None = None
     state: str | None = None
-    zip: str | None = None
+    zip_code: str | None = None
-
-
-@dataclass
-class Description:
-    primary_photo: str | None = None
-    alt_photos: list[str] | None = None
-    style: PropertyType | None = None
-    beds: int | None = None
-    baths_full: int | None = None
-    baths_half: int | None = None
-    sqft: int | None = None
-    lot_sqft: int | None = None
-    sold_price: int | None = None
-    year_built: int | None = None
-    garage: float | None = None
-    stories: int | None = None
-    text: str | None = None
-
-
-@dataclass
-class AgentPhone:  #: For documentation purposes only (at the moment)
-    number: str | None = None
-    type: str | None = None
-    primary: bool | None = None
-    ext: str | None = None
-
-
-@dataclass
-class Entity:
-    name: str
-    uuid: str | None = None
-
-
-@dataclass
-class Agent(Entity):
-    mls_set: str | None = None
-    nrds_id: str | None = None
-    phones: list[dict] | AgentPhone | None = None
-    email: str | None = None
-    href: str | None = None
-
-
-@dataclass
-class Office(Entity):
-    mls_set: str | None = None
-    email: str | None = None
-    href: str | None = None
-    phones: list[dict] | AgentPhone | None = None
-
-
-@dataclass
-class Broker(Entity):
-    pass
-
-
-@dataclass
-class Builder(Entity):
-    pass
-
-
-@dataclass
-class Advertisers:
-    agent: Agent | None = None
-    broker: Broker | None = None
-    builder: Builder | None = None
-    office: Office | None = None
 
 
 @dataclass
 class Property:
     property_url: str
+    site_name: SiteName
+    listing_type: ListingType
+    address: Address
+    property_type: PropertyType | None = None
 
-    property_id: str
+    # house for sale
-    #: allows_cats: bool
+    tax_assessed_value: int | None = None
-    #: allows_dogs: bool
+    lot_area_value: float | None = None
-
+    lot_area_unit: str | None = None
-    listing_id: str | None = None
+    stories: int | None = None
-
+    year_built: int | None = None
-    mls: str | None = None
+    price_per_sqft: int | None = None
     mls_id: str | None = None
-    status: str | None = None
-    address: Address | None = None
 
-    list_price: int | None = None
+    agent_name: str | None = None
-    list_price_min: int | None = None
+    img_src: str | None = None
-    list_price_max: int | None = None
+    description: str | None = None
+    status_text: str | None = None
+    posted_time: str | None = None
 
-    list_date: str | None = None
+    # building for sale
-    pending_date: str | None = None
+    bldg_name: str | None = None
-    last_sold_date: str | None = None
+    area_min: int | None = None
-    prc_sqft: int | None = None
+
-    new_construction: bool | None = None
+    beds_min: int | None = None
-    hoa_fee: int | None = None
+    beds_max: int | None = None
-    days_on_mls: int | None = None
+
-    description: Description | None = None
+    baths_min: float | None = None
-    tags: list[str] | None = None
+    baths_max: float | None = None
-    details: list[dict] | None = None
+
+    sqft_min: int | None = None
+    sqft_max: int | None = None
+
+    price_min: int | None = None
+    price_max: int | None = None
+
+    unit_count: int | None = None
 
     latitude: float | None = None
     longitude: float | None = None
-    neighborhoods: Optional[str] = None
-    county: Optional[str] = None
-    fips_code: Optional[str] = None
-    nearby_schools: list[str] = None
-    assessed_value: int | None = None
-    estimated_value: int | None = None
-    tax: int | None = None
-    tax_history: list[dict] | None = None
-
-    advertisers: Advertisers | None = None

homeharvest/core/scrapers/realtor/__init__.py

@@ -2,53 +2,39 @@
 homeharvest.realtor.__init__
 ~~~~~~~~~~~~
 
-This module implements the scraper for realtor.com
+This module implements the scraper for relator.com
 """
-
+from ..models import Property, Address
-from __future__ import annotations
-
-import json
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from datetime import datetime
-from json import JSONDecodeError
-from typing import Dict, Union, Optional
-
-from tenacity import (
-    retry,
-    retry_if_exception_type,
-    wait_exponential,
-    stop_after_attempt,
-)
-
 from .. import Scraper
-from ..models import (
+from ....exceptions import NoResultsFound
-    Property,
+from ....utils import parse_address_one, parse_address_two
-    Address,
+from concurrent.futures import ThreadPoolExecutor, as_completed
-    ListingType,
-    Description,
-    PropertyType,
-    Agent,
-    Broker,
-    Builder,
-    Advertisers,
-    Office,
-    ReturnType
-)
-from .queries import GENERAL_RESULTS_QUERY, SEARCH_HOMES_DATA, HOMES_DATA, HOME_FRAGMENT
 
 
 class RealtorScraper(Scraper):
-    SEARCH_GQL_URL = "https://www.realtor.com/api/v1/rdc_search_srp?client_id=rdc-search-new-communities&schema=vesta"
-    PROPERTY_URL = "https://www.realtor.com/realestateandhomes-detail/"
-    PROPERTY_GQL = "https://graph.realtor.com/graphql"
-    ADDRESS_AUTOCOMPLETE_URL = "https://parser-external.geo.moveaws.com/suggest"
-    NUM_PROPERTY_WORKERS = 20
-    DEFAULT_PAGE_SIZE = 200
-
     def __init__(self, scraper_input):
+        self.counter = 1
         super().__init__(scraper_input)
+        self.search_url = (
+            "https://www.realtor.com/api/v1/rdc_search_srp?client_id=rdc-search-new-communities&schema=vesta"
+        )
 
     def handle_location(self):
+        headers = {
+            "authority": "parser-external.geo.moveaws.com",
+            "accept": "*/*",
+            "accept-language": "en-US,en;q=0.9",
+            "origin": "https://www.realtor.com",
+            "referer": "https://www.realtor.com/",
+            "sec-ch-ua": '"Chromium";v="116", "Not)A;Brand";v="24", "Google Chrome";v="116"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "cross-site",
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36",
+        }
+
         params = {
             "input": self.location,
             "client_id": self.listing_type.value.lower().replace("_", "-"),
@@ -57,612 +43,288 @@ class RealtorScraper(Scraper):
         }
 
         response = self.session.get(
-            self.ADDRESS_AUTOCOMPLETE_URL,
+            "https://parser-external.geo.moveaws.com/suggest",
             params=params,
+            headers=headers,
         )
         response_json = response.json()
 
         result = response_json["autocomplete"]
 
         if not result:
-            return None
+            raise NoResultsFound("No results found for location: " + self.location)
 
         return result[0]
 
-    def get_latest_listing_id(self, property_id: str) -> str | None:
+    def handle_address(self, property_id: str) -> list[Property]:
+        """
+        Handles a specific address & returns one property
+        """
         query = """query Property($property_id: ID!) {
                     property(id: $property_id) {
-                        listings {
+                        property_id
-                            listing_id
+                        details {
-                            primary
+                            date_updated
+                            garage
+                            permalink
+                            year_built
+                            stories
+                        }
+                        address {
+                            address_validation_code
+                            city
+                            country
+                            county
+                            line
+                            postal_code
+                            state_code
+                            street_direction
+                            street_name
+                            street_number
+                            street_suffix
+                            street_post_direction
+                            unit_value
+                            unit
+                            unit_descriptor
+                            zip
+                        }
+                        basic {
+                            baths
+                            beds
+                            price
+                            sqft
+                            lot_sqft
+                            type
+                            sold_price
+                        }
+                        public_record {
+                            lot_size
+                            sqft
+                            stories
+                            units
+                            year_built
                         }
                     }
-                }
+                }"""
-                """
 
         variables = {"property_id": property_id}
+
         payload = {
             "query": query,
             "variables": variables,
         }
 
-        response = self.session.post(self.SEARCH_GQL_URL, json=payload)
+        response = self.session.post(self.search_url, json=payload)
         response_json = response.json()
 
         property_info = response_json["data"]["property"]
-        if property_info["listings"] is None:
+        address_one, address_two = parse_address_one(property_info["address"]["line"])
-            return None
 
-        primary_listing = next(
+        return [
-            (listing for listing in property_info["listings"] if listing["primary"]),
+            Property(
-            None,
+                site_name=self.site_name,
-        )
+                address=Address(
-        if primary_listing:
+                    address_one=address_one,
-            return primary_listing["listing_id"]
+                    address_two=address_two,
-        else:
+                    city=property_info["address"]["city"],
-            return property_info["listings"][0]["listing_id"]
+                    state=property_info["address"]["state_code"],
+                    zip_code=property_info["address"]["postal_code"],
+                ),
+                property_url="https://www.realtor.com/realestateandhomes-detail/"
+                + property_info["details"]["permalink"],
+                stories=property_info["details"]["stories"],
+                year_built=property_info["details"]["year_built"],
+                price_per_sqft=property_info["basic"]["price"] // property_info["basic"]["sqft"]
+                if property_info["basic"]["sqft"] is not None and property_info["basic"]["price"] is not None
+                else None,
+                mls_id=property_id,
+                listing_type=self.listing_type,
+                lot_area_value=property_info["public_record"]["lot_size"]
+                if property_info["public_record"] is not None
+                else None,
+                beds_min=property_info["basic"]["beds"],
+                beds_max=property_info["basic"]["beds"],
+                baths_min=property_info["basic"]["baths"],
+                baths_max=property_info["basic"]["baths"],
+                sqft_min=property_info["basic"]["sqft"],
+                sqft_max=property_info["basic"]["sqft"],
+                price_min=property_info["basic"]["price"],
+                price_max=property_info["basic"]["price"],
+            )
+        ]
 
-    def handle_home(self, property_id: str) -> list[Property]:
+    def handle_area(self, variables: dict, return_total: bool = False) -> list[Property] | int:
-        query = (
-            """query Home($property_id: ID!) {
-                    home(property_id: $property_id) %s
-                }"""
-            % HOMES_DATA
-        )
-
-        variables = {"property_id": property_id}
-        payload = {
-            "query": query,
-            "variables": variables,
-        }
-
-        response = self.session.post(self.SEARCH_GQL_URL, json=payload)
-        response_json = response.json()
-
-        property_info = response_json["data"]["home"]
-
-        return [self.process_property(property_info)]
-
-    @staticmethod
-    def process_advertisers(advertisers: list[dict] | None) -> Advertisers | None:
-        if not advertisers:
-            return None
-
-        def _parse_fulfillment_id(fulfillment_id: str | None) -> str | None:
-            return fulfillment_id if fulfillment_id and fulfillment_id != "0" else None
-
-        processed_advertisers = Advertisers()
-
-        for advertiser in advertisers:
-            advertiser_type = advertiser.get("type")
-            if advertiser_type == "seller":  #: agent
-                processed_advertisers.agent = Agent(
-                    uuid=_parse_fulfillment_id(advertiser.get("fulfillment_id")),
-                    nrds_id=advertiser.get("nrds_id"),
-                    mls_set=advertiser.get("mls_set"),
-                    name=advertiser.get("name"),
-                    email=advertiser.get("email"),
-                    phones=advertiser.get("phones"),
-                )
-
-                if advertiser.get("broker") and advertiser["broker"].get("name"):  #: has a broker
-                    processed_advertisers.broker = Broker(
-                        uuid=_parse_fulfillment_id(advertiser["broker"].get("fulfillment_id")),
-                        name=advertiser["broker"].get("name"),
-                    )
-
-                if advertiser.get("office"):  #: has an office
-                    processed_advertisers.office = Office(
-                        uuid=_parse_fulfillment_id(advertiser["office"].get("fulfillment_id")),
-                        mls_set=advertiser["office"].get("mls_set"),
-                        name=advertiser["office"].get("name"),
-                        email=advertiser["office"].get("email"),
-                        phones=advertiser["office"].get("phones"),
-                    )
-
-            if advertiser_type == "community":  #: could be builder
-                if advertiser.get("builder"):
-                    processed_advertisers.builder = Builder(
-                        uuid=_parse_fulfillment_id(advertiser["builder"].get("fulfillment_id")),
-                        name=advertiser["builder"].get("name"),
-                    )
-
-        return processed_advertisers
-
-    def process_property(self, result: dict) -> Property | None:
-        mls = result["source"].get("id") if "source" in result and isinstance(result["source"], dict) else None
-
-        if not mls and self.mls_only:
-            return
-
-        able_to_get_lat_long = (
-            result
-            and result.get("location")
-            and result["location"].get("address")
-            and result["location"]["address"].get("coordinate")
-        )
-
-        is_pending = result["flags"].get("is_pending")
-        is_contingent = result["flags"].get("is_contingent")
-
-        if (is_pending or is_contingent) and (self.exclude_pending and self.listing_type != ListingType.PENDING):
-            return
-
-        property_id = result["property_id"]
-        prop_details = self.process_extra_property_details(result) if self.extra_property_data else {}
-
-        property_estimates_root = result.get("current_estimates") or result.get("estimates", {}).get("currentValues")
-        estimated_value = self.get_key(property_estimates_root, [0, "estimate"])
-
-        advertisers = self.process_advertisers(result.get("advertisers"))
-
-        realty_property = Property(
-            mls=mls,
-            mls_id=(
-                result["source"].get("listing_id")
-                if "source" in result and isinstance(result["source"], dict)
-                else None
-            ),
-            property_url=result["href"],
-            property_id=property_id,
-            listing_id=result.get("listing_id"),
-            status=("PENDING" if is_pending else "CONTINGENT" if is_contingent else result["status"].upper()),
-            list_price=result["list_price"],
-            list_price_min=result["list_price_min"],
-            list_price_max=result["list_price_max"],
-            list_date=(result["list_date"].split("T")[0] if result.get("list_date") else None),
-            prc_sqft=result.get("price_per_sqft"),
-            last_sold_date=result.get("last_sold_date"),
-            new_construction=result["flags"].get("is_new_construction") is True,
-            hoa_fee=(result["hoa"]["fee"] if result.get("hoa") and isinstance(result["hoa"], dict) else None),
-            latitude=(result["location"]["address"]["coordinate"].get("lat") if able_to_get_lat_long else None),
-            longitude=(result["location"]["address"]["coordinate"].get("lon") if able_to_get_lat_long else None),
-            address=self._parse_address(result, search_type="general_search"),
-            description=self._parse_description(result),
-            neighborhoods=self._parse_neighborhoods(result),
-            county=(result["location"]["county"].get("name") if result["location"]["county"] else None),
-            fips_code=(result["location"]["county"].get("fips_code") if result["location"]["county"] else None),
-            days_on_mls=self.calculate_days_on_mls(result),
-            nearby_schools=prop_details.get("schools"),
-            assessed_value=prop_details.get("assessed_value"),
-            estimated_value=estimated_value if estimated_value else None,
-            advertisers=advertisers,
-            tax=prop_details.get("tax"),
-            tax_history=prop_details.get("tax_history"),
-        )
-        return realty_property
-
-    def general_search(self, variables: dict, search_type: str) -> Dict[str, Union[int, Union[list[Property], list[dict]]]]:
         """
         Handles a location area & returns a list of properties
         """
-
+        query = (
-        date_param = ""
+            """query Home_search(
-        if self.listing_type == ListingType.SOLD:
+                            $city: String,
-            if self.date_from and self.date_to:
+                            $county: [String],
-                date_param = f'sold_date: {{ min: "{self.date_from}", max: "{self.date_to}" }}'
+                            $state_code: String,
-            elif self.last_x_days:
+                            $postal_code: String
-                date_param = f'sold_date: {{ min: "$today-{self.last_x_days}D" }}'
+                            $offset: Int,
-        else:
+                        ) {
-            if self.date_from and self.date_to:
+                            home_search(
-                date_param = f'list_date: {{ min: "{self.date_from}", max: "{self.date_to}" }}'
+                                query: {
-            elif self.last_x_days:
+                                    city: $city
-                date_param = f'list_date: {{ min: "$today-{self.last_x_days}D" }}'
+                                    county: $county
-
+                                    postal_code: $postal_code
-        property_type_param = ""
+                                    state_code: $state_code
-        if self.property_type:
+                                    status: %s
-            property_types = [pt.value for pt in self.property_type]
-            property_type_param = f"type: {json.dumps(property_types)}"
-
-        sort_param = (
-            "sort: [{ field: sold_date, direction: desc }]"
-            if self.listing_type == ListingType.SOLD
-            else ""  #: "sort: [{ field: list_date, direction: desc }]"  #: prioritize normal fractal sort from realtor
-        )
-
-        pending_or_contingent_param = (
-            "or_filters: { contingent: true, pending: true }" if self.listing_type == ListingType.PENDING else ""
-        )
-
-        listing_type = ListingType.FOR_SALE if self.listing_type == ListingType.PENDING else self.listing_type
-        is_foreclosure = ""
-
-        if variables.get("foreclosure") is True:
-            is_foreclosure = "foreclosure: true"
-        elif variables.get("foreclosure") is False:
-            is_foreclosure = "foreclosure: false"
-
-        if search_type == "comps":  #: comps search, came from an address
-            query = """query Property_search(
-                    $coordinates: [Float]!
-                    $radius: String!
-                    $offset: Int!,
-                    ) {
-                        home_search(
-                            query: {
-                                %s
-                                nearby: {
-                                    coordinates: $coordinates
-                                    radius: $radius
                                 }
-                                status: %s
+                                limit: 200
-                                %s
+                                offset: $offset
-                                %s
-                                %s
-                            }
-                            %s
-                            limit: 200
-                            offset: $offset
-                    ) %s
-                }""" % (
-                is_foreclosure,
-                listing_type.value.lower(),
-                date_param,
-                property_type_param,
-                pending_or_contingent_param,
-                sort_param,
-                GENERAL_RESULTS_QUERY,
-            )
-        elif search_type == "area":  #: general search, came from a general location
-            query = """query Home_search(
-                                $location: String!,
-                                $offset: Int,
                             ) {
-                                home_search(
+                                count
-                                    query: {
+                                total
-                                        %s
+                                results {
-                                        search_location: {location: $location}
+                                    property_id
-                                        status: %s
+                                    description {
-                                        unique: true
+                                        baths
-                                        %s
+                                        beds
-                                        %s
+                                        lot_sqft
-                                        %s
+                                        sqft
+                                        text
+                                        sold_price
+                                        stories
+                                        year_built
+                                        garage
+                                        unit_number
+                                        floor_number
                                     }
-                                    bucket: { sort: "fractal_v1.1.3_fr" }
+                                    location {
-                                    %s
+                                        address {
-                                    limit: 200
+                                            city
-                                    offset: $offset
+                                            country
-                                ) %s
+                                            line
-                            }""" % (
+                                            postal_code
-                is_foreclosure,
+                                            state_code
-                listing_type.value.lower(),
+                                            state
-                date_param,
+                                            street_direction
-                property_type_param,
+                                            street_name
-                pending_or_contingent_param,
+                                            street_number
-                sort_param,
+                                            street_post_direction
-                GENERAL_RESULTS_QUERY,
+                                            street_suffix
-            )
+                                            unit
-        else:  #: general search, came from an address
+                                            coordinate {
-            query = (
+                                                lon
-                """query Property_search(
+                                                lat
-                        $property_id: [ID]!
+                                            }
-                        $offset: Int!,
+                                        }
-                    ) {
+                                    }
-                        home_search(
+                                    list_price
-                            query: {
+                                    price_per_sqft
-                                property_id: $property_id
+                                    source {
+                                        id
+                                    }
+                                }
                             }
-                            limit: 1
+                        }"""
-                            offset: $offset
+            % self.listing_type.value.lower()
-                        ) %s
+        )
-                    }"""
-                % GENERAL_RESULTS_QUERY
-            )
 
         payload = {
             "query": query,
             "variables": variables,
         }
 
-        response = self.session.post(self.SEARCH_GQL_URL, json=payload)
+        response = self.session.post(self.search_url, json=payload)
+        response.raise_for_status()
         response_json = response.json()
-        search_key = "home_search" if "home_search" in query else "property_search"
 
-        properties: list[Union[Property, dict]] = []
+        if return_total:
+            return response_json["data"]["home_search"]["total"]
+
+        properties: list[Property] = []
 
         if (
             response_json is None
             or "data" not in response_json
             or response_json["data"] is None
-            or search_key not in response_json["data"]
+            or "home_search" not in response_json["data"]
-            or response_json["data"][search_key] is None
+            or response_json["data"]["home_search"] is None
-            or "results" not in response_json["data"][search_key]
+            or "results" not in response_json["data"]["home_search"]
         ):
-            return {"total": 0, "properties": []}
+            return []
 
-        properties_list = response_json["data"][search_key]["results"]
+        for result in response_json["data"]["home_search"]["results"]:
-        total_properties = response_json["data"][search_key]["total"]
+            self.counter += 1
-        offset = variables.get("offset", 0)
+            address_one, _ = parse_address_one(result["location"]["address"]["line"])
+            realty_property = Property(
+                address=Address(
+                    address_one=address_one,
+                    city=result["location"]["address"]["city"],
+                    state=result["location"]["address"]["state_code"],
+                    zip_code=result["location"]["address"]["postal_code"],
+                    address_two=parse_address_two(result["location"]["address"]["unit"]),
+                ),
+                latitude=result["location"]["address"]["coordinate"]["lat"]
+                if result
+                and result.get("location")
+                and result["location"].get("address")
+                and result["location"]["address"].get("coordinate")
+                and "lat" in result["location"]["address"]["coordinate"]
+                else None,
+                longitude=result["location"]["address"]["coordinate"]["lon"]
+                if result
+                and result.get("location")
+                and result["location"].get("address")
+                and result["location"]["address"].get("coordinate")
+                and "lon" in result["location"]["address"]["coordinate"]
+                else None,
+                site_name=self.site_name,
+                property_url="https://www.realtor.com/realestateandhomes-detail/" + result["property_id"],
+                stories=result["description"]["stories"],
+                year_built=result["description"]["year_built"],
+                price_per_sqft=result["price_per_sqft"],
+                mls_id=result["property_id"],
+                listing_type=self.listing_type,
+                lot_area_value=result["description"]["lot_sqft"],
+                beds_min=result["description"]["beds"],
+                beds_max=result["description"]["beds"],
+                baths_min=result["description"]["baths"],
+                baths_max=result["description"]["baths"],
+                sqft_min=result["description"]["sqft"],
+                sqft_max=result["description"]["sqft"],
+                price_min=result["list_price"],
+                price_max=result["list_price"],
+            )
+            properties.append(realty_property)
 
-        #: limit the number of properties to be processed
+        return properties
-        #: example, if your offset is 200, and your limit is 250, return 50
-        properties_list: list[dict] = properties_list[: self.limit - offset]
-
-        if self.extra_property_data:
-            property_ids = [data["property_id"] for data in properties_list]
-            extra_property_details = self.get_bulk_prop_details(property_ids) or {}
-
-            for result in properties_list:
-                result.update(extra_property_details.get(result["property_id"], {}))
-
-        if self.return_type != ReturnType.raw:
-            with ThreadPoolExecutor(max_workers=self.NUM_PROPERTY_WORKERS) as executor:
-                futures = [executor.submit(self.process_property, result) for result in properties_list]
-
-                for future in as_completed(futures):
-                    result = future.result()
-                    if result:
-                        properties.append(result)
-        else:
-            properties = properties_list
-
-        return {
-            "total": total_properties,
-            "properties": properties,
-        }
 
     def search(self):
         location_info = self.handle_location()
-        if not location_info:
-            return []
-
         location_type = location_info["area_type"]
 
+        if location_type == "address":
+            property_id = location_info["mpr_id"]
+            return self.handle_address(property_id)
+
+        offset = 0
         search_variables = {
-            "offset": 0,
+            "city": location_info.get("city"),
+            "county": location_info.get("county"),
+            "state_code": location_info.get("state_code"),
+            "postal_code": location_info.get("postal_code"),
+            "offset": offset,
         }
 
-        search_type = (
+        total = self.handle_area(search_variables, return_total=True)
-            "comps"
-            if self.radius and location_type == "address"
-            else "address" if location_type == "address" and not self.radius else "area"
-        )
-        if location_type == "address":
-            if not self.radius:  #: single address search, non comps
-                property_id = location_info["mpr_id"]
-                return self.handle_home(property_id)
 
-            else:  #: general search, comps (radius)
+        homes = []
-                if not location_info.get("centroid"):
+        with ThreadPoolExecutor(max_workers=10) as executor:
-                    return []
-
-                coordinates = list(location_info["centroid"].values())
-                search_variables |= {
-                    "coordinates": coordinates,
-                    "radius": "{}mi".format(self.radius),
-                }
-
-        elif location_type == "postal_code":
-            search_variables |= {
-                "postal_code": location_info.get("postal_code"),
-            }
-
-        else:  #: general search, location
-            search_variables |= {
-                "location": self.location,
-            }
-
-        if self.foreclosure:
-            search_variables["foreclosure"] = self.foreclosure
-
-        result = self.general_search(search_variables, search_type=search_type)
-        total = result["total"]
-        homes = result["properties"]
-
-        with ThreadPoolExecutor() as executor:
             futures = [
                 executor.submit(
-                    self.general_search,
+                    self.handle_area,
                     variables=search_variables | {"offset": i},
-                    search_type=search_type,
+                    return_total=False,
-                )
-                for i in range(
-                    self.DEFAULT_PAGE_SIZE,
-                    min(total, self.limit),
-                    self.DEFAULT_PAGE_SIZE,
                 )
+                for i in range(0, total, 200)
             ]
 
             for future in as_completed(futures):
-                homes.extend(future.result()["properties"])
+                homes.extend(future.result())
 
         return homes
-
-    @staticmethod
-    def get_key(data: dict, keys: list):
-        try:
-            value = data
-            for key in keys:
-                value = value[key]
-
-            return value or {}
-        except (KeyError, TypeError, IndexError):
-            return {}
-
-    def process_extra_property_details(self, result: dict) -> dict:
-        schools = self.get_key(result, ["nearbySchools", "schools"])
-        assessed_value = self.get_key(result, ["taxHistory", 0, "assessment", "total"])
-        tax_history = self.get_key(result, ["taxHistory"])
-
-        schools = [school["district"]["name"] for school in schools if school["district"].get("name")]
-
-        # Process tax history
-        latest_tax = None
-        processed_tax_history = None
-        if tax_history and isinstance(tax_history, list):
-            tax_history = sorted(tax_history, key=lambda x: x.get("year", 0), reverse=True)
-
-            if tax_history and "tax" in tax_history[0]:
-                latest_tax = tax_history[0]["tax"]
-
-            processed_tax_history = []
-            for entry in tax_history:
-                if "year" in entry and "tax" in entry:
-                    processed_entry = {
-                        "year": entry["year"],
-                        "tax": entry["tax"],
-                    }
-                    if "assessment" in entry and isinstance(entry["assessment"], dict):
-                        processed_entry["assessment"] = {
-                            "building": entry["assessment"].get("building"),
-                            "land": entry["assessment"].get("land"),
-                            "total": entry["assessment"].get("total"),
-                        }
-                    processed_tax_history.append(processed_entry)
-
-        return {
-            "schools": schools if schools else None,
-            "assessed_value": assessed_value if assessed_value else None,
-            "tax": latest_tax,
-            "tax_history": processed_tax_history,
-        }
-
-    @retry(
-        retry=retry_if_exception_type(JSONDecodeError),
-        wait=wait_exponential(min=4, max=10),
-        stop=stop_after_attempt(3),
-    )
-    def get_bulk_prop_details(self, property_ids: list[str]) -> dict:
-        """
-        Fetch extra property details for multiple properties in a single GraphQL query.
-        Returns a map of property_id to its details.
-        """
-        if not self.extra_property_data or not property_ids:
-            return {}
-
-        property_ids = list(set(property_ids))
-
-        # Construct the bulk query
-        fragments = "\n".join(
-            f'home_{property_id}: home(property_id: {property_id}) {{ ...HomeData }}'
-            for property_id in property_ids
-        )
-        query = f"""{HOME_FRAGMENT}
-        
-        query GetHomes {{
-            {fragments}
-        }}"""
-
-        response = self.session.post(self.SEARCH_GQL_URL, json={"query": query})
-        data = response.json()
-
-        if "data" not in data:
-            return {}
-
-        properties = data["data"]
-        return {data.replace('home_', ''): properties[data] for data in properties if properties[data]}
-
-    @staticmethod
-    def _parse_neighborhoods(result: dict) -> Optional[str]:
-        neighborhoods_list = []
-        neighborhoods = result["location"].get("neighborhoods", [])
-
-        if neighborhoods:
-            for neighborhood in neighborhoods:
-                name = neighborhood.get("name")
-                if name:
-                    neighborhoods_list.append(name)
-
-        return ", ".join(neighborhoods_list) if neighborhoods_list else None
-
-    @staticmethod
-    def handle_none_safely(address_part):
-        if address_part is None:
-            return ""
-
-        return address_part
-
-    @staticmethod
-    def _parse_address(result: dict, search_type):
-        if search_type == "general_search":
-            address = result["location"]["address"]
-        else:
-            address = result["address"]
-
-        return Address(
-            full_line=address.get("line"),
-            street=" ".join(
-                part
-                for part in [
-                    address.get("street_number"),
-                    address.get("street_direction"),
-                    address.get("street_name"),
-                    address.get("street_suffix"),
-                ]
-                if part is not None
-            ).strip(),
-            unit=address["unit"],
-            city=address["city"],
-            state=address["state_code"],
-            zip=address["postal_code"],
-        )
-
-    @staticmethod
-    def _parse_description(result: dict) -> Description | None:
-        if not result:
-            return None
-
-        description_data = result.get("description", {})
-
-        if description_data is None or not isinstance(description_data, dict):
-            description_data = {}
-
-        style = description_data.get("type", "")
-        if style is not None:
-            style = style.upper()
-
-        primary_photo = ""
-        if (primary_photo_info := result.get("primary_photo")) and (
-            primary_photo_href := primary_photo_info.get("href")
-        ):
-            primary_photo = primary_photo_href.replace("s.jpg", "od-w480_h360_x2.webp?w=1080&q=75")
-
-        return Description(
-            primary_photo=primary_photo,
-            alt_photos=RealtorScraper.process_alt_photos(result.get("photos", [])),
-            style=(PropertyType.__getitem__(style) if style and style in PropertyType.__members__ else None),
-            beds=description_data.get("beds"),
-            baths_full=description_data.get("baths_full"),
-            baths_half=description_data.get("baths_half"),
-            sqft=description_data.get("sqft"),
-            lot_sqft=description_data.get("lot_sqft"),
-            sold_price=(
-                result.get("last_sold_price") or description_data.get("sold_price")
-                if result.get("last_sold_date") or result["list_price"] != description_data.get("sold_price")
-                else None
-            ),  #: has a sold date or list and sold price are different
-            year_built=description_data.get("year_built"),
-            garage=description_data.get("garage"),
-            stories=description_data.get("stories"),
-            text=description_data.get("text"),
-        )
-
-    @staticmethod
-    def calculate_days_on_mls(result: dict) -> Optional[int]:
-        list_date_str = result.get("list_date")
-        list_date = datetime.strptime(list_date_str.split("T")[0], "%Y-%m-%d") if list_date_str else None
-        last_sold_date_str = result.get("last_sold_date")
-        last_sold_date = datetime.strptime(last_sold_date_str, "%Y-%m-%d") if last_sold_date_str else None
-        today = datetime.now()
-
-        if list_date:
-            if result["status"] == "sold":
-                if last_sold_date:
-                    days = (last_sold_date - list_date).days
-                    if days >= 0:
-                        return days
-            elif result["status"] in ("for_sale", "for_rent"):
-                days = (today - list_date).days
-                if days >= 0:
-                    return days
-
-    @staticmethod
-    def process_alt_photos(photos_info: list[dict]) -> list[str] | None:
-        if not photos_info:
-            return None
-
-        return [
-            photo_info["href"].replace("s.jpg", "od-w480_h360_x2.webp?w=1080&q=75")
-            for photo_info in photos_info
-            if photo_info.get("href")
-        ]

homeharvest/core/scrapers/realtor/queries.py

@@ -1,242 +0,0 @@
-_SEARCH_HOMES_DATA_BASE = """{
-    pending_date
-    listing_id
-    property_id
-    href
-    list_date
-    status
-    last_sold_price
-    last_sold_date
-    list_price
-    list_price_max
-    list_price_min
-    price_per_sqft
-    tags
-    details {
-        category
-        text
-        parent_category
-    }
-    pet_policy {
-        cats
-        dogs
-        dogs_small
-        dogs_large
-        __typename
-    }
-    units {
-        availability {
-          date
-          __typename
-        }
-        description {
-          baths_consolidated
-          baths
-          beds
-          sqft
-          __typename
-        }
-        list_price
-        __typename
-    }
-    flags {
-        is_contingent
-        is_pending
-        is_new_construction
-    }
-    description {
-        type
-        sqft
-        beds
-        baths_full
-        baths_half
-        lot_sqft
-        year_built
-        garage
-        type
-        name
-        stories
-        text
-    }
-    source {
-        id
-        listing_id
-    }
-    hoa {
-        fee
-    }
-    location {
-        address {
-            street_direction
-            street_number
-            street_name
-            street_suffix
-            line
-            unit
-            city
-            state_code
-            postal_code
-            coordinate {
-                lon
-                lat
-            }
-        }
-        county {
-            name
-            fips_code
-        }
-        neighborhoods {
-            name
-        }
-    }
-    tax_record {
-        public_record_id
-    }
-    primary_photo(https: true) {
-        href
-    }
-    photos(https: true) {
-        href
-        tags {
-            label
-        }
-    }
-    advertisers {
-        email
-        broker {
-            name
-            fulfillment_id
-        }
-        type
-        name
-        fulfillment_id
-        builder {
-            name
-            fulfillment_id
-        }
-        phones {
-            ext
-            primary
-            type
-            number
-        }
-        office {
-            name
-            email
-            fulfillment_id
-            href
-            phones {
-                number
-                type
-                primary
-                ext
-            }
-            mls_set
-        }
-        corporation {
-            specialties
-            name
-            bio
-            href
-            fulfillment_id
-        }
-        mls_set
-        nrds_id
-        rental_corporation {
-            fulfillment_id
-        }
-        rental_management {
-            name
-            href
-            fulfillment_id
-        }
-    }
-    """
-
-
-HOME_FRAGMENT = """
-fragment HomeData on Home {
-    property_id
-    nearbySchools: nearby_schools(radius: 5.0, limit_per_level: 3) {
-        __typename schools { district { __typename id name } }
-    }
-    taxHistory: tax_history { __typename tax year assessment { __typename building land total } }
-    monthly_fees {
-        description
-        display_amount
-    }
-    one_time_fees {
-        description
-        display_amount
-    }
-    parking {
-        unassigned_space_rent
-        assigned_spaces_available
-        description
-        assigned_space_rent
-    }
-    terms {
-        text
-        category
-    }
-}
-"""
-
-HOMES_DATA = """%s
-                nearbySchools: nearby_schools(radius: 5.0, limit_per_level: 3) {
-                            __typename schools { district { __typename id name } }
-                        }
-                monthly_fees {
-                    description
-                    display_amount
-                }
-                one_time_fees {
-                    description
-                    display_amount
-                }
-                parking {
-                    unassigned_space_rent
-                    assigned_spaces_available
-                    description
-                    assigned_space_rent
-                }
-                terms {
-                    text
-                    category
-                }
-                taxHistory: tax_history { __typename tax year assessment { __typename building land total } }
-                estimates {
-                    __typename
-                    currentValues: current_values {
-                        __typename
-                        source { __typename type name }
-                        estimate
-                        estimateHigh: estimate_high
-                        estimateLow: estimate_low
-                        date
-                        isBestHomeValue: isbest_homevalue
-                    }
-                }
-}""" % _SEARCH_HOMES_DATA_BASE
-
-SEARCH_HOMES_DATA = """%s
-current_estimates {
-    __typename
-    source {
-        __typename
-        type
-        name
-    }
-    estimate
-    estimateHigh: estimate_high
-    estimateLow: estimate_low
-    date
-    isBestHomeValue: isbest_homevalue
-}
-}""" % _SEARCH_HOMES_DATA_BASE
-
-GENERAL_RESULTS_QUERY = """{
-                            count
-                            total
-                            results %s
-                        }""" % SEARCH_HOMES_DATA

homeharvest/core/scrapers/redfin/__init__.py

@@ -0,0 +1,233 @@
+"""
+homeharvest.redfin.__init__
+~~~~~~~~~~~~
+
+This module implements the scraper for redfin.com
+"""
+import json
+from typing import Any
+from .. import Scraper
+from ....utils import parse_address_two, parse_address_one
+from ..models import Property, Address, PropertyType, ListingType, SiteName
+from ....exceptions import NoResultsFound
+
+
+class RedfinScraper(Scraper):
+    def __init__(self, scraper_input):
+        super().__init__(scraper_input)
+        self.listing_type = scraper_input.listing_type
+
+    def _handle_location(self):
+        url = "https://www.redfin.com/stingray/do/location-autocomplete?v=2&al=1&location={}".format(self.location)
+
+        response = self.session.get(url)
+        response_json = json.loads(response.text.replace("{}&&", ""))
+
+        def get_region_type(match_type: str):
+            if match_type == "4":
+                return "2"  #: zip
+            elif match_type == "2":
+                return "6"  #: city
+            elif match_type == "1":
+                return "address"  #: address, needs to be handled differently
+
+        if "exactMatch" not in response_json["payload"]:
+            raise NoResultsFound("No results found for location: {}".format(self.location))
+
+        if response_json["payload"]["exactMatch"] is not None:
+            target = response_json["payload"]["exactMatch"]
+        else:
+            target = response_json["payload"]["sections"][0]["rows"][0]
+
+        return target["id"].split("_")[1], get_region_type(target["type"])
+
+    def _parse_home(self, home: dict, single_search: bool = False) -> Property:
+        def get_value(key: str) -> Any | None:
+            if key in home and "value" in home[key]:
+                return home[key]["value"]
+
+        if not single_search:
+            address = Address(
+                address_one=parse_address_one(get_value("streetLine"))[0],
+                address_two=parse_address_one(get_value("streetLine"))[1],
+                city=home.get("city"),
+                state=home.get("state"),
+                zip_code=home.get("zip"),
+            )
+        else:
+            address_info = home.get("streetAddress")
+            address_one, address_two = parse_address_one(address_info.get("assembledAddress"))
+
+            address = Address(
+                address_one=address_one,
+                address_two=address_two,
+                city=home.get("city"),
+                state=home.get("state"),
+                zip_code=home.get("zip"),
+            )
+
+        url = "https://www.redfin.com{}".format(home["url"])
+        lot_size_data = home.get("lotSize")
+
+        if not isinstance(lot_size_data, int):
+            lot_size = lot_size_data.get("value", None) if isinstance(lot_size_data, dict) else None
+        else:
+            lot_size = lot_size_data
+
+        return Property(
+            site_name=self.site_name,
+            listing_type=self.listing_type,
+            address=address,
+            property_url=url,
+            beds_min=home["beds"] if "beds" in home else None,
+            beds_max=home["beds"] if "beds" in home else None,
+            baths_min=home["baths"] if "baths" in home else None,
+            baths_max=home["baths"] if "baths" in home else None,
+            price_min=get_value("price"),
+            price_max=get_value("price"),
+            sqft_min=get_value("sqFt"),
+            sqft_max=get_value("sqFt"),
+            stories=home["stories"] if "stories" in home else None,
+            agent_name=get_value("listingAgent"),
+            description=home["listingRemarks"] if "listingRemarks" in home else None,
+            year_built=get_value("yearBuilt") if not single_search else home.get("yearBuilt"),
+            lot_area_value=lot_size,
+            property_type=PropertyType.from_int_code(home.get("propertyType")),
+            price_per_sqft=get_value("pricePerSqFt") if type(home.get("pricePerSqFt")) != int else home.get("pricePerSqFt"),
+            mls_id=get_value("mlsId"),
+            latitude=home["latLong"]["latitude"] if "latLong" in home and "latitude" in home["latLong"] else None,
+            longitude=home["latLong"]["longitude"] if "latLong" in home and "longitude" in home["latLong"] else None,
+        )
+
+    def _handle_rentals(self, region_id, region_type):
+        url = f"https://www.redfin.com/stingray/api/v1/search/rentals?al=1&isRentals=true&region_id={region_id}&region_type={region_type}&num_homes=100000"
+
+        response = self.session.get(url)
+        response.raise_for_status()
+        homes = response.json()
+
+        properties_list = []
+
+        for home in homes["homes"]:
+            home_data = home["homeData"]
+            rental_data = home["rentalExtension"]
+
+            property_url = f"https://www.redfin.com{home_data.get('url', '')}"
+            address_info = home_data.get("addressInfo", {})
+            centroid = address_info.get("centroid", {}).get("centroid", {})
+            address = Address(
+                address_one=parse_address_one(address_info.get("formattedStreetLine"))[0],
+                city=address_info.get("city"),
+                state=address_info.get("state"),
+                zip_code=address_info.get("zip"),
+            )
+
+            price_range = rental_data.get("rentPriceRange", {"min": None, "max": None})
+            bed_range = rental_data.get("bedRange", {"min": None, "max": None})
+            bath_range = rental_data.get("bathRange", {"min": None, "max": None})
+            sqft_range = rental_data.get("sqftRange", {"min": None, "max": None})
+
+            property_ = Property(
+                property_url=property_url,
+                site_name=SiteName.REDFIN,
+                listing_type=ListingType.FOR_RENT,
+                address=address,
+                description=rental_data.get("description"),
+                latitude=centroid.get("latitude"),
+                longitude=centroid.get("longitude"),
+                baths_min=bath_range.get("min"),
+                baths_max=bath_range.get("max"),
+                beds_min=bed_range.get("min"),
+                beds_max=bed_range.get("max"),
+                price_min=price_range.get("min"),
+                price_max=price_range.get("max"),
+                sqft_min=sqft_range.get("min"),
+                sqft_max=sqft_range.get("max"),
+                img_src=home_data.get("staticMapUrl"),
+                posted_time=rental_data.get("lastUpdated"),
+                bldg_name=rental_data.get("propertyName"),
+            )
+
+            properties_list.append(property_)
+
+        if not properties_list:
+            raise NoResultsFound("No rentals found for the given location.")
+
+        return properties_list
+
+    def _parse_building(self, building: dict) -> Property:
+        street_address = " ".join(
+            [
+                building["address"]["streetNumber"],
+                building["address"]["directionalPrefix"],
+                building["address"]["streetName"],
+                building["address"]["streetType"],
+            ]
+        )
+        return Property(
+            site_name=self.site_name,
+            property_type=PropertyType("BUILDING"),
+            address=Address(
+                address_one=parse_address_one(street_address)[0],
+                city=building["address"]["city"],
+                state=building["address"]["stateOrProvinceCode"],
+                zip_code=building["address"]["postalCode"],
+                address_two=parse_address_two(
+                    " ".join(
+                        [
+                            building["address"]["unitType"],
+                            building["address"]["unitValue"],
+                        ]
+                    )
+                ),
+            ),
+            property_url="https://www.redfin.com{}".format(building["url"]),
+            listing_type=self.listing_type,
+            unit_count=building.get("numUnitsForSale"),
+        )
+
+    def handle_address(self, home_id: str):
+        """
+        EPs:
+        https://www.redfin.com/stingray/api/home/details/initialInfo?al=1&path=/TX/Austin/70-Rainey-St-78701/unit-1608/home/147337694
+        https://www.redfin.com/stingray/api/home/details/mainHouseInfoPanelInfo?propertyId=147337694&accessLevel=3
+        https://www.redfin.com/stingray/api/home/details/aboveTheFold?propertyId=147337694&accessLevel=3
+        https://www.redfin.com/stingray/api/home/details/belowTheFold?propertyId=147337694&accessLevel=3
+        """
+        url = "https://www.redfin.com/stingray/api/home/details/aboveTheFold?propertyId={}&accessLevel=3".format(
+            home_id
+        )
+
+        response = self.session.get(url)
+        response_json = json.loads(response.text.replace("{}&&", ""))
+
+        parsed_home = self._parse_home(response_json["payload"]["addressSectionInfo"], single_search=True)
+        return [parsed_home]
+
+    def search(self):
+        region_id, region_type = self._handle_location()
+
+        if region_type == "address":
+            home_id = region_id
+            return self.handle_address(home_id)
+
+        if self.listing_type == ListingType.FOR_RENT:
+            return self._handle_rentals(region_id, region_type)
+        else:
+            if self.listing_type == ListingType.FOR_SALE:
+                url = f"https://www.redfin.com/stingray/api/gis?al=1&region_id={region_id}&region_type={region_type}&num_homes=100000"
+            else:
+                url = f"https://www.redfin.com/stingray/api/gis?al=1&region_id={region_id}&region_type={region_type}&sold_within_days=30&num_homes=100000"
+            response = self.session.get(url)
+            response_json = json.loads(response.text.replace("{}&&", ""))
+
+            if "payload" in response_json:
+                homes_list = response_json["payload"].get("homes", [])
+                buildings_list = response_json["payload"].get("buildings", {}).values()
+
+                homes = [self._parse_home(home) for home in homes_list] + [
+                    self._parse_building(building) for building in buildings_list
+                ]
+                return homes
+            else:
+                return []

homeharvest/core/scrapers/zillow/__init__.py

@@ -0,0 +1,314 @@
+"""
+homeharvest.zillow.__init__
+~~~~~~~~~~~~
+
+This module implements the scraper for zillow.com
+"""
+import re
+import json
+from .. import Scraper
+from ....utils import parse_address_one, parse_address_two
+from ....exceptions import GeoCoordsNotFound, NoResultsFound
+from ..models import Property, Address, ListingType, PropertyType
+
+
+class ZillowScraper(Scraper):
+    def __init__(self, scraper_input):
+        super().__init__(scraper_input)
+
+        if not self.is_plausible_location(self.location):
+            raise NoResultsFound("Invalid location input: {}".format(self.location))
+
+        listing_type_to_url_path = {
+            ListingType.FOR_SALE: "for_sale",
+            ListingType.FOR_RENT: "for_rent",
+            ListingType.SOLD: "recently_sold",
+        }
+
+        self.url = f"https://www.zillow.com/homes/{listing_type_to_url_path[self.listing_type]}/{self.location}_rb/"
+
+    def is_plausible_location(self, location: str) -> bool:
+        url = (
+            "https://www.zillowstatic.com/autocomplete/v3/suggestions?q={"
+            "}&abKey=6666272a-4b99-474c-b857-110ec438732b&clientId=homepage-render"
+        ).format(location)
+
+        response = self.session.get(url)
+
+        return response.json()["results"] != []
+
+    def search(self):
+        resp = self.session.get(self.url, headers=self._get_headers())
+        resp.raise_for_status()
+        content = resp.text
+
+        match = re.search(
+            r'<script id="__NEXT_DATA__" type="application/json">(.*?)</script>',
+            content,
+            re.DOTALL,
+        )
+        if not match:
+            raise NoResultsFound("No results were found for Zillow with the given Location.")
+
+        json_str = match.group(1)
+        data = json.loads(json_str)
+
+        if "searchPageState" in data["props"]["pageProps"]:
+            pattern = r'window\.mapBounds = \{\s*"west":\s*(-?\d+\.\d+),\s*"east":\s*(-?\d+\.\d+),\s*"south":\s*(-?\d+\.\d+),\s*"north":\s*(-?\d+\.\d+)\s*\};'
+
+            match = re.search(pattern, content)
+
+            if match:
+                coords = [float(coord) for coord in match.groups()]
+                return self._fetch_properties_backend(coords)
+
+            else:
+                raise GeoCoordsNotFound("Box bounds could not be located.")
+
+        elif "gdpClientCache" in data["props"]["pageProps"]:
+            gdp_client_cache = json.loads(data["props"]["pageProps"]["gdpClientCache"])
+            main_key = list(gdp_client_cache.keys())[0]
+
+            property_data = gdp_client_cache[main_key]["property"]
+            property = self._get_single_property_page(property_data)
+
+            return [property]
+        raise NoResultsFound("Specific property data not found in the response.")
+
+    def _fetch_properties_backend(self, coords):
+        url = "https://www.zillow.com/async-create-search-page-state"
+
+        filter_state_for_sale = {
+            "sortSelection": {
+                # "value": "globalrelevanceex"
+                "value": "days"
+            },
+            "isAllHomes": {"value": True},
+        }
+
+        filter_state_for_rent = {
+            "isForRent": {"value": True},
+            "isForSaleByAgent": {"value": False},
+            "isForSaleByOwner": {"value": False},
+            "isNewConstruction": {"value": False},
+            "isComingSoon": {"value": False},
+            "isAuction": {"value": False},
+            "isForSaleForeclosure": {"value": False},
+            "isAllHomes": {"value": True},
+        }
+
+        filter_state_sold = {
+            "isRecentlySold": {"value": True},
+            "isForSaleByAgent": {"value": False},
+            "isForSaleByOwner": {"value": False},
+            "isNewConstruction": {"value": False},
+            "isComingSoon": {"value": False},
+            "isAuction": {"value": False},
+            "isForSaleForeclosure": {"value": False},
+            "isAllHomes": {"value": True},
+        }
+
+        selected_filter = (
+            filter_state_for_rent
+            if self.listing_type == ListingType.FOR_RENT
+            else filter_state_for_sale
+            if self.listing_type == ListingType.FOR_SALE
+            else filter_state_sold
+        )
+
+        payload = {
+            "searchQueryState": {
+                "pagination": {},
+                "isMapVisible": True,
+                "mapBounds": {
+                    "west": coords[0],
+                    "east": coords[1],
+                    "south": coords[2],
+                    "north": coords[3],
+                },
+                "filterState": selected_filter,
+                "isListVisible": True,
+                "mapZoom": 11,
+            },
+            "wants": {"cat1": ["mapResults"]},
+            "isDebugRequest": False,
+        }
+        resp = self.session.put(url, headers=self._get_headers(), json=payload)
+        resp.raise_for_status()
+        a = resp.json()
+        return self._parse_properties(resp.json())
+
+    def _parse_properties(self, property_data: dict):
+        mapresults = property_data["cat1"]["searchResults"]["mapResults"]
+
+        properties_list = []
+
+        for result in mapresults:
+            if "hdpData" in result:
+                home_info = result["hdpData"]["homeInfo"]
+                address_data = {
+                    "address_one": parse_address_one(home_info.get("streetAddress"))[0],
+                    "address_two": parse_address_two(home_info["unit"]) if "unit" in home_info else "#",
+                    "city": home_info.get("city"),
+                    "state": home_info.get("state"),
+                    "zip_code": home_info.get("zipcode"),
+                }
+                property_obj = Property(
+                    site_name=self.site_name,
+                    address=Address(**address_data),
+                    property_url=f"https://www.zillow.com{result['detailUrl']}",
+                    tax_assessed_value=int(home_info["taxAssessedValue"]) if "taxAssessedValue" in home_info else None,
+                    property_type=PropertyType(home_info.get("homeType")),
+                    listing_type=ListingType(
+                        home_info["statusType"] if "statusType" in home_info else self.listing_type
+                    ),
+                    status_text=result.get("statusText"),
+                    posted_time=result["variableData"]["text"]
+                    if "variableData" in result
+                    and "text" in result["variableData"]
+                    and result["variableData"]["type"] == "TIME_ON_INFO"
+                    else None,
+                    price_min=home_info.get("price"),
+                    price_max=home_info.get("price"),
+                    beds_min=int(home_info["bedrooms"]) if "bedrooms" in home_info else None,
+                    beds_max=int(home_info["bedrooms"]) if "bedrooms" in home_info else None,
+                    baths_min=home_info.get("bathrooms"),
+                    baths_max=home_info.get("bathrooms"),
+                    sqft_min=int(home_info["livingArea"]) if "livingArea" in home_info else None,
+                    sqft_max=int(home_info["livingArea"]) if "livingArea" in home_info else None,
+                    price_per_sqft=int(home_info["price"] // home_info["livingArea"])
+                    if "livingArea" in home_info and home_info["livingArea"] != 0 and "price" in home_info
+                    else None,
+                    latitude=result["latLong"]["latitude"],
+                    longitude=result["latLong"]["longitude"],
+                    lot_area_value=round(home_info["lotAreaValue"], 2) if "lotAreaValue" in home_info else None,
+                    lot_area_unit=home_info.get("lotAreaUnit"),
+                    img_src=result.get("imgSrc"),
+                )
+
+                properties_list.append(property_obj)
+
+            elif "isBuilding" in result:
+                price_string = result["price"].replace("$", "").replace(",", "").replace("+/mo", "")
+
+                match = re.search(r"(\d+)", price_string)
+                price_value = int(match.group(1)) if match else None
+                building_obj = Property(
+                    property_url=f"https://www.zillow.com{result['detailUrl']}",
+                    site_name=self.site_name,
+                    property_type=PropertyType("BUILDING"),
+                    listing_type=ListingType(result["statusType"]),
+                    img_src=result.get("imgSrc"),
+                    address=self._extract_address(result["address"]),
+                    baths_min=result.get("minBaths"),
+                    area_min=result.get("minArea"),
+                    bldg_name=result.get("communityName"),
+                    status_text=result.get("statusText"),
+                    price_min=price_value if "+/mo" in result.get("price") else None,
+                    price_max=price_value if "+/mo" in result.get("price") else None,
+                    latitude=result.get("latLong", {}).get("latitude"),
+                    longitude=result.get("latLong", {}).get("longitude"),
+                    unit_count=result.get("unitCount"),
+                )
+
+                properties_list.append(building_obj)
+
+        return properties_list
+
+    def _get_single_property_page(self, property_data: dict):
+        """
+        This method is used when a user enters the exact location & zillow returns just one property
+        """
+        url = (
+            f"https://www.zillow.com{property_data['hdpUrl']}"
+            if "zillow.com" not in property_data["hdpUrl"]
+            else property_data["hdpUrl"]
+        )
+        address_data = property_data["address"]
+        address_one, address_two = parse_address_one(address_data["streetAddress"])
+        address = Address(
+            address_one=address_one,
+            address_two=address_two if address_two else "#",
+            city=address_data["city"],
+            state=address_data["state"],
+            zip_code=address_data["zipcode"],
+        )
+        property_type = property_data.get("homeType", None)
+        return Property(
+            site_name=self.site_name,
+            property_url=url,
+            property_type=PropertyType(property_type),
+            listing_type=self.listing_type,
+            address=address,
+            year_built=property_data.get("yearBuilt"),
+            tax_assessed_value=property_data.get("taxAssessedValue"),
+            lot_area_value=property_data.get("lotAreaValue"),
+            lot_area_unit=property_data["lotAreaUnits"].lower() if "lotAreaUnits" in property_data else None,
+            agent_name=property_data.get("attributionInfo", {}).get("agentName"),
+            stories=property_data.get("resoFacts", {}).get("stories"),
+            mls_id=property_data.get("attributionInfo", {}).get("mlsId"),
+            beds_min=property_data.get("bedrooms"),
+            beds_max=property_data.get("bedrooms"),
+            baths_min=property_data.get("bathrooms"),
+            baths_max=property_data.get("bathrooms"),
+            price_min=property_data.get("price"),
+            price_max=property_data.get("price"),
+            sqft_min=property_data.get("livingArea"),
+            sqft_max=property_data.get("livingArea"),
+            price_per_sqft=property_data.get("resoFacts", {}).get("pricePerSquareFoot"),
+            latitude=property_data.get("latitude"),
+            longitude=property_data.get("longitude"),
+            img_src=property_data.get("streetViewTileImageUrlMediumAddress"),
+            description=property_data.get("description"),
+        )
+
+    def _extract_address(self, address_str):
+        """
+        Extract address components from a string formatted like '555 Wedglea Dr, Dallas, TX',
+        and return an Address object.
+        """
+        parts = address_str.split(", ")
+
+        if len(parts) != 3:
+            raise ValueError(f"Unexpected address format: {address_str}")
+
+        address_one = parts[0].strip()
+        city = parts[1].strip()
+        state_zip = parts[2].split(" ")
+
+        if len(state_zip) == 1:
+            state = state_zip[0].strip()
+            zip_code = None
+        elif len(state_zip) == 2:
+            state = state_zip[0].strip()
+            zip_code = state_zip[1].strip()
+        else:
+            raise ValueError(f"Unexpected state/zip format in address: {address_str}")
+
+        address_one, address_two = parse_address_one(address_one)
+        return Address(
+            address_one=address_one,
+            address_two=address_two if address_two else "#",
+            city=city,
+            state=state,
+            zip_code=zip_code,
+        )
+
+    @staticmethod
+    def _get_headers():
+        return {
+            "authority": "www.zillow.com",
+            "accept": "*/*",
+            "accept-language": "en-US,en;q=0.9",
+            "content-type": "application/json",
+            "cookie": 'zjs_user_id=null; zg_anonymous_id=%220976ab81-2950-4013-98f0-108b15a554d2%22; zguid=24|%246b1bc625-3955-4d1e-a723-e59602e4ed08; g_state={"i_p":1693611172520,"i_l":1}; zgsession=1|d48820e2-1659-4d2f-b7d2-99a8127dd4f3; zjs_anonymous_id=%226b1bc625-3955-4d1e-a723-e59602e4ed08%22; JSESSIONID=82E8274D3DC8AF3AB9C8E613B38CF861; search=6|1697585860120%7Crb%3DDallas%252C-TX%26rect%3D33.016646%252C-96.555516%252C32.618763%252C-96.999347%26disp%3Dmap%26mdm%3Dauto%26sort%3Ddays%26listPriceActive%3D1%26fs%3D1%26fr%3D0%26mmm%3D0%26rs%3D0%26ah%3D0%26singlestory%3D0%26abo%3D0%26garage%3D0%26pool%3D0%26ac%3D0%26waterfront%3D0%26finished%3D0%26unfinished%3D0%26cityview%3D0%26mountainview%3D0%26parkview%3D0%26waterview%3D0%26hoadata%3D1%263dhome%3D0%26commuteMode%3Ddriving%26commuteTimeOfDay%3Dnow%09%0938128%09%7B%22isList%22%3Atrue%2C%22isMap%22%3Atrue%7D%09%09%09%09%09; AWSALB=gAlFj5Ngnd4bWP8k7CME/+YlTtX9bHK4yEkdPHa3VhL6K523oGyysFxBEpE1HNuuyL+GaRPvt2i/CSseAb+zEPpO4SNjnbLAJzJOOO01ipnWN3ZgPaa5qdv+fAki; AWSALBCORS=gAlFj5Ngnd4bWP8k7CME/+YlTtX9bHK4yEkdPHa3VhL6K523oGyysFxBEpE1HNuuyL+GaRPvt2i/CSseAb+zEPpO4SNjnbLAJzJOOO01ipnWN3ZgPaa5qdv+fAki; search=6|1697587741808%7Crect%3D33.37188814545521%2C-96.34484483007813%2C32.260490641365685%2C-97.21001816992188%26disp%3Dmap%26mdm%3Dauto%26p%3D1%26sort%3Ddays%26z%3D1%26listPriceActive%3D1%26fs%3D1%26fr%3D0%26mmm%3D0%26rs%3D0%26ah%3D0%26singlestory%3D0%26housing-connector%3D0%26abo%3D0%26garage%3D0%26pool%3D0%26ac%3D0%26waterfront%3D0%26finished%3D0%26unfinished%3D0%26cityview%3D0%26mountainview%3D0%26parkview%3D0%26waterview%3D0%26hoadata%3D1%26zillow-owned%3D0%263dhome%3D0%26featuredMultiFamilyBuilding%3D0%26commuteMode%3Ddriving%26commuteTimeOfDay%3Dnow%09%09%09%7B%22isList%22%3Atrue%2C%22isMap%22%3Atrue%7D%09%09%09%09%09',
+            "origin": "https://www.zillow.com",
+            "referer": "https://www.zillow.com",
+            "sec-ch-ua": '"Chromium";v="116", "Not)A;Brand";v="24", "Google Chrome";v="116"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-origin",
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36",
+        }

homeharvest/exceptions.py

@@ -1,14 +1,14 @@
+class InvalidSite(Exception):
+    """Raised when a provided site is does not exist."""
+
+
 class InvalidListingType(Exception):
     """Raised when a provided listing type is does not exist."""
 
 
-class InvalidDate(Exception):
+class NoResultsFound(Exception):
-    """Raised when only one of date_from or date_to is provided or not in the correct format. ex: 2023-10-23"""
+    """Raised when no results are found for the given location"""
 
 
-class AuthenticationError(Exception):
+class GeoCoordsNotFound(Exception):
-    """Raised when there is an issue with the authentication process."""
+    """Raised when no property is found for the given address"""
-    def __init__(self, *args, response):
-        super().__init__(*args)
-
-        self.response = response

homeharvest/utils.py

@@ -1,166 +1,38 @@
-from __future__ import annotations
+import re
-import pandas as pd
-from datetime import datetime
-from .core.scrapers.models import Property, ListingType, Advertisers
-from .exceptions import InvalidListingType, InvalidDate
-
-ordered_properties = [
-    "property_url",
-    "property_id",
-    "listing_id",
-    "mls",
-    "mls_id",
-    "status",
-    "text",
-    "style",
-    "full_street_line",
-    "street",
-    "unit",
-    "city",
-    "state",
-    "zip_code",
-    "beds",
-    "full_baths",
-    "half_baths",
-    "sqft",
-    "year_built",
-    "days_on_mls",
-    "list_price",
-    "list_price_min",
-    "list_price_max",
-    "list_date",
-    "sold_price",
-    "last_sold_date",
-    "assessed_value",
-    "estimated_value",
-    "tax",
-    "tax_history",
-    "new_construction",
-    "lot_sqft",
-    "price_per_sqft",
-    "latitude",
-    "longitude",
-    "neighborhoods",
-    "county",
-    "fips_code",
-    "stories",
-    "hoa_fee",
-    "parking_garage",
-    "agent_id",
-    "agent_name",
-    "agent_email",
-    "agent_phones",
-    "agent_mls_set",
-    "agent_nrds_id",
-    "broker_id",
-    "broker_name",
-    "builder_id",
-    "builder_name",
-    "office_id",
-    "office_mls_set",
-    "office_name",
-    "office_email",
-    "office_phones",
-    "nearby_schools",
-    "primary_photo",
-    "alt_photos",
-]
 
 
-def process_result(result: Property) -> pd.DataFrame:
+def parse_address_one(street_address: str) -> tuple:
-    prop_data = {prop: None for prop in ordered_properties}
+    if not street_address:
-    prop_data.update(result.__dict__)
+        return street_address, "#"
 
-    if "address" in prop_data:
+    apt_match = re.search(
-        address_data = prop_data["address"]
+        r"(APT\s*[\dA-Z]+|#[\dA-Z]+|UNIT\s*[\dA-Z]+|LOT\s*[\dA-Z]+|SUITE\s*[\dA-Z]+)$",
-        prop_data["full_street_line"] = address_data.full_line
+        street_address,
-        prop_data["street"] = address_data.street
+        re.I,
-        prop_data["unit"] = address_data.unit
+    )
-        prop_data["city"] = address_data.city
-        prop_data["state"] = address_data.state
-        prop_data["zip_code"] = address_data.zip
 
-    if "advertisers" in prop_data and prop_data.get("advertisers"):
+    if apt_match:
-        advertiser_data: Advertisers | None = prop_data["advertisers"]
+        apt_str = apt_match.group().strip()
-        if advertiser_data.agent:
+        cleaned_apt_str = re.sub(r"(APT\s*|UNIT\s*|LOT\s*|SUITE\s*)", "#", apt_str, flags=re.I)
-            agent_data = advertiser_data.agent
-            prop_data["agent_id"] = agent_data.uuid
-            prop_data["agent_name"] = agent_data.name
-            prop_data["agent_email"] = agent_data.email
-            prop_data["agent_phones"] = agent_data.phones
-            prop_data["agent_mls_set"] = agent_data.mls_set
-            prop_data["agent_nrds_id"] = agent_data.nrds_id
 
-        if advertiser_data.broker:
+        main_address = street_address.replace(apt_str, "").strip()
-            broker_data = advertiser_data.broker
+        return main_address, cleaned_apt_str
-            prop_data["broker_id"] = broker_data.uuid
+    else:
-            prop_data["broker_name"] = broker_data.name
+        return street_address, "#"
-
-        if advertiser_data.builder:
-            builder_data = advertiser_data.builder
-            prop_data["builder_id"] = builder_data.uuid
-            prop_data["builder_name"] = builder_data.name
-
-        if advertiser_data.office:
-            office_data = advertiser_data.office
-            prop_data["office_id"] = office_data.uuid
-            prop_data["office_name"] = office_data.name
-            prop_data["office_email"] = office_data.email
-            prop_data["office_phones"] = office_data.phones
-            prop_data["office_mls_set"] = office_data.mls_set
-
-    prop_data["price_per_sqft"] = prop_data["prc_sqft"]
-    prop_data["nearby_schools"] = filter(None, prop_data["nearby_schools"]) if prop_data["nearby_schools"] else None
-    prop_data["nearby_schools"] = ", ".join(set(prop_data["nearby_schools"])) if prop_data["nearby_schools"] else None
-
-    description = result.description
-    if description:
-        prop_data["primary_photo"] = description.primary_photo
-        prop_data["alt_photos"] = ", ".join(description.alt_photos) if description.alt_photos else None
-        prop_data["style"] = (
-            description.style
-            if isinstance(description.style, str)
-            else description.style.value if description.style else None
-        )
-        prop_data["beds"] = description.beds
-        prop_data["full_baths"] = description.baths_full
-        prop_data["half_baths"] = description.baths_half
-        prop_data["sqft"] = description.sqft
-        prop_data["lot_sqft"] = description.lot_sqft
-        prop_data["sold_price"] = description.sold_price
-        prop_data["year_built"] = description.year_built
-        prop_data["parking_garage"] = description.garage
-        prop_data["stories"] = description.stories
-        prop_data["text"] = description.text
-
-    properties_df = pd.DataFrame([prop_data])
-    properties_df = properties_df.reindex(columns=ordered_properties)
-
-    return properties_df[ordered_properties]
 
 
-def validate_input(listing_type: str) -> None:
+def parse_address_two(street_address: str):
-    if listing_type.upper() not in ListingType.__members__:
+    if not street_address:
-        raise InvalidListingType(f"Provided listing type, '{listing_type}', does not exist.")
+        return "#"
+    apt_match = re.search(
+        r"(APT\s*[\dA-Z]+|#[\dA-Z]+|UNIT\s*[\dA-Z]+|LOT\s*[\dA-Z]+|SUITE\s*[\dA-Z]+)$",
+        street_address,
+        re.I,
+    )
 
-
+    if apt_match:
-def validate_dates(date_from: str | None, date_to: str | None) -> None:
+        apt_str = apt_match.group().strip()
-    if isinstance(date_from, str) != isinstance(date_to, str):
+        apt_str = re.sub(r"(APT\s*|UNIT\s*|LOT\s*|SUITE\s*)", "#", apt_str, flags=re.I)
-        raise InvalidDate("Both date_from and date_to must be provided.")
+        return apt_str
-
+    else:
-    if date_from and date_to:
+        return "#"
-        try:
-            date_from_obj = datetime.strptime(date_from, "%Y-%m-%d")
-            date_to_obj = datetime.strptime(date_to, "%Y-%m-%d")
-
-            if date_to_obj < date_from_obj:
-                raise InvalidDate("date_to must be after date_from.")
-        except ValueError:
-            raise InvalidDate(f"Invalid date format or range")
-
-
-def validate_limit(limit: int) -> None:
-    #: 1 -> 10000 limit
-
-    if limit is not None and (limit < 1 or limit > 10000):
-        raise ValueError("Property limit must be between 1 and 10,000.")

poetry.lock

@@ -1,15 +1,4 @@
-# This file is automatically @generated by Poetry 1.8.4 and should not be changed by hand.
+# This file is automatically @generated by Poetry 1.6.1 and should not be changed by hand.
-
-[[package]]
-name = "annotated-types"
-version = "0.7.0"
-description = "Reusable constraint types to use with typing.Annotated"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53"},
-    {file = "annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89"},
-]
 
 [[package]]
 name = "certifi"
@@ -22,114 +11,88 @@ files = [
     {file = "certifi-2023.7.22.tar.gz", hash = "sha256:539cc1d13202e33ca466e88b2807e29f4c13049d6d87031a3c110744495cb082"},
 ]
 
-[[package]]
-name = "cfgv"
-version = "3.4.0"
-description = "Validate configuration and produce human readable error messages."
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "cfgv-3.4.0-py2.py3-none-any.whl", hash = "sha256:b7265b1f29fd3316bfcd2b330d63d024f2bfd8bcb8b0272f8e19a504856c48f9"},
-    {file = "cfgv-3.4.0.tar.gz", hash = "sha256:e52591d4c5f5dead8e0f673fb16db7949d2cfb3f7da4582893288f0ded8fe560"},
-]
-
 [[package]]
 name = "charset-normalizer"
-version = "3.3.0"
+version = "3.2.0"
 description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet."
 optional = false
 python-versions = ">=3.7.0"
 files = [
-    {file = "charset-normalizer-3.3.0.tar.gz", hash = "sha256:63563193aec44bce707e0c5ca64ff69fa72ed7cf34ce6e11d5127555756fd2f6"},
+    {file = "charset-normalizer-3.2.0.tar.gz", hash = "sha256:3bb3d25a8e6c0aedd251753a79ae98a093c7e7b471faa3aa9a93a81431987ace"},
-    {file = "charset_normalizer-3.3.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:effe5406c9bd748a871dbcaf3ac69167c38d72db8c9baf3ff954c344f31c4cbe"},
+    {file = "charset_normalizer-3.2.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:0b87549028f680ca955556e3bd57013ab47474c3124dc069faa0b6545b6c9710"},
-    {file = "charset_normalizer-3.3.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:4162918ef3098851fcd8a628bf9b6a98d10c380725df9e04caf5ca6dd48c847a"},
+    {file = "charset_normalizer-3.2.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:7c70087bfee18a42b4040bb9ec1ca15a08242cf5867c58726530bdf3945672ed"},
-    {file = "charset_normalizer-3.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0570d21da019941634a531444364f2482e8db0b3425fcd5ac0c36565a64142c8"},
+    {file = "charset_normalizer-3.2.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a103b3a7069b62f5d4890ae1b8f0597618f628b286b03d4bc9195230b154bfa9"},
-    {file = "charset_normalizer-3.3.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5707a746c6083a3a74b46b3a631d78d129edab06195a92a8ece755aac25a3f3d"},
+    {file = "charset_normalizer-3.2.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:94aea8eff76ee6d1cdacb07dd2123a68283cb5569e0250feab1240058f53b623"},
-    {file = "charset_normalizer-3.3.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:278c296c6f96fa686d74eb449ea1697f3c03dc28b75f873b65b5201806346a69"},
+    {file = "charset_normalizer-3.2.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:db901e2ac34c931d73054d9797383d0f8009991e723dab15109740a63e7f902a"},
-    {file = "charset_normalizer-3.3.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a4b71f4d1765639372a3b32d2638197f5cd5221b19531f9245fcc9ee62d38f56"},
+    {file = "charset_normalizer-3.2.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b0dac0ff919ba34d4df1b6131f59ce95b08b9065233446be7e459f95554c0dc8"},
-    {file = "charset_normalizer-3.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f5969baeaea61c97efa706b9b107dcba02784b1601c74ac84f2a532ea079403e"},
+    {file = "charset_normalizer-3.2.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:193cbc708ea3aca45e7221ae58f0fd63f933753a9bfb498a3b474878f12caaad"},
-    {file = "charset_normalizer-3.3.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a3f93dab657839dfa61025056606600a11d0b696d79386f974e459a3fbc568ec"},
+    {file = "charset_normalizer-3.2.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:09393e1b2a9461950b1c9a45d5fd251dc7c6f228acab64da1c9c0165d9c7765c"},
-    {file = "charset_normalizer-3.3.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:db756e48f9c5c607b5e33dd36b1d5872d0422e960145b08ab0ec7fd420e9d649"},
+    {file = "charset_normalizer-3.2.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:baacc6aee0b2ef6f3d308e197b5d7a81c0e70b06beae1f1fcacffdbd124fe0e3"},
-    {file = "charset_normalizer-3.3.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:232ac332403e37e4a03d209a3f92ed9071f7d3dbda70e2a5e9cff1c4ba9f0678"},
+    {file = "charset_normalizer-3.2.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:bf420121d4c8dce6b889f0e8e4ec0ca34b7f40186203f06a946fa0276ba54029"},
-    {file = "charset_normalizer-3.3.0-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:e5c1502d4ace69a179305abb3f0bb6141cbe4714bc9b31d427329a95acfc8bdd"},
+    {file = "charset_normalizer-3.2.0-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:c04a46716adde8d927adb9457bbe39cf473e1e2c2f5d0a16ceb837e5d841ad4f"},
-    {file = "charset_normalizer-3.3.0-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:2502dd2a736c879c0f0d3e2161e74d9907231e25d35794584b1ca5284e43f596"},
+    {file = "charset_normalizer-3.2.0-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:aaf63899c94de41fe3cf934601b0f7ccb6b428c6e4eeb80da72c58eab077b19a"},
-    {file = "charset_normalizer-3.3.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:23e8565ab7ff33218530bc817922fae827420f143479b753104ab801145b1d5b"},
+    {file = "charset_normalizer-3.2.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:d62e51710986674142526ab9f78663ca2b0726066ae26b78b22e0f5e571238dd"},
-    {file = "charset_normalizer-3.3.0-cp310-cp310-win32.whl", hash = "sha256:1872d01ac8c618a8da634e232f24793883d6e456a66593135aeafe3784b0848d"},
+    {file = "charset_normalizer-3.2.0-cp310-cp310-win32.whl", hash = "sha256:04e57ab9fbf9607b77f7d057974694b4f6b142da9ed4a199859d9d4d5c63fe96"},
-    {file = "charset_normalizer-3.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:557b21a44ceac6c6b9773bc65aa1b4cc3e248a5ad2f5b914b91579a32e22204d"},
+    {file = "charset_normalizer-3.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:48021783bdf96e3d6de03a6e39a1171ed5bd7e8bb93fc84cc649d11490f87cea"},
-    {file = "charset_normalizer-3.3.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:d7eff0f27edc5afa9e405f7165f85a6d782d308f3b6b9d96016c010597958e63"},
+    {file = "charset_normalizer-3.2.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:4957669ef390f0e6719db3613ab3a7631e68424604a7b448f079bee145da6e09"},
-    {file = "charset_normalizer-3.3.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6a685067d05e46641d5d1623d7c7fdf15a357546cbb2f71b0ebde91b175ffc3e"},
+    {file = "charset_normalizer-3.2.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:46fb8c61d794b78ec7134a715a3e564aafc8f6b5e338417cb19fe9f57a5a9bf2"},
-    {file = "charset_normalizer-3.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0d3d5b7db9ed8a2b11a774db2bbea7ba1884430a205dbd54a32d61d7c2a190fa"},
+    {file = "charset_normalizer-3.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f779d3ad205f108d14e99bb3859aa7dd8e9c68874617c72354d7ecaec2a054ac"},
-    {file = "charset_normalizer-3.3.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2935ffc78db9645cb2086c2f8f4cfd23d9b73cc0dc80334bc30aac6f03f68f8c"},
+    {file = "charset_normalizer-3.2.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f25c229a6ba38a35ae6e25ca1264621cc25d4d38dca2942a7fce0b67a4efe918"},
-    {file = "charset_normalizer-3.3.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9fe359b2e3a7729010060fbca442ca225280c16e923b37db0e955ac2a2b72a05"},
+    {file = "charset_normalizer-3.2.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2efb1bd13885392adfda4614c33d3b68dee4921fd0ac1d3988f8cbb7d589e72a"},
-    {file = "charset_normalizer-3.3.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:380c4bde80bce25c6e4f77b19386f5ec9db230df9f2f2ac1e5ad7af2caa70459"},
+    {file = "charset_normalizer-3.2.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1f30b48dd7fa1474554b0b0f3fdfdd4c13b5c737a3c6284d3cdc424ec0ffff3a"},
-    {file = "charset_normalizer-3.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f0d1e3732768fecb052d90d62b220af62ead5748ac51ef61e7b32c266cac9293"},
+    {file = "charset_normalizer-3.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:246de67b99b6851627d945db38147d1b209a899311b1305dd84916f2b88526c6"},
-    {file = "charset_normalizer-3.3.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1b2919306936ac6efb3aed1fbf81039f7087ddadb3160882a57ee2ff74fd2382"},
+    {file = "charset_normalizer-3.2.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9bd9b3b31adcb054116447ea22caa61a285d92e94d710aa5ec97992ff5eb7cf3"},
-    {file = "charset_normalizer-3.3.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:f8888e31e3a85943743f8fc15e71536bda1c81d5aa36d014a3c0c44481d7db6e"},
+    {file = "charset_normalizer-3.2.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:8c2f5e83493748286002f9369f3e6607c565a6a90425a3a1fef5ae32a36d749d"},
-    {file = "charset_normalizer-3.3.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:82eb849f085624f6a607538ee7b83a6d8126df6d2f7d3b319cb837b289123078"},
+    {file = "charset_normalizer-3.2.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:3170c9399da12c9dc66366e9d14da8bf7147e1e9d9ea566067bbce7bb74bd9c2"},
-    {file = "charset_normalizer-3.3.0-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:7b8b8bf1189b3ba9b8de5c8db4d541b406611a71a955bbbd7385bbc45fcb786c"},
+    {file = "charset_normalizer-3.2.0-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:7a4826ad2bd6b07ca615c74ab91f32f6c96d08f6fcc3902ceeedaec8cdc3bcd6"},
-    {file = "charset_normalizer-3.3.0-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:5adf257bd58c1b8632046bbe43ee38c04e1038e9d37de9c57a94d6bd6ce5da34"},
+    {file = "charset_normalizer-3.2.0-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:3b1613dd5aee995ec6d4c69f00378bbd07614702a315a2cf6c1d21461fe17c23"},
-    {file = "charset_normalizer-3.3.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c350354efb159b8767a6244c166f66e67506e06c8924ed74669b2c70bc8735b1"},
+    {file = "charset_normalizer-3.2.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9e608aafdb55eb9f255034709e20d5a83b6d60c054df0802fa9c9883d0a937aa"},
-    {file = "charset_normalizer-3.3.0-cp311-cp311-win32.whl", hash = "sha256:02af06682e3590ab952599fbadac535ede5d60d78848e555aa58d0c0abbde786"},
+    {file = "charset_normalizer-3.2.0-cp311-cp311-win32.whl", hash = "sha256:f2a1d0fd4242bd8643ce6f98927cf9c04540af6efa92323e9d3124f57727bfc1"},
-    {file = "charset_normalizer-3.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:86d1f65ac145e2c9ed71d8ffb1905e9bba3a91ae29ba55b4c46ae6fc31d7c0d4"},
+    {file = "charset_normalizer-3.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:681eb3d7e02e3c3655d1b16059fbfb605ac464c834a0c629048a30fad2b27489"},
-    {file = "charset_normalizer-3.3.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:3b447982ad46348c02cb90d230b75ac34e9886273df3a93eec0539308a6296d7"},
+    {file = "charset_normalizer-3.2.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c57921cda3a80d0f2b8aec7e25c8aa14479ea92b5b51b6876d975d925a2ea346"},
-    {file = "charset_normalizer-3.3.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:abf0d9f45ea5fb95051c8bfe43cb40cda383772f7e5023a83cc481ca2604d74e"},
+    {file = "charset_normalizer-3.2.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:41b25eaa7d15909cf3ac4c96088c1f266a9a93ec44f87f1d13d4a0e86c81b982"},
-    {file = "charset_normalizer-3.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b09719a17a2301178fac4470d54b1680b18a5048b481cb8890e1ef820cb80455"},
+    {file = "charset_normalizer-3.2.0-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f058f6963fd82eb143c692cecdc89e075fa0828db2e5b291070485390b2f1c9c"},
-    {file = "charset_normalizer-3.3.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b3d9b48ee6e3967b7901c052b670c7dda6deb812c309439adaffdec55c6d7b78"},
+    {file = "charset_normalizer-3.2.0-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a7647ebdfb9682b7bb97e2a5e7cb6ae735b1c25008a70b906aecca294ee96cf4"},
-    {file = "charset_normalizer-3.3.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:edfe077ab09442d4ef3c52cb1f9dab89bff02f4524afc0acf2d46be17dc479f5"},
+    {file = "charset_normalizer-3.2.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eef9df1eefada2c09a5e7a40991b9fc6ac6ef20b1372abd48d2794a316dc0449"},
-    {file = "charset_normalizer-3.3.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3debd1150027933210c2fc321527c2299118aa929c2f5a0a80ab6953e3bd1908"},
+    {file = "charset_normalizer-3.2.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e03b8895a6990c9ab2cdcd0f2fe44088ca1c65ae592b8f795c3294af00a461c3"},
-    {file = "charset_normalizer-3.3.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:86f63face3a527284f7bb8a9d4f78988e3c06823f7bea2bd6f0e0e9298ca0403"},
+    {file = "charset_normalizer-3.2.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:ee4006268ed33370957f55bf2e6f4d263eaf4dc3cfc473d1d90baff6ed36ce4a"},
-    {file = "charset_normalizer-3.3.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:24817cb02cbef7cd499f7c9a2735286b4782bd47a5b3516a0e84c50eab44b98e"},
+    {file = "charset_normalizer-3.2.0-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:c4983bf937209c57240cff65906b18bb35e64ae872da6a0db937d7b4af845dd7"},
-    {file = "charset_normalizer-3.3.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c71f16da1ed8949774ef79f4a0260d28b83b3a50c6576f8f4f0288d109777989"},
+    {file = "charset_normalizer-3.2.0-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:3bb7fda7260735efe66d5107fb7e6af6a7c04c7fce9b2514e04b7a74b06bf5dd"},
-    {file = "charset_normalizer-3.3.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:9cf3126b85822c4e53aa28c7ec9869b924d6fcfb76e77a45c44b83d91afd74f9"},
+    {file = "charset_normalizer-3.2.0-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:72814c01533f51d68702802d74f77ea026b5ec52793c791e2da806a3844a46c3"},
-    {file = "charset_normalizer-3.3.0-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:b3b2316b25644b23b54a6f6401074cebcecd1244c0b8e80111c9a3f1c8e83d65"},
+    {file = "charset_normalizer-3.2.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:70c610f6cbe4b9fce272c407dd9d07e33e6bf7b4aa1b7ffb6f6ded8e634e3592"},
-    {file = "charset_normalizer-3.3.0-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:03680bb39035fbcffe828eae9c3f8afc0428c91d38e7d61aa992ef7a59fb120e"},
+    {file = "charset_normalizer-3.2.0-cp37-cp37m-win32.whl", hash = "sha256:a401b4598e5d3f4a9a811f3daf42ee2291790c7f9d74b18d75d6e21dda98a1a1"},
-    {file = "charset_normalizer-3.3.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4cc152c5dd831641e995764f9f0b6589519f6f5123258ccaca8c6d34572fefa8"},
+    {file = "charset_normalizer-3.2.0-cp37-cp37m-win_amd64.whl", hash = "sha256:c0b21078a4b56965e2b12f247467b234734491897e99c1d51cee628da9786959"},
-    {file = "charset_normalizer-3.3.0-cp312-cp312-win32.whl", hash = "sha256:b8f3307af845803fb0b060ab76cf6dd3a13adc15b6b451f54281d25911eb92df"},
+    {file = "charset_normalizer-3.2.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:95eb302ff792e12aba9a8b8f8474ab229a83c103d74a750ec0bd1c1eea32e669"},
-    {file = "charset_normalizer-3.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:8eaf82f0eccd1505cf39a45a6bd0a8cf1c70dcfc30dba338207a969d91b965c0"},
+    {file = "charset_normalizer-3.2.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1a100c6d595a7f316f1b6f01d20815d916e75ff98c27a01ae817439ea7726329"},
-    {file = "charset_normalizer-3.3.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:dc45229747b67ffc441b3de2f3ae5e62877a282ea828a5bdb67883c4ee4a8810"},
+    {file = "charset_normalizer-3.2.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:6339d047dab2780cc6220f46306628e04d9750f02f983ddb37439ca47ced7149"},
-    {file = "charset_normalizer-3.3.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2f4a0033ce9a76e391542c182f0d48d084855b5fcba5010f707c8e8c34663d77"},
+    {file = "charset_normalizer-3.2.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e4b749b9cc6ee664a3300bb3a273c1ca8068c46be705b6c31cf5d276f8628a94"},
-    {file = "charset_normalizer-3.3.0-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ada214c6fa40f8d800e575de6b91a40d0548139e5dc457d2ebb61470abf50186"},
+    {file = "charset_normalizer-3.2.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a38856a971c602f98472050165cea2cdc97709240373041b69030be15047691f"},
-    {file = "charset_normalizer-3.3.0-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b1121de0e9d6e6ca08289583d7491e7fcb18a439305b34a30b20d8215922d43c"},
+    {file = "charset_normalizer-3.2.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f87f746ee241d30d6ed93969de31e5ffd09a2961a051e60ae6bddde9ec3583aa"},
-    {file = "charset_normalizer-3.3.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1063da2c85b95f2d1a430f1c33b55c9c17ffaf5e612e10aeaad641c55a9e2b9d"},
+    {file = "charset_normalizer-3.2.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:89f1b185a01fe560bc8ae5f619e924407efca2191b56ce749ec84982fc59a32a"},
-    {file = "charset_normalizer-3.3.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:70f1d09c0d7748b73290b29219e854b3207aea922f839437870d8cc2168e31cc"},
+    {file = "charset_normalizer-3.2.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e1c8a2f4c69e08e89632defbfabec2feb8a8d99edc9f89ce33c4b9e36ab63037"},
-    {file = "charset_normalizer-3.3.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:250c9eb0f4600361dd80d46112213dff2286231d92d3e52af1e5a6083d10cad9"},
+    {file = "charset_normalizer-3.2.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:2f4ac36d8e2b4cc1aa71df3dd84ff8efbe3bfb97ac41242fbcfc053c67434f46"},
-    {file = "charset_normalizer-3.3.0-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:750b446b2ffce1739e8578576092179160f6d26bd5e23eb1789c4d64d5af7dc7"},
+    {file = "charset_normalizer-3.2.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:a386ebe437176aab38c041de1260cd3ea459c6ce5263594399880bbc398225b2"},
-    {file = "charset_normalizer-3.3.0-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:fc52b79d83a3fe3a360902d3f5d79073a993597d48114c29485e9431092905d8"},
+    {file = "charset_normalizer-3.2.0-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:ccd16eb18a849fd8dcb23e23380e2f0a354e8daa0c984b8a732d9cfaba3a776d"},
-    {file = "charset_normalizer-3.3.0-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:588245972aca710b5b68802c8cad9edaa98589b1b42ad2b53accd6910dad3545"},
+    {file = "charset_normalizer-3.2.0-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:e6a5bf2cba5ae1bb80b154ed68a3cfa2fa00fde979a7f50d6598d3e17d9ac20c"},
-    {file = "charset_normalizer-3.3.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:e39c7eb31e3f5b1f88caff88bcff1b7f8334975b46f6ac6e9fc725d829bc35d4"},
+    {file = "charset_normalizer-3.2.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:45de3f87179c1823e6d9e32156fb14c1927fcc9aba21433f088fdfb555b77c10"},
-    {file = "charset_normalizer-3.3.0-cp37-cp37m-win32.whl", hash = "sha256:abecce40dfebbfa6abf8e324e1860092eeca6f7375c8c4e655a8afb61af58f2c"},
+    {file = "charset_normalizer-3.2.0-cp38-cp38-win32.whl", hash = "sha256:1000fba1057b92a65daec275aec30586c3de2401ccdcd41f8a5c1e2c87078706"},
-    {file = "charset_normalizer-3.3.0-cp37-cp37m-win_amd64.whl", hash = "sha256:24a91a981f185721542a0b7c92e9054b7ab4fea0508a795846bc5b0abf8118d4"},
+    {file = "charset_normalizer-3.2.0-cp38-cp38-win_amd64.whl", hash = "sha256:8b2c760cfc7042b27ebdb4a43a4453bd829a5742503599144d54a032c5dc7e9e"},
-    {file = "charset_normalizer-3.3.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:67b8cc9574bb518ec76dc8e705d4c39ae78bb96237cb533edac149352c1f39fe"},
+    {file = "charset_normalizer-3.2.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:855eafa5d5a2034b4621c74925d89c5efef61418570e5ef9b37717d9c796419c"},
-    {file = "charset_normalizer-3.3.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:ac71b2977fb90c35d41c9453116e283fac47bb9096ad917b8819ca8b943abecd"},
+    {file = "charset_normalizer-3.2.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:203f0c8871d5a7987be20c72442488a0b8cfd0f43b7973771640fc593f56321f"},
-    {file = "charset_normalizer-3.3.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:3ae38d325b512f63f8da31f826e6cb6c367336f95e418137286ba362925c877e"},
+    {file = "charset_normalizer-3.2.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:e857a2232ba53ae940d3456f7533ce6ca98b81917d47adc3c7fd55dad8fab858"},
-    {file = "charset_normalizer-3.3.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:542da1178c1c6af8873e143910e2269add130a299c9106eef2594e15dae5e482"},
+    {file = "charset_normalizer-3.2.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5e86d77b090dbddbe78867a0275cb4df08ea195e660f1f7f13435a4649e954e5"},
-    {file = "charset_normalizer-3.3.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:30a85aed0b864ac88309b7d94be09f6046c834ef60762a8833b660139cfbad13"},
+    {file = "charset_normalizer-3.2.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c4fb39a81950ec280984b3a44f5bd12819953dc5fa3a7e6fa7a80db5ee853952"},
-    {file = "charset_normalizer-3.3.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:aae32c93e0f64469f74ccc730a7cb21c7610af3a775157e50bbd38f816536b38"},
+    {file = "charset_normalizer-3.2.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2dee8e57f052ef5353cf608e0b4c871aee320dd1b87d351c28764fc0ca55f9f4"},
-    {file = "charset_normalizer-3.3.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15b26ddf78d57f1d143bdf32e820fd8935d36abe8a25eb9ec0b5a71c82eb3895"},
+    {file = "charset_normalizer-3.2.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8700f06d0ce6f128de3ccdbc1acaea1ee264d2caa9ca05daaf492fde7c2a7200"},
-    {file = "charset_normalizer-3.3.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7f5d10bae5d78e4551b7be7a9b29643a95aded9d0f602aa2ba584f0388e7a557"},
+    {file = "charset_normalizer-3.2.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1920d4ff15ce893210c1f0c0e9d19bfbecb7983c76b33f046c13a8ffbd570252"},
-    {file = "charset_normalizer-3.3.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:249c6470a2b60935bafd1d1d13cd613f8cd8388d53461c67397ee6a0f5dce741"},
+    {file = "charset_normalizer-3.2.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:c1c76a1743432b4b60ab3358c937a3fe1341c828ae6194108a94c69028247f22"},
-    {file = "charset_normalizer-3.3.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:c5a74c359b2d47d26cdbbc7845e9662d6b08a1e915eb015d044729e92e7050b7"},
+    {file = "charset_normalizer-3.2.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:f7560358a6811e52e9c4d142d497f1a6e10103d3a6881f18d04dbce3729c0e2c"},
-    {file = "charset_normalizer-3.3.0-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:b5bcf60a228acae568e9911f410f9d9e0d43197d030ae5799e20dca8df588287"},
+    {file = "charset_normalizer-3.2.0-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:c8063cf17b19661471ecbdb3df1c84f24ad2e389e326ccaf89e3fb2484d8dd7e"},
-    {file = "charset_normalizer-3.3.0-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:187d18082694a29005ba2944c882344b6748d5be69e3a89bf3cc9d878e548d5a"},
+    {file = "charset_normalizer-3.2.0-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:cd6dbe0238f7743d0efe563ab46294f54f9bc8f4b9bcf57c3c666cc5bc9d1299"},
-    {file = "charset_normalizer-3.3.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:81bf654678e575403736b85ba3a7867e31c2c30a69bc57fe88e3ace52fb17b89"},
+    {file = "charset_normalizer-3.2.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:1249cbbf3d3b04902ff081ffbb33ce3377fa6e4c7356f759f3cd076cc138d020"},
-    {file = "charset_normalizer-3.3.0-cp38-cp38-win32.whl", hash = "sha256:85a32721ddde63c9df9ebb0d2045b9691d9750cb139c161c80e500d210f5e26e"},
+    {file = "charset_normalizer-3.2.0-cp39-cp39-win32.whl", hash = "sha256:6c409c0deba34f147f77efaa67b8e4bb83d2f11c8806405f76397ae5b8c0d1c9"},
-    {file = "charset_normalizer-3.3.0-cp38-cp38-win_amd64.whl", hash = "sha256:468d2a840567b13a590e67dd276c570f8de00ed767ecc611994c301d0f8c014f"},
+    {file = "charset_normalizer-3.2.0-cp39-cp39-win_amd64.whl", hash = "sha256:7095f6fbfaa55defb6b733cfeb14efaae7a29f0b59d8cf213be4e7ca0b857b80"},
-    {file = "charset_normalizer-3.3.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:e0fc42822278451bc13a2e8626cf2218ba570f27856b536e00cfa53099724828"},
+    {file = "charset_normalizer-3.2.0-py3-none-any.whl", hash = "sha256:8e098148dd37b4ce3baca71fb394c81dc5d9c7728c95df695d2dca218edf40e6"},
-    {file = "charset_normalizer-3.3.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:09c77f964f351a7369cc343911e0df63e762e42bac24cd7d18525961c81754f4"},
-    {file = "charset_normalizer-3.3.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:12ebea541c44fdc88ccb794a13fe861cc5e35d64ed689513a5c03d05b53b7c82"},
-    {file = "charset_normalizer-3.3.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:805dfea4ca10411a5296bcc75638017215a93ffb584c9e344731eef0dcfb026a"},
-    {file = "charset_normalizer-3.3.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:96c2b49eb6a72c0e4991d62406e365d87067ca14c1a729a870d22354e6f68115"},
-    {file = "charset_normalizer-3.3.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:aaf7b34c5bc56b38c931a54f7952f1ff0ae77a2e82496583b247f7c969eb1479"},
-    {file = "charset_normalizer-3.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:619d1c96099be5823db34fe89e2582b336b5b074a7f47f819d6b3a57ff7bdb86"},
-    {file = "charset_normalizer-3.3.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a0ac5e7015a5920cfce654c06618ec40c33e12801711da6b4258af59a8eff00a"},
-    {file = "charset_normalizer-3.3.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:93aa7eef6ee71c629b51ef873991d6911b906d7312c6e8e99790c0f33c576f89"},
-    {file = "charset_normalizer-3.3.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:7966951325782121e67c81299a031f4c115615e68046f79b85856b86ebffc4cd"},
-    {file = "charset_normalizer-3.3.0-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:02673e456dc5ab13659f85196c534dc596d4ef260e4d86e856c3b2773ce09843"},
-    {file = "charset_normalizer-3.3.0-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:c2af80fb58f0f24b3f3adcb9148e6203fa67dd3f61c4af146ecad033024dde43"},
-    {file = "charset_normalizer-3.3.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:153e7b6e724761741e0974fc4dcd406d35ba70b92bfe3fedcb497226c93b9da7"},
-    {file = "charset_normalizer-3.3.0-cp39-cp39-win32.whl", hash = "sha256:d47ecf253780c90ee181d4d871cd655a789da937454045b17b5798da9393901a"},
-    {file = "charset_normalizer-3.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:d97d85fa63f315a8bdaba2af9a6a686e0eceab77b3089af45133252618e70884"},
-    {file = "charset_normalizer-3.3.0-py3-none-any.whl", hash = "sha256:e46cd37076971c1040fc8c41273a8b3e2c624ce4f2be3f5dfcb7a430c1d3acc2"},
 ]
 
 [[package]]
@@ -144,14 +107,14 @@ files = [
 ]
 
 [[package]]
-name = "distlib"
+name = "et-xmlfile"
-version = "0.3.8"
+version = "1.1.0"
-description = "Distribution utilities"
+description = "An implementation of lxml.xmlfile for the standard library"
 optional = false
-python-versions = "*"
+python-versions = ">=3.6"
 files = [
-    {file = "distlib-0.3.8-py2.py3-none-any.whl", hash = "sha256:034db59a0b96f8ca18035f36290806a9a6e6bd9d1ff91e45a7f172eb17e51784"},
+    {file = "et_xmlfile-1.1.0-py3-none-any.whl", hash = "sha256:a2ba85d1d6a74ef63837eed693bcb89c3f752169b0e3e7ae5b16ca5e1b3deada"},
-    {file = "distlib-0.3.8.tar.gz", hash = "sha256:1530ea13e350031b6312d8580ddb6b27a104275a31106523b8f123787f494f64"},
+    {file = "et_xmlfile-1.1.0.tar.gz", hash = "sha256:8eb9e2bc2f8c97e37a2dc85a09ecdcdec9d8a396530a6d5a33b30b9a92da0c5c"},
 ]
 
 [[package]]
@@ -168,36 +131,6 @@ files = [
 [package.extras]
 test = ["pytest (>=6)"]
 
-[[package]]
-name = "filelock"
-version = "3.13.4"
-description = "A platform independent file lock."
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "filelock-3.13.4-py3-none-any.whl", hash = "sha256:404e5e9253aa60ad457cae1be07c0f0ca90a63931200a47d9b6a6af84fd7b45f"},
-    {file = "filelock-3.13.4.tar.gz", hash = "sha256:d13f466618bfde72bd2c18255e269f72542c6e70e7bac83a0232d6b1cc5c8cf4"},
-]
-
-[package.extras]
-docs = ["furo (>=2023.9.10)", "sphinx (>=7.2.6)", "sphinx-autodoc-typehints (>=1.25.2)"]
-testing = ["covdefaults (>=2.3)", "coverage (>=7.3.2)", "diff-cover (>=8.0.1)", "pytest (>=7.4.3)", "pytest-cov (>=4.1)", "pytest-mock (>=3.12)", "pytest-timeout (>=2.2)"]
-typing = ["typing-extensions (>=4.8)"]
-
-[[package]]
-name = "identify"
-version = "2.5.35"
-description = "File identification library for Python"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "identify-2.5.35-py2.py3-none-any.whl", hash = "sha256:c4de0081837b211594f8e877a6b4fad7ca32bbfc1a9307fdd61c28bfe923f13e"},
-    {file = "identify-2.5.35.tar.gz", hash = "sha256:10a7ca245cfcd756a554a7288159f72ff105ad233c7c4b9c6f0f4d108f5f6791"},
-]
-
-[package.extras]
-license = ["ukkonen"]
-
 [[package]]
 name = "idna"
 version = "3.4"
@@ -221,19 +154,39 @@ files = [
 ]
 
 [[package]]
-name = "nodeenv"
+name = "numpy"
-version = "1.8.0"
+version = "1.25.2"
-description = "Node.js virtual environment builder"
+description = "Fundamental package for array computing in Python"
 optional = false
-python-versions = ">=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*"
+python-versions = ">=3.9"
 files = [
-    {file = "nodeenv-1.8.0-py2.py3-none-any.whl", hash = "sha256:df865724bb3c3adc86b3876fa209771517b0cfe596beff01a92700e0e8be4cec"},
+    {file = "numpy-1.25.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:db3ccc4e37a6873045580d413fe79b68e47a681af8db2e046f1dacfa11f86eb3"},
-    {file = "nodeenv-1.8.0.tar.gz", hash = "sha256:d51e0c37e64fbf47d017feac3145cdbb58836d7eee8c6f6d3b6880c5456227d2"},
+    {file = "numpy-1.25.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:90319e4f002795ccfc9050110bbbaa16c944b1c37c0baeea43c5fb881693ae1f"},
+    {file = "numpy-1.25.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dfe4a913e29b418d096e696ddd422d8a5d13ffba4ea91f9f60440a3b759b0187"},
+    {file = "numpy-1.25.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f08f2e037bba04e707eebf4bc934f1972a315c883a9e0ebfa8a7756eabf9e357"},
+    {file = "numpy-1.25.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:bec1e7213c7cb00d67093247f8c4db156fd03075f49876957dca4711306d39c9"},
+    {file = "numpy-1.25.2-cp310-cp310-win32.whl", hash = "sha256:7dc869c0c75988e1c693d0e2d5b26034644399dd929bc049db55395b1379e044"},
+    {file = "numpy-1.25.2-cp310-cp310-win_amd64.whl", hash = "sha256:834b386f2b8210dca38c71a6e0f4fd6922f7d3fcff935dbe3a570945acb1b545"},
+    {file = "numpy-1.25.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c5462d19336db4560041517dbb7759c21d181a67cb01b36ca109b2ae37d32418"},
+    {file = "numpy-1.25.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c5652ea24d33585ea39eb6a6a15dac87a1206a692719ff45d53c5282e66d4a8f"},
+    {file = "numpy-1.25.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0d60fbae8e0019865fc4784745814cff1c421df5afee233db6d88ab4f14655a2"},
+    {file = "numpy-1.25.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:60e7f0f7f6d0eee8364b9a6304c2845b9c491ac706048c7e8cf47b83123b8dbf"},
+    {file = "numpy-1.25.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:bb33d5a1cf360304754913a350edda36d5b8c5331a8237268c48f91253c3a364"},
+    {file = "numpy-1.25.2-cp311-cp311-win32.whl", hash = "sha256:5883c06bb92f2e6c8181df7b39971a5fb436288db58b5a1c3967702d4278691d"},
+    {file = "numpy-1.25.2-cp311-cp311-win_amd64.whl", hash = "sha256:5c97325a0ba6f9d041feb9390924614b60b99209a71a69c876f71052521d42a4"},
+    {file = "numpy-1.25.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b79e513d7aac42ae918db3ad1341a015488530d0bb2a6abcbdd10a3a829ccfd3"},
+    {file = "numpy-1.25.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:eb942bfb6f84df5ce05dbf4b46673ffed0d3da59f13635ea9b926af3deb76926"},
+    {file = "numpy-1.25.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e0746410e73384e70d286f93abf2520035250aad8c5714240b0492a7302fdca"},
+    {file = "numpy-1.25.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d7806500e4f5bdd04095e849265e55de20d8cc4b661b038957354327f6d9b295"},
+    {file = "numpy-1.25.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:8b77775f4b7df768967a7c8b3567e309f617dd5e99aeb886fa14dc1a0791141f"},
+    {file = "numpy-1.25.2-cp39-cp39-win32.whl", hash = "sha256:2792d23d62ec51e50ce4d4b7d73de8f67a2fd3ea710dcbc8563a51a03fb07b01"},
+    {file = "numpy-1.25.2-cp39-cp39-win_amd64.whl", hash = "sha256:76b4115d42a7dfc5d485d358728cdd8719be33cc5ec6ec08632a5d6fca2ed380"},
+    {file = "numpy-1.25.2-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:1a1329e26f46230bf77b02cc19e900db9b52f398d6722ca853349a782d4cff55"},
+    {file = "numpy-1.25.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4c3abc71e8b6edba80a01a52e66d83c5d14433cbcd26a40c329ec7ed09f37901"},
+    {file = "numpy-1.25.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:1b9735c27cea5d995496f46a8b1cd7b408b3f34b6d50459d9ac8fe3a20cc17bf"},
+    {file = "numpy-1.25.2.tar.gz", hash = "sha256:fd608e19c8d7c55021dffd43bfe5492fab8cc105cc8986f813f8c3c048b38760"},
 ]
 
-[package.dependencies]
-setuptools = "*"
-
 [[package]]
 name = "numpy"
 version = "1.26.0"
@@ -275,56 +228,63 @@ files = [
     {file = "numpy-1.26.0.tar.gz", hash = "sha256:f93fc78fe8bf15afe2b8d6b6499f1c73953169fad1e9a8dd086cdff3190e7fdf"},
 ]
 
+[[package]]
+name = "openpyxl"
+version = "3.1.2"
+description = "A Python library to read/write Excel 2010 xlsx/xlsm files"
+optional = false
+python-versions = ">=3.6"
+files = [
+    {file = "openpyxl-3.1.2-py2.py3-none-any.whl", hash = "sha256:f91456ead12ab3c6c2e9491cf33ba6d08357d802192379bb482f1033ade496f5"},
+    {file = "openpyxl-3.1.2.tar.gz", hash = "sha256:a6f5977418eff3b2d5500d54d9db50c8277a368436f4e4f8ddb1be3422870184"},
+]
+
+[package.dependencies]
+et-xmlfile = "*"
+
 [[package]]
 name = "packaging"
-version = "23.2"
+version = "23.1"
 description = "Core utilities for Python packages"
 optional = false
 python-versions = ">=3.7"
 files = [
-    {file = "packaging-23.2-py3-none-any.whl", hash = "sha256:8c491190033a9af7e1d931d0b5dacc2ef47509b34dd0de67ed209b5203fc88c7"},
+    {file = "packaging-23.1-py3-none-any.whl", hash = "sha256:994793af429502c4ea2ebf6bf664629d07c1a9fe974af92966e4b8d2df7edc61"},
-    {file = "packaging-23.2.tar.gz", hash = "sha256:048fb0e9405036518eaaf48a55953c750c11e1a1b68e0dd1a9d62ed0c092cfc5"},
+    {file = "packaging-23.1.tar.gz", hash = "sha256:a392980d2b6cffa644431898be54b0045151319d1e7ec34f0cfed48767dd334f"},
 ]
 
 [[package]]
 name = "pandas"
-version = "2.1.1"
+version = "2.1.0"
 description = "Powerful data structures for data analysis, time series, and statistics"
 optional = false
 python-versions = ">=3.9"
 files = [
-    {file = "pandas-2.1.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:58d997dbee0d4b64f3cb881a24f918b5f25dd64ddf31f467bb9b67ae4c63a1e4"},
+    {file = "pandas-2.1.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:40dd20439ff94f1b2ed55b393ecee9cb6f3b08104c2c40b0cb7186a2f0046242"},
-    {file = "pandas-2.1.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02304e11582c5d090e5a52aec726f31fe3f42895d6bfc1f28738f9b64b6f0614"},
+    {file = "pandas-2.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d4f38e4fedeba580285eaac7ede4f686c6701a9e618d8a857b138a126d067f2f"},
-    {file = "pandas-2.1.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ffa8f0966de2c22de408d0e322db2faed6f6e74265aa0856f3824813cf124363"},
+    {file = "pandas-2.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6e6a0fe052cf27ceb29be9429428b4918f3740e37ff185658f40d8702f0b3e09"},
-    {file = "pandas-2.1.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c1f84c144dee086fe4f04a472b5cd51e680f061adf75c1ae4fc3a9275560f8f4"},
+    {file = "pandas-2.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9d81e1813191070440d4c7a413cb673052b3b4a984ffd86b8dd468c45742d3cc"},
-    {file = "pandas-2.1.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:75ce97667d06d69396d72be074f0556698c7f662029322027c226fd7a26965cb"},
+    {file = "pandas-2.1.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:eb20252720b1cc1b7d0b2879ffc7e0542dd568f24d7c4b2347cb035206936421"},
-    {file = "pandas-2.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:4c3f32fd7c4dccd035f71734df39231ac1a6ff95e8bdab8d891167197b7018d2"},
+    {file = "pandas-2.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:38f74ef7ebc0ffb43b3d633e23d74882bce7e27bfa09607f3c5d3e03ffd9a4a5"},
-    {file = "pandas-2.1.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9e2959720b70e106bb1d8b6eadd8ecd7c8e99ccdbe03ee03260877184bb2877d"},
+    {file = "pandas-2.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cda72cc8c4761c8f1d97b169661f23a86b16fdb240bdc341173aee17e4d6cedd"},
-    {file = "pandas-2.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:25e8474a8eb258e391e30c288eecec565bfed3e026f312b0cbd709a63906b6f8"},
+    {file = "pandas-2.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d97daeac0db8c993420b10da4f5f5b39b01fc9ca689a17844e07c0a35ac96b4b"},
-    {file = "pandas-2.1.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b8bd1685556f3374520466998929bade3076aeae77c3e67ada5ed2b90b4de7f0"},
+    {file = "pandas-2.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8c58b1113892e0c8078f006a167cc210a92bdae23322bb4614f2f0b7a4b510f"},
-    {file = "pandas-2.1.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dc3657869c7902810f32bd072f0740487f9e030c1a3ab03e0af093db35a9d14e"},
+    {file = "pandas-2.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:629124923bcf798965b054a540f9ccdfd60f71361255c81fa1ecd94a904b9dd3"},
-    {file = "pandas-2.1.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:05674536bd477af36aa2effd4ec8f71b92234ce0cc174de34fd21e2ee99adbc2"},
+    {file = "pandas-2.1.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:70cf866af3ab346a10debba8ea78077cf3a8cd14bd5e4bed3d41555a3280041c"},
-    {file = "pandas-2.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:b407381258a667df49d58a1b637be33e514b07f9285feb27769cedb3ab3d0b3a"},
+    {file = "pandas-2.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:d53c8c1001f6a192ff1de1efe03b31a423d0eee2e9e855e69d004308e046e694"},
-    {file = "pandas-2.1.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c747793c4e9dcece7bb20156179529898abf505fe32cb40c4052107a3c620b49"},
+    {file = "pandas-2.1.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:86f100b3876b8c6d1a2c66207288ead435dc71041ee4aea789e55ef0e06408cb"},
-    {file = "pandas-2.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3bcad1e6fb34b727b016775bea407311f7721db87e5b409e6542f4546a4951ea"},
+    {file = "pandas-2.1.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:28f330845ad21c11db51e02d8d69acc9035edfd1116926ff7245c7215db57957"},
-    {file = "pandas-2.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f5ec7740f9ccb90aec64edd71434711f58ee0ea7f5ed4ac48be11cfa9abf7317"},
+    {file = "pandas-2.1.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b9a6ccf0963db88f9b12df6720e55f337447aea217f426a22d71f4213a3099a6"},
-    {file = "pandas-2.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:29deb61de5a8a93bdd033df328441a79fcf8dd3c12d5ed0b41a395eef9cd76f0"},
+    {file = "pandas-2.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d99e678180bc59b0c9443314297bddce4ad35727a1a2656dbe585fd78710b3b9"},
-    {file = "pandas-2.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4f99bebf19b7e03cf80a4e770a3e65eee9dd4e2679039f542d7c1ace7b7b1daa"},
+    {file = "pandas-2.1.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:b31da36d376d50a1a492efb18097b9101bdbd8b3fbb3f49006e02d4495d4c644"},
-    {file = "pandas-2.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:84e7e910096416adec68075dc87b986ff202920fb8704e6d9c8c9897fe7332d6"},
+    {file = "pandas-2.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:0164b85937707ec7f70b34a6c3a578dbf0f50787f910f21ca3b26a7fd3363437"},
-    {file = "pandas-2.1.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:366da7b0e540d1b908886d4feb3d951f2f1e572e655c1160f5fde28ad4abb750"},
+    {file = "pandas-2.1.0.tar.gz", hash = "sha256:62c24c7fc59e42b775ce0679cfa7b14a5f9bfb7643cfbe708c960699e05fb918"},
-    {file = "pandas-2.1.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:9e50e72b667415a816ac27dfcfe686dc5a0b02202e06196b943d54c4f9c7693e"},
-    {file = "pandas-2.1.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cc1ab6a25da197f03ebe6d8fa17273126120874386b4ac11c1d687df288542dd"},
-    {file = "pandas-2.1.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a0dbfea0dd3901ad4ce2306575c54348d98499c95be01b8d885a2737fe4d7a98"},
-    {file = "pandas-2.1.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:0489b0e6aa3d907e909aef92975edae89b1ee1654db5eafb9be633b0124abe97"},
-    {file = "pandas-2.1.1-cp39-cp39-win_amd64.whl", hash = "sha256:4cdb0fab0400c2cb46dafcf1a0fe084c8bb2480a1fa8d81e19d15e12e6d4ded2"},
-    {file = "pandas-2.1.1.tar.gz", hash = "sha256:fecb198dc389429be557cde50a2d46da8434a17fe37d7d41ff102e3987fd947b"},
 ]
 
 [package.dependencies]
 numpy = [
     {version = ">=1.22.4", markers = "python_version < \"3.11\""},
-    {version = ">=1.23.2", markers = "python_version == \"3.11\""},
+    {version = ">=1.23.2", markers = "python_version >= \"3.11\""},
-    {version = ">=1.26.0", markers = "python_version >= \"3.12\""},
 ]
 python-dateutil = ">=2.8.2"
 pytz = ">=2020.1"
@@ -354,21 +314,6 @@ sql-other = ["SQLAlchemy (>=1.4.36)"]
 test = ["hypothesis (>=6.46.1)", "pytest (>=7.3.2)", "pytest-asyncio (>=0.17.0)", "pytest-xdist (>=2.2.0)"]
 xml = ["lxml (>=4.8.0)"]
 
-[[package]]
-name = "platformdirs"
-version = "4.2.0"
-description = "A small Python package for determining appropriate platform-specific dirs, e.g. a \"user data dir\"."
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "platformdirs-4.2.0-py3-none-any.whl", hash = "sha256:0614df2a2f37e1a662acbd8e2b25b92ccf8632929bc6d43467e17fe89c75e068"},
-    {file = "platformdirs-4.2.0.tar.gz", hash = "sha256:ef0cc731df711022c174543cb70a9b5bd22e5a9337c8624ef2c2ceb8ddad8768"},
-]
-
-[package.extras]
-docs = ["furo (>=2023.9.10)", "proselint (>=0.13)", "sphinx (>=7.2.6)", "sphinx-autodoc-typehints (>=1.25.2)"]
-test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=7.4.3)", "pytest-cov (>=4.1)", "pytest-mock (>=3.12)"]
-
 [[package]]
 name = "pluggy"
 version = "1.3.0"
@@ -384,134 +329,6 @@ files = [
 dev = ["pre-commit", "tox"]
 testing = ["pytest", "pytest-benchmark"]
 
-[[package]]
-name = "pre-commit"
-version = "3.7.0"
-description = "A framework for managing and maintaining multi-language pre-commit hooks."
-optional = false
-python-versions = ">=3.9"
-files = [
-    {file = "pre_commit-3.7.0-py2.py3-none-any.whl", hash = "sha256:5eae9e10c2b5ac51577c3452ec0a490455c45a0533f7960f993a0d01e59decab"},
-    {file = "pre_commit-3.7.0.tar.gz", hash = "sha256:e209d61b8acdcf742404408531f0c37d49d2c734fd7cff2d6076083d191cb060"},
-]
-
-[package.dependencies]
-cfgv = ">=2.0.0"
-identify = ">=1.0.0"
-nodeenv = ">=0.11.1"
-pyyaml = ">=5.1"
-virtualenv = ">=20.10.0"
-
-[[package]]
-name = "pydantic"
-version = "2.7.4"
-description = "Data validation using Python type hints"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "pydantic-2.7.4-py3-none-any.whl", hash = "sha256:ee8538d41ccb9c0a9ad3e0e5f07bf15ed8015b481ced539a1759d8cc89ae90d0"},
-    {file = "pydantic-2.7.4.tar.gz", hash = "sha256:0c84efd9548d545f63ac0060c1e4d39bb9b14db8b3c0652338aecc07b5adec52"},
-]
-
-[package.dependencies]
-annotated-types = ">=0.4.0"
-pydantic-core = "2.18.4"
-typing-extensions = ">=4.6.1"
-
-[package.extras]
-email = ["email-validator (>=2.0.0)"]
-
-[[package]]
-name = "pydantic-core"
-version = "2.18.4"
-description = "Core functionality for Pydantic validation and serialization"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "pydantic_core-2.18.4-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:f76d0ad001edd426b92233d45c746fd08f467d56100fd8f30e9ace4b005266e4"},
-    {file = "pydantic_core-2.18.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:59ff3e89f4eaf14050c8022011862df275b552caef8082e37b542b066ce1ff26"},
-    {file = "pydantic_core-2.18.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a55b5b16c839df1070bc113c1f7f94a0af4433fcfa1b41799ce7606e5c79ce0a"},
-    {file = "pydantic_core-2.18.4-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4d0dcc59664fcb8974b356fe0a18a672d6d7cf9f54746c05f43275fc48636851"},
-    {file = "pydantic_core-2.18.4-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8951eee36c57cd128f779e641e21eb40bc5073eb28b2d23f33eb0ef14ffb3f5d"},
-    {file = "pydantic_core-2.18.4-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4701b19f7e3a06ea655513f7938de6f108123bf7c86bbebb1196eb9bd35cf724"},
-    {file = "pydantic_core-2.18.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e00a3f196329e08e43d99b79b286d60ce46bed10f2280d25a1718399457e06be"},
-    {file = "pydantic_core-2.18.4-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:97736815b9cc893b2b7f663628e63f436018b75f44854c8027040e05230eeddb"},
-    {file = "pydantic_core-2.18.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:6891a2ae0e8692679c07728819b6e2b822fb30ca7445f67bbf6509b25a96332c"},
-    {file = "pydantic_core-2.18.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:bc4ff9805858bd54d1a20efff925ccd89c9d2e7cf4986144b30802bf78091c3e"},
-    {file = "pydantic_core-2.18.4-cp310-none-win32.whl", hash = "sha256:1b4de2e51bbcb61fdebd0ab86ef28062704f62c82bbf4addc4e37fa4b00b7cbc"},
-    {file = "pydantic_core-2.18.4-cp310-none-win_amd64.whl", hash = "sha256:6a750aec7bf431517a9fd78cb93c97b9b0c496090fee84a47a0d23668976b4b0"},
-    {file = "pydantic_core-2.18.4-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:942ba11e7dfb66dc70f9ae66b33452f51ac7bb90676da39a7345e99ffb55402d"},
-    {file = "pydantic_core-2.18.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b2ebef0e0b4454320274f5e83a41844c63438fdc874ea40a8b5b4ecb7693f1c4"},
-    {file = "pydantic_core-2.18.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a642295cd0c8df1b86fc3dced1d067874c353a188dc8e0f744626d49e9aa51c4"},
-    {file = "pydantic_core-2.18.4-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5f09baa656c904807e832cf9cce799c6460c450c4ad80803517032da0cd062e2"},
-    {file = "pydantic_core-2.18.4-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:98906207f29bc2c459ff64fa007afd10a8c8ac080f7e4d5beff4c97086a3dabd"},
-    {file = "pydantic_core-2.18.4-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:19894b95aacfa98e7cb093cd7881a0c76f55731efad31073db4521e2b6ff5b7d"},
-    {file = "pydantic_core-2.18.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0fbbdc827fe5e42e4d196c746b890b3d72876bdbf160b0eafe9f0334525119c8"},
-    {file = "pydantic_core-2.18.4-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f85d05aa0918283cf29a30b547b4df2fbb56b45b135f9e35b6807cb28bc47951"},
-    {file = "pydantic_core-2.18.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:e85637bc8fe81ddb73fda9e56bab24560bdddfa98aa64f87aaa4e4b6730c23d2"},
-    {file = "pydantic_core-2.18.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:2f5966897e5461f818e136b8451d0551a2e77259eb0f73a837027b47dc95dab9"},
-    {file = "pydantic_core-2.18.4-cp311-none-win32.whl", hash = "sha256:44c7486a4228413c317952e9d89598bcdfb06399735e49e0f8df643e1ccd0558"},
-    {file = "pydantic_core-2.18.4-cp311-none-win_amd64.whl", hash = "sha256:8a7164fe2005d03c64fd3b85649891cd4953a8de53107940bf272500ba8a788b"},
-    {file = "pydantic_core-2.18.4-cp311-none-win_arm64.whl", hash = "sha256:4e99bc050fe65c450344421017f98298a97cefc18c53bb2f7b3531eb39bc7805"},
-    {file = "pydantic_core-2.18.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:6f5c4d41b2771c730ea1c34e458e781b18cc668d194958e0112455fff4e402b2"},
-    {file = "pydantic_core-2.18.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2fdf2156aa3d017fddf8aea5adfba9f777db1d6022d392b682d2a8329e087cef"},
-    {file = "pydantic_core-2.18.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4748321b5078216070b151d5271ef3e7cc905ab170bbfd27d5c83ee3ec436695"},
-    {file = "pydantic_core-2.18.4-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:847a35c4d58721c5dc3dba599878ebbdfd96784f3fb8bb2c356e123bdcd73f34"},
-    {file = "pydantic_core-2.18.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3c40d4eaad41f78e3bbda31b89edc46a3f3dc6e171bf0ecf097ff7a0ffff7cb1"},
-    {file = "pydantic_core-2.18.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:21a5e440dbe315ab9825fcd459b8814bb92b27c974cbc23c3e8baa2b76890077"},
-    {file = "pydantic_core-2.18.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:01dd777215e2aa86dfd664daed5957704b769e726626393438f9c87690ce78c3"},
-    {file = "pydantic_core-2.18.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4b06beb3b3f1479d32befd1f3079cc47b34fa2da62457cdf6c963393340b56e9"},
-    {file = "pydantic_core-2.18.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:564d7922e4b13a16b98772441879fcdcbe82ff50daa622d681dd682175ea918c"},
-    {file = "pydantic_core-2.18.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:0eb2a4f660fcd8e2b1c90ad566db2b98d7f3f4717c64fe0a83e0adb39766d5b8"},
-    {file = "pydantic_core-2.18.4-cp312-none-win32.whl", hash = "sha256:8b8bab4c97248095ae0c4455b5a1cd1cdd96e4e4769306ab19dda135ea4cdb07"},
-    {file = "pydantic_core-2.18.4-cp312-none-win_amd64.whl", hash = "sha256:14601cdb733d741b8958224030e2bfe21a4a881fb3dd6fbb21f071cabd48fa0a"},
-    {file = "pydantic_core-2.18.4-cp312-none-win_arm64.whl", hash = "sha256:c1322d7dd74713dcc157a2b7898a564ab091ca6c58302d5c7b4c07296e3fd00f"},
-    {file = "pydantic_core-2.18.4-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:823be1deb01793da05ecb0484d6c9e20baebb39bd42b5d72636ae9cf8350dbd2"},
-    {file = "pydantic_core-2.18.4-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:ebef0dd9bf9b812bf75bda96743f2a6c5734a02092ae7f721c048d156d5fabae"},
-    {file = "pydantic_core-2.18.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ae1d6df168efb88d7d522664693607b80b4080be6750c913eefb77e34c12c71a"},
-    {file = "pydantic_core-2.18.4-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f9899c94762343f2cc2fc64c13e7cae4c3cc65cdfc87dd810a31654c9b7358cc"},
-    {file = "pydantic_core-2.18.4-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:99457f184ad90235cfe8461c4d70ab7dd2680e28821c29eca00252ba90308c78"},
-    {file = "pydantic_core-2.18.4-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:18f469a3d2a2fdafe99296a87e8a4c37748b5080a26b806a707f25a902c040a8"},
-    {file = "pydantic_core-2.18.4-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b7cdf28938ac6b8b49ae5e92f2735056a7ba99c9b110a474473fd71185c1af5d"},
-    {file = "pydantic_core-2.18.4-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:938cb21650855054dc54dfd9120a851c974f95450f00683399006aa6e8abb057"},
-    {file = "pydantic_core-2.18.4-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:44cd83ab6a51da80fb5adbd9560e26018e2ac7826f9626bc06ca3dc074cd198b"},
-    {file = "pydantic_core-2.18.4-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:972658f4a72d02b8abfa2581d92d59f59897d2e9f7e708fdabe922f9087773af"},
-    {file = "pydantic_core-2.18.4-cp38-none-win32.whl", hash = "sha256:1d886dc848e60cb7666f771e406acae54ab279b9f1e4143babc9c2258213daa2"},
-    {file = "pydantic_core-2.18.4-cp38-none-win_amd64.whl", hash = "sha256:bb4462bd43c2460774914b8525f79b00f8f407c945d50881568f294c1d9b4443"},
-    {file = "pydantic_core-2.18.4-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:44a688331d4a4e2129140a8118479443bd6f1905231138971372fcde37e43528"},
-    {file = "pydantic_core-2.18.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a2fdd81edd64342c85ac7cf2753ccae0b79bf2dfa063785503cb85a7d3593223"},
-    {file = "pydantic_core-2.18.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:86110d7e1907ab36691f80b33eb2da87d780f4739ae773e5fc83fb272f88825f"},
-    {file = "pydantic_core-2.18.4-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:46387e38bd641b3ee5ce247563b60c5ca098da9c56c75c157a05eaa0933ed154"},
-    {file = "pydantic_core-2.18.4-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:123c3cec203e3f5ac7b000bd82235f1a3eced8665b63d18be751f115588fea30"},
-    {file = "pydantic_core-2.18.4-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dc1803ac5c32ec324c5261c7209e8f8ce88e83254c4e1aebdc8b0a39f9ddb443"},
-    {file = "pydantic_core-2.18.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:53db086f9f6ab2b4061958d9c276d1dbe3690e8dd727d6abf2321d6cce37fa94"},
-    {file = "pydantic_core-2.18.4-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:abc267fa9837245cc28ea6929f19fa335f3dc330a35d2e45509b6566dc18be23"},
-    {file = "pydantic_core-2.18.4-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:a0d829524aaefdebccb869eed855e2d04c21d2d7479b6cada7ace5448416597b"},
-    {file = "pydantic_core-2.18.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:509daade3b8649f80d4e5ff21aa5673e4ebe58590b25fe42fac5f0f52c6f034a"},
-    {file = "pydantic_core-2.18.4-cp39-none-win32.whl", hash = "sha256:ca26a1e73c48cfc54c4a76ff78df3727b9d9f4ccc8dbee4ae3f73306a591676d"},
-    {file = "pydantic_core-2.18.4-cp39-none-win_amd64.whl", hash = "sha256:c67598100338d5d985db1b3d21f3619ef392e185e71b8d52bceacc4a7771ea7e"},
-    {file = "pydantic_core-2.18.4-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:574d92eac874f7f4db0ca653514d823a0d22e2354359d0759e3f6a406db5d55d"},
-    {file = "pydantic_core-2.18.4-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:1f4d26ceb5eb9eed4af91bebeae4b06c3fb28966ca3a8fb765208cf6b51102ab"},
-    {file = "pydantic_core-2.18.4-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:77450e6d20016ec41f43ca4a6c63e9fdde03f0ae3fe90e7c27bdbeaece8b1ed4"},
-    {file = "pydantic_core-2.18.4-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d323a01da91851a4f17bf592faf46149c9169d68430b3146dcba2bb5e5719abc"},
-    {file = "pydantic_core-2.18.4-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:43d447dd2ae072a0065389092a231283f62d960030ecd27565672bd40746c507"},
-    {file = "pydantic_core-2.18.4-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:578e24f761f3b425834f297b9935e1ce2e30f51400964ce4801002435a1b41ef"},
-    {file = "pydantic_core-2.18.4-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:81b5efb2f126454586d0f40c4d834010979cb80785173d1586df845a632e4e6d"},
-    {file = "pydantic_core-2.18.4-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:ab86ce7c8f9bea87b9d12c7f0af71102acbf5ecbc66c17796cff45dae54ef9a5"},
-    {file = "pydantic_core-2.18.4-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:90afc12421df2b1b4dcc975f814e21bc1754640d502a2fbcc6d41e77af5ec312"},
-    {file = "pydantic_core-2.18.4-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:51991a89639a912c17bef4b45c87bd83593aee0437d8102556af4885811d59f5"},
-    {file = "pydantic_core-2.18.4-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:293afe532740370aba8c060882f7d26cfd00c94cae32fd2e212a3a6e3b7bc15e"},
-    {file = "pydantic_core-2.18.4-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b48ece5bde2e768197a2d0f6e925f9d7e3e826f0ad2271120f8144a9db18d5c8"},
-    {file = "pydantic_core-2.18.4-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:eae237477a873ab46e8dd748e515c72c0c804fb380fbe6c85533c7de51f23a8f"},
-    {file = "pydantic_core-2.18.4-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:834b5230b5dfc0c1ec37b2fda433b271cbbc0e507560b5d1588e2cc1148cf1ce"},
-    {file = "pydantic_core-2.18.4-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:e858ac0a25074ba4bce653f9b5d0a85b7456eaddadc0ce82d3878c22489fa4ee"},
-    {file = "pydantic_core-2.18.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:2fd41f6eff4c20778d717af1cc50eca52f5afe7805ee530a4fbd0bae284f16e9"},
-    {file = "pydantic_core-2.18.4.tar.gz", hash = "sha256:ec3beeada09ff865c344ff3bc2f427f5e6c26401cc6113d77e372c3fdac73864"},
-]
-
-[package.dependencies]
-typing-extensions = ">=4.6.0,<4.7.0 || >4.7.0"
-
 [[package]]
 name = "pytest"
 version = "7.4.2"
@@ -559,66 +376,6 @@ files = [
     {file = "pytz-2023.3.post1.tar.gz", hash = "sha256:7b4fddbeb94a1eba4b557da24f19fdf9db575192544270a9101d8509f9f43d7b"},
 ]
 
-[[package]]
-name = "pyyaml"
-version = "6.0.1"
-description = "YAML parser and emitter for Python"
-optional = false
-python-versions = ">=3.6"
-files = [
-    {file = "PyYAML-6.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d858aa552c999bc8a8d57426ed01e40bef403cd8ccdd0fc5f6f04a00414cac2a"},
-    {file = "PyYAML-6.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fd66fc5d0da6d9815ba2cebeb4205f95818ff4b79c3ebe268e75d961704af52f"},
-    {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:69b023b2b4daa7548bcfbd4aa3da05b3a74b772db9e23b982788168117739938"},
-    {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:81e0b275a9ecc9c0c0c07b4b90ba548307583c125f54d5b6946cfee6360c733d"},
-    {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba336e390cd8e4d1739f42dfe9bb83a3cc2e80f567d8805e11b46f4a943f5515"},
-    {file = "PyYAML-6.0.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:326c013efe8048858a6d312ddd31d56e468118ad4cdeda36c719bf5bb6192290"},
-    {file = "PyYAML-6.0.1-cp310-cp310-win32.whl", hash = "sha256:bd4af7373a854424dabd882decdc5579653d7868b8fb26dc7d0e99f823aa5924"},
-    {file = "PyYAML-6.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:fd1592b3fdf65fff2ad0004b5e363300ef59ced41c2e6b3a99d4089fa8c5435d"},
-    {file = "PyYAML-6.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6965a7bc3cf88e5a1c3bd2e0b5c22f8d677dc88a455344035f03399034eb3007"},
-    {file = "PyYAML-6.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f003ed9ad21d6a4713f0a9b5a7a0a79e08dd0f221aff4525a2be4c346ee60aab"},
-    {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:42f8152b8dbc4fe7d96729ec2b99c7097d656dc1213a3229ca5383f973a5ed6d"},
-    {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:062582fca9fabdd2c8b54a3ef1c978d786e0f6b3a1510e0ac93ef59e0ddae2bc"},
-    {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d2b04aac4d386b172d5b9692e2d2da8de7bfb6c387fa4f801fbf6fb2e6ba4673"},
-    {file = "PyYAML-6.0.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e7d73685e87afe9f3b36c799222440d6cf362062f78be1013661b00c5c6f678b"},
-    {file = "PyYAML-6.0.1-cp311-cp311-win32.whl", hash = "sha256:1635fd110e8d85d55237ab316b5b011de701ea0f29d07611174a1b42f1444741"},
-    {file = "PyYAML-6.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:bf07ee2fef7014951eeb99f56f39c9bb4af143d8aa3c21b1677805985307da34"},
-    {file = "PyYAML-6.0.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:855fb52b0dc35af121542a76b9a84f8d1cd886ea97c84703eaa6d88e37a2ad28"},
-    {file = "PyYAML-6.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40df9b996c2b73138957fe23a16a4f0ba614f4c0efce1e9406a184b6d07fa3a9"},
-    {file = "PyYAML-6.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a08c6f0fe150303c1c6b71ebcd7213c2858041a7e01975da3a99aed1e7a378ef"},
-    {file = "PyYAML-6.0.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c22bec3fbe2524cde73d7ada88f6566758a8f7227bfbf93a408a9d86bcc12a0"},
-    {file = "PyYAML-6.0.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8d4e9c88387b0f5c7d5f281e55304de64cf7f9c0021a3525bd3b1c542da3b0e4"},
-    {file = "PyYAML-6.0.1-cp312-cp312-win32.whl", hash = "sha256:d483d2cdf104e7c9fa60c544d92981f12ad66a457afae824d146093b8c294c54"},
-    {file = "PyYAML-6.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:0d3304d8c0adc42be59c5f8a4d9e3d7379e6955ad754aa9d6ab7a398b59dd1df"},
-    {file = "PyYAML-6.0.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:50550eb667afee136e9a77d6dc71ae76a44df8b3e51e41b77f6de2932bfe0f47"},
-    {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1fe35611261b29bd1de0070f0b2f47cb6ff71fa6595c077e42bd0c419fa27b98"},
-    {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:704219a11b772aea0d8ecd7058d0082713c3562b4e271b849ad7dc4a5c90c13c"},
-    {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:afd7e57eddb1a54f0f1a974bc4391af8bcce0b444685d936840f125cf046d5bd"},
-    {file = "PyYAML-6.0.1-cp36-cp36m-win32.whl", hash = "sha256:fca0e3a251908a499833aa292323f32437106001d436eca0e6e7833256674585"},
-    {file = "PyYAML-6.0.1-cp36-cp36m-win_amd64.whl", hash = "sha256:f22ac1c3cac4dbc50079e965eba2c1058622631e526bd9afd45fedd49ba781fa"},
-    {file = "PyYAML-6.0.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:b1275ad35a5d18c62a7220633c913e1b42d44b46ee12554e5fd39c70a243d6a3"},
-    {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:18aeb1bf9a78867dc38b259769503436b7c72f7a1f1f4c93ff9a17de54319b27"},
-    {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:596106435fa6ad000c2991a98fa58eeb8656ef2325d7e158344fb33864ed87e3"},
-    {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:baa90d3f661d43131ca170712d903e6295d1f7a0f595074f151c0aed377c9b9c"},
-    {file = "PyYAML-6.0.1-cp37-cp37m-win32.whl", hash = "sha256:9046c58c4395dff28dd494285c82ba00b546adfc7ef001486fbf0324bc174fba"},
-    {file = "PyYAML-6.0.1-cp37-cp37m-win_amd64.whl", hash = "sha256:4fb147e7a67ef577a588a0e2c17b6db51dda102c71de36f8549b6816a96e1867"},
-    {file = "PyYAML-6.0.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1d4c7e777c441b20e32f52bd377e0c409713e8bb1386e1099c2415f26e479595"},
-    {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a0cd17c15d3bb3fa06978b4e8958dcdc6e0174ccea823003a106c7d4d7899ac5"},
-    {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:28c119d996beec18c05208a8bd78cbe4007878c6dd15091efb73a30e90539696"},
-    {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7e07cbde391ba96ab58e532ff4803f79c4129397514e1413a7dc761ccd755735"},
-    {file = "PyYAML-6.0.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:49a183be227561de579b4a36efbb21b3eab9651dd81b1858589f796549873dd6"},
-    {file = "PyYAML-6.0.1-cp38-cp38-win32.whl", hash = "sha256:184c5108a2aca3c5b3d3bf9395d50893a7ab82a38004c8f61c258d4428e80206"},
-    {file = "PyYAML-6.0.1-cp38-cp38-win_amd64.whl", hash = "sha256:1e2722cc9fbb45d9b87631ac70924c11d3a401b2d7f410cc0e3bbf249f2dca62"},
-    {file = "PyYAML-6.0.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9eb6caa9a297fc2c2fb8862bc5370d0303ddba53ba97e71f08023b6cd73d16a8"},
-    {file = "PyYAML-6.0.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c8098ddcc2a85b61647b2590f825f3db38891662cfc2fc776415143f599bb859"},
-    {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5773183b6446b2c99bb77e77595dd486303b4faab2b086e7b17bc6bef28865f6"},
-    {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b786eecbdf8499b9ca1d697215862083bd6d2a99965554781d0d8d1ad31e13a0"},
-    {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc1bf2925a1ecd43da378f4db9e4f799775d6367bdb94671027b73b393a7c42c"},
-    {file = "PyYAML-6.0.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:04ac92ad1925b2cff1db0cfebffb6ffc43457495c9b3c39d3fcae417d7125dc5"},
-    {file = "PyYAML-6.0.1-cp39-cp39-win32.whl", hash = "sha256:faca3bdcf85b2fc05d06ff3fbc1f83e1391b3e724afa3feba7d13eeab355484c"},
-    {file = "PyYAML-6.0.1-cp39-cp39-win_amd64.whl", hash = "sha256:510c9deebc5c0225e8c96813043e62b680ba2f9c50a08d3724c7f28a747d1486"},
-    {file = "PyYAML-6.0.1.tar.gz", hash = "sha256:bfdf460b1736c775f2ba9f6a92bca30bc2095067b8a9d77876d1fad6cc3b4a43"},
-]
-
 [[package]]
 name = "requests"
 version = "2.31.0"
@@ -640,22 +397,6 @@ urllib3 = ">=1.21.1,<3"
 socks = ["PySocks (>=1.5.6,!=1.5.7)"]
 use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"]
 
-[[package]]
-name = "setuptools"
-version = "69.5.1"
-description = "Easily download, build, install, upgrade, and uninstall Python packages"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "setuptools-69.5.1-py3-none-any.whl", hash = "sha256:c636ac361bc47580504644275c9ad802c50415c7522212252c033bd15f301f32"},
-    {file = "setuptools-69.5.1.tar.gz", hash = "sha256:6c1fccdac05a97e598fb0ae3bbed5904ccb317337a51139dcd51453611bbb987"},
-]
-
-[package.extras]
-docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "pygments-github-lexers (==0.0.5)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-favicon", "sphinx-inline-tabs", "sphinx-lint", "sphinx-notfound-page (>=1,<2)", "sphinx-reredirects", "sphinxcontrib-towncrier"]
-testing = ["build[virtualenv]", "filelock (>=3.4.0)", "importlib-metadata", "ini2toml[lite] (>=0.9)", "jaraco.develop (>=7.21)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "mypy (==1.9)", "packaging (>=23.2)", "pip (>=19.1)", "pytest (>=6,!=8.1.1)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-home (>=0.5)", "pytest-mypy", "pytest-perf", "pytest-ruff (>=0.2.1)", "pytest-timeout", "pytest-xdist (>=3)", "tomli", "tomli-w (>=1.0.0)", "virtualenv (>=13.0.0)", "wheel"]
-testing-integration = ["build[virtualenv] (>=1.0.3)", "filelock (>=3.4.0)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "packaging (>=23.2)", "pytest", "pytest-enabler", "pytest-xdist", "tomli", "virtualenv (>=13.0.0)", "wheel"]
-
 [[package]]
 name = "six"
 version = "1.16.0"
@@ -667,21 +408,6 @@ files = [
     {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"},
 ]
 
-[[package]]
-name = "tenacity"
-version = "9.0.0"
-description = "Retry code until it succeeds"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "tenacity-9.0.0-py3-none-any.whl", hash = "sha256:93de0c98785b27fcf659856aa9f54bfbd399e29969b0621bc7f762bd441b4539"},
-    {file = "tenacity-9.0.0.tar.gz", hash = "sha256:807f37ca97d62aa361264d497b0e31e92b8027044942bfa756160d908320d73b"},
-]
-
-[package.extras]
-doc = ["reno", "sphinx"]
-test = ["pytest", "tornado (>=4.5)", "typeguard"]
-
 [[package]]
 name = "tomli"
 version = "2.0.1"
@@ -693,17 +419,6 @@ files = [
     {file = "tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f"},
 ]
 
-[[package]]
-name = "typing-extensions"
-version = "4.12.2"
-description = "Backported and Experimental Type Hints for Python 3.8+"
-optional = false
-python-versions = ">=3.8"
-files = [
-    {file = "typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d"},
-    {file = "typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8"},
-]
-
 [[package]]
 name = "tzdata"
 version = "2023.3"
@@ -717,13 +432,13 @@ files = [
 
 [[package]]
 name = "urllib3"
-version = "2.0.6"
+version = "2.0.4"
 description = "HTTP library with thread-safe connection pooling, file post, and more."
 optional = false
 python-versions = ">=3.7"
 files = [
-    {file = "urllib3-2.0.6-py3-none-any.whl", hash = "sha256:7a7c7003b000adf9e7ca2a377c9688bbc54ed41b985789ed576570342a375cd2"},
+    {file = "urllib3-2.0.4-py3-none-any.whl", hash = "sha256:de7df1803967d2c2a98e4b11bb7d6bd9210474c46e8a0401514e3a42a75ebde4"},
-    {file = "urllib3-2.0.6.tar.gz", hash = "sha256:b19e1a85d206b56d7df1d5e683df4a7725252a964e3993648dd0fb5a1c157564"},
+    {file = "urllib3-2.0.4.tar.gz", hash = "sha256:8d22f86aae8ef5e410d4f539fde9ce6b2113a001bb4d189e0aed70642d602b11"},
 ]
 
 [package.extras]
@@ -732,27 +447,7 @@ secure = ["certifi", "cryptography (>=1.9)", "idna (>=2.0.0)", "pyopenssl (>=17.
 socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"]
 zstd = ["zstandard (>=0.18.0)"]
 
-[[package]]
-name = "virtualenv"
-version = "20.25.1"
-description = "Virtual Python Environment builder"
-optional = false
-python-versions = ">=3.7"
-files = [
-    {file = "virtualenv-20.25.1-py3-none-any.whl", hash = "sha256:961c026ac520bac5f69acb8ea063e8a4f071bcc9457b9c1f28f6b085c511583a"},
-    {file = "virtualenv-20.25.1.tar.gz", hash = "sha256:e08e13ecdca7a0bd53798f356d5831434afa5b07b93f0abdf0797b7a06ffe197"},
-]
-
-[package.dependencies]
-distlib = ">=0.3.7,<1"
-filelock = ">=3.12.2,<4"
-platformdirs = ">=3.9.1,<5"
-
-[package.extras]
-docs = ["furo (>=2023.7.26)", "proselint (>=0.13)", "sphinx (>=7.1.2)", "sphinx-argparse (>=0.4)", "sphinxcontrib-towncrier (>=0.2.1a0)", "towncrier (>=23.6)"]
-test = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "coverage-enable-subprocess (>=1)", "flaky (>=3.7)", "packaging (>=23.1)", "pytest (>=7.4)", "pytest-env (>=0.8.2)", "pytest-freezer (>=0.4.8)", "pytest-mock (>=3.11.1)", "pytest-randomly (>=3.12)", "pytest-timeout (>=2.1)", "setuptools (>=68)", "time-machine (>=2.10)"]
-
 [metadata]
 lock-version = "2.0"
-python-versions = ">=3.9,<3.13"
+python-versions = "^3.10"
-content-hash = "cefc11b1bf5ad99d628f6d08f6f03003522cc1b6e48b519230d99d716a5c165c"
+content-hash = "3647d568f5623dd762f19029230626a62e68309fa2ef8be49a36382c19264a5f"

pyproject.toml

@@ -1,25 +1,23 @@
 [tool.poetry]
 name = "homeharvest"
-version = "0.4.7"
+version = "0.2.13"
-description = "Real estate scraping library"
+description = "Real estate scraping library supporting Zillow, Realtor.com & Redfin."
-authors = ["Zachary Hampton <zachary@bunsly.com>", "Cullen Watson <cullen@bunsly.com>"]
+authors = ["Zachary Hampton <zachary@zacharysproducts.com>", "Cullen Watson <cullen@cullen.ai>"]
-homepage = "https://github.com/Bunsly/HomeHarvest"
+homepage = "https://github.com/ZacharyHampton/HomeHarvest"
 readme = "README.md"
 
 [tool.poetry.scripts]
 homeharvest = "homeharvest.cli:main"
 
 [tool.poetry.dependencies]
-python = ">=3.9,<3.13"
+python = "^3.10"
 requests = "^2.31.0"
-pandas = "^2.1.1"
+pandas = "^2.1.0"
-pydantic = "^2.7.4"
+openpyxl = "^3.1.2"
-tenacity = "^9.0.0"
 
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^7.4.2"
-pre-commit = "^3.7.0"
 
 [build-system]
 requires = ["poetry-core"]

tests/test_realtor.py

@@ -1,302 +1,40 @@
-from homeharvest import scrape_property, Property
+from homeharvest import scrape_property
-import pandas as pd
+from homeharvest.exceptions import (
-
+    InvalidSite,
-
+    InvalidListingType,
-def test_realtor_pending_or_contingent():
+    NoResultsFound,
-    pending_or_contingent_result = scrape_property(location="Surprise, AZ", listing_type="pending")
+    GeoCoordsNotFound,
-
+)
-    regular_result = scrape_property(location="Surprise, AZ", listing_type="for_sale", exclude_pending=True)
-
-    assert all([result is not None for result in [pending_or_contingent_result, regular_result]])
-    assert len(pending_or_contingent_result) != len(regular_result)
-
-
-def test_realtor_pending_comps():
-    pending_comps = scrape_property(
-        location="2530 Al Lipscomb Way",
-        radius=5,
-        past_days=180,
-        listing_type="pending",
-    )
-
-    for_sale_comps = scrape_property(
-        location="2530 Al Lipscomb Way",
-        radius=5,
-        past_days=180,
-        listing_type="for_sale",
-    )
-
-    sold_comps = scrape_property(
-        location="2530 Al Lipscomb Way",
-        radius=5,
-        past_days=180,
-        listing_type="sold",
-    )
-
-    results = [pending_comps, for_sale_comps, sold_comps]
-    assert all([result is not None for result in results])
-
-    #: assert all lengths are different
-    assert len(set([len(result) for result in results])) == len(results)
-
-
-def test_realtor_sold_past():
-    result = scrape_property(
-        location="San Diego, CA",
-        past_days=30,
-        listing_type="sold",
-    )
-
-    assert result is not None and len(result) > 0
-
-
-def test_realtor_comps():
-    result = scrape_property(
-        location="2530 Al Lipscomb Way",
-        radius=0.5,
-        past_days=180,
-        listing_type="sold",
-    )
-
-    assert result is not None and len(result) > 0
-
-
-def test_realtor_last_x_days_sold():
-    days_result_30 = scrape_property(location="Dallas, TX", listing_type="sold", past_days=30)
-
-    days_result_10 = scrape_property(location="Dallas, TX", listing_type="sold", past_days=10)
-
-    assert all([result is not None for result in [days_result_30, days_result_10]]) and len(days_result_30) != len(
-        days_result_10
-    )
-
-
-def test_realtor_date_range_sold():
-    days_result_30 = scrape_property(
-        location="Dallas, TX", listing_type="sold", date_from="2023-05-01", date_to="2023-05-28"
-    )
-
-    days_result_60 = scrape_property(
-        location="Dallas, TX", listing_type="sold", date_from="2023-04-01", date_to="2023-06-10"
-    )
-
-    assert all([result is not None for result in [days_result_30, days_result_60]]) and len(days_result_30) < len(
-        days_result_60
-    )
-
-
-def test_realtor_single_property():
-    results = [
-        scrape_property(
-            location="15509 N 172nd Dr, Surprise, AZ 85388",
-            listing_type="for_sale",
-        ),
-        scrape_property(
-            location="2530 Al Lipscomb Way",
-            listing_type="for_sale",
-        ),
-    ]
-
-    assert all([result is not None for result in results])
 
 
 def test_realtor():
     results = [
         scrape_property(
             location="2530 Al Lipscomb Way",
+            site_name="realtor.com",
             listing_type="for_sale",
         ),
         scrape_property(
-            location="Phoenix, AZ", listing_type="for_rent", limit=1000
+            location="Phoenix, AZ", site_name=["realtor.com"], listing_type="for_rent"
         ),  #: does not support "city, state, USA" format
         scrape_property(
-            location="Dallas, TX", listing_type="sold", limit=1000
+            location="Dallas, TX", site_name="realtor.com", listing_type="sold"
         ),  #: does not support "city, state, USA" format
-        scrape_property(location="85281"),
+        scrape_property(location="85281", site_name="realtor.com"),
     ]
 
     assert all([result is not None for result in results])
 
-
+    bad_results = []
-def test_realtor_city():
+    try:
-    results = scrape_property(location="Atlanta, GA", listing_type="for_sale", limit=1000)
+        bad_results += [
-
+            scrape_property(
-    assert results is not None and len(results) > 0
+                location="abceefg ju098ot498hh9",
-
+                site_name="realtor.com",
-
+                listing_type="for_sale",
-def test_realtor_land():
+            )
-    results = scrape_property(location="Atlanta, GA", listing_type="for_sale", property_type=["land"], limit=1000)
+        ]
-
+    except (InvalidSite, InvalidListingType, NoResultsFound, GeoCoordsNotFound):
-    assert results is not None and len(results) > 0
-
-
-def test_realtor_bad_address():
-    bad_results = scrape_property(
-        location="abceefg ju098ot498hh9",
-        listing_type="for_sale",
-    )
-
-    if len(bad_results) == 0:
         assert True
 
-
+    assert all([result is None for result in bad_results])
-def test_realtor_foreclosed():
-    foreclosed = scrape_property(location="Dallas, TX", listing_type="for_sale", past_days=100, foreclosure=True)
-
-    not_foreclosed = scrape_property(location="Dallas, TX", listing_type="for_sale", past_days=100, foreclosure=False)
-
-    assert len(foreclosed) != len(not_foreclosed)
-
-
-def test_realtor_agent():
-    scraped = scrape_property(location="Detroit, MI", listing_type="for_sale", limit=1000, extra_property_data=False)
-    assert scraped["agent_name"].nunique() > 1
-
-
-def test_realtor_without_extra_details():
-    results = [
-        scrape_property(
-            location="00741",
-            listing_type="sold",
-            limit=10,
-            extra_property_data=False,
-        ),
-        scrape_property(
-            location="00741",
-            listing_type="sold",
-            limit=10,
-            extra_property_data=True,
-        ),
-    ]
-
-    assert not results[0].equals(results[1])
-
-
-def test_pr_zip_code():
-    results = scrape_property(
-        location="00741",
-        listing_type="for_sale",
-    )
-
-    assert results is not None and len(results) > 0
-
-
-def test_exclude_pending():
-    results = scrape_property(
-        location="33567",
-        listing_type="pending",
-        exclude_pending=True,
-    )
-
-    assert results is not None and len(results) > 0
-
-
-def test_style_value_error():
-    results = scrape_property(
-        location="Alaska, AK",
-        listing_type="sold",
-        extra_property_data=False,
-        limit=1000,
-    )
-
-    assert results is not None and len(results) > 0
-
-
-def test_primary_image_error():
-    results = scrape_property(
-        location="Spokane, PA",
-        listing_type="for_rent",  # or (for_sale, for_rent, pending)
-        past_days=360,
-        radius=3,
-        extra_property_data=False,
-    )
-
-    assert results is not None and len(results) > 0
-
-
-def test_limit():
-    over_limit = 876
-    extra_params = {"limit": over_limit}
-
-    over_results = scrape_property(
-        location="Waddell, AZ",
-        listing_type="for_sale",
-        **extra_params,
-    )
-
-    assert over_results is not None and len(over_results) <= over_limit
-
-    under_limit = 1
-    under_results = scrape_property(
-        location="Waddell, AZ",
-        listing_type="for_sale",
-        limit=under_limit,
-    )
-
-    assert under_results is not None and len(under_results) == under_limit
-
-
-def test_apartment_list_price():
-    results = scrape_property(
-        location="Spokane, WA",
-        listing_type="for_rent",  # or (for_sale, for_rent, pending)
-        extra_property_data=False,
-    )
-
-    assert results is not None
-
-    results = results[results["style"] == "APARTMENT"]
-
-    #: get percentage of results with atleast 1 of any column not none, list_price, list_price_min, list_price_max
-    assert (
-        len(results[results[["list_price", "list_price_min", "list_price_max"]].notnull().any(axis=1)]) / len(results)
-        > 0.5
-    )
-
-
-def test_builder_exists():
-    listing = scrape_property(
-        location="18149 W Poston Dr, Surprise, AZ 85387",
-        extra_property_data=False,
-    )
-
-    assert listing is not None
-    assert listing["builder_name"].nunique() > 0
-
-
-def test_phone_number_matching():
-    searches = [
-        scrape_property(
-            location="Phoenix, AZ",
-            listing_type="for_sale",
-            limit=100,
-        ),
-        scrape_property(
-            location="Phoenix, AZ",
-            listing_type="for_sale",
-            limit=100,
-        ),
-    ]
-
-    assert all([search is not None for search in searches])
-
-    #: random row
-    row = searches[0][searches[0]["agent_phones"].notnull()].sample()
-
-    #: find matching row
-    matching_row = searches[1].loc[searches[1]["property_url"] == row["property_url"].values[0]]
-
-    #: assert phone numbers are the same
-    assert row["agent_phones"].values[0] == matching_row["agent_phones"].values[0]
-
-
-def test_return_type():
-    results = {
-        "pandas": scrape_property(location="Surprise, AZ", listing_type="for_rent", limit=100),
-        "pydantic": scrape_property(location="Surprise, AZ", listing_type="for_rent", limit=100, return_type="pydantic"),
-        "raw": scrape_property(location="Surprise, AZ", listing_type="for_rent", limit=100, return_type="raw"),
-    }
-
-    assert isinstance(results["pandas"], pd.DataFrame)
-    assert isinstance(results["pydantic"][0], Property)
-    assert isinstance(results["raw"][0], dict)

tests/test_redfin.py

@@ -0,0 +1,32 @@
+from homeharvest import scrape_property
+from homeharvest.exceptions import (
+    InvalidSite,
+    InvalidListingType,
+    NoResultsFound,
+    GeoCoordsNotFound,
+)
+
+
+def test_redfin():
+    results = [
+        scrape_property(location="2530 Al Lipscomb Way", site_name="redfin", listing_type="for_sale"),
+        scrape_property(location="Phoenix, AZ, USA", site_name=["redfin"], listing_type="for_rent"),
+        scrape_property(location="Dallas, TX, USA", site_name="redfin", listing_type="sold"),
+        scrape_property(location="85281", site_name="redfin"),
+    ]
+
+    assert all([result is not None for result in results])
+
+    bad_results = []
+    try:
+        bad_results += [
+            scrape_property(
+                location="abceefg ju098ot498hh9",
+                site_name="redfin",
+                listing_type="for_sale",
+            )
+        ]
+    except (InvalidSite, InvalidListingType, NoResultsFound, GeoCoordsNotFound):
+        assert True
+
+    assert all([result is None for result in bad_results])

tests/test_utils.py

@@ -0,0 +1,24 @@
+from homeharvest.utils import parse_address_one, parse_address_two
+
+
+def test_parse_address_one():
+    test_data = [
+        ("4303 E Cactus Rd Apt 126", ("4303 E Cactus Rd", "#126")),
+        ("1234 Elm Street apt 2B", ("1234 Elm Street", "#2B")),
+        ("1234 Elm Street UNIT 3A", ("1234 Elm Street", "#3A")),
+        ("1234 Elm Street unit 3A", ("1234 Elm Street", "#3A")),
+        ("1234 Elm Street SuIte 3A", ("1234 Elm Street", "#3A")),
+    ]
+
+    for input_data, (exp_addr_one, exp_addr_two) in test_data:
+        address_one, address_two = parse_address_one(input_data)
+        assert address_one == exp_addr_one
+        assert address_two == exp_addr_two
+
+
+def test_parse_address_two():
+    test_data = [("Apt 126", "#126"), ("apt 2B", "#2B"), ("UNIT 3A", "#3A"), ("unit 3A", "#3A"), ("SuIte 3A", "#3A")]
+
+    for input_data, expected in test_data:
+        output = parse_address_two(input_data)
+        assert output == expected

tests/test_zillow.py

@@ -0,0 +1,32 @@
+from homeharvest import scrape_property
+from homeharvest.exceptions import (
+    InvalidSite,
+    InvalidListingType,
+    NoResultsFound,
+    GeoCoordsNotFound,
+)
+
+
+def test_zillow():
+    results = [
+        scrape_property(location="2530 Al Lipscomb Way", site_name="zillow", listing_type="for_sale"),
+        scrape_property(location="Phoenix, AZ, USA", site_name=["zillow"], listing_type="for_rent"),
+        scrape_property(location="Dallas, TX, USA", site_name="zillow", listing_type="sold"),
+        scrape_property(location="85281", site_name="zillow"),
+    ]
+
+    assert all([result is not None for result in results])
+
+    bad_results = []
+    try:
+        bad_results += [
+            scrape_property(
+                location="abceefg ju098ot498hh9",
+                site_name="zillow",
+                listing_type="for_sale",
+            )
+        ]
+    except (InvalidSite, InvalidListingType, NoResultsFound, GeoCoordsNotFound):
+        assert True
+
+    assert all([result is None for result in bad_results])