Property Unit Types API¶

def get_property_unit_types(
    top: Optional[int] = None,
    skip: Optional[int] = None,
    filter_query: Optional[str] = None,
    select: Optional[List[str]] = None,
    orderby: Optional[str] = None,
    count: bool = False
) -> Dict[str, Any]

from wfrmls import WFRMLSClient

client = WFRMLSClient()

# Get all unit types
unit_types = client.property_unit_types.get_property_unit_types()

# Get unit types for a specific property
property_units = client.property_unit_types.get_property_unit_types(
    filter_query="ListingKey eq '12345'"
)

# Get unit types with rental income > $1000
high_rent_units = client.property_unit_types.get_property_unit_types(
    filter_query="UnitTypeActualRent gt 1000",
    orderby="UnitTypeActualRent desc"
)

def get_unit_types_by_listing(
    listing_key: str
) -> Dict[str, Any]

# Get unit types for a property
units = client.property_unit_types.get_unit_types_by_listing("12345")

# Calculate total rental income
total_income = 0
for unit in units["value"]:
    units_count = unit.get("UnitTypeUnitsTotal", 0)
    rent = unit.get("UnitTypeActualRent", 0)
    total_income += units_count * rent

print(f"Total Monthly Income: ${total_income:,.2f}")

def get_residential_unit_types(
    top: Optional[int] = None,
    skip: Optional[int] = None
) -> Dict[str, Any]

def analyze_investment_property(listing_key: str):
    """Comprehensive analysis of rental income potential."""

    # Get unit types
    units_response = client.property_unit_types.get_unit_types_by_listing(listing_key)
    units = units_response["value"]

    # Get property details
    property_response = client.property.get_property_by_listing_key(listing_key)
    property_data = property_response

    # Calculate income metrics
    analysis = {
        "property_address": property_data.get("UnparsedAddress"),
        "list_price": property_data.get("ListPrice", 0),
        "unit_summary": [],
        "total_units": 0,
        "total_monthly_income": 0,
        "total_annual_income": 0,
        "gross_rent_multiplier": 0,
        "cap_rate": 0
    }

    # Analyze each unit type
    for unit in units:
        unit_count = unit.get("UnitTypeUnitsTotal", 0)
        rent = unit.get("UnitTypeActualRent", 0)
        beds = unit.get("UnitTypeBedsTotal", 0)
        baths = unit.get("UnitTypeBathsTotal", 0)

        monthly_income = unit_count * rent

        unit_info = {
            "type": f"{beds}BR/{baths}BA",
            "units": unit_count,
            "rent_per_unit": rent,
            "monthly_income": monthly_income,
            "description": unit.get("UnitTypeDescription", "")
        }

        analysis["unit_summary"].append(unit_info)
        analysis["total_units"] += unit_count
        analysis["total_monthly_income"] += monthly_income

    # Calculate investment metrics
    analysis["total_annual_income"] = analysis["total_monthly_income"] * 12

    if analysis["total_annual_income"] > 0:
        analysis["gross_rent_multiplier"] = (
            analysis["list_price"] / analysis["total_annual_income"]
        )

    # Estimate cap rate (simplified - doesn't include expenses)
    if analysis["list_price"] > 0:
        analysis["cap_rate"] = (
            (analysis["total_annual_income"] / analysis["list_price"]) * 100
        )

    return analysis

# Analyze a property
investment_analysis = analyze_investment_property("12345")

def generate_unit_mix_report(listing_keys: List[str]):
    """Generate report showing unit mix across multiple properties."""

    # Build filter for multiple properties
    filters = [f"ListingKey eq '{key}'" for key in listing_keys]
    filter_query = " or ".join(filters)

    # Get all unit types
    response = client.property_unit_types.get_property_unit_types(
        filter_query=f"({filter_query})"
    )

    # Aggregate by unit configuration
    unit_mix = {}
    property_summaries = {}

    for unit in response["value"]:
        listing_key = unit["ListingKey"]
        beds = unit.get("UnitTypeBedsTotal", 0)
        baths = unit.get("UnitTypeBathsTotal", 0)
        unit_config = f"{beds}BR/{baths}BA"

        # Update unit mix totals
        if unit_config not in unit_mix:
            unit_mix[unit_config] = {
                "total_units": 0,
                "avg_rent": 0,
                "rent_sum": 0,
                "properties": set()
            }

        units_count = unit.get("UnitTypeUnitsTotal", 0)
        rent = unit.get("UnitTypeActualRent", 0)

        unit_mix[unit_config]["total_units"] += units_count
        unit_mix[unit_config]["rent_sum"] += rent * units_count
        unit_mix[unit_config]["properties"].add(listing_key)

        # Track per property
        if listing_key not in property_summaries:
            property_summaries[listing_key] = {
                "total_units": 0,
                "total_income": 0
            }

        property_summaries[listing_key]["total_units"] += units_count
        property_summaries[listing_key]["total_income"] += rent * units_count

    # Calculate averages
    for config, data in unit_mix.items():
        if data["total_units"] > 0:
            data["avg_rent"] = data["rent_sum"] / data["total_units"]
        data["properties"] = len(data["properties"])
        del data["rent_sum"]  # Remove intermediate calculation

    return {
        "unit_mix": unit_mix,
        "property_summaries": property_summaries
    }

# Generate report for multiple properties
properties = ["12345", "67890", "11111"]
report = generate_unit_mix_report(properties)

def compare_rental_rates(bedroom_count: int, bathroom_count: int = None):
    """Compare rental rates for similar unit types."""

    # Build filter
    filters = [f"UnitTypeBedsTotal eq {bedroom_count}"]
    if bathroom_count:
        filters.append(f"UnitTypeBathsTotal eq {bathroom_count}")

    response = client.property_unit_types.get_property_unit_types(
        filter_query=" and ".join(filters),
        orderby="UnitTypeActualRent desc",
        top=100
    )

    # Calculate statistics
    rents = []
    for unit in response["value"]:
        rent = unit.get("UnitTypeActualRent", 0)
        if rent > 0:
            rents.append(rent)

    if rents:
        avg_rent = sum(rents) / len(rents)
        median_rent = sorted(rents)[len(rents) // 2]

        return {
            "bedroom_count": bedroom_count,
            "bathroom_count": bathroom_count,
            "sample_size": len(rents),
            "average_rent": avg_rent,
            "median_rent": median_rent,
            "min_rent": min(rents),
            "max_rent": max(rents),
            "rent_range": max(rents) - min(rents)
        }

    return None

# Compare 2-bedroom unit rates
comparison = compare_rental_rates(bedroom_count=2)

def calculate_portfolio_income(listing_keys: List[str]):
    """Calculate total income across a portfolio of properties."""

    portfolio = {
        "properties": {},
        "total_units": 0,
        "total_monthly_income": 0,
        "total_annual_income": 0,
        "unit_breakdown": {}
    }

    for listing_key in listing_keys:
        # Get units for this property
        units = client.property_unit_types.get_unit_types_by_listing(listing_key)

        property_income = 0
        property_units = 0

        for unit in units["value"]:
            units_count = unit.get("UnitTypeUnitsTotal", 0)
            rent = unit.get("UnitTypeActualRent", 0)
            beds = unit.get("UnitTypeBedsTotal", 0)

            income = units_count * rent
            property_income += income
            property_units += units_count

            # Track unit breakdown
            unit_type = f"{beds}BR"
            if unit_type not in portfolio["unit_breakdown"]:
                portfolio["unit_breakdown"][unit_type] = 0
            portfolio["unit_breakdown"][unit_type] += units_count

        # Store property summary
        portfolio["properties"][listing_key] = {
            "units": property_units,
            "monthly_income": property_income,
            "annual_income": property_income * 12
        }

        portfolio["total_units"] += property_units
        portfolio["total_monthly_income"] += property_income

    portfolio["total_annual_income"] = portfolio["total_monthly_income"] * 12

    return portfolio

# Calculate portfolio income
my_properties = ["12345", "67890", "11111"]
portfolio_summary = calculate_portfolio_income(my_properties)

def get_investment_properties_with_units():
    """Find investment properties with full unit details."""

    # Get multi-family properties
    properties = client.property.get_properties(
        filter_query="PropertySubType eq 'MultiFamily'",
        select=["ListingKey", "UnparsedAddress", "ListPrice", "UnitsTotal"],
        top=10
    )

    # Get unit types for all properties
    listing_keys = [p["ListingKey"] for p in properties["value"]]

    if listing_keys:
        filters = [f"ListingKey eq '{key}'" for key in listing_keys]
        units = client.property_unit_types.get_property_unit_types(
            filter_query=" or ".join(filters)
        )

        # Group units by property
        units_by_property = {}
        for unit in units["value"]:
            key = unit["ListingKey"]
            if key not in units_by_property:
                units_by_property[key] = []
            units_by_property[key].append(unit)

        # Combine data
        for prop in properties["value"]:
            prop["unit_types"] = units_by_property.get(prop["ListingKey"], [])

        return properties["value"]

    return []