scrapebadger-cli 0.2.1__py3-none-any.whl

scrapebadger_cli/commands/idealista.py

@@ -0,0 +1,220 @@
+"""Idealista real-estate commands."""
+
+import typer
+
+from scrapebadger_cli.client import api_get
+from scrapebadger_cli.output import render
+
+app = typer.Typer(no_args_is_help=True)
+
+FMT = typer.Option("json", "--output", "-o", help="Output format: json, csv, table, markdown")
+FIELDS = typer.Option(None, "--fields", "-f", help="Comma-separated fields to include")
+MARKET = typer.Option("es", "--market", "-m", help="Idealista market: es, it or pt")
+
+
+@app.command()
+def suggest(
+    query: str = typer.Argument(..., help="Free-text location, e.g. 'sagrada familia'"),
+    operation: str = typer.Option("sale", "--operation", help="sale or rent"),
+    property_type: str = typer.Option("homes", "--property-type", help="e.g. homes, offices"),
+    market: str = MARKET,
+    locale: str | None = typer.Option(None, "--locale", help="Response locale: en, es, it or pt"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Resolve free-text location text into Idealista location codes."""
+    data = api_get(
+        "/v1/idealista/suggest",
+        {
+            "query": query,
+            "operation": operation,
+            "property_type": property_type,
+            "market": market,
+            "locale": locale,
+        },
+    )
+    render(data, fmt, fields)
+
+
+@app.command()
+def search(
+    location: str = typer.Argument(..., help="Idealista location code (from suggest)"),
+    operation: str = typer.Option("sale", "--operation", help="sale or rent"),
+    property_type: str = typer.Option("homes", "--property-type", help="e.g. homes, offices"),
+    market: str = MARKET,
+    page: int = typer.Option(1, "--page", "-p"),
+    max_items: int = typer.Option(30, "--max-items", help="Results per page (1..50)"),
+    sort_by: str | None = typer.Option(
+        None,
+        "--sort-by",
+        help="distance, size, rooms, floor, ratioeurm2, price, street, photos, "
+        "modificationDate, publicationDate, weigh, priceDown, "
+        "preservationTypeAndPrice or privateAds",
+    ),
+    sort_order: str = typer.Option("desc", "--sort-order", help="asc or desc"),
+    min_price: float | None = typer.Option(None, "--min-price"),
+    max_price: float | None = typer.Option(None, "--max-price"),
+    min_size: float | None = typer.Option(None, "--min-size"),
+    max_size: float | None = typer.Option(None, "--max-size"),
+    min_rooms: int | None = typer.Option(None, "--min-rooms"),
+    max_rooms: int | None = typer.Option(None, "--max-rooms"),
+    locale: str | None = typer.Option(None, "--locale", help="Response locale: en, es, it or pt"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Search Idealista property listings by location code."""
+    data = api_get(
+        "/v1/idealista/search",
+        {
+            "location": location,
+            "operation": operation,
+            "property_type": property_type,
+            "market": market,
+            "page": page,
+            "max_items": max_items,
+            "sort_by": sort_by,
+            "sort_order": sort_order,
+            "min_price": min_price,
+            "max_price": max_price,
+            "min_size": min_size,
+            "max_size": max_size,
+            "min_rooms": min_rooms,
+            "max_rooms": max_rooms,
+            "locale": locale,
+        },
+    )
+    render(data, fmt, fields)
+
+
+@app.command(name="search-all")
+def search_all(
+    location: str = typer.Argument(..., help="Idealista location code (from suggest)"),
+    operation: str = typer.Option("sale", "--operation", help="sale or rent"),
+    property_type: str = typer.Option("homes", "--property-type", help="e.g. homes, offices"),
+    market: str = MARKET,
+    max_results: int = typer.Option(500, "--max-results", help="Max deduped results (1..3000)"),
+    min_price: float | None = typer.Option(None, "--min-price"),
+    max_price: float | None = typer.Option(None, "--max-price"),
+    min_size: float | None = typer.Option(None, "--min-size"),
+    max_size: float | None = typer.Option(None, "--max-size"),
+    min_rooms: int | None = typer.Option(None, "--min-rooms"),
+    max_rooms: int | None = typer.Option(None, "--max-rooms"),
+    locale: str | None = typer.Option(None, "--locale", help="Response locale: en, es, it or pt"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Fetch the full Idealista inventory for a location via price tiling."""
+    data = api_get(
+        "/v1/idealista/search/all",
+        {
+            "location": location,
+            "operation": operation,
+            "property_type": property_type,
+            "market": market,
+            "max_results": max_results,
+            "min_price": min_price,
+            "max_price": max_price,
+            "min_size": min_size,
+            "max_size": max_size,
+            "min_rooms": min_rooms,
+            "max_rooms": max_rooms,
+            "locale": locale,
+        },
+    )
+    render(data, fmt, fields)
+
+
+@app.command()
+def property(
+    property_code: str = typer.Argument(..., help="Idealista property code"),
+    market: str = MARKET,
+    locale: str = typer.Option("en", "--locale", help="Response locale: en, es, it or pt"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get the full detail of a single Idealista property by its code."""
+    data = api_get(
+        f"/v1/idealista/properties/{property_code}",
+        {"market": market, "locale": locale},
+    )
+    render(data, fmt, fields)
+
+
+@app.command()
+def stats(
+    property_code: str = typer.Argument(..., help="Idealista property code"),
+    market: str = MARKET,
+    locale: str = typer.Option("en", "--locale", help="Response locale: en, es, it or pt"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get engagement stats (views, contacts, favorites) for an Idealista listing."""
+    data = api_get(
+        f"/v1/idealista/properties/{property_code}/stats",
+        {"market": market, "locale": locale},
+    )
+    render(data, fmt, fields)
+
+
+@app.command()
+def agency(
+    short_name: str = typer.Argument(..., help="Agency URL slug (micrositeShortName)"),
+    market: str = MARKET,
+    operation: str | None = typer.Option(None, "--operation", help="sale or rent"),
+    property_type: str | None = typer.Option(None, "--property-type", help="e.g. homes, offices"),
+    page: int = typer.Option(1, "--page", "-p"),
+    max_items: int = typer.Option(30, "--max-items", help="Listings per page (1..50)"),
+    include_listings: bool = typer.Option(True, "--include-listings/--no-listings"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get an Idealista agency (microsite) profile plus a page of its listings."""
+    data = api_get(
+        f"/v1/idealista/agency/{short_name}",
+        {
+            "market": market,
+            "operation": operation,
+            "property_type": property_type,
+            "page": page,
+            "max_items": max_items,
+            "include_listings": include_listings,
+        },
+    )
+    render(data, fmt, fields)
+
+
+@app.command(name="agency-by-phone")
+def agency_by_phone(
+    phone: str = typer.Argument(..., help="Agency national contact number (no country prefix)"),
+    market: str = MARKET,
+    operation: str | None = typer.Option(None, "--operation", help="sale or rent"),
+    property_type: str | None = typer.Option(None, "--property-type", help="e.g. homes, offices"),
+    page: int = typer.Option(1, "--page", "-p"),
+    max_items: int = typer.Option(30, "--max-items", help="Listings per page (1..50)"),
+    include_listings: bool = typer.Option(True, "--include-listings/--no-listings"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Reverse-lookup an Idealista agency from its contact phone number."""
+    data = api_get(
+        f"/v1/idealista/agency/by-phone/{phone}",
+        {
+            "market": market,
+            "operation": operation,
+            "property_type": property_type,
+            "page": page,
+            "max_items": max_items,
+            "include_listings": include_listings,
+        },
+    )
+    render(data, fmt, fields)
+
+
+@app.command()
+def markets(
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """List all supported Idealista markets (es, it, pt)."""
+    data = api_get("/v1/idealista/markets")
+    render(data, fmt, fields)

scrapebadger_cli/commands/immobiliare.py

@@ -0,0 +1,151 @@
+"""Immobiliare.it real-estate commands."""
+
+import typer
+
+from scrapebadger_cli.client import api_get
+from scrapebadger_cli.output import render
+
+app = typer.Typer(no_args_is_help=True)
+
+FMT = typer.Option("json", "--output", "-o", help="Output format: json, csv, table, markdown")
+FIELDS = typer.Option(None, "--fields", "-f", help="Comma-separated fields to include")
+MARKET = typer.Option("it", "--market", "-m", help="Market: it, es, gr, lu")
+
+
+@app.command()
+def autocomplete(
+    query: str = typer.Argument(..., help="Partial location text"),
+    market: str = MARKET,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get Immobiliare location autocomplete suggestions."""
+    data = api_get("/v1/immobiliare/autocomplete", {"query": query, "market": market})
+    render(data, fmt, fields)
+
+
+@app.command()
+def search(
+    location: str | None = typer.Option(None, "--location", "-l", help="Free-text location"),
+    region_id: str | None = typer.Option(None, "--region-id", help="Region ID"),
+    province_id: str | None = typer.Option(None, "--province-id", help="Province ID"),
+    city_id: str | None = typer.Option(None, "--city-id", help="City ID"),
+    contract: str | None = typer.Option(None, "--contract", help="sale, rent"),
+    category: str | None = typer.Option(
+        None,
+        "--category",
+        help="residential, commercial, garages, offices, land, buildings, warehouses",
+    ),
+    price_min: int | None = typer.Option(None, "--price-min"),
+    price_max: int | None = typer.Option(None, "--price-max"),
+    surface_min: int | None = typer.Option(None, "--surface-min", help="Min surface (m²)"),
+    surface_max: int | None = typer.Option(None, "--surface-max", help="Max surface (m²)"),
+    rooms_min: int | None = typer.Option(None, "--rooms-min"),
+    rooms_max: int | None = typer.Option(None, "--rooms-max"),
+    bathrooms_min: int | None = typer.Option(None, "--bathrooms-min"),
+    sort: str | None = typer.Option(
+        None,
+        "--sort",
+        help="relevance, price_asc, price_desc, newest, oldest, surface_desc, surface_asc",
+    ),
+    page: int = typer.Option(1, "--page", "-p"),
+    market: str = MARKET,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Search Immobiliare real-estate listings."""
+    data = api_get(
+        "/v1/immobiliare/search",
+        {
+            "market": market,
+            "location": location,
+            "region_id": region_id,
+            "province_id": province_id,
+            "city_id": city_id,
+            "contract": contract,
+            "category": category,
+            "price_min": price_min,
+            "price_max": price_max,
+            "surface_min": surface_min,
+            "surface_max": surface_max,
+            "rooms_min": rooms_min,
+            "rooms_max": rooms_max,
+            "bathrooms_min": bathrooms_min,
+            "sort": sort,
+            "page": page,
+        },
+    )
+    render(data, fmt, fields)
+
+
+@app.command()
+def listing(
+    listing_id: int = typer.Argument(..., help="Immobiliare listing ID"),
+    market: str = MARKET,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get a full Immobiliare listing detail by ID."""
+    data = api_get(f"/v1/immobiliare/listings/{listing_id}", {"market": market})
+    render(data, fmt, fields)
+
+
+@app.command()
+def agency(
+    agency_id: int = typer.Argument(..., help="Immobiliare agency ID"),
+    market: str = MARKET,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get an Immobiliare agency profile by ID."""
+    data = api_get(f"/v1/immobiliare/agencies/{agency_id}", {"market": market})
+    render(data, fmt, fields)
+
+
+@app.command(name="agency-listings")
+def agency_listings(
+    agency_id: int = typer.Argument(..., help="Immobiliare agency ID"),
+    page: int = typer.Option(1, "--page", "-p"),
+    market: str = MARKET,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get the active listings of an Immobiliare agency."""
+    data = api_get(
+        f"/v1/immobiliare/agencies/{agency_id}/listings", {"market": market, "page": page}
+    )
+    render(data, fmt, fields)
+
+
+@app.command(name="price-insights")
+def price_insights(
+    region_id: str = typer.Option(..., "--region-id", help="Region ID (required)"),
+    province_id: str | None = typer.Option(None, "--province-id", help="Narrow to a province"),
+    city_id: str | None = typer.Option(None, "--city-id", help="Narrow to a city"),
+    contract: str | None = typer.Option(None, "--contract", help="sale, rent"),
+    market: str = MARKET,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get price-per-m² history (monthly EUR/m² time series) for an area."""
+    data = api_get(
+        "/v1/immobiliare/market-insights/prices",
+        {
+            "market": market,
+            "region_id": region_id,
+            "province_id": province_id,
+            "city_id": city_id,
+            "contract": contract,
+        },
+    )
+    render(data, fmt, fields)
+
+
+@app.command()
+def markets(
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """List supported Immobiliare Group markets (it, es, gr, lu)."""
+    data = api_get("/v1/immobiliare/markets")
+    render(data, fmt, fields)

scrapebadger_cli/commands/leboncoin.py

@@ -0,0 +1,154 @@
+"""Leboncoin classifieds commands."""
+
+import typer
+
+from scrapebadger_cli.client import api_get
+from scrapebadger_cli.output import render
+
+app = typer.Typer(no_args_is_help=True)
+
+FMT = typer.Option("json", "--output", "-o", help="Output format: json, csv, table, markdown")
+FIELDS = typer.Option(None, "--fields", "-f", help="Comma-separated fields to include")
+
+
+@app.command()
+def search(
+    text: str | None = typer.Option(None, "--text", "-t", help="Search text / keywords"),
+    category: str | None = typer.Option(None, "--category", help="Restrict to a category"),
+    region_id: str | None = typer.Option(None, "--region-id", help="Restrict to a region"),
+    department_id: str | None = typer.Option(
+        None, "--department-id", help="Restrict to a department"
+    ),
+    city: str | None = typer.Option(None, "--city", help="Restrict to a city"),
+    zipcode: str | None = typer.Option(None, "--zipcode", help="Restrict to a zip/postal code"),
+    price_min: int | None = typer.Option(None, "--price-min"),
+    price_max: int | None = typer.Option(None, "--price-max"),
+    owner_type: str | None = typer.Option(None, "--owner-type", help="all, pro, private"),
+    ad_type: str | None = typer.Option(None, "--ad-type", help="offer, demand"),
+    sort: str | None = typer.Option(
+        None, "--sort", help="relevance, newest, oldest, price_low, price_high"
+    ),
+    page: int = typer.Option(1, "--page", "-p"),
+    limit: int | None = typer.Option(None, "--limit", help="Results per page (max 100)"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Search Leboncoin classified ads (France)."""
+    data = api_get(
+        "/v1/leboncoin/search",
+        {
+            "text": text,
+            "category": category,
+            "region_id": region_id,
+            "department_id": department_id,
+            "city": city,
+            "zipcode": zipcode,
+            "price_min": price_min,
+            "price_max": price_max,
+            "owner_type": owner_type,
+            "ad_type": ad_type,
+            "sort": sort,
+            "page": page,
+            "limit": limit,
+        },
+    )
+    render(data, fmt, fields)
+
+
+@app.command()
+def ad(
+    list_id: int = typer.Argument(..., help="Leboncoin ad list ID"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get a full Leboncoin ad detail page by list ID."""
+    data = api_get(f"/v1/leboncoin/ads/{list_id}")
+    render(data, fmt, fields)
+
+
+@app.command()
+def similar(
+    list_id: int = typer.Argument(..., help="Leboncoin ad list ID"),
+    limit: int | None = typer.Option(None, "--limit", help="Max similar ads to return"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get ads similar to a Leboncoin ad."""
+    data = api_get(f"/v1/leboncoin/ads/{list_id}/similar", {"limit": limit})
+    render(data, fmt, fields)
+
+
+@app.command()
+def seller(
+    user_id: str = typer.Argument(..., help="Leboncoin seller UUID"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get a Leboncoin seller / pro-store profile."""
+    data = api_get(f"/v1/leboncoin/sellers/{user_id}")
+    render(data, fmt, fields)
+
+
+@app.command(name="seller-listings")
+def seller_listings(
+    user_id: str = typer.Argument(..., help="Leboncoin seller UUID"),
+    page: int = typer.Option(1, "--page", "-p"),
+    limit: int | None = typer.Option(None, "--limit", help="Results per page (max 100)"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get the active listings of a Leboncoin seller."""
+    data = api_get(f"/v1/leboncoin/sellers/{user_id}/listings", {"page": page, "limit": limit})
+    render(data, fmt, fields)
+
+
+@app.command()
+def categories(
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """List reference Leboncoin categories."""
+    data = api_get("/v1/leboncoin/categories")
+    render(data, fmt, fields)
+
+
+@app.command()
+def regions(
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """List reference Leboncoin regions."""
+    data = api_get("/v1/leboncoin/regions")
+    render(data, fmt, fields)
+
+
+@app.command()
+def departments(
+    region_id: str | None = typer.Option(None, "--region-id", help="Restrict to a region"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """List reference Leboncoin departments (optionally scoped to a region)."""
+    data = api_get("/v1/leboncoin/departments", {"region_id": region_id})
+    render(data, fmt, fields)
+
+
+@app.command()
+def locations(
+    q: str = typer.Argument(..., help="Partial location text"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get Leboncoin location autocomplete suggestions."""
+    data = api_get("/v1/leboncoin/locations/search", {"q": q})
+    render(data, fmt, fields)
+
+
+@app.command()
+def markets(
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """List all supported Leboncoin markets (France only)."""
+    data = api_get("/v1/leboncoin/markets")
+    render(data, fmt, fields)

scrapebadger_cli/commands/loopnet.py

@@ -0,0 +1,89 @@
+"""LoopNet commercial real-estate commands."""
+
+import typer
+
+from scrapebadger_cli.client import api_get
+from scrapebadger_cli.output import render
+
+app = typer.Typer(no_args_is_help=True)
+
+FMT = typer.Option("json", "--output", "-o", help="Output format: json, csv, table, markdown")
+FIELDS = typer.Option(None, "--fields", "-f", help="Comma-separated fields to include")
+MARKET = typer.Option("us", "--market", "-m", help="us, ca, uk, fr, es")
+
+
+@app.command()
+def search(
+    location: str = typer.Argument(..., help='City/state, ZIP, state code or "usa"'),
+    market: str = MARKET,
+    listing_type: str = typer.Option(
+        "for-lease", "--listing-type", "-t", help="for-lease, for-sale, auctions"
+    ),
+    property_type: str | None = typer.Option(
+        None, "--property-type", help="Slug from `loopnet property-types` (default all)"
+    ),
+    page: int = typer.Option(1, "--page", "-p", help="1-20 (LoopNet caps at ~500 results)"),
+    min_price: int | None = typer.Option(None, "--min-price"),
+    max_price: int | None = typer.Option(None, "--max-price"),
+    price_type: str | None = typer.Option(None, "--price-type", help="unit, sf, acre"),
+    min_size: int | None = typer.Option(None, "--min-size", help="Minimum size (SF)"),
+    max_size: int | None = typer.Option(None, "--max-size", help="Maximum size (SF)"),
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Search LoopNet for commercial real-estate listings."""
+    data = api_get(
+        "/v1/loopnet/search",
+        {
+            "location": location,
+            "market": market,
+            "listing_type": listing_type,
+            "property_type": property_type,
+            "page": page,
+            "min_price": min_price,
+            "max_price": max_price,
+            "price_type": price_type,
+            "min_size": min_size,
+            "max_size": max_size,
+        },
+    )
+    render(data, fmt, fields)
+
+
+@app.command()
+def listing(
+    listing_id: str = typer.Argument(..., help="LoopNet listing id"),
+    market: str = MARKET,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get a LoopNet listing's full detail by listing id."""
+    data = api_get(f"/v1/loopnet/listings/{listing_id}", {"market": market})
+    render(data, fmt, fields)
+
+
+@app.command()
+def broker(
+    slug: str = typer.Argument(..., help="Broker URL slug"),
+    broker_id: str = typer.Argument(..., help="LoopNet broker id"),
+    market: str = MARKET,
+    fmt: str = FMT,
+    fields: str | None = FIELDS,
+) -> None:
+    """Get a LoopNet broker's profile and their active listings."""
+    data = api_get(f"/v1/loopnet/brokers/{slug}/{broker_id}", {"market": market})
+    render(data, fmt, fields)
+
+
+@app.command("markets")
+def list_markets(fmt: str = FMT, fields: str | None = FIELDS) -> None:
+    """List LoopNet coverage markets (US, CA, UK, FR, ES)."""
+    data = api_get("/v1/loopnet/markets", {})
+    render(data, fmt, fields)
+
+
+@app.command("property-types")
+def list_property_types(fmt: str = FMT, fields: str | None = FIELDS) -> None:
+    """List LoopNet property-type slugs (office, retail, industrial, etc.)."""
+    data = api_get("/v1/loopnet/property-types", {})
+    render(data, fmt, fields)