vtorynka_api.py

import ssl
import logging
import aiohttp
from typing import Optional
from dataclasses import dataclass

logger = logging.getLogger(__name__)

API_BASE_URL = "https://api.vtorynka.com.ua"
PROPERTY_BASE_URL = "https://vtorynka.com.ua/ua/property"


@dataclass
class PropertyOffer:
    """Property offer from Vtorynka API"""
    slug: str
    title: str
    price: Optional[int]
    rooms: Optional[int]
    area: Optional[float]
    address: Optional[str]
    type_code: Optional[str]
    category_code: Optional[str]

    @property
    def url(self) -> str:
        return f"{PROPERTY_BASE_URL}/{self.slug}"


async def filter_offers(
    type_code: Optional[str] = None,
    category_code: Optional[str] = None,
    locality_name: Optional[str] = None,
    price_from: Optional[int] = None,
    price_to: Optional[int] = None,
    rooms: Optional[str] = None,
    page: int = 1,
    limit: int = 5
) -> tuple[list[PropertyOffer], int]:
    """
    Filter property offers from Vtorynka API

    Args:
        type_code: Type of deal - 'sale' or 'rent'
        category_code: Category - 'flat', 'house', etc.
        locality_name: City name - 'kyiv', 'odesa', etc.
        price_from: Minimum price
        price_to: Maximum price
        rooms: Number of rooms, can be comma-separated for multiple values (e.g., "1,2,3")
        page: Page number for pagination
        limit: Number of results per page

    Returns:
        tuple: (list of PropertyOffer, total count)
    """
    params = {}

    if type_code:
        params["typeCode"] = type_code
    if category_code:
        params["categoryCode"] = category_code
    if locality_name:
        params["localityName"] = locality_name
    if price_from is not None:
        params["priceFrom"] = price_from
    if price_to is not None:
        params["priceTo"] = price_to
    if rooms:
        params["rooms"] = rooms

    params["page"] = page
    params["limit"] = limit

    url = f"{API_BASE_URL}/realty/offers/filter"

    try:
        ssl_context = ssl.create_default_context()
        ssl_context.check_hostname = False
        ssl_context.verify_mode = ssl.CERT_NONE

        connector = aiohttp.TCPConnector(ssl=ssl_context)
        async with aiohttp.ClientSession(connector=connector) as session:
            # Log the full URL with params
            query_string = "&".join(f"{k}={v}" for k, v in params.items())
            full_url = f"{url}?{query_string}" if query_string else url
            logger.info(f"Vtorynka API request: {full_url}")

            async with session.get(url, params=params, timeout=aiohttp.ClientTimeout(total=10)) as response:
                if response.status != 200:
                    return [], 0

                data = await response.json()

                offers = []
                items = data.get("data", data.get("items", data)) if isinstance(data, dict) else data

                if isinstance(items, list):
                    for item in items:
                        offer = PropertyOffer(
                            slug=item.get("slug", ""),
                            title=item.get("title", item.get("name", "")),
                            price=item.get("price"),
                            rooms=item.get("rooms", item.get("roomCount")),
                            area=item.get("area", item.get("totalArea")),
                            address=item.get("address", item.get("location", "")),
                            type_code=item.get("typeCode", type_code),
                            category_code=item.get("categoryCode", category_code)
                        )
                        if offer.slug:
                            offers.append(offer)

                total = data.get("total", data.get("count", len(offers))) if isinstance(data, dict) else len(offers)

                logger.info(f"Vtorynka API response: {len(offers)} offers (total: {total})")
                return offers, total

    except Exception as e:
        logger.error(f"Vtorynka API error: {e}")
        return [], 0


def format_offers_json(offers: list[PropertyOffer]) -> str:
    """Format offers list as JSON for AI processing"""
    import json

    if not offers:
        return json.dumps({"offers": [], "total": 0})

    offers_data = []
    for offer in offers:
        offers_data.append({
            "title": offer.title,
            "rooms": offer.rooms,
            "area": offer.area,
            "price": offer.price,
            "address": offer.address,
            "url": offer.url
        })

    return json.dumps({"offers": offers_data, "total": len(offers_data)}, ensure_ascii=False)


# Function definition for OpenAI function calling
SEARCH_PROPERTIES_FUNCTION = {
    "name": "search_properties",
    "description": "Search for real estate properties/apartments using filters. Use this when a user asks about available properties, wants to see listings, or specifies criteria like number of rooms, price range, or location.",
    "parameters": {
        "type": "object",
        "properties": {
            "type_code": {
                "type": "string",
                "enum": ["sale", "rent"],
                "description": "Type of deal: 'sale' for buying, 'rent' for renting. Default is 'sale'."
            },
            "category_code": {
                "type": "string",
                "enum": ["apartment", "house", "commercial", "land"],
                "description": "Property category: 'apartment' for apartments/flats, 'house' for houses"
            },
            "locality_name": {
                "type": "string",
                "enum": ["Kyev", "Odesa", "Lviv", "Kharkiv", "Dnipro"],
                "description": "City name. IMPORTANT: Use 'Kyev' for Kyiv (not 'Kyiv'!)"
            },
            "price_from": {
                "type": "integer",
                "description": "Minimum price in USD"
            },
            "price_to": {
                "type": "integer",
                "description": "Maximum price in USD"
            },
            "rooms": {
                "type": "string",
                "description": "Number of rooms. Can be single value '2' or comma-separated '1,2,3' for multiple options"
            }
        }
    }
}