pypararius 2.0.0__py3-none-any.whl

pypararius/__init__.py

@@ -0,0 +1,20 @@
+"""
+Pararius - Python API for Pararius.com real estate listings.
+
+Example usage:
+    >>> from pypararius import Pararius
+    >>> p = Pararius()
+    >>> listing = p.get_listing('amsterdam/abc123/street')
+    >>> print(listing['title'], listing['price'])
+    Ridderspoorweg 10 1850
+
+    >>> results = p.search_listing('amsterdam', price_max=2000)
+    >>> for r in results[:3]:
+    ...     print(r['title'], r['city'])
+"""
+
+from pypararius.pararius import Pararius, ParariusAPI
+from pypararius.listing import Listing
+
+__version__ = "2.0.0"
+__all__ = ["Pararius", "ParariusAPI", "Listing"]

pypararius/listing.py

@@ -0,0 +1,138 @@
+"""Listing class - represents a Pararius property listing."""
+
+from typing import Any
+
+
+class Listing:
+    """A Pararius property listing.
+
+    Data can be accessed as listing['key'] or listing.get('key').
+
+    Example:
+        >>> listing = pararius.get_listing('amsterdam/abc123/street')
+        >>> listing['title']
+        'Ridderspoorweg 10'
+        >>> listing['price']
+        1850
+        >>> listing['city']
+        'Amsterdam'
+    """
+
+    keys_alias = {
+        'name': 'title',
+        'address': 'title',
+        'location': 'city',
+        'locality': 'city',
+        'area': 'living_area',
+        'size': 'living_area',
+        'area_m2': 'living_area',
+        'coords': 'coordinates',
+        'lat': 'latitude',
+        'lng': 'longitude',
+        'lon': 'longitude',
+        'zip': 'postcode',
+        'zipcode': 'postcode',
+        'postal_code': 'postcode',
+        'type': 'object_type',
+        'property_type': 'object_type',
+        'images': 'photos',
+        'pictures': 'photos',
+        'media': 'photos',
+        'desc': 'description',
+        'text': 'description',
+        'agent': 'broker',
+        'realtor': 'broker',
+        'makelaar': 'broker',
+        'energy_rating': 'energy_label',
+        'street': 'title',
+    }
+
+    def __init__(self, listing_id: str | int | None = None, data: dict | None = None):
+        self.listing_id = str(listing_id) if listing_id else None
+        self.data: dict[str, Any] = data or {}
+
+    def __repr__(self) -> str:
+        title = self.data.get('title', 'Unknown')
+        city = self.data.get('city', '')
+        return f"<Listing id:{self.listing_id} [{title}, {city}]>"
+
+    def __str__(self) -> str:
+        return self.__repr__()
+
+    def __contains__(self, key: str) -> bool:
+        return self._normalize_key(key) in self.data
+
+    def __getitem__(self, key: str) -> Any:
+        normalized = self._normalize_key(key)
+        if normalized not in self.data:
+            raise KeyError(key)
+        return self.data[normalized]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.data[self._normalize_key(key)] = value
+
+    def __bool__(self) -> bool:
+        return bool(self.listing_id or self.data.get('title'))
+
+    def _normalize_key(self, key: str) -> str:
+        """Normalize key using aliases."""
+        key = key.lower().replace('-', '_').replace(' ', '_')
+        return self.keys_alias.get(key, key)
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """Get a value with optional default."""
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
+    def keys(self) -> list[str]:
+        """Return all available keys."""
+        return list(self.data.keys())
+
+    def items(self) -> list[tuple[str, Any]]:
+        """Return all key-value pairs."""
+        return list(self.data.items())
+
+    def values(self) -> list[Any]:
+        """Return all values."""
+        return list(self.data.values())
+
+    def to_dict(self) -> dict[str, Any]:
+        """Return data as a plain dictionary."""
+        return self.data.copy()
+
+    def summary(self) -> str:
+        """Return a text summary of the listing."""
+        lines = []
+        title = self.data.get('title', 'Unknown')
+        city = self.data.get('city', '')
+        lines.append(f"Listing: {title}, {city}")
+
+        if price := self.data.get('price_formatted'):
+            lines.append(f"Price: {price}")
+        elif price := self.data.get('price'):
+            lines.append(f"Price: €{price:,}")
+
+        if area := self.data.get('living_area'):
+            lines.append(f"Living area: {area} m²")
+
+        if bedrooms := self.data.get('bedrooms'):
+            lines.append(f"Bedrooms: {bedrooms}")
+
+        if energy := self.data.get('energy_label'):
+            lines.append(f"Energy label: {energy}")
+
+        if url := self.data.get('url'):
+            lines.append(f"URL: {url}")
+
+        return '\n'.join(lines)
+
+    def getID(self) -> str | None:
+        """Return the listing ID."""
+        return self.listing_id
+
+    @property
+    def id(self) -> str | None:
+        """Alias for listing_id."""
+        return self.listing_id

pypararius/pararius.py

@@ -0,0 +1,238 @@
+"""Main Pararius API class."""
+
+import re
+from urllib.parse import urljoin
+
+import httpx
+
+from pypararius.listing import Listing
+from pypararius.parser import parse_listing_details, parse_search_response
+
+
+# Base URL
+BASE_URL = "https://www.pararius.com"
+
+# Headers
+HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36",
+    "Accept": "application/json, text/html",
+}
+
+
+class Pararius:
+    """Main interface to Pararius API.
+
+    Example:
+        >>> from pypararius import Pararius
+        >>> p = Pararius()
+        >>> listing = p.get_listing('amsterdam/abc123/street')
+        >>> print(listing['title'], listing['city'])
+        Ridderspoorweg 10 Amsterdam
+        >>> results = p.search_listing('amsterdam', price_max=2000)
+        >>> for r in results[:3]:
+        ...     print(r['title'], r['price'])
+    """
+
+    ID_PATTERN = re.compile(r"/([a-f0-9]{8})/")
+
+    def __init__(self, timeout: int = 30):
+        """Initialize Pararius API client.
+
+        Args:
+            timeout: Request timeout in seconds
+        """
+        self.timeout = timeout
+        self._client: httpx.Client | None = None
+
+    @property
+    def client(self) -> httpx.Client:
+        """Lazily create HTTP client."""
+        if self._client is None:
+            self._client = httpx.Client(
+                timeout=self.timeout,
+                headers=HEADERS,
+                follow_redirects=True,
+            )
+        return self._client
+
+    def close(self) -> None:
+        """Close the HTTP client."""
+        if self._client:
+            self._client.close()
+            self._client = None
+
+    def __enter__(self) -> "Pararius":
+        return self
+
+    def __exit__(self, *args) -> None:
+        self.close()
+
+    # -------------------------------------------------------------------------
+    # Listing methods
+    # -------------------------------------------------------------------------
+
+    def get_listing(self, listing_id: str) -> Listing:
+        """Get a listing by ID or URL.
+
+        Args:
+            listing_id: Listing ID (e.g., 'abc123de') or full/partial URL
+
+        Returns:
+            Listing object with property data
+
+        Example:
+            >>> p.get_listing('eecd88d9')
+            >>> p.get_listing('amsterdam/eecd88d9/ridderspoorweg')
+            >>> p.get_listing('https://www.pararius.com/apartment-for-rent/amsterdam/eecd88d9/ridderspoorweg')
+        """
+        # If it's a full URL, use it directly
+        if listing_id.startswith("http"):
+            url = listing_id
+        # If it contains slashes, it's a partial path
+        elif "/" in listing_id:
+            # Could be 'amsterdam/abc123/street' or '/apartment-for-rent/amsterdam/abc123/street'
+            if listing_id.startswith("/"):
+                url = urljoin(BASE_URL, listing_id)
+            else:
+                url = f"{BASE_URL}/apartment-for-rent/{listing_id}"
+        else:
+            # Just an ID - we need to search for it
+            raise ValueError(
+                f"Cannot fetch listing by ID alone. Please provide a URL or path like 'amsterdam/{listing_id}/street'"
+            )
+
+        response = self.client.get(url)
+
+        if response.status_code == 404:
+            raise LookupError(f"Listing {listing_id} not found")
+
+        response.raise_for_status()
+        return parse_listing_details(response.text, str(response.url))
+
+    def search_listing(
+        self,
+        location: str | list[str] | None = None,
+        price_min: int | None = None,
+        price_max: int | None = None,
+        area_min: int | None = None,
+        bedrooms: int | None = None,
+        interior: str | None = None,
+        sort: str | None = None,
+        page: int = 0,
+    ) -> list[Listing]:
+        """Search for listings.
+
+        Args:
+            location: City name to search in (e.g., 'amsterdam')
+            price_min: Minimum rent price
+            price_max: Maximum rent price
+            area_min: Minimum living area in m²
+            bedrooms: Minimum number of bedrooms
+            interior: Interior type ('furnished', 'upholstered', 'shell')
+            sort: Sort order - 'newest', 'price_asc', 'price_desc',
+                  'area_asc', 'area_desc', or None
+            page: Page number (0-indexed, ~30 results per page)
+
+        Returns:
+            List of Listing objects
+
+        Example:
+            >>> p.search_listing('amsterdam', price_max=2000)
+            >>> p.search_listing('rotterdam', bedrooms=2, interior='furnished')
+        """
+        # Normalize location
+        if isinstance(location, list):
+            city = location[0] if location else "amsterdam"
+        else:
+            city = location or "amsterdam"
+
+        city = city.lower().replace(" ", "-")
+
+        # Build URL
+        url = self._build_search_url(
+            city=city,
+            price_min=price_min,
+            price_max=price_max,
+            area_min=area_min,
+            bedrooms=bedrooms,
+            interior=interior,
+            sort=sort,
+            page=page + 1,  # Pararius uses 1-indexed pages
+        )
+
+        # Add XHR header to get JSON response
+        headers = {"X-Requested-With": "XMLHttpRequest"}
+
+        response = self.client.get(url, headers=headers)
+
+        if response.status_code != 200:
+            raise RuntimeError(f"Search failed (status {response.status_code})")
+
+        data = response.json()
+        return parse_search_response(data, city)
+
+    # -------------------------------------------------------------------------
+    # URL building
+    # -------------------------------------------------------------------------
+
+    def _build_search_url(
+        self,
+        city: str,
+        price_min: int | None = None,
+        price_max: int | None = None,
+        area_min: int | None = None,
+        bedrooms: int | None = None,
+        interior: str | None = None,
+        sort: str | None = None,
+        page: int = 1,
+    ) -> str:
+        """Build the search URL with filters."""
+        parts = [f"{BASE_URL}/apartments/{city}"]
+
+        # Price filter
+        if price_min is not None or price_max is not None:
+            p_min = price_min or 0
+            p_max = price_max or 0
+            if p_min > 0 or p_max > 0:
+                parts.append(f"{p_min}-{p_max}")
+
+        # Bedrooms filter
+        if bedrooms is not None and bedrooms > 0:
+            parts.append(f"{bedrooms}-bedrooms")
+
+        # Area filter
+        if area_min is not None and area_min > 0:
+            parts.append(f"{area_min}m2")
+
+        # Interior filter
+        if interior is not None:
+            interior_map = {
+                "furnished": "furnished",
+                "upholstered": "upholstered",
+                "shell": "shell",
+            }
+            if interior.lower() in interior_map:
+                parts.append(interior_map[interior.lower()])
+
+        # Page (must come before sort in URL)
+        if page > 1:
+            parts.append(f"page-{page}")
+
+        # Sort order
+        if sort is not None:
+            sort_map = {
+                "newest": "",  # Default
+                "price_asc": "sort-price-low",
+                "price_desc": "sort-price-high",
+                "area_asc": "sort-floor-low",
+                "area_desc": "sort-floor-high",
+            }
+            sort_val = sort_map.get(sort, "")
+            if sort_val:
+                parts.append(sort_val)
+
+        return "/".join(parts)
+
+
+# Convenience alias
+ParariusAPI = Pararius

pypararius/parser.py

@@ -0,0 +1,328 @@
+"""Parser utilities for Pararius HTML responses."""
+
+import json
+import re
+from typing import Optional
+
+from .listing import Listing
+
+
+def parse_search_response(data: dict, city: str) -> list[Listing]:
+    """Parse the JSON response from search endpoint into list of Listings."""
+    results_html = data.get("components", {}).get("results", "")
+    return _parse_listings_from_html(results_html, city)
+
+
+def _parse_listings_from_html(html: str, city: str) -> list[Listing]:
+    """Extract listings from search results HTML."""
+    listings = []
+
+    # Split by section starts
+    sections = re.split(r'<section\s+class="listing-search-item[^>]*>', html)
+
+    for section in sections[1:]:  # Skip first split
+        end_idx = section.find("</section>")
+        if end_idx <= 0:
+            continue
+
+        block = section[:end_idx]
+        listing = _parse_listing_block(block, city)
+        if listing:
+            listings.append(listing)
+
+    return listings
+
+
+def _parse_listing_block(block: str, city: str) -> Optional[Listing]:
+    """Parse a single listing block from search HTML."""
+    # URL and ID
+    url_match = re.search(r'href="(/apartment-for-rent/[^/]+/([^/]+)/([^"]+))"', block)
+    if not url_match:
+        return None
+
+    listing_id = url_match.group(2)
+    street = url_match.group(3).replace("-", " ").title()
+    url = f"https://www.pararius.com{url_match.group(1)}"
+
+    # Title from analytics data (more accurate street name)
+    title_match = re.search(r'element_text&quot;:&quot;([^&]+)&quot;', block)
+    if title_match:
+        title = title_match.group(1)
+        # Extract street from title like "Flat Ridderspoorweg"
+        if " " in title:
+            street = " ".join(title.split()[1:])
+
+    # Price
+    price = None
+    price_formatted = None
+    price_match = re.search(r'listing-search-item__price-main">([^<]+)</span>', block)
+    if price_match:
+        price_formatted = price_match.group(1).strip()
+        # Extract numeric price
+        price_nums = re.sub(r'[^\d]', '', price_formatted)
+        if price_nums:
+            price = int(price_nums)
+
+    # Neighborhood
+    neighbourhood = None
+    sub_match = re.search(r'listing-search-item__sub-title"[^>]*>\s*([^<]+)<', block)
+    if sub_match:
+        neighbourhood = sub_match.group(1).strip()
+
+    # Area
+    living_area = None
+    area_match = re.search(r'title="(\d+)\s*m[²2]"', block)
+    if area_match:
+        living_area = int(area_match.group(1))
+
+    # Rooms
+    rooms = None
+    rooms_match = re.search(r'title="(\d+)\s*room', block)
+    if rooms_match:
+        rooms = int(rooms_match.group(1))
+
+    # Image
+    photo_url = None
+    img_match = re.search(r'data-src="([^"]+)"', block)
+    if img_match:
+        photo_url = img_match.group(1).replace("&amp;", "&")
+
+    listing_data = {
+        "title": street,
+        "city": city.title(),
+        "neighbourhood": neighbourhood,
+        "price": price,
+        "price_formatted": price_formatted,
+        "living_area": living_area,
+        "rooms": rooms,
+        "url": url,
+        "photos": [photo_url] if photo_url else [],
+        "photo_urls": [photo_url] if photo_url else [],
+    }
+
+    return Listing(listing_id=listing_id, data=listing_data)
+
+
+def parse_listing_details(html: str, url: str) -> Listing:
+    """Parse full listing details from detail page HTML."""
+    listing_id = url.split("/")[-2] if "/" in url else ""
+
+    # Extract JSON-LD
+    jsonld = _extract_jsonld(html)
+
+    # Basic info from JSON-LD
+    name = jsonld.get("name", "")
+    description = jsonld.get("description")
+    main_image = jsonld.get("image")
+
+    # Address
+    addr_data = jsonld.get("address", {})
+    street = addr_data.get("streetAddress", "")
+    city = addr_data.get("addressLocality", "")
+    postcode = addr_data.get("postalCode")
+    neighbourhood = addr_data.get("addressRegion")
+
+    # Rooms and area from JSON-LD
+    rooms = None
+    rooms_data = jsonld.get("numberOfRooms", [])
+    if rooms_data and isinstance(rooms_data, list) and len(rooms_data) > 0:
+        rooms = rooms_data[0].get("value")
+
+    living_area = None
+    floor_data = jsonld.get("floorSize", {})
+    if floor_data:
+        living_area = floor_data.get("value")
+
+    # Price
+    price = None
+    currency = "EUR"
+    offer = jsonld.get("offers", {})
+    if offer:
+        price_str = offer.get("price")
+        if price_str:
+            price = int(float(price_str))
+        currency = offer.get("priceCurrency", "EUR")
+
+    # Features from HTML
+    features = _extract_features(html)
+
+    # All images
+    images = _extract_images(html)
+    if main_image and main_image not in images:
+        images.insert(0, main_image)
+
+    # Agent/Broker
+    broker = _extract_agent(html)
+
+    # Coordinates
+    coords = _extract_coordinates(html)
+
+    # Extract specific features
+    deposit = features.get("Deposit")
+    interior = features.get("Interior")
+    available = features.get("Available")
+    offered_since = features.get("Offered since")
+    rental_agreement = features.get("Rental agreement")
+    energy_label = features.get("Energy rating")
+
+    # Boolean features
+    smoking_allowed = None
+    pets_allowed = None
+    if "Smoking allowed" in features:
+        smoking_allowed = features["Smoking allowed"].lower() in ("yes", "ja", "allowed")
+    if "Pets allowed" in features:
+        pets_allowed = features["Pets allowed"].lower() in ("yes", "ja", "allowed", "in consultation")
+
+    # Bedrooms
+    bedrooms = None
+    if "Number of bedrooms" in features:
+        try:
+            bedrooms = int(features["Number of bedrooms"])
+        except ValueError:
+            pass
+
+    # Price formatted
+    price_formatted = f"€{price:,} per month" if price else None
+
+    listing_data = {
+        "title": name or street,
+        "city": city,
+        "postcode": postcode,
+        "neighbourhood": neighbourhood,
+        "price": price,
+        "price_formatted": price_formatted,
+        "currency": currency,
+        "living_area": living_area,
+        "rooms": rooms,
+        "bedrooms": bedrooms,
+        "description": description,
+        "url": url,
+        "photos": images,
+        "photo_urls": images,
+        "photo_count": len(images),
+        "energy_label": energy_label,
+        "offered_since": offered_since,
+        "characteristics": features,
+        # Rental-specific
+        "deposit": deposit,
+        "interior": interior,
+        "available": available,
+        "rental_agreement": rental_agreement,
+        "smoking_allowed": smoking_allowed,
+        "pets_allowed": pets_allowed,
+        "offering_type": "rent",
+        "object_type": "apartment",
+    }
+
+    # Coordinates
+    if coords:
+        listing_data["latitude"] = coords[0]
+        listing_data["longitude"] = coords[1]
+        listing_data["coordinates"] = coords
+
+    # Broker
+    if broker:
+        listing_data["broker"] = broker.get("name")
+        listing_data["broker_url"] = broker.get("url")
+        listing_data["broker_phone"] = broker.get("phone")
+
+    return Listing(listing_id=listing_id, data=listing_data)
+
+
+def _extract_jsonld(html: str) -> dict:
+    """Extract JSON-LD structured data from HTML."""
+    matches = re.findall(
+        r'<script type="application/ld\+json">(.*?)</script>',
+        html,
+        re.DOTALL,
+    )
+    for match in matches:
+        try:
+            data = json.loads(match)
+            type_val = data.get("@type", "")
+            if "House" in str(type_val) or "Product" in str(type_val):
+                return data
+        except json.JSONDecodeError:
+            continue
+    return {}
+
+
+def _extract_features(html: str) -> dict[str, str]:
+    """Extract features from listing HTML."""
+    features = {}
+
+    # Pattern 1: <dd class="listing-features__term">Term</dd> <dd ...><span>Value</span>
+    pattern1 = (
+        r'<dd class="listing-features__term">([^<]+)</dd>\s*'
+        r'<dd class="listing-features__description[^"]*">\s*'
+        r'(?:<span class="listing-features__main-description">)?([^<]+)'
+    )
+    for term, value in re.findall(pattern1, html):
+        features[term.strip()] = value.strip().replace("&nbsp;", " ")
+
+    # Pattern 2: <dt ...>Term</dt> <dd ...><span>Value</span> (for some features)
+    pattern2 = (
+        r'<dt class="listing-features__term[^"]*">([^<]+)</dt>\s*'
+        r'<dd class="listing-features__description[^"]*">\s*'
+        r'(?:\s*<span class="listing-features__main-description">)?([^<]+)'
+    )
+    for term, value in re.findall(pattern2, html):
+        features[term.strip()] = value.strip().replace("&nbsp;", " ")
+
+    return features
+
+
+def _extract_images(html: str) -> list[str]:
+    """Extract all listing images from HTML."""
+    images = set()
+    pattern = r'(https://casco-media-prod[^"&\s]+\.(?:jpg|png|webp))'
+    for img in re.findall(pattern, html):
+        # Prefer full-size images
+        if "width=600" in img or "width=" not in img:
+            clean_url = img.replace("&amp;", "&")
+            images.add(clean_url)
+    return list(images)[:20]  # Limit to 20 images
+
+
+def _extract_agent(html: str) -> Optional[dict]:
+    """Extract agent information from HTML."""
+    agent_url = None
+    agent_name = None
+    agent_phone = None
+
+    url_match = re.search(r'href="(/real-estate-agent[^"]+)"', html)
+    if url_match:
+        agent_url = f"https://www.pararius.com{url_match.group(1)}"
+
+    # Agent name is inside: <a class="agent-summary__title-link" ...>Name</a>
+    name_match = re.search(r'agent-summary__title-link"[^>]*>([^<]+)', html)
+    if name_match:
+        agent_name = name_match.group(1).strip()
+
+    phone_match = re.search(r'tel:([^"]+)', html)
+    if phone_match:
+        agent_phone = phone_match.group(1)
+
+    if agent_url or agent_name:
+        return {"name": agent_name, "url": agent_url, "phone": agent_phone}
+    return None
+
+
+def _extract_coordinates(html: str) -> Optional[tuple[float, float]]:
+    """Extract map coordinates from HTML."""
+    # Try data-latitude/data-longitude attributes
+    match = re.search(r'data-latitude="([^"]+)"[^>]*data-longitude="([^"]+)"', html)
+    if match:
+        return (float(match.group(1)), float(match.group(2)))
+
+    # Try data-lat/data-lon attributes (fallback)
+    match = re.search(r'data-lat="([^"]+)"[^>]*data-lon="([^"]+)"', html)
+    if match:
+        return (float(match.group(1)), float(match.group(2)))
+
+    # Try JSON in script
+    match = re.search(r'"lat":\s*([\d.]+).*?"lon":\s*([\d.]+)', html)
+    if match:
+        return (float(match.group(1)), float(match.group(2)))
+
+    return None

pypararius-2.0.0.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: pypararius
+Version: 2.0.0
+Summary: Python API wrapper for Pararius.com real estate listings
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'

pypararius-2.0.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+pypararius/__init__.py,sha256=q68u5npo3QIW3BV84YCIPrRyAqcydlJ4TrILELdlB3o,586
+pypararius/listing.py,sha256=sxm7jl6Sod0ynW5-hcTFdZpvgIKgDXdjmQS60CnSO90,4166
+pypararius/pararius.py,sha256=1673qk6Hd8nU4OKS3pbGcdczuN5BpyIbBWYnEvEHdIU,7493
+pypararius/parser.py,sha256=mVtSkPCExxQMLLG5PzZXli_GUJeqmUKPpPXE4P8-DlI,10519
+pypararius-2.0.0.dist-info/METADATA,sha256=QsYdxD0TbJB10bU9vH0kofGI1n8Uv9rs5w76XQsr17o,292
+pypararius-2.0.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+pypararius-2.0.0.dist-info/RECORD,,

pypararius-2.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any