repeaterbook 0.1.0__py3-none-any.whl

repeaterbook/__init__.py

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

repeaterbook/models.py

@@ -0,0 +1,289 @@
+"""Models."""
+# ruff: noqa: TC003
+
+from __future__ import annotations
+
+__all__: list[str] = [
+    "Emergency",
+    "EmergencyJSON",
+    "ErrorJSON",
+    "ExportBaseQuery",
+    "ExportErrorJSON",
+    "ExportJSON",
+    "ExportNorthAmericaQuery",
+    "ExportQuery",
+    "ExportWorldQuery",
+    "Mode",
+    "ModeJSON",
+    "Repeater",
+    "RepeaterJSON",
+    "ServiceType",
+    "ServiceTypeJSON",
+    "Status",
+    "StatusJSON",
+    "Use",
+    "UseJSON",
+    "YesNoJSON",
+    "ZeroOneJSON",
+]
+
+from datetime import date
+from decimal import Decimal
+from enum import Enum, auto
+from typing import Literal, TypeAlias, TypedDict
+
+import attrs
+from pycountry.db import Country  # noqa: TC002
+from sqlmodel import Field, SQLModel
+
+
+class Status(Enum):
+    """Status."""
+
+    OFF_AIR = auto()
+    ON_AIR = auto()
+    UNKNOWN = auto()
+
+
+class Use(Enum):
+    """Use."""
+
+    OPEN = auto()
+    PRIVATE = auto()
+    CLOSED = auto()
+
+
+class Mode(Enum):
+    """Mode."""
+
+    ANALOG = auto()
+    DMR = auto()
+    NXDN = auto()
+    P25 = auto()
+    TETRA = auto()
+
+
+class Emergency(Enum):
+    """Emergency."""
+
+    ARES = auto()
+    RACES = auto()
+    SKYWARN = auto()
+    CANWARN = auto()
+
+
+class ServiceType(Enum):
+    """Service type."""
+
+    GMRS = auto()
+
+
+class Repeater(SQLModel, table=True):
+    """Repeater."""
+
+    state_id: str = Field(primary_key=True)
+    repeater_id: int = Field(primary_key=True)
+    frequency: Decimal
+    input_frequency: Decimal
+    pl_ctcss_uplink: str | None
+    pl_ctcss_tsq_downlink: str | None
+    location_nearest_city: str
+    landmark: str | None
+    region: str | None
+    country: str | None
+    county: str | None
+    state: str | None
+    latitude: Decimal
+    longitude: Decimal
+    precise: bool
+    callsign: str | None
+    use_membership: Use
+    operational_status: Status
+    ares: str | None
+    races: str | None
+    skywarn: str | None
+    canwarn: str | None
+    #' operating_mode: str
+    allstar_node: str | None
+    echolink_node: str | None
+    irlp_node: str | None
+    wires_node: str | None
+    dmr_capable: bool
+    dmr_id: str | None
+    dmr_color_code: str | None
+    d_star_capable: bool
+    nxdn_capable: bool
+    apco_p_25_capable: bool
+    p_25_nac: str | None
+    m17_capable: bool
+    m17_can: str | None
+    tetra_capable: bool
+    tetra_mcc: str | None
+    tetra_mnc: str | None
+    yaesu_system_fusion_capable: bool
+    ysf_digital_id_uplink: str | None
+    ysf_digital_id_downlink: str | None
+    ysf_dsc: str | None
+    analog_capable: bool
+    fm_bandwidth: Decimal | None
+    notes: str | None
+    last_update: date
+
+
+ZeroOneJSON: TypeAlias = Literal[
+    0,
+    1,
+]
+YesNoJSON: TypeAlias = Literal[
+    "Yes",
+    "No",
+]
+UseJSON: TypeAlias = Literal[
+    "OPEN",
+    "PRIVATE",
+    "CLOSED",
+]
+StatusJSON: TypeAlias = Literal[
+    "Off-air",
+    "On-air",
+    "Unknown",
+]
+ErrorJSON: TypeAlias = Literal["error"]
+ModeJSON: TypeAlias = Literal[
+    "analog",
+    "DMR",
+    "NXDN",
+    "P25",
+    "tetra",
+]
+EmergencyJSON: TypeAlias = Literal[
+    "ARES",
+    "RACES",
+    "SKYWARN",
+    "CANWARN",
+]
+ServiceTypeJSON: TypeAlias = Literal["GMRS"]
+
+
+RepeaterJSON = TypedDict(
+    "RepeaterJSON",
+    {
+        "State ID": str,
+        "Rptr ID": int,
+        "Frequency": str,
+        "Input Freq": str,
+        "PL": str,
+        "TSQ": str,
+        "Nearest City": str,
+        "Landmark": str,
+        "Region": str | None,
+        "State": str,
+        "Country": str,
+        "Lat": str,
+        "Long": str,
+        "Precise": ZeroOneJSON,
+        "Callsign": str,
+        "Use": UseJSON,
+        "Operational Status": StatusJSON,
+        "AllStar Node": str,
+        "EchoLink Node": str | int,
+        "IRLP Node": str,
+        "Wires Node": str,
+        "FM Analog": YesNoJSON,
+        "FM Bandwidth": str,
+        "DMR": YesNoJSON,
+        "DMR Color Code": str,
+        "DMR ID": str | int,
+        "D-Star": YesNoJSON,
+        "NXDN": YesNoJSON,
+        "APCO P-25": YesNoJSON,
+        "P-25 NAC": str,
+        "M17": YesNoJSON,
+        "M17 CAN": str,
+        "Tetra": YesNoJSON,
+        "Tetra MCC": str,
+        "Tetra MNC": str,
+        "System Fusion": YesNoJSON,
+        "Notes": str,
+        "Last Update": str,
+    },
+)
+
+
+class ExportJSON(TypedDict):
+    """RepeaterBook API export response."""
+
+    count: int
+    results: list[RepeaterJSON]
+
+
+class ExportErrorJSON(TypedDict):
+    """RepeaterBook API export error response."""
+
+    status: ErrorJSON
+    message: str
+
+
+class ExportBaseQuery(TypedDict, total=False):
+    """RepeaterBook API export query.
+
+    `%` - wildcard
+    """
+
+    callsign: list[str]
+    """Repeater callsign."""
+    city: list[str]
+    """Repeater city."""
+    landmark: list[str]
+    country: list[str]
+    """Repeater country."""
+    frequency: list[str]
+    """Repeater frequency."""
+    mode: list[ModeJSON]
+    """Repeater operating mode (analog, DMR, NXDN, P25, tetra)."""
+
+
+class ExportNorthAmericaQuery(ExportBaseQuery, total=False):
+    """RepeaterBook API export North America query.
+
+    `%` - wildcard
+    """
+
+    state_id: list[str]
+    """State / province."""
+    county: list[str]
+    """Repeater county."""
+    emcomm: list[EmergencyJSON]
+    """ARES, RACES, SKYWARN, CANWARN."""
+    stype: list[ServiceTypeJSON]
+    """Service type. Only required when searching for GMRS repeaters."""
+
+
+class ExportWorldQuery(ExportBaseQuery, total=False):
+    """RepeaterBook API export World query.
+
+    `%` - wildcard
+    """
+
+    region: list[str]
+    """Repeater region (if available)."""
+
+
+@attrs.frozen
+class ExportQuery:
+    """RepeaterBook API export query.
+
+    `%` - wildcard
+    """
+
+    callsigns: frozenset[str] = frozenset()
+    cities: frozenset[str] = frozenset()
+    landmarks: frozenset[str] = frozenset()
+    countries: frozenset[Country] = frozenset()
+    frequencies: frozenset[Decimal] = frozenset()
+    modes: frozenset[Mode] = frozenset()
+    state_ids: frozenset[str] = frozenset()
+    counties: frozenset[str] = frozenset()
+    emergency_services: frozenset[Emergency] = frozenset()
+    service_types: frozenset[ServiceType] = frozenset()
+    regions: frozenset[str] = frozenset()

repeaterbook/services.py

@@ -0,0 +1,396 @@
+"""Services."""
+
+from __future__ import annotations
+
+__all__: list[str] = [
+    "BOOL_MAP",
+    "STATUS_MAP",
+    "USE_MAP",
+    "RepeaterBook",
+    "fetch_json",
+    "json_to_model",
+]
+
+import asyncio
+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
+
+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
+
+from repeaterbook.models import (
+    Emergency,
+    EmergencyJSON,
+    ExportErrorJSON,
+    ExportJSON,
+    ExportNorthAmericaQuery,
+    ExportQuery,
+    ExportWorldQuery,
+    Mode,
+    ModeJSON,
+    Repeater,
+    RepeaterJSON,
+    ServiceType,
+    ServiceTypeJSON,
+    Status,
+    Use,
+)
+from repeaterbook.utils import LatLon, square_bounds
+
+if TYPE_CHECKING:  # pragma: no cover
+    from sqlalchemy import Engine
+
+
+async def fetch_json(
+    url: URL,
+    *,
+    headers: dict[str, str] | None = None,
+    cache_dir: Path | None = None,
+    max_cache_age: timedelta = timedelta(seconds=3600),
+    chunk_size: int = 1024,
+) -> Any:  # noqa: ANN401
+    """Fetches JSON data from the specified URL using a streaming response.
+
+    - If a cached copy exists and is recent (not older than max_cache_age seconds) and
+      not forced, it loads and returns the cached data.
+    - Otherwise, it streams the data in chunks while displaying a progress bar, caches
+      it, and returns the parsed JSON data.
+    """
+    # Create a unique filename for caching based on the URL hash.
+    if cache_dir is None:
+        cache_dir = Path()
+    hashed_url = hashlib.md5(str(url).encode("utf-8")).hexdigest()  # noqa: S324
+    cache_file = cache_dir / f"api_cache_{hashed_url}.json"
+
+    # Check if fresh cached data exists.
+    if await cache_file.exists():
+        file_age = time.time() - (await cache_file.stat()).st_mtime
+        if file_age < max_cache_age.total_seconds():
+            logger.info("Using cached data.")
+            return json.loads(await cache_file.read_text(encoding="utf-8"))
+
+    await cache_file.unlink(missing_ok=True)
+
+    logger.info("Fetching new data from API...")
+    async with (
+        aiohttp.ClientSession() as session,
+        session.get(url, headers=headers) as response,
+    ):
+        response.raise_for_status()
+        # Open file for writing in binary mode and stream content into it.
+        async with await cache_file.open("wb") as f:
+            with tqdm(
+                total=response.content_length,
+                unit="B",
+                unit_scale=True,
+            ) as progress:
+                async for chunk in response.content.iter_chunked(chunk_size):
+                    await f.write(chunk)
+                    progress.update(len(chunk))
+
+    # After saving the file, load and parse the JSON data.
+    return json.loads(await cache_file.read_text(encoding="utf-8"))
+
+
+BOOL_MAP: Final = {
+    "Yes": True,
+    "No": False,
+    1: True,
+    0: False,
+}
+
+
+USE_MAP: Final = {
+    "OPEN": Use.OPEN,
+    "PRIVATE": Use.PRIVATE,
+    "CLOSED": Use.CLOSED,
+}
+
+STATUS_MAP: Final = {
+    "Off-air": Status.OFF_AIR,
+    "On-air": Status.ON_AIR,
+    "Unknown": Status.UNKNOWN,
+}
+
+
+def parse_date(date_str: str) -> date:
+    """Parses a date string in the format YYYY-MM-DD."""
+    try:
+        return date.fromisoformat(date_str)
+    except ValueError:
+        return date.min
+
+
+def json_to_model(j: RepeaterJSON, /) -> Repeater:
+    """Converts a JSON object to a Repeater model."""
+    return Repeater.model_validate(
+        Repeater(
+            state_id=j["State ID"],
+            repeater_id=j["Rptr ID"],
+            frequency=j["Frequency"],
+            input_frequency=j["Input Freq"],
+            pl_ctcss_uplink=j["PL"] or None,
+            pl_ctcss_tsq_downlink=j["TSQ"] or None,
+            location_nearest_city=j["Nearest City"],
+            landmark=j["Landmark"] or None,
+            region=j["Region"],
+            state=j["State"],
+            country=j["Country"],
+            latitude=j["Lat"],
+            longitude=j["Long"],
+            precise=BOOL_MAP[j["Precise"]],
+            callsign=j["Callsign"],
+            use_membership=USE_MAP[j["Use"]],
+            operational_status=STATUS_MAP[j["Operational Status"]],
+            allstar_node=j["AllStar Node"],
+            echolink_node=str(j["EchoLink Node"]) or None,
+            irlp_node=j["IRLP Node"] or None,
+            wires_node=j["Wires Node"] or None,
+            analog_capable=BOOL_MAP[j["FM Analog"]],
+            fm_bandwidth=j["FM Bandwidth"].replace(" kHz", "") or None,
+            dmr_capable=BOOL_MAP[j["DMR"]],
+            dmr_color_code=j["DMR Color Code"] or None,
+            dmr_id=str(j["DMR ID"]) or None,
+            d_star_capable=BOOL_MAP[j["D-Star"]],
+            nxdn_capable=BOOL_MAP[j["NXDN"]],
+            apco_p_25_capable=BOOL_MAP[j["APCO P-25"]],
+            p_25_nac=j["P-25 NAC"] or None,
+            m17_capable=BOOL_MAP[j["M17"]],
+            m17_can=j["M17 CAN"] or None,
+            tetra_capable=BOOL_MAP[j["Tetra"]],
+            tetra_mcc=j["Tetra MCC"] or None,
+            tetra_mnc=j["Tetra MNC"] or None,
+            yaesu_system_fusion_capable=BOOL_MAP[j["System Fusion"]],
+            notes=j["Notes"] or None,
+            last_update=parse_date(j["Last Update"]),
+        )
+    )
+
+
+@attrs.frozen
+class RepeaterBook:
+    """RepeaterBook API client."""
+
+    base_url: URL = attrs.Factory(lambda: URL("https://repeaterbook.com"))
+    app_name: str = "RepeaterBook Python SDK"
+    app_email: str = "micael@jarniac.dev"
+
+    working_dir: Path = attrs.Factory(lambda: Path())
+    database: str = "repeaterbook.db"
+
+    MAX_COUNT: ClassVar[int] = 3500
+
+    async def cache_dir(self) -> Path:
+        """Cache directory for API responses."""
+        cache = self.working_dir / ".repeaterbook_cache"
+        if not await cache.exists():
+            logger.info("Creating cache directory.")
+            await cache.mkdir(parents=True, exist_ok=True)
+            gitignore = cache / ".gitignore"
+            if not await gitignore.exists():
+                logger.info("Creating .gitignore file.")
+                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."""
+        return self.base_url / "api"
+
+    @property
+    def url_export_north_america(self) -> URL:
+        """North-america export URL."""
+        return self.url_api / "export.php"
+
+    @property
+    def url_export_rest_of_world(self) -> URL:
+        """Rest of world (not north-america) export URL."""
+        return self.url_api / "exportROW.php"
+
+    def urls_export(
+        self,
+        query: ExportQuery,
+    ) -> set[URL]:
+        """Generate export URLs for given query."""
+        mode_map: dict[Mode, ModeJSON] = {
+            Mode.ANALOG: "analog",
+            Mode.DMR: "DMR",
+            Mode.NXDN: "NXDN",
+            Mode.P25: "P25",
+            Mode.TETRA: "tetra",
+        }
+        emergency_map: dict[Emergency, EmergencyJSON] = {
+            Emergency.ARES: "ARES",
+            Emergency.RACES: "RACES",
+            Emergency.SKYWARN: "SKYWARN",
+            Emergency.CANWARN: "CANWARN",
+        }
+        type_map: dict[ServiceType, ServiceTypeJSON] = {
+            ServiceType.GMRS: "GMRS",
+        }
+
+        query_na = ExportNorthAmericaQuery(
+            callsign=list(query.callsigns),
+            city=list(query.cities),
+            landmark=list(query.landmarks),
+            country=[country.name for country in query.countries],
+            frequency=[str(frequency) for frequency in query.frequencies],
+            mode=[mode_map[mode] for mode in query.modes],
+            state_id=list(query.state_ids),
+            county=list(query.counties),
+            emcomm=[emergency_map[emergency] for emergency in query.emergency_services],
+            stype=[type_map[service_type] for service_type in query.service_types],
+        )
+        query_na = cast(
+            "ExportNorthAmericaQuery", {k: v for k, v in query_na.items() if v}
+        )
+
+        query_world = ExportWorldQuery(
+            callsign=list(query.callsigns),
+            city=list(query.cities),
+            landmark=list(query.landmarks),
+            country=[country.name for country in query.countries],
+            frequency=[str(frequency) for frequency in query.frequencies],
+            mode=[mode_map[mode] for mode in query.modes],
+            region=list(query.regions),
+        )
+        query_world = cast(
+            "ExportWorldQuery", {k: v for k, v in query_world.items() if v}
+        )
+
+        return {
+            #' self.url_export_north_america % cast("dict[str, str]", query_na),
+            self.url_export_rest_of_world % cast("dict[str, str]", query_world),
+        }
+
+    async def export_json(self, url: URL) -> ExportJSON:
+        """Export data for given URL."""
+        data: ExportJSON | ExportErrorJSON = await fetch_json(
+            url,
+            headers={"User-Agent": f"{self.app_name} <{self.app_email}>"},
+            cache_dir=await self.cache_dir(),
+        )
+
+        if not isinstance(data, dict):
+            raise TypeError
+
+        if data.get("status") == "error":
+            raise ValueError(data.get("message"))
+
+        if "count" not in data or "results" not in data:
+            raise ValueError
+
+        data = cast("ExportJSON", data)
+
+        if data["count"] >= self.MAX_COUNT:
+            logger.warning(
+                "Reached max count for API response. Response may have been trimmed."
+            )
+
+        if data["count"] != len(data["results"]):
+            logger.warning("Mismatched count and length of results.")
+
+        return data
+
+    async def export_multi_json(self, urls: set[URL]) -> list[ExportJSON]:
+        """Export data for given URLs."""
+        tasks = [self.export_json(url) for url in urls]
+        return await asyncio.gather(*tasks)
+
+    async def download(self, query: ExportQuery) -> list[Repeater]:
+        """Download data and populate internal database."""
+        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.add(repeater)
+                repeaters.append(repeater)
+            session.commit()
+
+        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/utils.py

@@ -0,0 +1,49 @@
+"""Utilities."""
+
+from __future__ import annotations
+
+__all__: list[str] = [
+    "LatLon",
+    "SquareBounds",
+    "square_bounds",
+]
+
+from typing import NamedTuple
+
+from haversine import Direction, Unit, inverse_haversine  # type: ignore[import-untyped]
+
+
+class LatLon(NamedTuple):
+    """Latitude and Longitude."""
+
+    lat: float
+    lon: float
+
+
+class SquareBounds(NamedTuple):
+    """Square bounds."""
+
+    north: float
+    south: float
+    east: float
+    west: float
+
+
+def square_bounds(
+    origin: LatLon, distance: float, unit: Unit = Unit.KILOMETERS
+) -> 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]
+
+    # If we've gone all the way around, things get messy. Just open it up to everything.
+    if south > north:
+        north = 90.0
+        south = -90.0
+    if west > east:
+        west = -180.0
+        east = 180.0
+
+    return SquareBounds(north=north, south=south, east=east, west=west)

repeaterbook-0.1.0.dist-info/METADATA

@@ -0,0 +1,174 @@
+Metadata-Version: 2.4
+Name: repeaterbook
+Version: 0.1.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
+Project-URL: download, https://pypi.org/project/repeaterbook/#files
+Project-URL: changelog, https://github.com/MicaelJarniac/repeaterbook/blob/main/docs/CHANGELOG.md
+Project-URL: documentation, https://repeaterbook.readthedocs.io
+Project-URL: issues, https://github.com/MicaelJarniac/repeaterbook/issues
+Author-email: Micael Jarniac <micael@jarniac.dev>
+License: MIT
+License-File: LICENSE
+Classifier: Development Status :: 1 - Planning
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: aiohttp>=3.11.14
+Requires-Dist: anyio>=4.9.0
+Requires-Dist: attrs>=25.3.0
+Requires-Dist: haversine>=2.9.0
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: pycountry>=24.6.1
+Requires-Dist: sqlmodel>=0.0.24
+Requires-Dist: tqdm>=4.67.1
+Requires-Dist: yarl>=1.18.3
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+  [![Discord][badge-chat]][chat]
+  <br>
+  <br>
+
+  | | ![Badges][label-badges] |
+  |:-|:-|
+  | ![Build][label-build] | [![Nox][badge-actions]][actions] [![semantic-release][badge-semantic-release]][semantic-release] [![PyPI][badge-pypi]][pypi] [![Read the Docs][badge-docs]][docs] |
+  | ![Tests][label-tests] | [![coverage][badge-coverage]][coverage] [![pre-commit][badge-pre-commit]][pre-commit] [![asv][badge-asv]][asv] |
+  | ![Standards][label-standards] | [![SemVer 2.0.0][badge-semver]][semver] [![Conventional Commits][badge-conventional-commits]][conventional-commits] |
+  | ![Code][label-code] | [![uv][badge-uv]][uv] [![Ruff][badge-ruff]][ruff] [![Nox][badge-nox]][nox] [![Checked with mypy][badge-mypy]][mypy] |
+  | ![Repo][label-repo] | [![GitHub issues][badge-issues]][issues] [![GitHub stars][badge-stars]][stars] [![GitHub license][badge-license]][license] [![All Contributors][badge-all-contributors]][contributors] [![Contributor Covenant][badge-code-of-conduct]][code-of-conduct] |
+</div>
+
+<!-- Badges -->
+[badge-chat]: https://img.shields.io/badge/dynamic/json?color=green&label=chat&query=%24.approximate_presence_count&suffix=%20online&logo=discord&style=flat-square&url=https%3A%2F%2Fdiscord.com%2Fapi%2Fv10%2Finvites%2FYe9yJtZQuN%3Fwith_counts%3Dtrue
+[chat]: https://discord.gg/Ye9yJtZQuN
+
+<!-- Labels -->
+[label-badges]: https://img.shields.io/badge/%F0%9F%94%96-badges-purple?style=for-the-badge
+[label-build]: https://img.shields.io/badge/%F0%9F%94%A7-build-darkblue?style=flat-square
+[label-tests]: https://img.shields.io/badge/%F0%9F%A7%AA-tests-darkblue?style=flat-square
+[label-standards]: https://img.shields.io/badge/%F0%9F%93%91-standards-darkblue?style=flat-square
+[label-code]: https://img.shields.io/badge/%F0%9F%92%BB-code-darkblue?style=flat-square
+[label-repo]: https://img.shields.io/badge/%F0%9F%93%81-repo-darkblue?style=flat-square
+
+<!-- Build -->
+[badge-actions]: https://img.shields.io/github/actions/workflow/status/MicaelJarniac/repeaterbook/ci.yml?branch=main&style=flat-square
+[actions]: https://github.com/MicaelJarniac/repeaterbook/actions
+[badge-semantic-release]: https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079?style=flat-square
+[semantic-release]: https://github.com/semantic-release/semantic-release
+[badge-pypi]: https://img.shields.io/pypi/v/repeaterbook?style=flat-square
+[pypi]: https://pypi.org/project/repeaterbook
+[badge-docs]: https://img.shields.io/readthedocs/repeaterbook?style=flat-square
+[docs]: https://repeaterbook.readthedocs.io
+
+<!-- Tests -->
+[badge-coverage]: https://img.shields.io/codecov/c/gh/MicaelJarniac/repeaterbook?logo=codecov&style=flat-square
+[coverage]: https://codecov.io/gh/MicaelJarniac/repeaterbook
+[badge-pre-commit]: https://img.shields.io/badge/pre--commit-enabled-brightgreen?style=flat-square&logo=pre-commit&logoColor=white
+[pre-commit]: https://github.com/pre-commit/pre-commit
+[badge-asv]: https://img.shields.io/badge/benchmarked%20by-asv-blue?style=flat-square
+[asv]: https://github.com/airspeed-velocity/asv
+
+<!-- Standards -->
+[badge-semver]: https://img.shields.io/badge/SemVer-2.0.0-blue?style=flat-square&logo=semver
+[semver]: https://semver.org/spec/v2.0.0.html
+[badge-conventional-commits]: https://img.shields.io/badge/Conventional%20Commits-1.0.0-yellow?style=flat-square
+[conventional-commits]: https://conventionalcommits.org
+
+<!-- Code -->
+[badge-uv]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json&style=flat-square
+[uv]: https://github.com/astral-sh/uv
+[badge-ruff]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&style=flat-square
+[ruff]: https://github.com/astral-sh/ruff
+[badge-nox]: https://img.shields.io/badge/%F0%9F%A6%8A-Nox-D85E00.svg?style=flat-square
+[nox]: https://github.com/wntrblm/nox
+[badge-mypy]: https://img.shields.io/badge/mypy-checked-2A6DB2?style=flat-square
+[mypy]: http://mypy-lang.org
+
+<!-- Repo -->
+[badge-issues]: https://img.shields.io/github/issues/MicaelJarniac/repeaterbook?style=flat-square
+[issues]: https://github.com/MicaelJarniac/repeaterbook/issues
+[badge-stars]: https://img.shields.io/github/stars/MicaelJarniac/repeaterbook?style=flat-square
+[stars]: https://github.com/MicaelJarniac/repeaterbook/stargazers
+[badge-license]: https://img.shields.io/github/license/MicaelJarniac/repeaterbook?style=flat-square
+[license]: https://github.com/MicaelJarniac/repeaterbook/blob/main/LICENSE
+<!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
+[badge-all-contributors]: https://img.shields.io/badge/all_contributors-0-orange.svg?style=flat-square
+<!-- ALL-CONTRIBUTORS-BADGE:END -->
+[contributors]: #Contributors-✨
+[badge-code-of-conduct]: https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa?style=flat-square
+[code-of-conduct]: CODE_OF_CONDUCT.md
+<!---->
+
+# RepeaterBook
+Python utility to work with data from RepeaterBook.
+
+[Read the Docs][docs]
+
+Read RepeaterBook's official [API documentation](https://www.repeaterbook.com/wiki/doku.php?id=api) for more information.
+
+## See Also
+- https://github.com/afourney/hamkit/tree/main/packages/repeaterbook
+- https://github.com/desertblade/OpenGD77-Repeaterbook
+- https://github.com/TomHW/OpenGD77
+
+## Installation
+
+### PyPI
+[*repeaterbook*][pypi] is available on PyPI:
+
+```bash
+# With uv
+uv add repeaterbook
+# With pip
+pip install repeaterbook
+# With Poetry
+poetry add repeaterbook
+```
+
+### GitHub
+You can also install the latest version of the code directly from GitHub:
+```bash
+# With uv
+uv add git+https://github.com/MicaelJarniac/repeaterbook
+# With pip
+pip install git+git://github.com/MicaelJarniac/repeaterbook
+# With Poetry
+poetry add git+git://github.com/MicaelJarniac/repeaterbook
+```
+
+## Usage
+For more examples, see the [full documentation][docs].
+
+```python
+from repeaterbook import repeaterbook
+```
+
+## Contributing
+Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
+
+Please make sure to update tests as appropriate.
+
+More details can be found in [CONTRIBUTING](CONTRIBUTING.md).
+
+## Contributors ✨
+<!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
+<!-- prettier-ignore-start -->
+<!-- markdownlint-disable -->
+<table>
+</table>
+
+<!-- markdownlint-restore -->
+<!-- prettier-ignore-end -->
+
+<!-- ALL-CONTRIBUTORS-LIST:END -->
+
+## License
+[MIT](../LICENSE)
+
+This project was created with the [MicaelJarniac/crustypy](https://github.com/MicaelJarniac/crustypy) template.

repeaterbook-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+repeaterbook/__init__.py,sha256=S_Y8t081UnaTlJu4bqSLPb-Zpo4NpwfSOlftqlrR6Bg,58
+repeaterbook/models.py,sha256=XZhpAyWuIIrYLy4i8DEp5R_KTwoGqtUiCVkH3A6L5eY,6116
+repeaterbook/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+repeaterbook/services.py,sha256=Oam2rxTAg8Te_FLy7u0FugiYmQZhrbGLnLQAXfmU6xQ,12995
+repeaterbook/utils.py,sha256=6I0NQdxPdNlBP_AKYidhRbM1XOZOHdPJpN8gQ-jNd2I,1227
+repeaterbook-0.1.0.dist-info/METADATA,sha256=vXldXpUbTdCsqZboeyQku3yS3LVpyHrz6Q0GaLUuuP8,7824
+repeaterbook-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+repeaterbook-0.1.0.dist-info/licenses/LICENSE,sha256=TtbMt69RbQyifR_It2bTHKdlLR1Dj6x2A5y_oLOyoVk,1071
+repeaterbook-0.1.0.dist-info/RECORD,,

repeaterbook-0.1.0.dist-info/WHEEL

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

repeaterbook-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Micael Jarniac
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.