geocodio-library-python 1.0.0__tar.gz → 1.3.0__tar.gz

{geocodio_library_python-1.0.0 → geocodio_library_python-1.3.0}/CHANGELOG.md

@@ -7,6 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.3.0] - 2026-08-25
+
+### Added
+- United Kingdom data append support. The `uk-westminster`, `uk-devolved`, and `uk-local` appends (and their `-next` variants) are now parsed into a typed `UKLegislativeDistrict` model, exposed via `fields.uk_westminster`, `fields.uk_devolved`, and `fields.uk_local`.
+
 ## [1.0.0] - 2026-06-05
 
 ### Changed
@@ -79,7 +84,8 @@ When ready to release:
 5. Push tags: `git push --tags`
 6. GitHub Actions will automatically publish to PyPI
 
-[Unreleased]: https://github.com/Geocodio/geocodio-library-python/compare/v1.0.0...HEAD
+[Unreleased]: https://github.com/Geocodio/geocodio-library-python/compare/v1.3.0...HEAD
+[1.3.0]: https://github.com/Geocodio/geocodio-library-python/compare/v1.2.0...v1.3.0
 [1.0.0]: https://github.com/Geocodio/geocodio-library-python/compare/v0.7.0...v1.0.0
 [0.7.0]: https://github.com/Geocodio/geocodio-library-python/compare/v0.6.0...v0.7.0
 [0.6.0]: https://github.com/Geocodio/geocodio-library-python/compare/v0.5.1...v0.6.0

{geocodio_library_python-1.0.0 → geocodio_library_python-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: geocodio-library-python
-Version: 1.0.0
+Version: 1.3.0
 Summary: A Python client for the Geocodio API
 Project-URL: Homepage, https://www.geocod.io
 Project-URL: Documentation, https://www.geocod.io/docs/?python
@@ -100,6 +100,7 @@ To batch geocode, simply pass a list of addresses or coordinates instead of a si
 response = client.geocode([
     "1109 N Highland St, Arlington VA",
     "525 University Ave, Toronto, ON, Canada",
+    "10 Downing St, London, United Kingdom",
     "4410 S Highway 17 92, Casselberry FL",
     "15000 NE 24th Street, Redmond WA",
     "17015 Walnut Grove Drive, Morgan Hill CA"
@@ -116,15 +117,16 @@ response = client.reverse([
 response = client.geocode({
     "MyId1": "1109 N Highland St, Arlington VA",
     "MyId2": "525 University Ave, Toronto, ON, Canada",
-    "MyId3": "4410 S Highway 17 92, Casselberry FL",
-    "MyId4": "15000 NE 24th Street, Redmond WA",
-    "MyId5": "17015 Walnut Grove Drive, Morgan Hill CA"
+    "MyId3": "10 Downing St, London, United Kingdom",
+    "MyId4": "4410 S Highway 17 92, Casselberry FL",
+    "MyId5": "15000 NE 24th Street, Redmond WA",
+    "MyId6": "17015 Walnut Grove Drive, Morgan Hill CA"
 })
 ```
 
 ### Field appends
 
-Geocodio allows you to append additional data points such as congressional districts, census codes, timezone, ACS survey results and [much more](https://www.geocod.io/docs/#fields).
+Geocodio allows you to append additional data points such as congressional districts, census codes, timezone, ACS survey results, UK constituencies and wards, and [much more](https://www.geocod.io/docs/#fields).
 
 To request additional fields, simply supply them as a list:
 
@@ -138,6 +140,13 @@ response = client.geocode(
 )
 
 response = client.reverse("38.9002898,-76.9990361", fields=["census2010"])
+
+# United Kingdom addresses support UK-specific appends such as Westminster and
+# devolved parliament constituencies, and local authority wards
+response = client.geocode(
+    "10 Downing St, London, United Kingdom",
+    fields=["uk-westminster", "uk-local"]
+)
 ```
 
 ### Address components
@@ -163,6 +172,12 @@ response = client.geocode([
         "city": "Toronto",
         "state": "ON",
         "country": "Canada"
+    },
+    {
+        "street": "10 Downing St",
+        "city": "London",
+        "postal_code": "SW1A 2AA",
+        "country": "United Kingdom"
     }
 ])
 ```

{geocodio_library_python-1.0.0 → geocodio_library_python-1.3.0}/README.md

@@ -65,6 +65,7 @@ To batch geocode, simply pass a list of addresses or coordinates instead of a si
 response = client.geocode([
     "1109 N Highland St, Arlington VA",
     "525 University Ave, Toronto, ON, Canada",
+    "10 Downing St, London, United Kingdom",
     "4410 S Highway 17 92, Casselberry FL",
     "15000 NE 24th Street, Redmond WA",
     "17015 Walnut Grove Drive, Morgan Hill CA"
@@ -81,15 +82,16 @@ response = client.reverse([
 response = client.geocode({
     "MyId1": "1109 N Highland St, Arlington VA",
     "MyId2": "525 University Ave, Toronto, ON, Canada",
-    "MyId3": "4410 S Highway 17 92, Casselberry FL",
-    "MyId4": "15000 NE 24th Street, Redmond WA",
-    "MyId5": "17015 Walnut Grove Drive, Morgan Hill CA"
+    "MyId3": "10 Downing St, London, United Kingdom",
+    "MyId4": "4410 S Highway 17 92, Casselberry FL",
+    "MyId5": "15000 NE 24th Street, Redmond WA",
+    "MyId6": "17015 Walnut Grove Drive, Morgan Hill CA"
 })
 ```
 
 ### Field appends
 
-Geocodio allows you to append additional data points such as congressional districts, census codes, timezone, ACS survey results and [much more](https://www.geocod.io/docs/#fields).
+Geocodio allows you to append additional data points such as congressional districts, census codes, timezone, ACS survey results, UK constituencies and wards, and [much more](https://www.geocod.io/docs/#fields).
 
 To request additional fields, simply supply them as a list:
 
@@ -103,6 +105,13 @@ response = client.geocode(
 )
 
 response = client.reverse("38.9002898,-76.9990361", fields=["census2010"])
+
+# United Kingdom addresses support UK-specific appends such as Westminster and
+# devolved parliament constituencies, and local authority wards
+response = client.geocode(
+    "10 Downing St, London, United Kingdom",
+    fields=["uk-westminster", "uk-local"]
+)
 ```
 
 ### Address components
@@ -128,6 +137,12 @@ response = client.geocode([
         "city": "Toronto",
         "state": "ON",
         "country": "Canada"
+    },
+    {
+        "street": "10 Downing St",
+        "city": "London",
+        "postal_code": "SW1A 2AA",
+        "country": "United Kingdom"
     }
 ])
 ```

{geocodio_library_python-1.0.0 → geocodio_library_python-1.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "geocodio-library-python"
-version = "1.0.0"
+version = "1.3.0"
 description = "A Python client for the Geocodio API"
 readme = "README.md"
 requires-python = ">=3.11"

{geocodio_library_python-1.0.0 → geocodio_library_python-1.3.0}/src/geocodio/_version.py

@@ -1,3 +1,3 @@
 """Version information for geocodio package."""
 
-__version__ = "1.0.0"
+__version__ = "1.3.0"

{geocodio_library_python-1.0.0 → geocodio_library_python-1.3.0}/src/geocodio/client.py

@@ -63,6 +63,7 @@ from geocodio.models import (
     StateLegislativeDistrict,
     StatisticsCanadaData,
     Timezone,
+    UKLegislativeDistrict,
     ZIP4Data,
 )
 
@@ -379,26 +380,44 @@ class Geocodio:
             and response_json["results"]
             and "response" in response_json["results"][0]
         ):
-            results = [
-                GeocodingResult(
-                    address_components=AddressComponents.from_api(
-                        res["response"]["results"][0]["address_components"]
-                    ),
-                    formatted_address=res["response"]["results"][0][
-                        "formatted_address"
-                    ],
-                    location=Location(**res["response"]["results"][0]["location"]),
-                    accuracy=res["response"]["results"][0].get("accuracy", 0.0),
-                    accuracy_type=res["response"]["results"][0].get(
-                        "accuracy_type", ""
-                    ),
-                    source=res["response"]["results"][0].get("source", ""),
-                    fields=self._parse_fields(
-                        res["response"]["results"][0].get("fields")
-                    ),
+            results = []
+            for res in response_json["results"]:
+                query = res.get("query", "")
+                matches = res.get("response", {}).get("results") or []
+
+                # Unmatched query (e.g. an unparseable address): keep an entry
+                # so the result list stays aligned with the submitted addresses,
+                # but with no coordinates.
+                if not matches:
+                    results.append(
+                        GeocodingResult(
+                            address_components=AddressComponents.from_api({}),
+                            formatted_address="",
+                            location=None,
+                            accuracy=0.0,
+                            accuracy_type="",
+                            source="",
+                            query=query,
+                        )
+                    )
+                    continue
+
+                top = matches[0]
+                results.append(
+                    GeocodingResult(
+                        address_components=AddressComponents.from_api(
+                            top["address_components"]
+                        ),
+                        formatted_address=top["formatted_address"],
+                        location=Location(**top["location"]),
+                        accuracy=top.get("accuracy", 0.0),
+                        accuracy_type=top.get("accuracy_type", ""),
+                        source=top.get("source", ""),
+                        query=query,
+                        fields=self._parse_fields(top.get("fields")),
+                        stable_address_key=top.get("stable_address_key"),
+                    )
                 )
-                for res in response_json["results"]
-            ]
             return GeocodingResponse(results=results)
 
         # Handle single response format
@@ -413,6 +432,7 @@ class Geocodio:
                 accuracy_type=res.get("accuracy_type", ""),
                 source=res.get("source", ""),
                 fields=self._parse_fields(res.get("fields")),
+                stable_address_key=res.get("stable_address_key"),
             )
             for res in response_json.get("results", [])
         ]
@@ -452,6 +472,7 @@ class Geocodio:
                    - acs, acs-demographics, acs-economics, acs-families, acs-housing, acs-social
                    - riding, provriding, provriding-next (Canadian data)
                    - statcan (Statistics Canada data)
+                   - uk-westminster, uk-westminster-next, uk-devolved, uk-devolved-next, uk-local, uk-local-next (UK legislative districts)
                    - zip4 (ZIP+4 data)
                    - ffiec (FFIEC data, beta)
 
@@ -832,6 +853,35 @@ class Geocodio:
             else None
         )
 
+        # United Kingdom fields (each append returns a list of districts). The
+        # ``-next`` request variants fold into these same response keys.
+        uk_westminster = (
+            [
+                UKLegislativeDistrict.from_api(district)
+                for district in fields_data["uk_westminster"]
+            ]
+            if "uk_westminster" in fields_data
+            else None
+        )
+
+        uk_devolved = (
+            [
+                UKLegislativeDistrict.from_api(district)
+                for district in fields_data["uk_devolved"]
+            ]
+            if "uk_devolved" in fields_data
+            else None
+        )
+
+        uk_local = (
+            [
+                UKLegislativeDistrict.from_api(district)
+                for district in fields_data["uk_local"]
+            ]
+            if "uk_local" in fields_data
+            else None
+        )
+
         # Collect all known field keys that were parsed
         parsed_keys = {
             "timezone",
@@ -856,6 +906,9 @@ class Geocodio:
             "provriding",
             "provriding-next",
             "statcan",
+            "uk_westminster",
+            "uk_devolved",
+            "uk_local",
         }
         # Add flat census keys that were parsed (census2000, census2020, etc.)
         # All census years are now stored in _census dict for dynamic access
@@ -878,6 +931,9 @@ class Geocodio:
             provriding=provriding,
             provriding_next=provriding_next,
             statcan=statcan,
+            uk_westminster=uk_westminster,
+            uk_devolved=uk_devolved,
+            uk_local=uk_local,
             extras=extras,
             _census=census_data_dict,  # All census years stored here
             **acs_fields,  # Dynamically include all ACS metric fields

{geocodio_library_python-1.0.0 → geocodio_library_python-1.3.0}/src/geocodio/models.py

@@ -309,6 +309,20 @@ class StatisticsCanadaData(ApiModelMixin):
     extras: Dict[str, Any] = field(default_factory=dict, repr=False)
 
 
+@dataclass(slots=True, frozen=True)
+class UKLegislativeDistrict(ApiModelMixin):
+    """UK legislative district returned by the uk-westminster, uk-devolved, and
+    uk-local appends (and their ``-next`` variants)."""
+
+    district_type: Optional[str] = None
+    gss_code: Optional[str] = None
+    ocd_id: Optional[str] = None
+    name: Optional[str] = None
+    is_upcoming_district: Optional[bool] = None
+    source: Optional[str] = None
+    extras: Dict[str, Any] = field(default_factory=dict, repr=False)
+
+
 @dataclass(slots=True, frozen=True)
 class FFIECData(ApiModelMixin):
     """FFIEC CRA/HMDA Data (Beta)."""
@@ -373,6 +387,11 @@ class GeocodioFields:
     provriding_next: Optional[ProvincialRiding] = None
     statcan: Optional[StatisticsCanadaData] = None
 
+    # United Kingdom fields
+    uk_westminster: Optional[List[UKLegislativeDistrict]] = None
+    uk_devolved: Optional[List[UKLegislativeDistrict]] = None
+    uk_local: Optional[List[UKLegislativeDistrict]] = None
+
     # Catch-all for any future or unknown fields from the API
     extras: Dict[str, Any] = field(default_factory=dict, repr=False)
 
@@ -665,11 +684,18 @@ class DistanceJobResponse:
 class GeocodingResult:
     address_components: AddressComponents
     formatted_address: str
-    location: Location
+    location: Optional[Location]
     accuracy: float
     accuracy_type: str
     source: str
     fields: Optional[GeocodioFields] = None
+    query: str = ""
+    stable_address_key: Optional[str] = None
+
+    @property
+    def matched(self) -> bool:
+        """True when the API returned coordinates for this query."""
+        return self.location is not None
 
 
 @dataclass(slots=True, frozen=True)

{geocodio_library_python-1.0.0 → geocodio_library_python-1.3.0}/tests/e2e/test_api.py

@@ -51,6 +51,32 @@ def test_integration_geocode(client):
     assert components.postal_code is not None
 
 
+def test_integration_stable_address_key(client):
+    """Verify stable_address_key is exposed on real single, reverse, and batch calls."""
+    # Single forward geocode
+    single = client.geocode("1109 N Highland St, Arlington, VA").results[0]
+    assert single.stable_address_key is not None
+    assert isinstance(single.stable_address_key, str)
+    assert single.stable_address_key != ""
+
+    # Reverse geocode (White House)
+    reverse = client.reverse((38.897699, -77.036547)).results[0]
+    assert reverse.stable_address_key is not None
+    assert isinstance(reverse.stable_address_key, str)
+
+    # Batch geocode (nested response format)
+    batch = client.geocode(
+        ["3730 N Clark St, Chicago, IL", "638 E 13th Ave, Denver, CO"]
+    )
+    for result in batch.results:
+        assert result.stable_address_key is not None
+        assert isinstance(result.stable_address_key, str)
+
+    # The key should be stable: the same address returns the same key.
+    again = client.geocode("1109 N Highland St, Arlington, VA").results[0]
+    assert again.stable_address_key == single.stable_address_key
+
+
 def test_integration_reverse(client):
     """Test real reverse geocoding API call."""
     # Test coordinates (White House)
@@ -584,6 +610,40 @@ def test_integration_with_canadian_fields(client):
         assert isinstance(fields.statcan.census_year, int)
 
 
+def test_integration_with_uk_fields(client):
+    """Test real API call with United Kingdom legislative district fields."""
+    response = client.geocode(
+        "10 Downing St, London",
+        fields=["uk-westminster", "uk-local"],
+        country="United Kingdom",  # Country hint so the address resolves to the UK
+    )
+
+    # Verify response structure
+    assert response is not None
+    assert len(response.results) > 0
+    result = response.results[0]
+
+    # Verify fields data
+    fields = result.fields
+    assert fields is not None
+
+    # Check Westminster parliamentary constituency
+    assert fields.uk_westminster is not None
+    assert len(fields.uk_westminster) > 0
+    westminster = fields.uk_westminster[0]
+    assert westminster.district_type is not None
+    assert westminster.name is not None
+    assert westminster.gss_code is not None
+    assert westminster.ocd_id is not None
+    assert isinstance(westminster.is_upcoming_district, bool)
+    assert westminster.source is not None
+
+    # Check local authority ward
+    assert fields.uk_local is not None
+    assert len(fields.uk_local) > 0
+    assert fields.uk_local[0].name is not None
+
+
 def test_integration_with_census_years(client):
     """Test real API call with various census years."""
     # Test address

{geocodio_library_python-1.0.0 → geocodio_library_python-1.3.0}/tests/unit/test_geocode.py

@@ -34,6 +34,7 @@ def sample_payload() -> dict:
                         "observes_dst": True,
                     }
                 },
+                "stable_address_key": "abc123stablekey",
             }
         ],
     }
@@ -67,6 +68,8 @@ def test_geocode_single(client, httpx_mock):
     tz = resp.results[0].fields.timezone
     assert tz.name == "America/New_York"
     assert tz.observes_dst is True
+    # stable address key (v2 returns this on every result)
+    assert resp.results[0].stable_address_key == "abc123stablekey"
 
 
 def test_geocode_batch(client, httpx_mock):
@@ -748,3 +751,255 @@ def test_geocode_with_stateleg_fields(client, httpx_mock):
 
     # Ensure state_legislative_districts didn't leak into extras
     assert "state_legislative_districts" not in fields.extras
+
+
+def test_geocode_with_uk_fields(client, httpx_mock):
+    """Test geocoding a UK address with the UK legislative district appends.
+
+    The API returns uk_westminster / uk_local as lists of district objects.
+    """
+
+    def response_callback(request):
+        assert request.url.params["fields"] == "uk-westminster,uk-local"
+        return httpx.Response(
+            200,
+            json={
+                "results": [
+                    {
+                        "address_components": {
+                            "number": "10",
+                            "street": "Downing",
+                            "suffix": "St",
+                            "city": "London",
+                            "nation": "England",
+                            "postal_code": "SW1A 2AA",
+                            "country": "GB",
+                        },
+                        "formatted_address": "10 Downing St, London SW1A 2AA",
+                        "location": {"lat": 51.503541, "lng": -0.12767},
+                        "accuracy": 1,
+                        "accuracy_type": "rooftop",
+                        "source": "Contains OS data © Crown copyright.",
+                        "fields": {
+                            "uk_westminster": [
+                                {
+                                    "district_type": "westminster_constituency",
+                                    "gss_code": "E14001172",
+                                    "ocd_id": "ocd-division/country:gb/part:eng/region:uki/ed:cities_of_london_and_westminster",
+                                    "name": "Cities of London and Westminster",
+                                    "is_upcoming_district": False,
+                                    "source": "Office for National Statistics",
+                                }
+                            ],
+                            "uk_local": [
+                                {
+                                    "district_type": "ward",
+                                    "gss_code": "E05013806",
+                                    "ocd_id": "ocd-division/country:gb/part:eng/ward:e05013806",
+                                    "name": "St James's",
+                                    "is_upcoming_district": False,
+                                    "source": "Office for National Statistics",
+                                }
+                            ],
+                        },
+                    }
+                ]
+            },
+        )
+
+    httpx_mock.add_callback(
+        callback=response_callback,
+        url=httpx.URL(
+            "https://api.test/v2/geocode",
+            params={
+                "q": "10 Downing St, London, United Kingdom",
+                "fields": "uk-westminster,uk-local",
+            },
+        ),
+        match_headers={"Authorization": "Bearer TEST_KEY"},
+    )
+
+    # Act
+    resp = client.geocode(
+        "10 Downing St, London, United Kingdom",
+        fields=["uk-westminster", "uk-local"],
+    )
+
+    # Assert - UK appends should be parsed into typed models, not None
+    fields = resp.results[0].fields
+    assert fields.uk_westminster is not None
+    assert len(fields.uk_westminster) == 1
+    assert fields.uk_westminster[0].name == "Cities of London and Westminster"
+    assert fields.uk_westminster[0].district_type == "westminster_constituency"
+
+    assert fields.uk_local is not None
+    assert fields.uk_local[0].district_type == "ward"
+    assert fields.uk_local[0].name == "St James's"
+
+    # UK devolved was not requested for this address, so it stays None
+    assert fields.uk_devolved is None
+
+    # Ensure UK fields didn't leak into extras
+    assert "uk_westminster" not in fields.extras
+    assert "uk_local" not in fields.extras
+
+
+def test_geocode_batch_with_unmatched_address(client, httpx_mock):
+    """Batch responses can include queries with no results (e.g. an address
+    the API could not match). Those entries must not raise IndexError, and the
+    result list stays aligned with the submitted addresses so callers can tell
+    which query failed."""
+    addresses = ["3730 N Clark St, Chicago, IL", "qwertyuiop asdfghjkl zxcvbnm"]
+
+    def batch_response_callback(request):
+        return httpx.Response(
+            200,
+            json={
+                "results": [
+                    {
+                        "query": "3730 N Clark St, Chicago, IL",
+                        "response": {
+                            "results": [
+                                {
+                                    "address_components": {
+                                        "number": "3730",
+                                        "predirectional": "N",
+                                        "street": "Clark",
+                                        "suffix": "St",
+                                        "city": "Chicago",
+                                        "county": "Cook County",
+                                        "state_province": "IL",
+                                        "postal_code": "60613",
+                                        "country": "US",
+                                    },
+                                    "formatted_address": "3730 N Clark St, Chicago, IL 60613",
+                                    "location": {"lat": 41.94987, "lng": -87.65893},
+                                    "accuracy": 1,
+                                    "accuracy_type": "rooftop",
+                                    "source": "Cook",
+                                }
+                            ]
+                        },
+                    },
+                    {
+                        "query": "qwertyuiop asdfghjkl zxcvbnm",
+                        "response": {
+                            "error": "Could not geocode address. No matches found.",
+                            "results": [],
+                        },
+                    },
+                ]
+            },
+        )
+
+    httpx_mock.add_callback(
+        callback=batch_response_callback,
+        url=httpx.URL("https://api.test/v2/geocode"),
+        match_headers={"Authorization": "Bearer TEST_KEY"},
+    )
+
+    resp = client.geocode(addresses)
+
+    # One entry per submitted address, in order.
+    assert len(resp.results) == 2
+
+    matched, unmatched = resp.results
+    assert matched.matched is True
+    assert matched.query == "3730 N Clark St, Chicago, IL"
+    assert matched.formatted_address == "3730 N Clark St, Chicago, IL 60613"
+    assert matched.location.lat == 41.94987
+
+    # Unmatched query is preserved with no coordinates.
+    assert unmatched.matched is False
+    assert unmatched.location is None
+    assert unmatched.query == "qwertyuiop asdfghjkl zxcvbnm"
+    assert unmatched.formatted_address == ""
+
+def test_geocode_batch_exposes_stable_address_key(client, httpx_mock):
+    """stable_address_key is parsed from the nested batch response format."""
+    addresses = ["1109 N Highland St, Arlington, VA"]
+
+    def batch_response_callback(request):
+        return httpx.Response(
+            200,
+            json={
+                "results": [
+                    {
+                        "query": "1109 N Highland St, Arlington, VA",
+                        "response": {
+                            "results": [
+                                {
+                                    "address_components": {
+                                        "number": "1109",
+                                        "street": "Highland",
+                                        "suffix": "St",
+                                        "city": "Arlington",
+                                        "state_province": "VA",
+                                        "postal_code": "22201",
+                                        "country": "US",
+                                    },
+                                    "formatted_address": "1109 N Highland St, Arlington, VA 22201",
+                                    "location": {"lat": 38.886672, "lng": -77.094735},
+                                    "accuracy": 1,
+                                    "accuracy_type": "rooftop",
+                                    "source": "Arlington",
+                                    "stable_address_key": "arlington-stable-key",
+                                }
+                            ]
+                        },
+                    },
+                ]
+            },
+        )
+
+    httpx_mock.add_callback(
+        callback=batch_response_callback,
+        url=httpx.URL("https://api.test/v2/geocode"),
+        match_headers={"Authorization": "Bearer TEST_KEY"},
+    )
+
+    resp = client.geocode(addresses)
+
+    assert resp.results[0].stable_address_key == "arlington-stable-key"
+
+
+def test_geocode_stable_address_key_absent_is_none(client, httpx_mock):
+    """stable_address_key defaults to None when the API omits it."""
+
+    def response_callback(request):
+        return httpx.Response(
+            200,
+            json={
+                "results": [
+                    {
+                        "address_components": {
+                            "number": "1109",
+                            "street": "Highland",
+                            "suffix": "St",
+                            "city": "Arlington",
+                            "state_province": "VA",
+                            "postal_code": "22201",
+                            "country": "US",
+                        },
+                        "formatted_address": "1109 N Highland St, Arlington, VA 22201",
+                        "location": {"lat": 38.886672, "lng": -77.094735},
+                        "accuracy": 1,
+                        "accuracy_type": "rooftop",
+                        "source": "Arlington",
+                    }
+                ],
+            },
+        )
+
+    httpx_mock.add_callback(
+        callback=response_callback,
+        url=httpx.URL(
+            "https://api.test/v2/geocode",
+            params={"q": "1109 N Highland St, Arlington, VA"},
+        ),
+        match_headers={"Authorization": "Bearer TEST_KEY"},
+    )
+
+    resp = client.geocode("1109 N Highland St, Arlington, VA")
+
+    assert resp.results[0].stable_address_key is None

{geocodio_library_python-1.0.0 → geocodio_library_python-1.3.0}/tests/unit/test_models.py

@@ -19,6 +19,7 @@ from geocodio.models import (
     StateLegislativeDistrict,
     StatisticsCanadaData,
     Timezone,
+    UKLegislativeDistrict,
     ZIP4Data,
 )
 
@@ -338,6 +339,26 @@ def test_canadian_riding():
     assert riding.get_extra("extra_field") == "extra value"
 
 
+def test_uk_legislative_district():
+    """Test UK legislative district data model."""
+    data = {
+        "district_type": "westminster_constituency",
+        "gss_code": "E14001172",
+        "ocd_id": "ocd-division/country:gb/part:eng/region:uki/ed:cities_of_london_and_westminster",
+        "name": "Cities of London and Westminster",
+        "is_upcoming_district": False,
+        "source": "Office for National Statistics",
+        "extra_field": "extra value",
+    }
+    district = UKLegislativeDistrict.from_api(data)
+    assert district.district_type == "westminster_constituency"
+    assert district.gss_code == "E14001172"
+    assert district.name == "Cities of London and Westminster"
+    assert district.is_upcoming_district is False
+    assert district.source == "Office for National Statistics"
+    assert district.get_extra("extra_field") == "extra value"
+
+
 def test_statistics_canada_data():
     """Test Statistics Canada data model."""
     data = {

{geocodio_library_python-1.0.0 → geocodio_library_python-1.3.0}/uv.lock

@@ -1,5 +1,5 @@
 version = 1
-revision = 2
+revision = 3
 requires-python = ">=3.11"
 
 [[package]]
@@ -149,7 +149,7 @@ wheels = [
 
 [[package]]
 name = "geocodio-library-python"
-version = "1.0.0"
+version = "1.3.0"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },