spitzeisen 0.1.0__tar.gz

spitzeisen-0.1.0/PKG-INFO

@@ -0,0 +1,182 @@
+Metadata-Version: 2.3
+Name: spitzeisen
+Version: 0.1.0
+Summary: A shared async/sync core for REST API SDKs
+Keywords: api,client,rest,rate-limiting,sdk,async
+Author: dodofarm
+Author-email: dodofarm <ea01052002@gmail.com>
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Dist: httpx2>=2.7.0
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: steindamm>=0.11.1
+Requires-Dist: structlog>=25.1.0
+Requires-Dist: httpx2-pytest>=2.0.0 ; extra == 'testing'
+Requires-Dist: pytest-asyncio>=1.0.0 ; extra == 'testing'
+Requires-Python: >=3.12
+Project-URL: Homepage, https://github.com/feuerstein-org/spitzeisen
+Project-URL: Repository, https://github.com/feuerstein-org/spitzeisen
+Provides-Extra: testing
+Description-Content-Type: text/markdown
+
+# Spitzeisen
+
+Spitzeisen (Pickaxe in German) is a Python framework for building REST API clients, with async and sync support. Spitzeisen handles HTTP requests, retries, rate limiting, and pagination. You write the endpoint methods and Pydantic models for your API. It's intended for simple data APIs e.g. financial APIs, product APIs etc.
+
+This project is in Alpha, I've built this to simplify/unite the code from the various financial APIs I'm working on (e.g. [eodhd-py](https://github.com/feuerstein-org/eodhd-py) and [massive-api](https://github.com/feuerstein-org/massive-api)). Feel free to use it as a building block for your own SDKs, better documentation is currently being worked on. In the future I want to add the possibility to generate the entire SDK off of OpenAPI and Smithy models but that's just an idea for now.
+
+## Installation
+
+Requires Python 3.12 or newer.
+
+```bash
+pip install spitzeisen
+```
+
+The library is still in alpha, so the API may change.
+
+## Usage
+
+> Note: It is **strongly** recommended to review the example weather SDK in `examples`, the below is just a very simple showcase, it is advised to create endpoint groups within one SDK Baseclass.
+
+Here's a client for an API that returns a single item from `/item/{item_id}`:
+
+```python
+import asyncio
+
+from spitzeisen import (
+    BearerHeader,
+    SpitzeisenApi,
+    SpitzeisenConfig,
+    SpitzeisenModel,
+    SpitzeisenOperationSpec,
+    serialize_path_param,
+)
+
+
+class Item(SpitzeisenModel):
+    id: str
+    name: str
+
+
+_ITEM = SpitzeisenOperationSpec(path="/item/{item_id}")
+
+
+class ItemsApi(SpitzeisenApi):
+    async def get_item(self, item_id: str) -> Item:
+        item = await self.get_object(_ITEM, item_id=serialize_path_param(item_id))
+        return self.validate_record(item, Item, mode="raise")
+
+
+async def main():
+    config = SpitzeisenConfig(
+        base_url="https://api.example.com",  # Replace with your API's URL
+        auth=BearerHeader("YOUR_API_KEY"),
+    )
+
+    async with ItemsApi(config) as api:
+        item = await api.get_item("123")
+        print(item.id, item.name)
+
+
+asyncio.run(main())
+```
+
+`serialize_path_param` URL-encodes the item ID before inserting it into the path. `get_object` fetches the JSON response. `validate_record` converts it into an `Item` model. With `mode="raise"`, a response that doesn't match the model raises a Pydantic validation error.
+
+For a sync client, subclass `SyncSpitzeisenApi` and use `SyncSpitzeisenConfig`. Write regular methods with `with` blocks and no `await`. The [weather example](examples/weather_sdk) includes both versions. It's recommended to generate the sync counterparts as much as possible using unasync, the Weather example already does this.
+
+## Config
+
+Authentication, retries, timeouts, and rate limits are configured through `SpitzeisenConfig`.
+For example:
+
+```python
+from spitzeisen import BearerHeader, SpitzeisenConfig, single_bucket
+
+config = SpitzeisenConfig(
+    base_url="https://api.example.com",
+    auth=BearerHeader("YOUR_API_KEY"),
+    limiter=single_bucket("example-account", 60, 60),  # 60 tokens, refilled over 60 seconds
+    max_retries=3,
+    request_timeout=30,
+    on_validation_error="raise",
+)
+```
+
+Rate limiting uses [steindamm](https://github.com/feuerstein-org/steindamm).
+The bucket above starts full and refills gradually. Each request costs one token by default, including retries and page requests. Pass a Redis connection to `single_bucket` to share the limit across processes.
+Without a limiter, requests are unlimited. Sync clients use `sync_single_bucket`.
+
+For authentication, you can also use `HeaderKey` or `QueryParamAuth`. The default is `NoAuth`.
+
+Those are by far not the only ways to authenticate which are supported. You can easily implement your own authentication strategy, same applies to for example pagination, to do that simply pass your custom strategy in the `SpitzeisenOperationSpec`, see [here](examples/inventory_sdk.py) for an example pagination strategy.
+
+Retryable requests use exponential backoff for HTTP 429, server errors, timeouts, and connection errors. POST and PATCH requests are not retried unless you opt in with `retryable=True` on the operation.
+
+Endpoint groups created with `self.api(GroupClass)` share the parent's config, HTTP connection, and rate limiter. Use context managers to close connections when you're done. A supplied HTTP client stays open unless you set `owns_http_client=True`.
+
+## Testing
+
+Install the testing helpers with `pip install "spitzeisen[testing]"`, then enable the pytest plugin in your root `conftest.py`:
+
+```python
+pytest_plugins = ["spitzeisen.testing.plugin"]
+```
+
+`api_factory` creates and closes your client. `httpx2_mock` supplies responses without calling the real API.
+Using the `ItemsApi` class above:
+
+```python
+import pytest
+from spitzeisen import SpitzeisenConfig
+
+
+@pytest.mark.asyncio
+async def test_get_item(api_factory, httpx2_mock):
+    httpx2_mock.add_response(
+        url="https://api.example.com/item/123",
+        json={"id": "123", "name": "Example item"},
+    )
+    api = await api_factory.create(
+        ItemsApi,
+        config=SpitzeisenConfig(base_url="https://api.example.com"),
+    )
+
+    item = await api.get_item("123")
+    assert item.name == "Example item"
+```
+
+For sync clients, use `sync_api_factory`. See the [example tests](examples/tests) for more.
+
+## Examples
+
+- [Weather SDK](examples/weather_sdk): endpoint groups, response models, and async and sync clients.
+- [Inventory SDK](examples/inventory_sdk.py): custom pagination and record iteration.
+- [Offline demo](examples/demo.py): runs both weather clients with saved responses.
+
+To run the demo from the repository root:
+
+```bash
+mise run install
+mise run demo-example
+```
+
+The demo needs no API key or network connection.
+
+## Development
+
+```bash
+mise run install
+mise run build-sync
+mise run lint
+mise run test
+```
+
+The sync code is generated from the async code with `unasync`.
+After editing the async implementation, run `mise run build-sync` to update both the library and weather example.
+`mise run check-sync` checks that the generated files are up to date.

spitzeisen-0.1.0/README.md

@@ -0,0 +1,157 @@
+# Spitzeisen
+
+Spitzeisen (Pickaxe in German) is a Python framework for building REST API clients, with async and sync support. Spitzeisen handles HTTP requests, retries, rate limiting, and pagination. You write the endpoint methods and Pydantic models for your API. It's intended for simple data APIs e.g. financial APIs, product APIs etc.
+
+This project is in Alpha, I've built this to simplify/unite the code from the various financial APIs I'm working on (e.g. [eodhd-py](https://github.com/feuerstein-org/eodhd-py) and [massive-api](https://github.com/feuerstein-org/massive-api)). Feel free to use it as a building block for your own SDKs, better documentation is currently being worked on. In the future I want to add the possibility to generate the entire SDK off of OpenAPI and Smithy models but that's just an idea for now.
+
+## Installation
+
+Requires Python 3.12 or newer.
+
+```bash
+pip install spitzeisen
+```
+
+The library is still in alpha, so the API may change.
+
+## Usage
+
+> Note: It is **strongly** recommended to review the example weather SDK in `examples`, the below is just a very simple showcase, it is advised to create endpoint groups within one SDK Baseclass.
+
+Here's a client for an API that returns a single item from `/item/{item_id}`:
+
+```python
+import asyncio
+
+from spitzeisen import (
+    BearerHeader,
+    SpitzeisenApi,
+    SpitzeisenConfig,
+    SpitzeisenModel,
+    SpitzeisenOperationSpec,
+    serialize_path_param,
+)
+
+
+class Item(SpitzeisenModel):
+    id: str
+    name: str
+
+
+_ITEM = SpitzeisenOperationSpec(path="/item/{item_id}")
+
+
+class ItemsApi(SpitzeisenApi):
+    async def get_item(self, item_id: str) -> Item:
+        item = await self.get_object(_ITEM, item_id=serialize_path_param(item_id))
+        return self.validate_record(item, Item, mode="raise")
+
+
+async def main():
+    config = SpitzeisenConfig(
+        base_url="https://api.example.com",  # Replace with your API's URL
+        auth=BearerHeader("YOUR_API_KEY"),
+    )
+
+    async with ItemsApi(config) as api:
+        item = await api.get_item("123")
+        print(item.id, item.name)
+
+
+asyncio.run(main())
+```
+
+`serialize_path_param` URL-encodes the item ID before inserting it into the path. `get_object` fetches the JSON response. `validate_record` converts it into an `Item` model. With `mode="raise"`, a response that doesn't match the model raises a Pydantic validation error.
+
+For a sync client, subclass `SyncSpitzeisenApi` and use `SyncSpitzeisenConfig`. Write regular methods with `with` blocks and no `await`. The [weather example](examples/weather_sdk) includes both versions. It's recommended to generate the sync counterparts as much as possible using unasync, the Weather example already does this.
+
+## Config
+
+Authentication, retries, timeouts, and rate limits are configured through `SpitzeisenConfig`.
+For example:
+
+```python
+from spitzeisen import BearerHeader, SpitzeisenConfig, single_bucket
+
+config = SpitzeisenConfig(
+    base_url="https://api.example.com",
+    auth=BearerHeader("YOUR_API_KEY"),
+    limiter=single_bucket("example-account", 60, 60),  # 60 tokens, refilled over 60 seconds
+    max_retries=3,
+    request_timeout=30,
+    on_validation_error="raise",
+)
+```
+
+Rate limiting uses [steindamm](https://github.com/feuerstein-org/steindamm).
+The bucket above starts full and refills gradually. Each request costs one token by default, including retries and page requests. Pass a Redis connection to `single_bucket` to share the limit across processes.
+Without a limiter, requests are unlimited. Sync clients use `sync_single_bucket`.
+
+For authentication, you can also use `HeaderKey` or `QueryParamAuth`. The default is `NoAuth`.
+
+Those are by far not the only ways to authenticate which are supported. You can easily implement your own authentication strategy, same applies to for example pagination, to do that simply pass your custom strategy in the `SpitzeisenOperationSpec`, see [here](examples/inventory_sdk.py) for an example pagination strategy.
+
+Retryable requests use exponential backoff for HTTP 429, server errors, timeouts, and connection errors. POST and PATCH requests are not retried unless you opt in with `retryable=True` on the operation.
+
+Endpoint groups created with `self.api(GroupClass)` share the parent's config, HTTP connection, and rate limiter. Use context managers to close connections when you're done. A supplied HTTP client stays open unless you set `owns_http_client=True`.
+
+## Testing
+
+Install the testing helpers with `pip install "spitzeisen[testing]"`, then enable the pytest plugin in your root `conftest.py`:
+
+```python
+pytest_plugins = ["spitzeisen.testing.plugin"]
+```
+
+`api_factory` creates and closes your client. `httpx2_mock` supplies responses without calling the real API.
+Using the `ItemsApi` class above:
+
+```python
+import pytest
+from spitzeisen import SpitzeisenConfig
+
+
+@pytest.mark.asyncio
+async def test_get_item(api_factory, httpx2_mock):
+    httpx2_mock.add_response(
+        url="https://api.example.com/item/123",
+        json={"id": "123", "name": "Example item"},
+    )
+    api = await api_factory.create(
+        ItemsApi,
+        config=SpitzeisenConfig(base_url="https://api.example.com"),
+    )
+
+    item = await api.get_item("123")
+    assert item.name == "Example item"
+```
+
+For sync clients, use `sync_api_factory`. See the [example tests](examples/tests) for more.
+
+## Examples
+
+- [Weather SDK](examples/weather_sdk): endpoint groups, response models, and async and sync clients.
+- [Inventory SDK](examples/inventory_sdk.py): custom pagination and record iteration.
+- [Offline demo](examples/demo.py): runs both weather clients with saved responses.
+
+To run the demo from the repository root:
+
+```bash
+mise run install
+mise run demo-example
+```
+
+The demo needs no API key or network connection.
+
+## Development
+
+```bash
+mise run install
+mise run build-sync
+mise run lint
+mise run test
+```
+
+The sync code is generated from the async code with `unasync`.
+After editing the async implementation, run `mise run build-sync` to update both the library and weather example.
+`mise run check-sync` checks that the generated files are up to date.

spitzeisen-0.1.0/examples/build_sync.py

@@ -0,0 +1,102 @@
+"""
+Generate the blocking weather SDK from its async implementation.
+
+Run `python build_sync.py` to regenerate, or add `python build_sync.py --check` to CI.
+Copy this script with the SDK and adjust ASYNC_DIR and SYNC_DIR for your package layout.
+The development environment needs unasync and ruff, the script uses no core build helpers.
+"""
+
+import argparse
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+import unasync
+
+ROOT = Path(__file__).resolve().parent
+# Keep code shared by the async and sync surfaces outside these folders.
+ASYNC_DIR = ROOT / "weather_sdk/_async"
+SYNC_DIR = ROOT / "weather_sdk/_sync"
+
+# unasync converts Async-prefixed class names to Sync, public exports drop the Async prefix.
+# E.g. it's "Api" and "SyncApi" instead of "AsyncApi" and "SyncApi". Async is our main usecase.
+REPLACEMENTS = {
+    # Route generated imports to the matching module tree.
+    "_async": "_sync",
+    # httpx2 names its sync client `Client`.
+    "AsyncClient": "Client",
+    "aclose": "close",
+    # Core types also use unprefixed async names.
+    "SpitzeisenApi": "SyncSpitzeisenApi",
+    "SpitzeisenConfig": "SyncSpitzeisenConfig",
+}
+
+HEADER = f"""# Generated from {ASYNC_DIR.relative_to(ROOT)}/ by build_sync.py -- do not edit.
+# Change the async module and run `python build_sync.py`.
+"""
+
+
+def generate(destination: Path) -> None:
+    """Convert async modules, check imports and names, then format using the project's Ruff configuration."""
+    sources = sorted(ASYNC_DIR.rglob("*.py"))
+    if not sources:
+        msg = f"No Python modules found in {ASYNC_DIR}"
+        raise RuntimeError(msg)
+    rule = unasync.Rule(
+        fromdir=f"{ASYNC_DIR}/",
+        todir=f"{destination}/",
+        additional_replacements=REPLACEMENTS,
+    )
+    unasync.unasync_files([str(path) for path in sources], [rule])
+    for path in sorted(destination.rglob("*.py")):
+        path.write_text(HEADER + path.read_text())
+    subprocess.run(  # noqa: S603
+        [sys.executable, "-m", "ruff", "check", "--select", "I,F", "--fix", "--quiet", str(destination)],
+        cwd=ROOT,
+        check=True,
+    )
+    subprocess.run(  # noqa: S603
+        [sys.executable, "-m", "ruff", "format", "--quiet", str(destination)],
+        cwd=ROOT,
+        check=True,
+    )
+
+
+def stale_files(expected: Path) -> list[Path]:
+    """Find missing, changed, or extra Python modules in the generated package."""
+    wanted = {path.relative_to(expected) for path in expected.rglob("*.py")}
+    actual = {path.relative_to(SYNC_DIR) for path in SYNC_DIR.rglob("*.py")}
+    changed = {path for path in wanted & actual if (expected / path).read_bytes() != (SYNC_DIR / path).read_bytes()}
+    return sorted((wanted ^ actual) | changed)
+
+
+def main() -> int:
+    """Regenerate the sync package, or verify it without changing files."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--check", action="store_true", help="fail if generated files are stale")
+    args = parser.parse_args()
+    with tempfile.TemporaryDirectory(dir=ROOT) as temporary:
+        # Preserve the package context so Ruff groups internal imports consistently.
+        expected = Path(temporary) / SYNC_DIR.relative_to(ROOT)
+        expected.parent.mkdir(parents=True)
+        (expected.parent / "__init__.py").touch()
+        generate(expected)
+        if args.check:
+            stale = stale_files(expected)
+            if stale:
+                print("Sync package is stale; run `python build_sync.py`:")
+                for path in stale:
+                    print(f"  {path}")
+                return 1
+            print("Sync package is up to date")
+        else:
+            shutil.rmtree(SYNC_DIR, ignore_errors=True)
+            shutil.copytree(expected, SYNC_DIR)
+            print(f"Generated {len(list(SYNC_DIR.rglob('*.py')))} modules in {SYNC_DIR.relative_to(ROOT)}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

spitzeisen-0.1.0/examples/demo.py

@@ -0,0 +1,91 @@
+"""Run both weather clients end to end without making a network request."""
+
+import asyncio
+import json
+from pathlib import Path
+
+import httpx2
+from weather_sdk import (
+    CurrentWeather,
+    Forecast,
+    SyncWeatherApi,
+    SyncWeatherApiConfig,
+    WeatherApi,
+    WeatherApiConfig,
+)
+
+
+# This is to return fake data and not call the actual API - can be ignored
+def mock_response(request: httpx2.Request) -> httpx2.Response:
+    """Return a saved response for either client's demo request."""
+    responses = Path(__file__).parent / "responses"
+    filename = {"/data/2.5/weather": "current_weather.json", "/data/2.5/forecast": "forecast.json"}[request.url.path]
+    return httpx2.Response(200, json=json.loads((responses / filename).read_text()))
+
+
+def print_weather(weather: CurrentWeather | None, forecast: Forecast | None) -> None:
+    """Display the shared response models returned by both clients."""
+    if weather is not None:
+        print(f"city: {weather.name}")
+        print(f"temperature: {weather.measurements.temperature} °C")
+        print(f"condition: {weather.conditions[0].description}")
+    if forecast is not None:
+        print(f"forecast city: {forecast.city.name}")
+        for reading in forecast.readings:
+            print(
+                f"forecast: {reading.time.isoformat()} - "
+                f"{reading.measurements.temperature} °C - {reading.conditions[0].description}"
+            )
+
+
+# Asynchronous example
+async def main_async() -> None:
+    """Fetch current conditions and forecasts with the async client."""
+    config = WeatherApiConfig(
+        api_key="example-key",
+        on_validation_error="skip",  # If a single record from the API fails validation - skip it
+        validate_inputs=True,  # Check inputs before sending request
+        http_client=httpx2.AsyncClient(transport=httpx2.MockTransport(mock_response)),
+        owns_http_client=True,  # Spitzeisen owns it and will close it when no longer needed
+    )
+
+    async with WeatherApi(config) as api:
+        weather = await api.current_weather_api.get_current_weather(
+            latitude=52.52,
+            longitude=13.405,
+            units="metric",
+            language="en",
+        )
+        forecast = await api.forecast_api.get_forecast("Berlin", units="metric")
+
+    print_weather(weather, forecast)
+
+
+# Synchronous example
+def main_sync() -> None:
+    """Fetch the same models with the blocking client."""
+    config = SyncWeatherApiConfig(
+        api_key="example-key",
+        on_validation_error="skip",  # If a single record from the API fails validation - skip it
+        validate_inputs=True,  # Check inputs before sending request
+        http_client=httpx2.Client(transport=httpx2.MockTransport(mock_response)),
+        owns_http_client=True,  # Spitzeisen owns it and will close it when no longer needed
+    )
+
+    with SyncWeatherApi(config) as api:
+        weather = api.current_weather_api.get_current_weather(
+            latitude=52.52,
+            longitude=13.405,
+            units="metric",
+            language="en",
+        )
+        forecast = api.forecast_api.get_forecast("Berlin", units="metric")
+
+    print_weather(weather, forecast)
+
+
+if __name__ == "__main__":
+    print("Async client")
+    asyncio.run(main_async())
+    print("Sync client")
+    main_sync()

spitzeisen-0.1.0/examples/inventory_sdk.py

@@ -0,0 +1,75 @@
+"""A dummy inventory SDK yielding records through custom bookmark pagination."""
+
+from collections.abc import AsyncIterator
+
+from spitzeisen import (
+    JsonObject,
+    JsonValue,
+    QueryParams,
+    ResponseShapeError,
+    SpitzeisenApi,
+    SpitzeisenModel,
+    SpitzeisenOperationSpec,
+    extract_records,
+    serialize_query_map,
+)
+
+
+class BookmarkPagination:
+    """Read `items` and send each response's `bookmark` as the next request's `after`."""
+
+    def first_params(self, params: QueryParams) -> QueryParams:
+        """Start with the SDK method's query parameters."""
+        return list(params)
+
+    def records(self, page: JsonValue) -> list[JsonObject]:
+        """Extract raw records without validating inventory model fields."""
+        return extract_records(page, "items")
+
+    def next_params(
+        self,
+        page: JsonValue,
+        records: list[JsonObject],  # noqa: ARG002 - required by the pagination protocol
+        params: QueryParams,
+    ) -> QueryParams | None:
+        """Stop without a bookmark, otherwise replace `after` and preserve other parameters."""
+        if not isinstance(page, dict):
+            msg = "expected an inventory response object"
+            raise ResponseShapeError(msg)
+        bookmark = page.get("bookmark")
+        if bookmark is None:
+            return None
+        if not isinstance(bookmark, str) or not bookmark:
+            msg = "expected a non-empty bookmark string"
+            raise ResponseShapeError(msg)
+        return [*(param for param in params if param.name != "after"), *serialize_query_map({"after": bookmark})]
+
+
+class InventoryItem(SpitzeisenModel):
+    """A model returned by the inventory endpoint's typed method."""
+
+    id: str
+    stock: int
+
+
+_LIST_ITEMS = SpitzeisenOperationSpec(path="/items", pagination=BookmarkPagination())
+
+
+class InventoryApi(SpitzeisenApi):
+    """Iterate or collect inventory using a standard SpitzeisenConfig and bookmark pagination."""
+
+    async def iter_items_raw(self) -> AsyncIterator[JsonObject]:
+        """Yield raw items, fetching the next page as iteration advances."""
+        async for record in self.iter_records(_LIST_ITEMS):
+            yield record
+
+    async def iter_items(self) -> AsyncIterator[InventoryItem]:
+        """Validate and yield each item, following the config's validation policy."""
+        async for record in self.iter_items_raw():
+            item = self.validate_record(record, InventoryItem)
+            if item is not None:
+                yield item
+
+    async def list_items(self) -> list[InventoryItem]:
+        """Return all items in the inventory."""
+        return [item async for item in self.iter_items()]

spitzeisen-0.1.0/examples/responses/current_weather.json

@@ -0,0 +1,47 @@
+{
+  "coord": {
+    "lon": 13.405,
+    "lat": 52.52
+  },
+  "weather": [
+    {
+      "id": 800,
+      "main": "Clear",
+      "description": "clear sky",
+      "icon": "01d"
+    }
+  ],
+  "base": "stations",
+  "main": {
+    "temp": 22.4,
+    "feels_like": 22.6,
+    "temp_min": 21.0,
+    "temp_max": 23.5,
+    "pressure": 1015,
+    "humidity": 64,
+    "sea_level": 1015,
+    "grnd_level": 1008
+  },
+  "visibility": 10000,
+  "wind": {
+    "speed": 2.3,
+    "deg": 180,
+    "gust": 3.5
+  },
+  "clouds": {
+    "all": 0
+  },
+  "dt": 1787227200,
+  "sys": {
+    "type": 2,
+    "id": 2011538,
+    "message": 0.0,
+    "country": "DE",
+    "sunrise": 1787198400,
+    "sunset": 1787248800
+  },
+  "timezone": 7200,
+  "id": 2950159,
+  "name": "Berlin",
+  "cod": 200
+}