repeaterbook 0.1.1__tar.gz → 0.2.0__tar.gz

{repeaterbook-0.1.1 → repeaterbook-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: repeaterbook
-Version: 0.1.1
+Version: 0.2.0
 Summary: Python utility to work with data from RepeaterBook.
 Project-URL: homepage, https://github.com/MicaelJarniac/repeaterbook
 Project-URL: source, https://github.com/MicaelJarniac/repeaterbook

{repeaterbook-0.1.1 → repeaterbook-0.2.0}/docs/CHANGELOG.md

@@ -1,6 +1,14 @@
 # CHANGELOG
 
 
+## v0.2.0 (2025-04-08)
+
+### Features
+
+- Queries
+  ([`78972e5`](https://github.com/MicaelJarniac/repeaterbook/commit/78972e5cbdcd150dd9e6435d5dd5c759bb22f96b))
+
+
 ## v0.1.1 (2025-04-03)
 
 ### Bug Fixes

repeaterbook-0.2.0/playground/examples.ipynb

@@ -0,0 +1,107 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pycountry\n",
+    "from anyio import Path\n",
+    "\n",
+    "from repeaterbook.models import ExportQuery\n",
+    "from repeaterbook.services import RepeaterBookAPI\n",
+    "\n",
+    "rb_api = RepeaterBookAPI(\n",
+    "    app_name=\"RepeaterBook Python SDK\",\n",
+    "    app_email=\"micael@jarniac.dev\",\n",
+    "    working_dir=Path(),\n",
+    ")\n",
+    "repeaters = await rb_api.download(\n",
+    "    query=ExportQuery(countries={pycountry.countries.get(name=\"Brazil\")})\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from repeaterbook import RepeaterBook\n",
+    "\n",
+    "rb = RepeaterBook(\n",
+    "    working_dir=Path(),\n",
+    ")\n",
+    "rb.populate(repeaters)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from haversine import Unit\n",
+    "from rich import print as pprint\n",
+    "\n",
+    "from repeaterbook import queries\n",
+    "from repeaterbook.models import Repeater\n",
+    "from repeaterbook.utils import LatLon, Radius\n",
+    "\n",
+    "radius = Radius(\n",
+    "    origin=LatLon(\n",
+    "        lat=-22.4000,\n",
+    "        lon=-46.9000,\n",
+    "    ),\n",
+    "    distance=50,\n",
+    "    unit=Unit.KILOMETERS,\n",
+    ")\n",
+    "\n",
+    "filtered_repeaters = queries.filter_radius(\n",
+    "    rb.query(*queries.square(radius), Repeater.dmr_capable), radius\n",
+    ")\n",
+    "pprint(filtered_repeaters)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from repeaterbook import queries\n",
+    "from repeaterbook.models import Status, Use\n",
+    "from repeaterbook.queries import Bands\n",
+    "\n",
+    "rb.query(\n",
+    "    Repeater.dmr_capable | Repeater.analog_capable,\n",
+    "    Repeater.operational_status == Status.ON_AIR,\n",
+    "    Repeater.use_membership == Use.OPEN,\n",
+    "    queries.band(Bands.M_2, Bands.CM_70),\n",
+    ")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

{repeaterbook-0.1.1 → repeaterbook-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "repeaterbook"
-version = "0.1.1"
+version = "0.2.0"
 description = "Python utility to work with data from RepeaterBook."
 authors = [
   {name = "Micael Jarniac", email = "micael@jarniac.dev"},

repeaterbook-0.2.0/src/repeaterbook/__init__.py

@@ -0,0 +1,11 @@
+"""Python utility to work with data from RepeaterBook."""
+
+from __future__ import annotations
+
+__all__: tuple[str, ...] = (
+    "Repeater",
+    "RepeaterBook",
+)
+
+from repeaterbook.database import RepeaterBook
+from repeaterbook.models import Repeater

repeaterbook-0.2.0/src/repeaterbook/database.py

@@ -0,0 +1,74 @@
+"""Internal database module for RepeaterBook."""
+
+from __future__ import annotations
+
+__all__: tuple[str, ...] = ("RepeaterBook",)
+
+from functools import cached_property
+from typing import TYPE_CHECKING
+
+import attrs
+from anyio import Path
+from loguru import logger
+from sqlmodel import Session, SQLModel, create_engine, select
+
+from repeaterbook.models import (
+    Repeater,
+)
+
+if TYPE_CHECKING:  # pragma: no cover
+    from collections.abc import Iterable, Sequence
+
+    from sqlalchemy import Engine
+    from sqlalchemy.sql._typing import _ColumnExpressionArgument
+
+
+@attrs.frozen
+class RepeaterBook:
+    """RepeaterBook API client."""
+
+    working_dir: Path = attrs.Factory(Path)
+    database: str = "repeaterbook.db"
+
+    @property
+    def database_path(self) -> Path:
+        """Database path."""
+        return self.working_dir / self.database
+
+    @property
+    def database_uri(self) -> str:
+        """Database URI."""
+        return f"sqlite:///{self.database_path}"
+
+    @cached_property
+    def engine(self) -> Engine:
+        """Create database engine."""
+        return create_engine(self.database_uri)
+
+    def init_db(self) -> None:
+        """Initialize database."""
+        SQLModel.metadata.create_all(self.engine)
+
+    def populate(self, repeaters: Iterable[Repeater]) -> None:
+        """Populate internal database."""
+        self.init_db()
+
+        with Session(self.engine) as session:
+            for repeater in repeaters:
+                session.merge(repeater)
+            session.commit()
+
+        logger.info("Populated repeaters.")
+
+    def query(
+        self,
+        *where: _ColumnExpressionArgument[bool] | bool,
+    ) -> Sequence[Repeater]:
+        """Query the database."""
+        with Session(self.engine) as session:
+            statement = select(Repeater).where(*where)
+            repeaters = session.exec(statement).all()
+
+        logger.info(f"Found {len(repeaters)} repeaters.")
+
+        return repeaters

{repeaterbook-0.1.1 → repeaterbook-0.2.0}/src/repeaterbook/models.py

@@ -83,22 +83,22 @@ class Repeater(SQLModel, table=True):
 
     state_id: str = Field(primary_key=True)
     repeater_id: int = Field(primary_key=True)
-    frequency: Decimal
-    input_frequency: Decimal
+    frequency: Decimal = Field(index=True)
+    input_frequency: Decimal = Field(index=True)
     pl_ctcss_uplink: str | None
     pl_ctcss_tsq_downlink: str | None
     location_nearest_city: str
     landmark: str | None
     region: str | None
-    country: str | None
+    country: str | None = Field(index=True)
     county: str | None
     state: str | None
-    latitude: Decimal
-    longitude: Decimal
+    latitude: Decimal = Field(index=True)
+    longitude: Decimal = Field(index=True)
     precise: bool
     callsign: str | None
-    use_membership: Use
-    operational_status: Status
+    use_membership: Use = Field(index=True)
+    operational_status: Status = Field(index=True)
     ares: str | None
     races: str | None
     skywarn: str | None
@@ -108,23 +108,23 @@ class Repeater(SQLModel, table=True):
     echolink_node: str | None
     irlp_node: str | None
     wires_node: str | None
-    dmr_capable: bool
+    dmr_capable: bool = Field(index=True)
     dmr_id: str | None
     dmr_color_code: str | None
-    d_star_capable: bool
-    nxdn_capable: bool
-    apco_p_25_capable: bool
+    d_star_capable: bool = Field(index=True)
+    nxdn_capable: bool = Field(index=True)
+    apco_p_25_capable: bool = Field(index=True)
     p_25_nac: str | None
-    m17_capable: bool
+    m17_capable: bool = Field(index=True)
     m17_can: str | None
-    tetra_capable: bool
+    tetra_capable: bool = Field(index=True)
     tetra_mcc: str | None
     tetra_mnc: str | None
-    yaesu_system_fusion_capable: bool
+    yaesu_system_fusion_capable: bool = Field(index=True)
     ysf_digital_id_uplink: str | None
     ysf_digital_id_downlink: str | None
     ysf_dsc: str | None
-    analog_capable: bool
+    analog_capable: bool = Field(index=True)
     fm_bandwidth: Decimal | None
     notes: str | None
     last_update: date

repeaterbook-0.2.0/src/repeaterbook/queries.py

@@ -0,0 +1,113 @@
+"""Queries."""
+
+from __future__ import annotations
+
+__all__: tuple[str, ...] = (
+    "Band",
+    "Bands",
+    "band",
+    "filter_radius",
+    "square",
+)
+
+from decimal import Decimal
+from enum import Enum
+from typing import TYPE_CHECKING, NamedTuple
+
+from haversine import haversine  # type: ignore[import-untyped]
+from loguru import logger
+from sqlmodel import or_
+
+from repeaterbook.models import Repeater
+from repeaterbook.utils import Radius, square_bounds
+
+if TYPE_CHECKING:  # pragma: no cover
+    from collections.abc import Iterable
+
+    from sqlalchemy.sql._typing import _ColumnExpressionArgument
+    from sqlalchemy.sql.elements import ColumnElement
+
+
+def square(radius: Radius) -> tuple[_ColumnExpressionArgument[bool] | bool, ...]:
+    """Return a query for repeaters within a given square.
+
+    Note: This is a square, not a circle. Use `filter_radius` afterwards.
+    """
+    bounds = square_bounds(radius=radius)
+    return (
+        Repeater.latitude >= bounds.south,
+        Repeater.latitude <= bounds.north,
+        Repeater.longitude >= bounds.west,
+        Repeater.longitude <= bounds.east,
+    )
+
+
+def filter_radius(
+    repeaters: Iterable[Repeater],
+    radius: Radius,
+) -> list[Repeater]:
+    """Filter repeaters within a given radius, and sort by distance.
+
+    Use after `square` to limit the number of repeaters to check.
+    This is a brute-force search, so it should be used with care.
+    """
+
+    class RepDist(NamedTuple):
+        """Repeater distance."""
+
+        repeater: Repeater
+        distance: float
+
+    rep_dists: list[RepDist] = []
+    for repeater in repeaters:
+        # Calculate the distance to the repeater.
+        distance = haversine(
+            radius.origin,
+            (repeater.latitude, repeater.longitude),
+            unit=radius.unit,
+        )
+
+        if distance <= radius.distance:
+            rep_dists.append(RepDist(repeater=repeater, distance=distance))
+
+    # Sort by distance.
+    rep_dists.sort(key=lambda x: x.distance)
+
+    # Log the number of repeaters found.
+    logger.info(
+        f"Found {len(rep_dists)} repeaters within {radius.distance} {radius.unit.name}."
+    )
+
+    # Convert to a list of repeaters.
+    return [rep_dist.repeater for rep_dist in rep_dists]
+
+
+class Band(NamedTuple):
+    """Band."""
+
+    low: Decimal
+    high: Decimal
+
+
+class Bands(Band, Enum):
+    """Bands."""
+
+    M_10 = Band(low=Decimal("28.0"), high=Decimal("29.7"))
+    M_6 = Band(low=Decimal("50.0"), high=Decimal("54.0"))
+    M_4 = Band(low=Decimal("70.0"), high=Decimal("72.0"))
+    M_2 = Band(low=Decimal("144.0"), high=Decimal("148.0"))
+    CM_70 = Band(low=Decimal("420.0"), high=Decimal("450.0"))
+    CM_33 = Band(low=Decimal("902.0"), high=Decimal("928.0"))
+    CM_23 = Band(low=Decimal("1240.0"), high=Decimal("1300.0"))
+    CM_13 = Band(low=Decimal("2300.0"), high=Decimal("2450.0"))
+    CM_3 = Band(low=Decimal("10000.0"), high=Decimal("10500.0"))
+
+
+def band(*bands: Band) -> ColumnElement[bool]:
+    """Return a query for repeaters within a given band."""
+    return or_(
+        *(
+            (Repeater.frequency >= band.low) & (Repeater.frequency <= band.high)
+            for band in bands
+        )
+    )

{repeaterbook-0.1.1 → repeaterbook-0.2.0}/src/repeaterbook/services.py

@@ -6,7 +6,7 @@ __all__: tuple[str, ...] = (
     "BOOL_MAP",
     "STATUS_MAP",
     "USE_MAP",
-    "RepeaterBook",
+    "RepeaterBookAPI",
     "fetch_json",
     "json_to_model",
 )
@@ -16,15 +16,12 @@ import hashlib
 import json
 import time
 from datetime import date, timedelta
-from functools import cached_property
-from typing import TYPE_CHECKING, Any, ClassVar, Final, NamedTuple, cast
+from typing import Any, ClassVar, Final, cast
 
 import aiohttp
 import attrs
 from anyio import Path
-from haversine import Unit, haversine  # type: ignore[import-untyped]
 from loguru import logger
-from sqlmodel import Session, SQLModel, create_engine, select
 from tqdm import tqdm
 from yarl import URL
 
@@ -45,10 +42,6 @@ from repeaterbook.models import (
     Status,
     Use,
 )
-from repeaterbook.utils import LatLon, square_bounds
-
-if TYPE_CHECKING:  # pragma: no cover
-    from sqlalchemy import Engine
 
 
 async def fetch_json(
@@ -178,7 +171,7 @@ def json_to_model(j: RepeaterJSON, /) -> Repeater:
 
 
 @attrs.frozen
-class RepeaterBook:
+class RepeaterBookAPI:
     """RepeaterBook API client."""
 
     base_url: URL = attrs.Factory(lambda: URL("https://repeaterbook.com"))
@@ -186,7 +179,6 @@ class RepeaterBook:
     app_email: str = "micael@jarniac.dev"
 
     working_dir: Path = attrs.Factory(Path)
-    database: str = "repeaterbook.db"
 
     MAX_COUNT: ClassVar[int] = 3500
 
@@ -202,25 +194,6 @@ class RepeaterBook:
                 await gitignore.write_text("*\n", encoding="utf-8")
         return cache
 
-    @property
-    def database_path(self) -> Path:
-        """Database path."""
-        return self.working_dir / self.database
-
-    @property
-    def database_uri(self) -> str:
-        """Database URI."""
-        return f"sqlite:///{self.database_path}"
-
-    @cached_property
-    def engine(self) -> Engine:
-        """Create database engine."""
-        return create_engine(self.database_uri)
-
-    def init_db(self) -> None:
-        """Initialize database."""
-        SQLModel.metadata.create_all(self.engine)
-
     @property
     def url_api(self) -> URL:
         """RepeaterBook API base URL."""
@@ -327,70 +300,14 @@ class RepeaterBook:
         return await asyncio.gather(*tasks)
 
     async def download(self, query: ExportQuery) -> list[Repeater]:
-        """Download data and populate internal database."""
+        """Download repeaters."""
         data = await self.export_multi_json(self.urls_export(query))
 
         results: list[RepeaterJSON] = []
         for export in data:
             results.extend(export["results"])
 
-        self.init_db()
-
-        repeaters: list[Repeater] = []
-        with Session(self.engine) as session:
-            for result in results:
-                repeater = json_to_model(result)
-                session.merge(repeater)
-                repeaters.append(repeater)
-            session.commit()
+        repeaters = [json_to_model(result) for result in results]
 
         logger.info(f"Downloaded {len(repeaters)} repeaters.")
         return repeaters
-
-    def find_nearest(
-        self,
-        latitude: float,
-        longitude: float,
-        *,
-        max_distance: float = 80.0,
-        unit: Unit = Unit.KILOMETERS,
-    ) -> list[Repeater]:
-        """Find repeaters within a given distance."""
-
-        class RepDist(NamedTuple):
-            """Repeater distance."""
-
-            repeater: Repeater
-            distance: float
-
-        rep_dists: list[RepDist] = []
-        with Session(self.engine) as session:
-            # Calculate the square bounds for the given distance.
-            bounds = square_bounds(LatLon(latitude, longitude), max_distance, unit=unit)
-            statement = select(Repeater).where(
-                Repeater.latitude >= bounds.south,
-                Repeater.latitude <= bounds.north,
-                Repeater.longitude >= bounds.west,
-                Repeater.longitude <= bounds.east,
-            )
-            for repeater in session.exec(statement):
-                # Calculate the distance to the repeater.
-                distance = haversine(
-                    (latitude, longitude),
-                    (repeater.latitude, repeater.longitude),
-                    unit=unit,
-                )
-
-                if distance <= max_distance:
-                    rep_dists.append(RepDist(repeater=repeater, distance=distance))
-
-        # Sort by distance.
-        rep_dists.sort(key=lambda x: x.distance)
-
-        # Log the number of repeaters found.
-        logger.info(
-            f"Found {len(rep_dists)} repeaters within {max_distance} {unit.name}."
-        )
-
-        # Convert to a list of repeaters.
-        return [rep_dist.repeater for rep_dist in rep_dists]

{repeaterbook-0.1.1 → repeaterbook-0.2.0}/src/repeaterbook/utils.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 __all__: tuple[str, ...] = (
     "LatLon",
+    "Radius",
     "SquareBounds",
     "square_bounds",
 )
@@ -20,6 +21,14 @@ class LatLon(NamedTuple):
     lon: float
 
 
+class Radius(NamedTuple):
+    """Radius."""
+
+    origin: LatLon
+    distance: float
+    unit: Unit = Unit.KILOMETERS
+
+
 class SquareBounds(NamedTuple):
     """Square bounds."""
 
@@ -29,14 +38,20 @@ class SquareBounds(NamedTuple):
     west: float
 
 
-def square_bounds(
-    origin: LatLon, distance: float, unit: Unit = Unit.KILOMETERS
-) -> SquareBounds:
+def square_bounds(radius: Radius) -> SquareBounds:
     """Get square bounds around a point."""
-    north = inverse_haversine(origin, distance, Direction.NORTH, unit=unit)[0]
-    south = inverse_haversine(origin, distance, Direction.SOUTH, unit=unit)[0]
-    east = inverse_haversine(origin, distance, Direction.EAST, unit=unit)[1]
-    west = inverse_haversine(origin, distance, Direction.WEST, unit=unit)[1]
+    north = inverse_haversine(
+        radius.origin, radius.distance, Direction.NORTH, unit=radius.unit
+    )[0]
+    south = inverse_haversine(
+        radius.origin, radius.distance, Direction.SOUTH, unit=radius.unit
+    )[0]
+    east = inverse_haversine(
+        radius.origin, radius.distance, Direction.EAST, unit=radius.unit
+    )[1]
+    west = inverse_haversine(
+        radius.origin, radius.distance, Direction.WEST, unit=radius.unit
+    )[1]
 
     # If we've gone all the way around, things get messy. Just open it up to everything.
     if south > north:

{repeaterbook-0.1.1 → repeaterbook-0.2.0}/uv.lock

@@ -2072,7 +2072,7 @@ wheels = [
 
 [[package]]
 name = "repeaterbook"
-version = "0.1.1"
+version = "0.2.0"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },

repeaterbook-0.1.1/playground/examples.ipynb

@@ -1,63 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import pycountry\n",
-    "from anyio import Path\n",
-    "\n",
-    "from repeaterbook.models import ExportQuery\n",
-    "from repeaterbook.services import RepeaterBook\n",
-    "\n",
-    "rb = RepeaterBook(\n",
-    "    app_name=\"RepeaterBook Python SDK\",\n",
-    "    app_email=\"micael@jarniac.dev\",\n",
-    "    working_dir=Path(),\n",
-    ")\n",
-    "await rb.download(query=ExportQuery(countries={pycountry.countries.get(name=\"Brazil\")}))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from haversine import Unit\n",
-    "from rich import print as pprint\n",
-    "\n",
-    "repeaters = rb.find_nearest(\n",
-    "    latitude=-22.4000,\n",
-    "    longitude=-46.9000,\n",
-    "    max_distance=50,\n",
-    "    unit=Unit.KILOMETERS,\n",
-    ")\n",
-    "pprint(repeaters)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.13.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

repeaterbook-0.1.1/src/repeaterbook/__init__.py

@@ -1 +0,0 @@
-"""Python utility to work with data from RepeaterBook."""