- version bump

- test case updates
- types addition
- docs grammar

.gitignore

@@ -1,2 +1,6 @@
 /.idea
-dist
+**/dist/
+**/__pycache__/
+**/.pytest_cache/
+*.pyc
+/.ipynb_checkpoints/

HomeHarvest_Demo.ipynb

@@ -0,0 +1,73 @@
+{
+ "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": [
+    "scrape_property(\n",
+    "    location=\"dallas\", site_name=\"zillow\", listing_type=\"for_sale\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ab7b4c21-da1d-4713-9df4-d7425d8ce21e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "scrape_property(\n",
+    "    location=\"dallas\", site_name=\"redfin\", listing_type=\"for_sale\"\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
+}

LICENSE

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

README.md

@@ -1 +1,33 @@
-# HomeHarvest
+# HomeHarvest
+
+**HomeHarvest** aims to be the top Python real estate scraping library.
+
+_**Under Consideration**: We're looking into the possibility of an Excel plugin to cater to a broader audience._
+
+## Installation
+
+```bash
+pip install --upgrade homeharvest
+```
+
+## Example Usage
+```
+from homeharvest import scrape_property
+
+properties = scrape_property(
+    location="85281", site_name="zillow", listing_type="for_rent"
+)
+print(properties)
+```
+
+### Site Name Options
+
+- `zillow`
+- `redfin`
+- `realtor.com`
+
+### Listing Types
+
+- `for_rent`
+- `for_sale`
+- `sold`

homeharvest/__init__.py

@@ -1,30 +1,117 @@
 from .core.scrapers.redfin import RedfinScraper
-from .core.scrapers.types import ListingType, Home
+from .core.scrapers.realtor import RealtorScraper
+from .core.scrapers.zillow import ZillowScraper
+from .core.scrapers.models import ListingType, Property, Building, SiteName
 from .core.scrapers import ScraperInput
 from .exceptions import InvalidSite, InvalidListingType
+from typing import Union
+import pandas as pd
 
 
 _scrapers = {
     "redfin": RedfinScraper,
+    "realtor.com": RealtorScraper,
+    "zillow": ZillowScraper,
 }
 
 
-def scrape_property(
-        location: str,
-        listing_type: str = "for_sale",  #: for_sale, for_rent, sold
-        site_name: str = "redfin",
-) -> list[Home]:  #: eventually, return pandas dataframe
+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.")
+        raise InvalidListingType(
+            f"Provided listing type, '{listing_type}', does not exist."
+        )
+
+
+def get_ordered_properties(result: Union[Building, Property]) -> list[str]:
+    if isinstance(result, Property):
+        return [
+            "listing_type",
+            "address_one",
+            "city",
+            "state",
+            "zip_code",
+            "address_two",
+            "url",
+            "property_type",
+            "price",
+            "beds",
+            "baths",
+            "square_feet",
+            "price_per_square_foot",
+            "lot_size",
+            "stories",
+            "year_built",
+            "agent_name",
+            "mls_id",
+            "description",
+        ]
+    elif isinstance(result, Building):
+        return [
+            "address_one",
+            "city",
+            "state",
+            "zip_code",
+            "address_two",
+            "url",
+            "num_units",
+            "min_unit_price",
+            "max_unit_price",
+            "avg_unit_price",
+            "listing_type",
+        ]
+    return []
+
+
+def process_result(result: Union[Building, Property]) -> pd.DataFrame:
+    prop_data = result.__dict__
+
+    address_data = prop_data["address"]
+    prop_data["site_name"] = prop_data["site_name"]
+    prop_data["listing_type"] = prop_data["listing_type"].value
+    prop_data["property_type"] = prop_data["property_type"].value.lower() if prop_data.get("property_type") else None
+    prop_data["address_one"] = address_data.address_one
+    prop_data["city"] = address_data.city
+    prop_data["state"] = address_data.state
+    prop_data["zip_code"] = address_data.zip_code
+    prop_data["address_two"] = address_data.address_two
+
+    del prop_data["address"]
+
+    properties_df = pd.DataFrame([prop_data])
+    properties_df = properties_df[get_ordered_properties(result)]
+
+    return properties_df
+
+
+def scrape_property(
+    location: str,
+    site_name: str,
+    listing_type: str = "for_sale",  #: for_sale, for_rent, sold
+) -> pd.DataFrame:
+    """
+    Scrape property from various sites from a given location and listing type.
+
+    :returns: pd.DataFrame
+    :param location: US Location (e.g. 'San Francisco, CA', 'Cook County, IL', '85281', '2530 Al Lipscomb Way')
+    :param site_name: Site name (e.g. 'realtor.com', 'zillow', 'redfin')
+    :param listing_type: Listing type (e.g. 'for_sale', 'for_rent', 'sold')
+    :return: pd.DataFrame containing properties
+    """
+
+    validate_input(site_name, listing_type)
 
     scraper_input = ScraperInput(
         location=location,
         listing_type=ListingType[listing_type.upper()],
+        site_name=site_name.lower(),
     )
 
     site = _scrapers[site_name.lower()](scraper_input)
+    results = site.search()
 
-    return site.search()
+    properties_dfs = [process_result(result) for result in results]
+
+    return pd.concat(properties_dfs, ignore_index=True)

homeharvest/core/scrapers/__init__.py

@@ -1,19 +1,24 @@
 from dataclasses import dataclass
 import requests
-from .types import Home, ListingType
+from .models import Property, ListingType, SiteName
 
 
 @dataclass
 class ScraperInput:
     location: str
     listing_type: ListingType
+    site_name: str
     proxy_url: str | None = None
 
 
 class Scraper:
     def __init__(self, scraper_input: ScraperInput):
         self.location = scraper_input.location
+        self.listing_type = scraper_input.listing_type
+
         self.session = requests.Session()
+        self.listing_type = scraper_input.listing_type
+        self.site_name = scraper_input.site_name
 
         if scraper_input.proxy_url:
             self.session.proxies = {
@@ -21,7 +26,12 @@ class Scraper:
                 "https": scraper_input.proxy_url,
             }
 
-    def search(self) -> list[Home]: ...
+    def search(self) -> list[Property]:
+        ...
 
     @staticmethod
-    def parse_home(home) -> Home: ...
+    def _parse_home(home) -> Property:
+        ...
+
+    def handle_location(self):
+        ...

homeharvest/core/scrapers/models.py

@@ -0,0 +1,84 @@
+from dataclasses import dataclass
+from enum import Enum
+
+
+class SiteName(Enum):
+    ZILLOW = "zillow"
+    REDFIN = "redfin"
+    REALTOR = "realtor.com"
+
+
+class ListingType(Enum):
+    FOR_SALE = "for_sale"
+    FOR_RENT = "for_rent"
+    SOLD = "sold"
+
+
+class PropertyType(Enum):
+    HOUSE = "HOUSE"
+    CONDO = "CONDO"
+    TOWNHOUSE = "TOWNHOUSE"
+    SINGLE_FAMILY = "SINGLE_FAMILY"
+    MULTI_FAMILY = "MULTI_FAMILY"
+    MANUFACTURED = "MANUFACTURED"
+    APARTMENT = "APARTMENT"
+    LAND = "LAND"
+    OTHER = "OTHER"
+
+    @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.OTHER)
+
+
+@dataclass
+class Address:
+    address_one: str
+    city: str
+    state: str
+    zip_code: str
+
+    address_two: str | None = None
+
+
+@dataclass()
+class Realty:
+    site_name: str
+    address: Address
+    url: str
+    listing_type: ListingType | None = None
+
+
+@dataclass
+class Property(Realty):
+    price: int | None = None
+    beds: int | None = None
+    baths: float | None = None
+    stories: int | None = None
+    year_built: int | None = None
+    square_feet: int | None = None
+    price_per_square_foot: int | None = None
+    mls_id: str | None = None
+
+    agent_name: str | None = None
+    property_type: PropertyType | None = None
+    lot_size: int | None = None
+    description: str | None = None
+
+
+@dataclass
+class Building(Realty):
+    num_units: int | None = None
+    min_unit_price: int | None = None
+    max_unit_price: int | None = None
+    avg_unit_price: int | None = None

homeharvest/core/scrapers/realtor/__init__.py

@@ -0,0 +1,268 @@
+import json
+from ..models import Property, Address
+from .. import Scraper
+from typing import Any, Generator
+from ....exceptions import NoResultsFound
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+
+class RealtorScraper(Scraper):
+    def __init__(self, scraper_input):
+        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.replace('_', '-'),
+            "limit": "1",
+            "area_types": "city,state,county,postal_code,address,street,neighborhood,school,school_district,university,park",
+        }
+
+        response = self.session.get(
+            "https://parser-external.geo.moveaws.com/suggest",
+            params=params,
+            headers=headers,
+        )
+        response_json = response.json()
+
+        result = response_json["autocomplete"]
+
+        if result is None:
+            raise NoResultsFound("No results found for location: " + self.location)
+
+        return result[0]
+
+    def handle_address(self, property_id: str) -> list[Property]:
+        query = """query Property($property_id: ID!) {
+                    property(id: $property_id) {
+                        property_id
+                        details {
+                            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_url, json=payload)
+        response_json = response.json()
+
+        property_info = response_json['data']['property']
+
+        return [Property(
+            site_name=self.site_name,
+            address=Address(
+                address_one=property_info['address']['line'],
+                city=property_info['address']['city'],
+                state=property_info['address']['state_code'],
+                zip_code=property_info['address']['postal_code'],
+            ),
+            url="https://www.realtor.com/realestateandhomes-detail/" + property_info['details']['permalink'],
+            beds=property_info['basic']['beds'],
+            baths=property_info['basic']['baths'],
+            stories=property_info['details']['stories'],
+            year_built=property_info['details']['year_built'],
+            square_feet=property_info['basic']['sqft'],
+            price_per_square_foot=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,
+            price=property_info['basic']['price'],
+            mls_id=property_id,
+            listing_type=self.listing_type,
+            lot_size=property_info['public_record']['lot_size'] if property_info['public_record'] is not None else None,
+        )]
+
+    def handle_area(self, variables: dict, return_total: bool = False) -> list[Property] | int:
+        query = """query Home_search(
+                            $city: String,
+                            $county: [String],
+                            $state_code: String,
+                            $postal_code: String
+                            $offset: Int,
+                        ) {
+                            home_search(
+                                query: {
+                                    city: $city
+                                    county: $county
+                                    postal_code: $postal_code
+                                    state_code: $state_code
+                                    status: %s
+                                }
+                                limit: 200
+                                offset: $offset
+                            ) {
+                                count
+                                total
+                                results {
+                                    property_id
+                                    description {
+                                        baths
+                                        beds
+                                        lot_sqft
+                                        sqft
+                                        text
+                                        sold_price
+                                        stories
+                                        year_built
+                                        garage
+                                        unit_number
+                                        floor_number
+                                    }
+                                    location {
+                                        address {
+                                            city
+                                            country
+                                            line
+                                            postal_code
+                                            state_code
+                                            state
+                                            street_direction
+                                            street_name
+                                            street_number
+                                            street_post_direction
+                                            street_suffix
+                                            unit
+                                        }
+                                    }
+                                    list_price
+                                    price_per_sqft
+                                    source {
+                                        id
+                                    }
+                                }
+                            }
+                        }""" % self.listing_type.value
+
+        payload = {
+            'query': query,
+            'variables': variables,
+        }
+
+        response = self.session.post(self.search_url, json=payload)
+        response_json = response.json()
+
+        if return_total:
+            return response_json['data']['home_search']['total']
+
+        properties: list[Property] = []
+
+        for result in response_json['data']['home_search']['results']:
+            realty_property = Property(
+                address=Address(
+                    address_one=result['location']['address']['line'],
+                    city=result['location']['address']['city'],
+                    state=result['location']['address']['state_code'],
+                    zip_code=result['location']['address']['postal_code'],
+                    address_two=result['location']['address']['unit'],
+                ),
+                site_name=self.site_name,
+                url="https://www.realtor.com/realestateandhomes-detail/" + result['property_id'],
+                beds=result['description']['beds'],
+                baths=result['description']['baths'],
+                stories=result['description']['stories'],
+                year_built=result['description']['year_built'],
+                square_feet=result['description']['sqft'],
+                price_per_square_foot=result['price_per_sqft'],
+                price=result['list_price'],
+                mls_id=result['property_id'],
+                listing_type=self.listing_type,
+                lot_size=result['description']['lot_sqft'],
+            )
+
+            properties.append(realty_property)
+
+        return properties
+
+    def search(self):
+        location_info = self.handle_location()
+        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 = {
+            '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,
+        }
+
+        total = self.handle_area(search_variables, return_total=True)
+
+        homes = []
+        with ThreadPoolExecutor(max_workers=10) as executor:
+            futures = [
+                executor.submit(
+                    self.handle_area, variables=search_variables | {'offset': i}, return_total=False
+                ) for i in range(0, total, 200)
+            ]
+
+            for future in as_completed(futures):
+                homes.extend(future.result())
+
+        return homes

homeharvest/core/scrapers/redfin/__init__.py

@@ -1,5 +1,5 @@
 import json
-from ..types import Home, Address
+from ..models import Property, Address, PropertyType, Building
 from .. import Scraper
 from typing import Any
 
@@ -7,57 +7,152 @@ from typing import Any
 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('{}&&', ''))
-
-        if response_json['payload']['exactMatch'] is not None:
-            return response_json['payload']['exactMatch']['id'].split('_')[1]
-        else:
-            return response_json['payload']['sections'][0]['rows'][0].split('_')[1]
-
-    @staticmethod
-    def parse_home(home: dict) -> Home:
-        address = Address(
-            address_one=home['streetLine']['value'],
-            city=home['city'],
-            state=home['state'],
-            zip_code=home['zip']
+    def _handle_location(self):
+        url = "https://www.redfin.com/stingray/do/location-autocomplete?v=2&al=1&location={}".format(
+            self.location
         )
 
-        url = 'https://www.redfin.com{}'.format(home['url'])
+        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 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 key in home and "value" in home[key]:
+                return home[key]["value"]
 
-        return Home(
+        if not single_search:
+            address = Address(
+                address_one=get_value("streetLine"),
+                city=home["city"],
+                state=home["state"],
+                zip_code=home["zip"],
+            )
+        else:
+            address_info = home["streetAddress"]
+
+            address = Address(
+                address_one=address_info["assembledAddress"],
+                city=home["city"],
+                state=home["state"],
+                zip_code=home["zip"],
+            )
+        url = "https://www.redfin.com{}".format(home["url"])
+        property_type = home["propertyType"] if "propertyType" in home else None
+        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,
             url=url,
-            beds=home['beds'] if 'beds' in home else None,
-            baths=home['baths'] if 'baths' in home else None,
-            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'),
-            square_feet=get_value('sqFt'),
-            price_per_square_foot=get_value('pricePerSqFt'),
-            price=get_value('price'),
-            mls_id=get_value('mlsId')
+            beds=home["beds"] if "beds" in home else None,
+            baths=home["baths"] if "baths" in home else None,
+            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["yearBuilt"],
+            square_feet=get_value("sqFt"),
+            lot_size=lot_size,
+            property_type=PropertyType.from_int_code(home.get("propertyType")),
+            price_per_square_foot=get_value("pricePerSqFt"),
+            price=get_value("price"),
+            mls_id=get_value("mlsId"),
         )
 
-    def search(self):
-        region_id = self.handle_location()
+    def _parse_building(self, building: dict) -> Building:
+        return Building(
+            address=Address(
+                address_one=" ".join(
+                    [
+                        building['address']['streetNumber'],
+                        building['address']['directionalPrefix'],
+                        building['address']['streetName'],
+                        building['address']['streetType'],
+                    ]
+                ),
+                city=building['address']['city'],
+                state=building['address']['stateOrProvinceCode'],
+                zip_code=building['address']['postalCode'],
+                address_two=" ".join(
+                    [
+                        building['address']['unitType'],
+                        building['address']['unitValue'],
+                    ]
+                )
+            ),
+            site_name=self.site_name,
+            url="https://www.redfin.com{}".format(building["url"]),
+            listing_type=self.listing_type,
+            num_units=building["numUnitsForSale"],
+        )
 
-        url = 'https://www.redfin.com/stingray/api/gis?al=1&region_id={}&region_type=2'.format(region_id)
+
+    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('{}&&', ''))
+        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)
+
+        url = "https://www.redfin.com/stingray/api/gis?al=1&region_id={}&region_type={}".format(
+            region_id, region_type
+        )
+
+        response = self.session.get(url)
+        response_json = json.loads(response.text.replace("{}&&", ""))
+
+        homes = [
+            self._parse_home(home) for home in response_json["payload"]["homes"]
+        ] + [
+            self._parse_building(building) for building in response_json["payload"]["buildings"].values()
+        ]
 
-        homes = [self.parse_home(home) for home in response_json['payload']['homes']]
         return homes
-
-

homeharvest/core/scrapers/types.py

@@ -1,35 +0,0 @@
-from dataclasses import dataclass
-from enum import Enum
-
-
-class ListingType(Enum):
-    FOR_SALE = "for_sale"
-    FOR_RENT = "for_rent"
-    SOLD = "sold"
-
-
-@dataclass
-class Address:
-    address_one: str
-    city: str
-    state: str
-    zip_code: str
-
-    address_two: str | None = None
-
-
-@dataclass
-class Home:
-    address: Address
-    url: str
-
-    beds: int | None = None
-    baths: int | None = None
-    stories: int | None = None
-    agent_name: str | None = None
-    description: str | None = None
-    year_built: int | None = None
-    square_feet: int | None = None
-    price_per_square_foot: int | None = None
-    price: int | None = None
-    mls_id: str | None = None

homeharvest/core/scrapers/zillow/__init__.py

@@ -0,0 +1,210 @@
+import re
+import json
+from ..models import Property, Address, Building, ListingType, PropertyType
+from ....exceptions import NoResultsFound, PropertyNotFound
+from .. import Scraper
+
+
+class ZillowScraper(Scraper):
+    def __init__(self, scraper_input):
+        super().__init__(scraper_input)
+        self.listing_type = scraper_input.listing_type
+        if self.listing_type == ListingType.FOR_SALE:
+            self.url = f"https://www.zillow.com/homes/for_sale/{self.location}_rb/"
+        elif self.listing_type == ListingType.FOR_RENT:
+            self.url = f"https://www.zillow.com/homes/for_rent/{self.location}_rb/"
+
+    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"]:
+            houses = data["props"]["pageProps"]["searchPageState"]["cat1"][
+                "searchResults"
+            ]["listResults"]
+            return [self._parse_home(house) for house in houses]
+        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 PropertyNotFound("Specific property data not found in the response.")
+
+    def _parse_home(self, home: dict):
+        """
+        This method is used when a user enters a generic location & zillow returns more than one property
+        """
+        url = (
+            f"https://www.zillow.com{home['detailUrl']}"
+            if "zillow.com" not in home["detailUrl"]
+            else home["detailUrl"]
+        )
+
+        if "hdpData" in home and "homeInfo" in home["hdpData"]:
+            price_data = self._extract_price(home)
+            address = self._extract_address(home)
+            agent_name = self._extract_agent_name(home)
+            beds = home["hdpData"]["homeInfo"]["bedrooms"]
+            baths = home["hdpData"]["homeInfo"]["bathrooms"]
+            property_type = home["hdpData"]["homeInfo"].get("homeType")
+
+            return Property(
+                site_name=self.site_name,
+                address=address,
+                agent_name=agent_name,
+                url=url,
+                beds=beds,
+                baths=baths,
+                listing_type=self.listing_type,
+                property_type=PropertyType(property_type),
+                **price_data,
+            )
+        else:
+            keys = ("addressStreet", "addressCity", "addressState", "addressZipcode")
+            address_one, city, state, zip_code = (home[key] for key in keys)
+            address_one, address_two = self._parse_address_two(address_one)
+            address = Address(address_one, city, state, zip_code, address_two)
+
+            building_info = self._extract_building_info(home)
+            return Building(
+                site_name=self.site_name, address=address, url=url, **building_info
+            )
+
+    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 = self._parse_address_two(
+            address_data["streetAddress"]
+        )
+        address = Address(
+            address_one=address_one,
+            address_two=address_two,
+            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,
+            address=address,
+            url=url,
+            beds=property_data.get("bedrooms", None),
+            baths=property_data.get("bathrooms", None),
+            year_built=property_data.get("yearBuilt", None),
+            price=property_data.get("price", None),
+            lot_size=property_data.get("lotSize", None),
+            agent_name=property_data.get("attributionInfo", {}).get("agentName", None),
+            stories=property_data.get("resoFacts", {}).get("stories", None),
+            description=property_data.get("description", None),
+            mls_id=property_data.get("attributionInfo", {}).get("mlsId", None),
+            price_per_square_foot=property_data.get("resoFacts", {}).get(
+                "pricePerSquareFoot", None
+            ),
+            square_feet=property_data.get("livingArea", None),
+            property_type=PropertyType(property_type),
+            listing_type=self.listing_type,
+        )
+
+    def _extract_building_info(self, home: dict) -> dict:
+        num_units = len(home["units"])
+        prices = [
+            int(unit["price"].replace("$", "").replace(",", "").split("+")[0])
+            for unit in home["units"]
+        ]
+        return {
+            "listing_type": self.listing_type,
+            "num_units": len(home["units"]),
+            "min_unit_price": min(
+                (
+                    int(unit["price"].replace("$", "").replace(",", "").split("+")[0])
+                    for unit in home["units"]
+                )
+            ),
+            "max_unit_price": max(
+                (
+                    int(unit["price"].replace("$", "").replace(",", "").split("+")[0])
+                    for unit in home["units"]
+                )
+            ),
+            "avg_unit_price": sum(prices) // len(prices) if num_units else None,
+        }
+
+    @staticmethod
+    def _extract_price(home: dict) -> dict:
+        price = int(home["hdpData"]["homeInfo"]["priceForHDP"])
+        square_feet = home["hdpData"]["homeInfo"].get("livingArea")
+
+        lot_size = home["hdpData"]["homeInfo"].get("lotAreaValue")
+        price_per_square_foot = price // square_feet if square_feet and price else None
+
+        return {
+            k: v
+            for k, v in locals().items()
+            if k in ["price", "square_feet", "lot_size", "price_per_square_foot"]
+        }
+
+    @staticmethod
+    def _extract_agent_name(home: dict) -> str | None:
+        broker_str = home.get("brokerName", "")
+        match = re.search(r"Listing by: (.+)", broker_str)
+        return match.group(1) if match else None
+
+    @staticmethod
+    def _parse_address_two(address_one: str):
+        apt_match = re.search(r"(APT\s*.+|#[\s\S]+)$", address_one, re.I)
+        address_two = apt_match.group().strip() if apt_match else None
+        address_one = (
+            address_one.replace(address_two, "").strip() if address_two else address_one
+        )
+        return address_one, address_two
+
+    @staticmethod
+    def _extract_address(home: dict) -> Address:
+        keys = ("streetAddress", "city", "state", "zipcode")
+        address_one, city, state, zip_code = (
+            home["hdpData"]["homeInfo"][key] for key in keys
+        )
+        address_one, address_two = ZillowScraper._parse_address_two(address_one)
+        return Address(address_one, city, state, zip_code, address_two=address_two)
+
+    @staticmethod
+    def _get_headers():
+        return {
+            "authority": "parser-external.geo.moveaws.com",
+            "accept": "*/*",
+            "accept-language": "en-US,en;q=0.9",
+            "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": "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",
+        }

homeharvest/exceptions.py

@@ -1,8 +1,14 @@
 class InvalidSite(Exception):
     """Raised when a provided site is does not exist."""
-    pass
 
 
 class InvalidListingType(Exception):
     """Raised when a provided listing type is does not exist."""
-    pass
+
+
+class NoResultsFound(Exception):
+    """Raised when no results are found for the given location"""
+
+
+class PropertyNotFound(Exception):
+    """Raised when no property is found for the given address"""

poetry.lock

@@ -142,6 +142,81 @@ files = [
     {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"},
 ]
 
+[[package]]
+name = "numpy"
+version = "1.25.2"
+description = "Fundamental package for array computing in Python"
+optional = false
+python-versions = ">=3.9"
+files = [
+    {file = "numpy-1.25.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:db3ccc4e37a6873045580d413fe79b68e47a681af8db2e046f1dacfa11f86eb3"},
+    {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]]
+name = "numpy"
+version = "1.26.0"
+description = "Fundamental package for array computing in Python"
+optional = false
+python-versions = "<3.13,>=3.9"
+files = [
+    {file = "numpy-1.26.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:f8db2f125746e44dce707dd44d4f4efeea8d7e2b43aace3f8d1f235cfa2733dd"},
+    {file = "numpy-1.26.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0621f7daf973d34d18b4e4bafb210bbaf1ef5e0100b5fa750bd9cde84c7ac292"},
+    {file = "numpy-1.26.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:51be5f8c349fdd1a5568e72713a21f518e7d6707bcf8503b528b88d33b57dc68"},
+    {file = "numpy-1.26.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:767254ad364991ccfc4d81b8152912e53e103ec192d1bb4ea6b1f5a7117040be"},
+    {file = "numpy-1.26.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:436c8e9a4bdeeee84e3e59614d38c3dbd3235838a877af8c211cfcac8a80b8d3"},
+    {file = "numpy-1.26.0-cp310-cp310-win32.whl", hash = "sha256:c2e698cb0c6dda9372ea98a0344245ee65bdc1c9dd939cceed6bb91256837896"},
+    {file = "numpy-1.26.0-cp310-cp310-win_amd64.whl", hash = "sha256:09aaee96c2cbdea95de76ecb8a586cb687d281c881f5f17bfc0fb7f5890f6b91"},
+    {file = "numpy-1.26.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:637c58b468a69869258b8ae26f4a4c6ff8abffd4a8334c830ffb63e0feefe99a"},
+    {file = "numpy-1.26.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:306545e234503a24fe9ae95ebf84d25cba1fdc27db971aa2d9f1ab6bba19a9dd"},
+    {file = "numpy-1.26.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c6adc33561bd1d46f81131d5352348350fc23df4d742bb246cdfca606ea1208"},
+    {file = "numpy-1.26.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e062aa24638bb5018b7841977c360d2f5917268d125c833a686b7cbabbec496c"},
+    {file = "numpy-1.26.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:546b7dd7e22f3c6861463bebb000646fa730e55df5ee4a0224408b5694cc6148"},
+    {file = "numpy-1.26.0-cp311-cp311-win32.whl", hash = "sha256:c0b45c8b65b79337dee5134d038346d30e109e9e2e9d43464a2970e5c0e93229"},
+    {file = "numpy-1.26.0-cp311-cp311-win_amd64.whl", hash = "sha256:eae430ecf5794cb7ae7fa3808740b015aa80747e5266153128ef055975a72b99"},
+    {file = "numpy-1.26.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:166b36197e9debc4e384e9c652ba60c0bacc216d0fc89e78f973a9760b503388"},
+    {file = "numpy-1.26.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f042f66d0b4ae6d48e70e28d487376204d3cbf43b84c03bac57e28dac6151581"},
+    {file = "numpy-1.26.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e5e18e5b14a7560d8acf1c596688f4dfd19b4f2945b245a71e5af4ddb7422feb"},
+    {file = "numpy-1.26.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f6bad22a791226d0a5c7c27a80a20e11cfe09ad5ef9084d4d3fc4a299cca505"},
+    {file = "numpy-1.26.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4acc65dd65da28060e206c8f27a573455ed724e6179941edb19f97e58161bb69"},
+    {file = "numpy-1.26.0-cp312-cp312-win32.whl", hash = "sha256:bb0d9a1aaf5f1cb7967320e80690a1d7ff69f1d47ebc5a9bea013e3a21faec95"},
+    {file = "numpy-1.26.0-cp312-cp312-win_amd64.whl", hash = "sha256:ee84ca3c58fe48b8ddafdeb1db87388dce2c3c3f701bf447b05e4cfcc3679112"},
+    {file = "numpy-1.26.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:4a873a8180479bc829313e8d9798d5234dfacfc2e8a7ac188418189bb8eafbd2"},
+    {file = "numpy-1.26.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:914b28d3215e0c721dc75db3ad6d62f51f630cb0c277e6b3bcb39519bed10bd8"},
+    {file = "numpy-1.26.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c78a22e95182fb2e7874712433eaa610478a3caf86f28c621708d35fa4fd6e7f"},
+    {file = "numpy-1.26.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:86f737708b366c36b76e953c46ba5827d8c27b7a8c9d0f471810728e5a2fe57c"},
+    {file = "numpy-1.26.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:b44e6a09afc12952a7d2a58ca0a2429ee0d49a4f89d83a0a11052da696440e49"},
+    {file = "numpy-1.26.0-cp39-cp39-win32.whl", hash = "sha256:5671338034b820c8d58c81ad1dafc0ed5a00771a82fccc71d6438df00302094b"},
+    {file = "numpy-1.26.0-cp39-cp39-win_amd64.whl", hash = "sha256:020cdbee66ed46b671429c7265cf00d8ac91c046901c55684954c3958525dab2"},
+    {file = "numpy-1.26.0-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:0792824ce2f7ea0c82ed2e4fecc29bb86bee0567a080dacaf2e0a01fe7654369"},
+    {file = "numpy-1.26.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7d484292eaeb3e84a51432a94f53578689ffdea3f90e10c8b203a99be5af57d8"},
+    {file = "numpy-1.26.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:186ba67fad3c60dbe8a3abff3b67a91351100f2661c8e2a80364ae6279720299"},
+    {file = "numpy-1.26.0.tar.gz", hash = "sha256:f93fc78fe8bf15afe2b8d6b6499f1c73953169fad1e9a8dd086cdff3190e7fdf"},
+]
+
 [[package]]
 name = "packaging"
 version = "23.1"
@@ -153,6 +228,67 @@ files = [
     {file = "packaging-23.1.tar.gz", hash = "sha256:a392980d2b6cffa644431898be54b0045151319d1e7ec34f0cfed48767dd334f"},
 ]
 
+[[package]]
+name = "pandas"
+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.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:40dd20439ff94f1b2ed55b393ecee9cb6f3b08104c2c40b0cb7186a2f0046242"},
+    {file = "pandas-2.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d4f38e4fedeba580285eaac7ede4f686c6701a9e618d8a857b138a126d067f2f"},
+    {file = "pandas-2.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6e6a0fe052cf27ceb29be9429428b4918f3740e37ff185658f40d8702f0b3e09"},
+    {file = "pandas-2.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9d81e1813191070440d4c7a413cb673052b3b4a984ffd86b8dd468c45742d3cc"},
+    {file = "pandas-2.1.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:eb20252720b1cc1b7d0b2879ffc7e0542dd568f24d7c4b2347cb035206936421"},
+    {file = "pandas-2.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:38f74ef7ebc0ffb43b3d633e23d74882bce7e27bfa09607f3c5d3e03ffd9a4a5"},
+    {file = "pandas-2.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cda72cc8c4761c8f1d97b169661f23a86b16fdb240bdc341173aee17e4d6cedd"},
+    {file = "pandas-2.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d97daeac0db8c993420b10da4f5f5b39b01fc9ca689a17844e07c0a35ac96b4b"},
+    {file = "pandas-2.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8c58b1113892e0c8078f006a167cc210a92bdae23322bb4614f2f0b7a4b510f"},
+    {file = "pandas-2.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:629124923bcf798965b054a540f9ccdfd60f71361255c81fa1ecd94a904b9dd3"},
+    {file = "pandas-2.1.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:70cf866af3ab346a10debba8ea78077cf3a8cd14bd5e4bed3d41555a3280041c"},
+    {file = "pandas-2.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:d53c8c1001f6a192ff1de1efe03b31a423d0eee2e9e855e69d004308e046e694"},
+    {file = "pandas-2.1.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:86f100b3876b8c6d1a2c66207288ead435dc71041ee4aea789e55ef0e06408cb"},
+    {file = "pandas-2.1.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:28f330845ad21c11db51e02d8d69acc9035edfd1116926ff7245c7215db57957"},
+    {file = "pandas-2.1.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b9a6ccf0963db88f9b12df6720e55f337447aea217f426a22d71f4213a3099a6"},
+    {file = "pandas-2.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d99e678180bc59b0c9443314297bddce4ad35727a1a2656dbe585fd78710b3b9"},
+    {file = "pandas-2.1.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:b31da36d376d50a1a492efb18097b9101bdbd8b3fbb3f49006e02d4495d4c644"},
+    {file = "pandas-2.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:0164b85937707ec7f70b34a6c3a578dbf0f50787f910f21ca3b26a7fd3363437"},
+    {file = "pandas-2.1.0.tar.gz", hash = "sha256:62c24c7fc59e42b775ce0679cfa7b14a5f9bfb7643cfbe708c960699e05fb918"},
+]
+
+[package.dependencies]
+numpy = [
+    {version = ">=1.22.4", markers = "python_version < \"3.11\""},
+    {version = ">=1.23.2", markers = "python_version >= \"3.11\""},
+]
+python-dateutil = ">=2.8.2"
+pytz = ">=2020.1"
+tzdata = ">=2022.1"
+
+[package.extras]
+all = ["PyQt5 (>=5.15.6)", "SQLAlchemy (>=1.4.36)", "beautifulsoup4 (>=4.11.1)", "bottleneck (>=1.3.4)", "dataframe-api-compat (>=0.1.7)", "fastparquet (>=0.8.1)", "fsspec (>=2022.05.0)", "gcsfs (>=2022.05.0)", "html5lib (>=1.1)", "hypothesis (>=6.46.1)", "jinja2 (>=3.1.2)", "lxml (>=4.8.0)", "matplotlib (>=3.6.1)", "numba (>=0.55.2)", "numexpr (>=2.8.0)", "odfpy (>=1.4.1)", "openpyxl (>=3.0.10)", "pandas-gbq (>=0.17.5)", "psycopg2 (>=2.9.3)", "pyarrow (>=7.0.0)", "pymysql (>=1.0.2)", "pyreadstat (>=1.1.5)", "pytest (>=7.3.2)", "pytest-asyncio (>=0.17.0)", "pytest-xdist (>=2.2.0)", "pyxlsb (>=1.0.9)", "qtpy (>=2.2.0)", "s3fs (>=2022.05.0)", "scipy (>=1.8.1)", "tables (>=3.7.0)", "tabulate (>=0.8.10)", "xarray (>=2022.03.0)", "xlrd (>=2.0.1)", "xlsxwriter (>=3.0.3)", "zstandard (>=0.17.0)"]
+aws = ["s3fs (>=2022.05.0)"]
+clipboard = ["PyQt5 (>=5.15.6)", "qtpy (>=2.2.0)"]
+compression = ["zstandard (>=0.17.0)"]
+computation = ["scipy (>=1.8.1)", "xarray (>=2022.03.0)"]
+consortium-standard = ["dataframe-api-compat (>=0.1.7)"]
+excel = ["odfpy (>=1.4.1)", "openpyxl (>=3.0.10)", "pyxlsb (>=1.0.9)", "xlrd (>=2.0.1)", "xlsxwriter (>=3.0.3)"]
+feather = ["pyarrow (>=7.0.0)"]
+fss = ["fsspec (>=2022.05.0)"]
+gcp = ["gcsfs (>=2022.05.0)", "pandas-gbq (>=0.17.5)"]
+hdf5 = ["tables (>=3.7.0)"]
+html = ["beautifulsoup4 (>=4.11.1)", "html5lib (>=1.1)", "lxml (>=4.8.0)"]
+mysql = ["SQLAlchemy (>=1.4.36)", "pymysql (>=1.0.2)"]
+output-formatting = ["jinja2 (>=3.1.2)", "tabulate (>=0.8.10)"]
+parquet = ["pyarrow (>=7.0.0)"]
+performance = ["bottleneck (>=1.3.4)", "numba (>=0.55.2)", "numexpr (>=2.8.0)"]
+plot = ["matplotlib (>=3.6.1)"]
+postgresql = ["SQLAlchemy (>=1.4.36)", "psycopg2 (>=2.9.3)"]
+spss = ["pyreadstat (>=1.1.5)"]
+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 = "pluggy"
 version = "1.3.0"
@@ -190,6 +326,31 @@ tomli = {version = ">=1.0.0", markers = "python_version < \"3.11\""}
 [package.extras]
 testing = ["argcomplete", "attrs (>=19.2.0)", "hypothesis (>=3.56)", "mock", "nose", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"]
 
+[[package]]
+name = "python-dateutil"
+version = "2.8.2"
+description = "Extensions to the standard Python datetime module"
+optional = false
+python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7"
+files = [
+    {file = "python-dateutil-2.8.2.tar.gz", hash = "sha256:0123cacc1627ae19ddf3c27a5de5bd67ee4586fbdd6440d9748f8abb483d3e86"},
+    {file = "python_dateutil-2.8.2-py2.py3-none-any.whl", hash = "sha256:961d03dc3453ebbc59dbdea9e4e11c5651520a876d0f4db161e8674aae935da9"},
+]
+
+[package.dependencies]
+six = ">=1.5"
+
+[[package]]
+name = "pytz"
+version = "2023.3.post1"
+description = "World timezone definitions, modern and historical"
+optional = false
+python-versions = "*"
+files = [
+    {file = "pytz-2023.3.post1-py2.py3-none-any.whl", hash = "sha256:ce42d816b81b68506614c11e8937d3aa9e41007ceb50bfdcb0749b921bf646c7"},
+    {file = "pytz-2023.3.post1.tar.gz", hash = "sha256:7b4fddbeb94a1eba4b557da24f19fdf9db575192544270a9101d8509f9f43d7b"},
+]
+
 [[package]]
 name = "requests"
 version = "2.31.0"
@@ -211,6 +372,17 @@ urllib3 = ">=1.21.1,<3"
 socks = ["PySocks (>=1.5.6,!=1.5.7)"]
 use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"]
 
+[[package]]
+name = "six"
+version = "1.16.0"
+description = "Python 2 and 3 compatibility utilities"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*"
+files = [
+    {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"},
+    {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"},
+]
+
 [[package]]
 name = "tomli"
 version = "2.0.1"
@@ -222,6 +394,17 @@ files = [
     {file = "tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f"},
 ]
 
+[[package]]
+name = "tzdata"
+version = "2023.3"
+description = "Provider of IANA time zone data"
+optional = false
+python-versions = ">=2"
+files = [
+    {file = "tzdata-2023.3-py2.py3-none-any.whl", hash = "sha256:7e65763eef3120314099b6939b5546db7adce1e7d6f2e179e3df563c70511eda"},
+    {file = "tzdata-2023.3.tar.gz", hash = "sha256:11ef1e08e54acb0d4f95bdb1be05da659673de4acbd21bf9c69e94cc5e907a3a"},
+]
+
 [[package]]
 name = "urllib3"
 version = "2.0.4"
@@ -242,4 +425,4 @@ zstd = ["zstandard (>=0.18.0)"]
 [metadata]
 lock-version = "2.0"
 python-versions = "^3.10"
-content-hash = "bc3567f9501f9e18bf9f53d8b4efe1e7e3fc2d750ceda2fbab165bfa22d49c64"
+content-hash = "eede625d6d45085e143b0af246cb2ce00cff8579c667be3b63387c8594a5570d"

pyproject.toml

@@ -1,14 +1,15 @@
 [tool.poetry]
 name = "homeharvest"
-version = "0.1.1"
+version = "0.1.3"
 description = "Real estate scraping library"
-authors = ["Zachary Hampton <zachary@zacharysproducts.com>"]
+authors = ["Zachary Hampton <zachary@zacharysproducts.com>", "Cullen Watson <cullen@cullen.ai>"]
 homepage = "https://github.com/ZacharyHampton/HomeHarvest"
 readme = "README.md"
 
 [tool.poetry.dependencies]
 python = "^3.10"
 requests = "^2.31.0"
+pandas = "^2.1.0"
 
 
 [tool.poetry.group.dev.dependencies]

tests/test_realtor.py

@@ -0,0 +1,12 @@
+from homeharvest import scrape_property
+
+
+def test_realtor():
+    results = [
+        scrape_property(location="2530 Al Lipscomb Way", site_name="realtor.com"),
+        scrape_property(location="Phoenix, AZ", site_name="realtor.com"),  #: does not support "city, state, USA" format
+        scrape_property(location="Dallas, TX", site_name="realtor.com"),  #: does not support "city, state, USA" format
+        scrape_property(location="85281", site_name="realtor.com"),
+    ]
+
+    assert all([result is not None for result in results])

tests/test_redfin.py

@@ -2,8 +2,11 @@ from homeharvest import scrape_property
 
 
 def test_redfin():
-    result = scrape_property(
-        location="85281"
-    )
+    results = [
+        scrape_property(location="2530 Al Lipscomb Way", site_name="redfin"),
+        scrape_property(location="Phoenix, AZ, USA", site_name="redfin"),
+        scrape_property(location="Dallas, TX, USA", site_name="redfin"),
+        scrape_property(location="85281", site_name="redfin"),
+    ]
 
-    assert result is not None
+    assert all([result is not None for result in results])

tests/test_zillow.py

@@ -0,0 +1,12 @@
+from homeharvest import scrape_property
+
+
+def test_zillow():
+    results = [
+        scrape_property(location="2530 Al Lipscomb Way", site_name="zillow"),
+        scrape_property(location="Phoenix, AZ, USA", site_name="zillow"),
+        scrape_property(location="Dallas, TX, USA", site_name="zillow"),
+        scrape_property(location="85281", site_name="zillow"),
+    ]
+
+    assert all([result is not None for result in results])