@camstack/addon-waste-collections 0.0.0-stage → 0.1.1

package/python/vendor/waste_collection_schedule/source/insert_it_de.py

@@ -0,0 +1,199 @@
+import json
+from datetime import datetime
+
+import requests
+from waste_collection_schedule import Collection  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import (
+    SourceArgumentExceptionMultiple,
+    SourceArgumentNotFound,
+    SourceArgumentNotFoundWithSuggestions,
+)
+from waste_collection_schedule.service.ICS import ICS
+from waste_collection_schedule.service.InsertITDe import SERVICE_MAP
+
+TITLE = "Insert IT Apps"
+DESCRIPTION = "Source for Apps by Insert IT"
+URL = "https://insert-infotech.de/"
+COUNTRY = "de"
+
+
+def EXTRA_INFO():
+    return [{"title": s["title"], "url": s["url"]} for s in SERVICE_MAP]
+
+
+TEST_CASES = {
+    "Offenbach Address": {
+        "municipality": "Offenbach",
+        "street": "Kaiserstraße",
+        "hnr": 1,
+    },
+    "Offenbach Location ID": {"municipality": "Offenbach", "location_id": 7036},
+    "Mannheim Address": {"municipality": "Mannheim", "street": "A 3", "hnr": 1},
+    "Mannheim Location ID": {"municipality": "Mannheim", "location_id": 430650},
+}
+
+
+MUNICIPALITIES = {
+    "Hattingen": "BmsAbfallkalenderHattingen",
+    "Herne": "BmsAbfallkalenderHerne",
+    "Kassel": "BmsAbfallkalenderKassel",
+    "Krefeld": "BmsAbfallkalenderKrefeld",
+    "Luebeck": "BmsAbfallkalenderLuebeck",
+    "Mannheim": "BmsAbfallkalenderMannheim",
+    "Offenbach": "BmsAbfallkalenderOffenbach",
+}
+
+ICON_MAP = {
+    "Offenbach": {
+        "Restmüll": {"icon": "mdi:trash-can", "name": "Restmüll"},
+        "Biomüll": {"icon": "mdi:leaf", "name": "Biomüll"},
+        "DSD": {"icon": "mdi:recycle", "name": "DSD"},
+        "Altpapier": {"icon": "mdi:package-variant", "name": "Altpapier"},
+    },
+    "Mannheim": {
+        "Rest": {"icon": "mdi:trash-can", "name": "Restmüll"},
+        "Wertstoff": {"icon": "mdi:recycle", "name": "Sack/Tonne gelb"},
+        "Bio": {"icon": "mdi:leaf", "name": "Biomüll"},
+        "Papier": {"icon": "mdi:package-variant", "name": "Altpapier"},
+        "Grünschnitt": {"icon": "mdi:leaf", "name": "Grünschnitt"},
+    },
+}
+
+REGEX_MAP = {
+    "Hattingen": r"Leerung:\s+(.*)\s+\(.*\)",
+    "Herne": r"Leerung:\s+(.*)\s+\(.*\)",
+    "Kassel": r"Leerung:\s+(.*)\s+\(.*\)",
+    "Krefeld": r"Leerung:\s+(.*)\s+\(.*\)",
+    "Luebeck": r"Leerung:\s+(.*)\s+\(.*\)",
+    "Mannheim": r"Leerung:\s+(.*)",
+    "Offenbach": r"Leerung:\s+(.*)\s+\(.*\)",
+}
+
+PARAM_TRANSLATIONS = {
+    "de": {
+        "municipality": "Ort",
+        "street": "Straße",
+        "hnr": "Hausnummer",
+        "location_id": "Standort ID",
+    }
+}
+
+
+class Source:
+    def __init__(self, municipality, street=None, hnr=None, location_id=None):
+        self._municipality = municipality
+        self._street = street
+        self._hnr = hnr
+        self._location = location_id
+
+        # Check if municipality is in list
+        municipalities = MUNICIPALITIES
+        if municipality not in municipalities:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "municipality", municipality, list(municipalities.keys())
+            )
+
+        self._api_url = f"https://www.insert-it.de/{municipalities[municipality]}"
+        self._ics = ICS(regex=REGEX_MAP.get(municipality))
+
+        # Check if at least either location_id is set or both street and hnr are set
+        if not ((location_id is not None) or (street is not None and hnr is not None)):
+            problems = []
+            if street is not None:
+                problems.append("hnr")
+            elif hnr is not None:
+                problems.append("street")
+            else:
+                problems = ["location_id", "street", "hnr"]
+
+            raise SourceArgumentExceptionMultiple(
+                problems,
+                "At least either location_id should be set or both street and hnr should be set.",
+            )
+
+        self._uselocation = location_id is not None
+
+    def get_street_id(self):
+        """Return ID of matching street."""
+        s = requests.Session()
+        params = {"text": self._street}
+
+        r = s.get(f"{self._api_url}/Main/GetStreets", params=params)
+        r.raise_for_status()
+        r.encoding = "utf-8"
+
+        result = json.loads(r.text)
+        if not result:
+            raise SourceArgumentNotFound("street", self._street)
+
+        for element in result:
+            if element["Name"] == self._street:
+                street_id = element["ID"]
+                return street_id
+
+        raise SourceArgumentNotFoundWithSuggestions(
+            "street", self._street, [x["Name"] for x in result]
+        )
+
+    def get_location_id(self, street_id):
+        """Return ID of first matching location."""
+        s = requests.Session()
+        params = {"streetId": street_id, "houseNumber": self._hnr}
+
+        r = s.get(f"{self._api_url}/Main/GetLocations", params=params)
+        r.raise_for_status()
+        r.encoding = "utf-8"
+
+        result = json.loads(r.text)
+        if not result:
+            raise Exception(
+                f"No locations found for Street ID {street_id} and House number {self._hnr}"
+            )
+
+        for element in result:
+            if element["StreetId"] == street_id and element["Text"] == str(self._hnr):
+                location_id = element["ID"]
+                return location_id
+
+        raise SourceArgumentNotFound(
+            "hnr", self._hnr, [x["Text"] for x in result if x["StreetId"] == street_id]
+        )
+
+    def fetch(self):
+        if not (self._uselocation):
+            street_id = self.get_street_id()
+            self._location = self.get_location_id(street_id)
+
+        now = datetime.now()
+
+        entries = self.fetch_year(now.year)
+        if now.month == 12:
+            entries += self.fetch_year(now.year + 1)
+        return entries
+
+    def fetch_year(self, year):
+        s = requests.Session()
+        params = {"bmsLocationId": self._location, "year": year}
+
+        r = s.get(f"{self._api_url}/Main/Calender", params=params)
+        r.raise_for_status()
+        r.encoding = "utf-8"
+
+        entries = []
+
+        dates = self._ics.convert(r.text)
+        mapping = ICON_MAP.get(self._municipality)
+
+        for d in dates:
+            if mapping is not None and d[1] in mapping:
+                entries.append(
+                    Collection(
+                        date=d[0],
+                        t=mapping[d[1]]["name"],
+                        icon=mapping[d[1]]["icon"],
+                    )
+                )
+            else:
+                entries.append(Collection(d[0], d[1]))
+
+        return entries

package/python/vendor/waste_collection_schedule/source/inverclyde_gov_uk.py

@@ -0,0 +1,160 @@
+import re
+
+from curl_cffi import requests
+from dateutil.parser import parse as parse_date
+from waste_collection_schedule import Collection, Icons  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFoundWithSuggestions
+
+TITLE = "Inverclyde Council"
+DESCRIPTION = "Source for Inverclyde Council, UK, waste collection."
+URL = "https://www.inverclyde.gov.uk"
+TEST_CASES = {
+    "1 Findhorn Crescent": {"postcode": "PA16 0FG", "address": "1 Findhorn Crescent"},
+    "1 Merrylee Avenue": {"postcode": "PA14 5UT", "address": "1 Merrylee Avenue"},
+    "10 St John's Road": {"postcode": "PA19 1PL", "address": "10 St John's Road"},
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Visit https://maps.inverclyde.gov.uk/noticeboard8/noticeboard.aspx, "
+    "search for your postcode and note down your address exactly as it is shown "
+    "in the address list, e.g. '10 St John's Road'."
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "postcode": "Postcode",
+        "address": "Address",
+    }
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "postcode": "The postcode of the property, e.g. 'PA16 0FG'",
+        "address": "The first line of the address exactly as returned by the "
+        "council's address search, e.g. '10 St John's Road'",
+    }
+}
+
+ICON_MAP = {
+    "black": Icons.GENERAL_WASTE,
+    "grey": Icons.GENERAL_WASTE,
+    "food": Icons.BIO_KITCHEN,
+    "blue": Icons.RECYCLING,
+    "brown": Icons.GARDEN,
+}
+
+BIN_NAME_MAP = {
+    "black": "General Waste",
+    "grey": "General Waste",
+    "food": "Food Waste",
+    "blue": "Recycling",
+    "brown": "Garden Waste",
+}
+
+API_BASE = "https://maps.inverclyde.gov.uk/noticeboard8"
+QUICKSEARCH_URL = f"{API_BASE}/quicksearch.asmx/GetMoreResults"
+LOCALKNOWLEDGE_URL = f"{API_BASE}/LocalKnowledge.asmx/AboutTheLocationForOverlay"
+
+# IDs of the "Address Results" quick search and the "Bin Collections" overlay,
+# as configured on the council's NoticeBoard map (maps.inverclyde.gov.uk).
+ADDRESS_SEARCH_ID = 7
+LOCAL_KNOWLEDGE_ID = 3
+BIN_COLLECTIONS_OVERLAY_NO = 20
+
+HEADERS = {
+    "User-Agent": "Mozilla/5.0",
+    "Content-Type": "application/json; charset=UTF-8",
+    "Accept": "application/json, text/javascript, */*; q=0.01",
+    "X-Requested-With": "XMLHttpRequest",
+    "Referer": f"{API_BASE}/noticeboard.aspx",
+}
+
+BIN_ALT_TEXT_PATTERN = re.compile(r'alt="Image of an? (\w+) bin"', re.IGNORECASE)
+DATE_PATTERN = re.compile(r"[A-Za-z]+\s+\d{1,2}(?:st|nd|rd|th)\s+[A-Za-z]+\s+\d{4}")
+
+
+def _parse_date(text: str | None):
+    if not text:
+        return None
+    match = DATE_PATTERN.search(text)
+    if not match:
+        return None
+    try:
+        return parse_date(match.group(0), fuzzy=True).date()
+    except (ValueError, OverflowError):
+        return None
+
+
+class Source:
+    def __init__(self, postcode: str, address: str):
+        self._postcode = postcode
+        self._address = address
+
+    def fetch(self) -> list[Collection]:
+        session = requests.Session(impersonate="chrome")
+
+        r = session.post(
+            QUICKSEARCH_URL,
+            headers=HEADERS,
+            json={
+                "searchId": ADDRESS_SEARCH_ID,
+                "filter": self._postcode,
+                "startIndex": 0,
+                "endIndex": 199,
+            },
+        )
+        r.raise_for_status()
+        results = r.json().get("d", {}).get("Data") or []
+
+        matched_columns = None
+        suggestions = []
+        for item in results:
+            columns = {c["Name"]: c["Value"] for c in item.get("Columns", [])}
+            address_text = columns.get("RESULTS", "")
+            first_line = address_text.split("\r\n")[0].strip()
+            suggestions.append(first_line)
+            if first_line.lower() == self._address.strip().lower():
+                matched_columns = columns
+                break
+
+        if matched_columns is None:
+            raise SourceArgumentNotFoundWithSuggestions(
+                "address", self._address, suggestions
+            )
+
+        r = session.post(
+            LOCALKNOWLEDGE_URL,
+            headers=HEADERS,
+            json={
+                "localKnowledgeID": LOCAL_KNOWLEDGE_ID,
+                "overlayNo": BIN_COLLECTIONS_OVERLAY_NO,
+                "x": matched_columns["E"],
+                "y": matched_columns["N"],
+            },
+        )
+        r.raise_for_status()
+        data = r.json().get("d") or {}
+
+        attributes: dict[str, str] = {}
+        for fmn in data.get("FMNResults") or []:
+            for item in fmn.get("Items") or []:
+                for attr in item.get("Attributes") or []:
+                    attributes[attr["Name"]] = attr.get("Value", "")
+
+        entries: list[Collection] = []
+        for date_key, graphic_key in (
+            ("top_bin_date2", "top_bin_graphic"),
+            ("bottom_bin_date2", "bottom_bin_graphic"),
+        ):
+            date = _parse_date(attributes.get(date_key))
+            if date is None:
+                continue
+
+            graphic = attributes.get(graphic_key, "")
+            colours = BIN_ALT_TEXT_PATTERN.findall(graphic)
+            for colour in colours:
+                colour = colour.lower()
+                name = BIN_NAME_MAP.get(colour, f"{colour.title()} Bin")
+                entries.append(Collection(date, name, ICON_MAP.get(colour)))
+
+        return entries

package/python/vendor/waste_collection_schedule/source/ipswich_gov_uk.py

@@ -0,0 +1,159 @@
+import re
+from datetime import date
+
+import requests
+from bs4 import BeautifulSoup
+from waste_collection_schedule import Collection  # type: ignore[attr-defined]
+from waste_collection_schedule.exceptions import SourceArgumentNotFound
+
+TITLE = "Ipswich Borough Council"
+DESCRIPTION = (
+    "Source for waste collection schedules provided by Ipswich Borough Council, UK."
+)
+URL = "https://www.ipswich.gov.uk"
+COUNTRY = "uk"
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": (
+        "Visit https://app.ipswich.gov.uk/bin-collection-better-recycling/ and search "
+        "for your street. Once your schedule is displayed the URL will end with "
+        "/weeks/<number> — use that number as the `location_id` argument."
+    ),
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "location_id": (
+            "Numeric location ID from the end of the schedule URL. "
+            "Example: for …/weeks/549 use location_id: 549."
+        ),
+    },
+}
+
+TEST_CASES = {
+    "High Street (id 549)": {"location_id": 549},
+}
+
+_SCHEDULE_URL = "https://app.ipswich.gov.uk/bin-collection-better-recycling/months/{}"
+
+# Map keywords found in <dt> text to a canonical display name and MDI icon.
+# Evaluated in order; first match wins.
+_BIN_MAP: list[tuple[str, str, str]] = [
+    ("food", "Food Waste", "mdi:food-apple"),
+    ("black", "General Waste", "mdi:trash-can"),
+    ("blue", "Recycling (Blue bin)", "mdi:recycle"),
+    ("green", "Recycling (Green bin)", "mdi:recycle"),
+    ("brown", "Garden Waste", "mdi:leaf"),
+]
+
+# Strips ordinal suffixes so "4th" → 4, "22nd" → 22, etc.
+_ORDINAL_RE = re.compile(r"(\d+)(?:st|nd|rd|th)", re.IGNORECASE)
+
+# Matches "<Month> <Year>" headings produced by <h4> elements.
+_MONTH_HEADING_RE = re.compile(
+    r"^(January|February|March|April|May|June|July|August|September|"
+    r"October|November|December)\s+(\d{4})$",
+    re.IGNORECASE,
+)
+
+_MONTH_NAMES: dict[str, int] = {
+    "january": 1,
+    "february": 2,
+    "march": 3,
+    "april": 4,
+    "may": 5,
+    "june": 6,
+    "july": 7,
+    "august": 8,
+    "september": 9,
+    "october": 10,
+    "november": 11,
+    "december": 12,
+}
+
+
+def _classify(dt_text: str) -> tuple[str, str]:
+    """Return (display_name, icon) for a <dt> bin description."""
+    lower = dt_text.lower()
+    for keyword, name, icon in _BIN_MAP:
+        if keyword in lower:
+            return name, icon
+    return dt_text.strip().title(), "mdi:trash-can"
+
+
+def _parse_days(dd_text: str) -> list[int]:
+    """Parse a comma-separated ordinal list, e.g. '4th, 11th, 18th' → [4, 11, 18]."""
+    return [int(m.group(1)) for m in _ORDINAL_RE.finditer(dd_text)]
+
+
+class Source:
+    def __init__(self, location_id: int | str) -> None:
+        self._location_id = int(location_id)
+
+    def fetch(self) -> list[Collection]:
+        url = _SCHEDULE_URL.format(self._location_id)
+        response = requests.get(url, timeout=30)
+        try:
+            response.raise_for_status()
+        except requests.HTTPError as exc:
+            if exc.response is not None and exc.response.status_code == 404:
+                raise SourceArgumentNotFound(
+                    "location_id",
+                    self._location_id,
+                ) from exc
+            raise
+
+        soup = BeautifulSoup(response.text, "html.parser")
+
+        # The relevant page structure inside <article>:
+        #
+        #   <h4>June 2026</h4>
+        #   <dl class="ibc-columns ibc-zebra">
+        #     <dt>Large food waste caddy</dt>  <dd>4th, 11th, 18th, 25th</dd>
+        #     <dt>Black refuse bin</dt>         <dd>11th, 25th</dd>
+        #     <dt>Blue recycling bin</dt>       <dd>4th</dd>
+        #     …
+        #   </dl>
+        #   <h4>July 2026</h4>
+        #   <dl …> … </dl>
+        #
+        # We walk all <h4> and <dl> siblings in document order, tracking the
+        # current month/year from each <h4> and emitting Collections for each
+        # <dt>/<dd> pair in the following <dl>.
+
+        article = soup.find("article")
+        if article is None:
+            raise SourceArgumentNotFound("location_id", self._location_id)
+
+        collections: list[Collection] = []
+        current_month: int | None = None
+        current_year: int | None = None
+
+        for element in article.find_all(["h4", "dl"]):
+            if element.name == "h4":
+                m = _MONTH_HEADING_RE.match(element.get_text(strip=True))
+                if m:
+                    current_month = _MONTH_NAMES[m.group(1).lower()]
+                    current_year = int(m.group(2))
+
+            elif element.name == "dl":
+                if current_month is None or current_year is None:
+                    continue  # <dl> before any recognisable month heading
+
+                for dt, dd in zip(
+                    element.find_all("dt"), element.find_all("dd"), strict=False
+                ):
+                    bin_name, icon = _classify(dt.get_text(strip=True))
+                    for day in _parse_days(dd.get_text(strip=True)):
+                        try:
+                            collection_date = date(current_year, current_month, day)
+                        except ValueError:
+                            continue  # guard against malformed day numbers
+                        collections.append(
+                            Collection(date=collection_date, t=bin_name, icon=icon)
+                        )
+
+        if not collections:
+            raise SourceArgumentNotFound("location_id", self._location_id)
+
+        return collections

package/python/vendor/waste_collection_schedule/source/ipswich_qld_gov_au.py

@@ -0,0 +1,157 @@
+from urllib.parse import quote
+
+import requests
+from waste_collection_schedule import Collection, Icons
+from waste_collection_schedule.exceptions import SourceArgumentNotFound
+from waste_collection_schedule.service.WhatBinDay import WhatBinDayService
+
+TITLE = "Ipswich City Council"
+DESCRIPTION = "Source for Ipswich City Council rubbish collection."
+URL = "https://www.ipswich.qld.gov.au"
+COUNTRY = "au"
+SOURCE_CODEOWNERS = ["@CRZTFR"]
+# Every case carries a post_code. Without one the source falls back to the
+# council app's shared Google key, which is regularly out of quota, so cases
+# omitting it fail on a third party's billing rather than on this source.
+TEST_CASES = {
+    "Camira State School": {
+        "street": "184-202 Old Logan Rd",
+        "suburb": "Camira",
+        "post_code": "4300",
+    },
+    "Random": {
+        "street": "50 Brisbane Road",
+        "suburb": "Redbank",
+        "post_code": "4301",
+    },
+    "Ipswich CBD": {
+        "street": "1 Bell Street",
+        "suburb": "Ipswich",
+        "post_code": "4305",
+    },
+}
+
+HOW_TO_GET_ARGUMENTS_DESCRIPTION = {
+    "en": "Use your street number and street name (including the street type, e.g. Road, Street, Avenue) for `street`, and the suburb name only for `suburb`. Do not add QLD or Australia. Adding your `post_code` is optional but recommended: it skips the council app's address search, which is shared between all of its users and is regularly out of quota."
+}
+
+PARAM_DESCRIPTIONS = {
+    "en": {
+        "street": "Street number and street name, e.g. 50 Brisbane Road.",
+        "suburb": "Suburb name, e.g. Redbank.",
+        "post_code": "Optional four-digit post code, e.g. 4301.",
+    }
+}
+
+PARAM_TRANSLATIONS = {
+    "en": {
+        "street": "Street",
+        "suburb": "Suburb",
+        "post_code": "Post code",
+    }
+}
+
+APP_PACKAGE = "com.socketsoftware.whatbinday.ipswich"
+CONFIG_URL = "https://api.whatbinday.com/V3/Device/{}/Config"
+
+ICON_MAP = {
+    "WasteBin": Icons.GENERAL_WASTE,
+    "RecycleBin": Icons.RECYCLING,
+    "GreenBin": Icons.ORGANIC,
+    "GlassBin": Icons.GLASS,
+}
+
+BIN_NAMES = {
+    "WasteBin": "Waste Bin",
+    "RecycleBin": "Recycle Bin",
+    "GreenBin": "Garden Organics (GO)",
+    "GlassBin": "Glass Bin",
+}
+
+
+class Source:
+    def __init__(self, street, suburb, post_code=None):
+        self._street = " ".join(str(street).split())
+        self._suburb = " ".join(str(suburb).split())
+        self._post_code = " ".join(str(post_code or "").split())
+        self._service = WhatBinDayService(
+            location_key="ipswich_city_council",
+            icon_map=ICON_MAP,
+            bin_names=BIN_NAMES,
+            app_package=APP_PACKAGE,
+        )
+
+    def _address_data(self) -> dict:
+        """Build the council's address payload without geocoding.
+
+        The service matches on the address components, not the coordinates:
+        a payload carrying 0/0 resolves the same schedule as the rooftop
+        result Google returns. It does need the state spelled out in full
+        and a post code belonging to the suburb; with the abbreviated "QLD"
+        in place of "Queensland" it reports that it found no bin services.
+        """
+        number, _, name = self._street.partition(" ")
+        if not name:
+            raise SourceArgumentNotFound("street", self._street)
+        return self._service.build_address_data(
+            street_number=number,
+            street_name=name,
+            suburb=self._suburb,
+            post_code=self._post_code,
+            state="Queensland",
+            coordinates={"lat": 0, "lng": 0},
+        )
+
+    def _geocode(self) -> dict:
+        device_key = self._service.register_device()
+        config_response = requests.get(
+            CONFIG_URL.format(device_key),
+            headers=self._service.HEADERS,
+            timeout=30,
+        )
+        config_response.raise_for_status()
+        config_payload = config_response.json()
+        if not config_payload.get("success"):
+            raise RuntimeError(
+                "Device configuration failed: "
+                f"{config_payload.get('info') or 'Unknown error'}"
+            )
+
+        search_url = config_payload["data"]["config"]["googleAddressSearchURL"]
+        address = f"{self._street}, {self._suburb} QLD, Australia"
+        geocode_response = requests.get(
+            search_url.replace("%s", quote(address, safe="")),
+            headers=self._service.HEADERS,
+            timeout=30,
+        )
+        geocode_response.raise_for_status()
+        geocode_payload = geocode_response.json()
+
+        # The key belongs to the council's own app and is shared by every user
+        # of it, so it is regularly out of quota. Without this check an
+        # exhausted key is indistinguishable from an unknown street, and the
+        # visitor is told to correct an address that was right all along.
+        status = geocode_payload.get("status")
+        if status not in ("OK", "ZERO_RESULTS"):
+            raise RuntimeError(
+                "Ipswich City Council's address search is unavailable "
+                f"(Google returned {status}). Supplying post_code skips it."
+            )
+
+        for result in geocode_payload.get("results", []):
+            component_types = {
+                component_type
+                for component in result.get("address_components", [])
+                for component_type in component.get("types", [])
+            }
+            if {"street_number", "route", "locality"}.issubset(component_types):
+                return result
+
+        raise SourceArgumentNotFound("street", self._street)
+
+    def fetch(self) -> list[Collection]:
+        location = self._address_data() if self._post_code else self._geocode()
+        entries = self._service.get_collection_schedule(location)
+        if not entries:
+            raise SourceArgumentNotFound("street", self._street)
+        return entries