traewelling-api 0.1.0__tar.gz

traewelling_api-0.1.0/LICENSE

@@ -0,0 +1,8 @@
+Copyright (c) 2026 Lambda Crime
+
+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.
+

traewelling_api-0.1.0/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: traewelling-api
+Version: 0.1.0
+Summary: Add your description here
+License-Expression: MIT
+Project-URL: Homepage, https://codeberg.org/lambda-crime/traewelling-api
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fptf-pydantic>=0.1.0
+Requires-Dist: pydantic-extra-types>=2.11.0
+Requires-Dist: rich>=14.2.0
+Requires-Dist: textual>=7.2.0
+Requires-Dist: traewelling-pydantic>=0.2.1
+Requires-Dist: typer>=0.21.1
+Dynamic: license-file
+
+# Traewelling-API
+
+This is a simple Traewelling API wrapper.
+
+The goal is to provide an easy way to talk with the Traewelling API from Python
+
+## TODOs
+
+- add every API endpoint for Traewelling
+- add FPTF converterter for Traewelling API responses
+- add command for every API endpoint to CLI
+- [OPTIONAL] add TUI for interactive API requests

traewelling_api-0.1.0/README.md

@@ -0,0 +1,12 @@
+# Traewelling-API
+
+This is a simple Traewelling API wrapper.
+
+The goal is to provide an easy way to talk with the Traewelling API from Python
+
+## TODOs
+
+- add every API endpoint for Traewelling
+- add FPTF converterter for Traewelling API responses
+- add command for every API endpoint to CLI
+- [OPTIONAL] add TUI for interactive API requests

traewelling_api-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[project]
+name = "traewelling-api"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "fptf-pydantic>=0.1.0",
+    "pydantic-extra-types>=2.11.0",
+    "rich>=14.2.0",
+    "textual>=7.2.0",
+    "traewelling-pydantic>=0.2.1",
+    "typer>=0.21.1",
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICENSE"]
+
+[project.scripts]
+traewelling-cli = "traewelling_api:app"
+
+[project.urls]
+Homepage = "https://codeberg.org/lambda-crime/traewelling-api"

traewelling_api-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

traewelling_api-0.1.0/src/traewelling_api/__init__.py

@@ -0,0 +1,5 @@
+from . import api
+from . import client
+from . import cli
+
+from .cli import app

traewelling_api-0.1.0/src/traewelling_api/api/__init__.py

@@ -0,0 +1,23 @@
+from . import auth
+from . import checkin
+from . import community
+from . import configuration_information
+from . import dashboard
+from . import events
+from . import ics_tokens
+from . import leaderboard
+from . import likes
+from . import notifications
+from . import polyline
+from . import report
+from . import security
+from . import settings
+from . import statistics
+from . import status
+from . import trips
+from . import user
+from . import user_follow
+from . import user_hide_and_block
+from . import webhooks
+from . import generic
+from . import models

traewelling_api-0.1.0/src/traewelling_api/api/auth.py

@@ -0,0 +1,52 @@
+"""
+Logging in, creating Accounts, etc.
+"""
+
+from typing import Optional
+
+from . import generic
+import traewelling_pydantic.models as trwlm
+from . import model
+
+
+def post_auth_logout(token: str) -> bool:
+    """
+    Logout & invalidate current bearer token
+    """
+
+    generic.post(token=token, path="auth/logout")
+
+    return True
+
+
+def get_auth_user(token: str) -> trwlm.UserAuth:
+    """
+    Get authenticated user information
+    """
+
+    response, status_code = generic.get(token=token, path="auth/user")
+
+    return trwlm.UserAuth.model_validate(response["data"])
+
+
+def post_auth_refresh(token: str) -> model.response.BearerTokenResponse:
+    """
+    Refresh Bearer Token
+    """
+
+    response, status_code = generic.post(token=token, path="auth/refresh")
+
+    return model.response.BearerTokenResponse.model_validate(response["data"])
+
+
+def get_user_statuses_active(token: str) -> Optional[trwlm.Status]:
+    """
+    User state
+    """
+
+    response, status_code = generic.get(token=token, path="user/statuses/active")
+
+    if status_code == 204:
+        return None
+
+    return trwlm.Status.model_validate(response["data"])

traewelling_api-0.1.0/src/traewelling_api/api/checkin.py

@@ -0,0 +1,226 @@
+"""
+Checkin related endpoints. Regular process is departures -> trip -> checkin
+"""
+
+from datetime import datetime
+from typing import Optional, Union
+import uuid
+from pydantic_extra_types.coordinate import Latitude, Longitude
+
+from . import generic
+import traewelling_pydantic.api_models as trwla
+import traewelling_pydantic.models as trwlm
+from . import model
+from requests.exceptions import HTTPError
+from urllib.parse import quote
+
+
+def get_operators(token: str) -> list[trwlm.Operator]:
+    response, status_code = generic.get(token=token, path="operators")
+
+    return [
+        trwlm.Operator.model_validate(operator) for operator in response["data"]
+    ]
+
+
+def get_stations(
+    token: str,
+    identifier_provider: Optional[str] = None,
+    query: Optional[str] = None,
+    identifier: Optional[str] = None,
+    min_lat: Optional[Latitude] = None,
+    max_lat: Optional[Latitude] = None,
+    min_lon: Optional[Longitude] = None,
+    max_lon: Optional[Longitude] = None,
+    limit: int = 50,
+    with_identifiers: bool = False,
+) -> Optional[list[trwlm.Station]]:
+    """
+    UNSTABLE: Returns stations by fuzzy text, exact identifier, or within a bounding box (BBOX).
+    """
+
+    def valid_bounding_box(
+        min_lat: Optional[Latitude] = None,
+        max_lat: Optional[Latitude] = None,
+        min_lon: Optional[Longitude] = None,
+        max_lon: Optional[Longitude] = None,
+    ) -> bool:
+        if min_lat is None:
+            return False
+        if max_lat is None:
+            return False
+        if min_lon is None:
+            return False
+        if max_lon is None:
+            return False
+
+        if min_lat > max_lat:
+            return False
+
+        if min_lon > max_lon:
+            return False
+
+        return True
+
+    if (
+        query is not None
+        and (identifier is not None and identifier_provider is not None)
+        and valid_bounding_box(min_lat, max_lat, min_lon, max_lon)
+    ):
+        raise ValueError(
+            "Only specify one: query, identifier+identifier_provider or bounding box"
+        )
+
+    if query is not None:
+        params = {
+            "query": quote(query),
+            "limit": limit,
+            "withIdentifiers": with_identifiers,
+        }
+    elif identifier is not None:
+        params = {
+            "identifier_provider": identifier_provider,
+            "identifier": identifier,
+            "limit": limit,
+            "withIdentifiers": with_identifiers,
+        }
+    elif valid_bounding_box(min_lat, max_lat, min_lon, max_lon):
+        params = {
+            "min_lat": min_lat,
+            "max_lat": max_lat,
+            "min_lon": min_lon,
+            "max_lon": max_lon,
+            "limit": limit,
+            "withIdentifiers": with_identifiers,
+        }
+    else:
+        raise ValueError(
+            "Specify one: query, identifier+identifier_provider or bounding box"
+        )
+
+    try:
+        response, status_code = generic.get(token=token, path="stations", params=params)
+
+        return [trwlm.Station.model_validate(i) for i in response["data"]]
+    except HTTPError as error:
+        if error.response.status_code == 404:
+            return None
+        raise error
+
+
+def get_stations_by_id(
+    token: str, station_id: Union[uuid.UUID, int], with_identifiers: bool = False
+) -> Optional[trwlm.Station]:
+    """
+    This request returns a single station object
+    """
+    try:
+        response, status_code = generic.get(
+            token=token,
+            path=f"station/{station_id}",
+            params={"withIdentifiers": with_identifiers},
+        )
+
+        return trwlm.Station.model_validate(response["data"])
+    except HTTPError as error:
+        if error.response.status_code == 404:
+            return None
+        raise error
+
+def get_station_departures(token: str, station_id: Union[uuid.UUID, int], when: datetime, travelType: str) -> Optional[tuple[list[model.response.Departure], model.response.DepartureMeta]]:
+    """
+    Get departures from a station.
+    """
+    try:
+        response, status_code = generic.get(
+            token=token,
+            path=f"station/{station_id}/departures",
+            params={"when": when, "travelType": travelType},
+        )
+
+        return [model.response.Departure.model_validate(i) for i in response["data"]], model.response.DepartureMeta.model_validate(response["meta"])
+    except HTTPError as error:
+        if error.response.status_code == 404:
+            return None
+        raise error
+    
+
+def get_trains_trip(token: str, hafasTripId: str, lineName: str) -> Optional[trwlm.Trip]:
+    """
+    Get the stopovers and trip information for a given train
+    """
+    try:
+        response, status_code = generic.get(
+                token=token,
+                path="trains/trip",
+                params={"hafasTripId": hafasTripId, "lineName": lineName},
+            )
+        return trwlm.Trip.model_validate(response["data"])
+    except HTTPError as error:
+        if error.response.status_code == 404:
+            return None
+        raise error
+
+def get_trains_station_nearby(token: str, latitude: Latitude, longitude: Longitude) -> Optional[list[trwlm.Station]]:
+    """
+    Location based search for stations
+    """
+    try:
+        response, status_code = generic.get(
+                token=token,
+                path="trains/trip",
+                params={"latidtude": latitude, "longitude": longitude},
+            )
+        return [trwlm.Station.model_validate(i) for i in response["data"]]
+    except HTTPError as error:
+        if error.response.status_code == 404:
+            return None
+        raise error
+
+def post_trains_checkin(token: str, checkin: model.request.CheckinRequest) -> trwla.CheckinResponse:
+    """
+    Check in to a trip.
+    """
+    response, status_code = generic.post(
+        token=token,
+        path="trains/checkin",
+        data=checkin.model_dump(mode="json")
+    )
+
+    return trwla.CheckinResponse.model_validate(response)
+
+def put_station_as_home(token: str, station_id: int) -> Optional[trwlm.Station]:
+    """
+    Set a station as home station
+    """
+    try:
+        response, status_code = generic.put(
+                token=token,
+                path=f"station/{station_id}/home",
+            )
+        return trwlm.Station.model_validate(response["data"])
+    except HTTPError as error:
+        if error.response.status_code == 404:
+            return None
+        raise error
+
+def get_trains_station_autocomplete(token: str, query: str) -> list[trwlm.Station]:
+    """
+    This request returns an array of max. 10 station objects matching the query.
+    """
+    response, status_code = generic.get(
+            token=token,
+            path=f"trains/station/autocomplete/{quote(query)}",
+        )
+    return [trwlm.Station.model_validate(i) for i in response["data"]]
+
+
+def get_trains_station_history(token: str) -> list[trwlm.Station]:
+    """
+    This request returns an array of max. 10 most recent station objects that the user has arrived at.
+    """
+    response, status_code = generic.get(
+            token=token,
+            path="trains/station/history",
+        )
+    return [trwlm.Station.model_validate(i) for i in response["data"]]

traewelling_api-0.1.0/src/traewelling_api/api/configuration_information.py

@@ -0,0 +1,16 @@
+"""
+Endpoints related to application configuration information.
+"""
+
+from . import generic
+import traewelling_pydantic.config as trwlc
+
+
+def get_app_configuration(token: str) -> trwlc.ConfigurationInformation:
+    """
+    Retrieves configuration information about the application, including features and supported languages.
+    """
+    
+    response, status_code = generic.get(token=token, path="app/configuration")
+
+    return trwlc.ConfigurationInformation.model_validate(response)

traewelling_api-0.1.0/src/traewelling_api/api/events.py

@@ -0,0 +1,81 @@
+"""
+Events that users can check in to
+"""
+
+from datetime import datetime
+from typing import Optional
+
+import traewelling_pydantic.models as trwlm
+from requests import HTTPError
+
+from . import generic, model
+
+
+def get_event(token: str, slug: str) -> trwlm.Event:
+    """
+    [Auth optional] Get basic information for event
+    """
+    response, status_code = generic.get(token=token, path=f"event/{slug}")
+
+    return trwlm.Event.model_validate(response["data"])
+
+
+def get_events(
+    token: str, timestamp: datetime, only_upcoming: bool = False
+) -> list[trwlm.Event]:
+    """
+    Returns all active or upcoming events for the given timestamp. Default timestamp is now. If upcoming is set to true, all events ending after the timestamp are returned.
+    """
+    response, status_code = generic.get(
+        token=token,
+        path="events",
+        params={"timestamp": timestamp.isoformat(), "upcoming": only_upcoming},
+    )
+
+    return [trwlm.Event.model_validate(event) for event in response["data"]]
+
+
+def get_event_details(token: str, slug: str) -> model.response.EventDetailsResponse:
+    """
+    Returns overall travelled distance and duration for an event
+    """
+    response, status_code = generic.get(token=token, path=f"event/{slug}/details")
+
+    return model.response.EventDetailsResponse.model_validate(response["data"])
+
+
+def get_event_statuses(
+    token: str, slug: str, page: int
+) -> Optional[tuple[list[trwlm.Event], model.response.Links, model.response.Meta]]:
+    """
+    Returns all for user visible statuses for an event
+    """
+    try:
+        response, status_code = generic.get(
+            token=token,
+            path=f"event/{slug}/statuses",
+            params={"page": page},
+        )
+    except HTTPError as error:
+        if error.response.status_code == 404:
+            return None
+        raise error
+
+    return (
+        [trwlm.Event.model_validate(event) for event in response["data"]],
+        model.response.Links.model_validate(response["links"]),
+        model.response.Meta.model_validate(response["meta"]),
+    )
+
+
+def post_event(
+    token: str, event_suggestion: model.request.EventSuggestionRequest
+) -> bool:
+    """
+    Submit a possible event for our administrators to publish
+    """
+    response, status_code = generic.post(
+        token=token, path="event", data=event_suggestion.model_dump(mode="json")
+    )
+
+    return True

traewelling_api-0.1.0/src/traewelling_api/api/generic.py

@@ -0,0 +1,100 @@
+from typing import Optional
+import requests
+from urllib.parse import urljoin
+
+
+def request(
+    token: str,
+    path: str,
+    method: str = "GET",
+    params: Optional[dict] = None,
+    data: Optional[dict] = None,
+    headers: Optional[dict] = None,
+    base_url: str = "https://traewelling.de/api/v1/",
+) -> tuple[dict, int]:
+    response = requests.request(
+        method=method.upper(),
+        url=urljoin(base_url, path),
+        params=params,
+        headers={"Authorization": f"Bearer {token}"}
+        if headers is None
+        else {"Authorization": f"Bearer {token}", **headers},
+        data=data,
+    )
+
+    response.raise_for_status()
+
+    return response.json(), response.status_code
+
+
+def get(
+    token: str,
+    path: str,
+    params: Optional[dict] = None,
+    data: Optional[dict] = None,
+    headers: Optional[dict] = None,
+    base_url: str = "https://traewelling.de/api/v1/",
+) -> tuple[dict, int]:
+    return request(
+        method="GET",
+        token=token,
+        path=path,
+        params=params,
+        data=data,
+        headers=headers,
+        base_url=base_url,
+    )
+
+def put(
+    token: str,
+    path: str,
+    params: Optional[dict] = None,
+    data: Optional[dict] = None,
+    headers: Optional[dict] = None,
+    base_url: str = "https://traewelling.de/api/v1/",
+) -> tuple[dict, int]:
+    return request(
+        method="PUT",
+        token=token,
+        path=path,
+        params=params,
+        data=data,
+        headers=headers,
+        base_url=base_url,
+    )
+
+def post(
+    token: str,
+    path: str,
+    params: Optional[dict] = None,
+    data: Optional[dict] = None,
+    headers: Optional[dict] = None,
+    base_url: str = "https://traewelling.de/api/v1/",
+) -> tuple[dict, int]:
+    return request(
+        method="POST",
+        token=token,
+        path=path,
+        params=params,
+        data=data,
+        headers=headers,
+        base_url=base_url,
+    )
+
+def delete(
+    token: str,
+    path: str,
+    params: Optional[dict] = None,
+    data: Optional[dict] = None,
+    headers: Optional[dict] = None,
+    base_url: str = "https://traewelling.de/api/v1/",
+) -> tuple[dict, int]:
+    return request(
+        method="DELETE",
+        token=token,
+        path=path,
+        params=params,
+        data=data,
+        headers=headers,
+        base_url=base_url,
+    )

traewelling_api-0.1.0/src/traewelling_api/api/model/__init__.py

@@ -0,0 +1,2 @@
+from . import request
+from . import response

traewelling_api-0.1.0/src/traewelling_api/api/model/request.py

@@ -0,0 +1,107 @@
+import traewelling_pydantic as trwl
+from typing import Optional, Union
+import uuid
+import pydantic
+
+from datetime import datetime
+
+
+class TraewellingRequestModel(trwl.models.TraewellingModel):
+    pass
+
+
+class UpdateProfileInformationRequest(TraewellingRequestModel):
+    username: str
+    displayName: str
+    privateProfile: Optional[bool] = None
+    preventIndex: Optional[bool] = None
+    privacyHideDays: Optional[int] = None
+    defaultStatusVisibility: Optional[trwl.enums.Visibility] = None
+    mastodonVisibility: Optional[trwl.enums.MastodonVisibility] = None
+    mapProvider: Optional[trwl.enums.MapProvider] = None
+    friendCheckin: Optional[trwl.enums.FriendCheckinSetting] = None
+    pointsEnabled: Optional[bool] = None
+    bio: Optional[str] = None
+    experimental: bool
+    profileLinks: Optional[list[trwl.models.ProfileLink]] = None
+    timezone: str
+
+
+class CheckinRequest(TraewellingRequestModel):
+    body: str
+    business: trwl.enums.Business
+    visibility: trwl.enums.Visibility
+    eventId: int
+    toot: bool
+    chainPost: bool
+    ibnr: bool
+    tripId: str
+    lineName: str
+    start: int
+    destination: int
+    departure: datetime
+    arrival: datetime
+    force: bool
+    with_: list[Union[int, uuid.UUID]] = pydantic.Field(alias="with")
+
+
+class EventSuggestionRequest(TraewellingRequestModel):
+    name: str
+    host: str
+    begin: datetime
+    end: datetime
+    url: Optional[str] = None
+    hashtag: Optional[str] = None
+    nearestStationId: Optional[int] = None
+
+
+class ICSTokenRequest(TraewellingRequestModel):
+    name: str
+
+
+class ICSTokenDeleteRequest(TraewellingRequestModel):
+    tokenId: int
+
+
+class PolylineRequest(TraewellingRequestModel):
+    from_station_id: int
+    to_station_id: int
+    stopover_id: int
+
+
+class ReportRequest(TraewellingRequestModel):
+    subjectType: str
+    subjectId: int
+    reason: str
+    description: str
+
+
+class UpdateEmailRequest(TraewellingRequestModel):
+    email: str
+    password: str
+
+
+class AccountDeletionRequest(TraewellingRequestModel):
+    confirmation: str
+
+
+class UpdateStatusRequest(TraewellingRequestModel):
+    body: Optional[str] = None
+    business: Optional[trwl.enums.Business] = None
+    visibility: Optional[trwl.enums.Visibility] = None
+    eventId: Optional[str] = None
+    manualDeparture: Optional[datetime] = None
+    manualArrival: Optional[datetime] = None
+    destinationId: Optional[str] = None
+    destinationArrivalPlanned: Optional[datetime] = None
+
+
+class UpdateStatusTagRequest(TraewellingRequestModel):
+    key: str
+    value: str
+    visibility: trwl.enums.Visibility
+
+
+class UpdateUserTrustedRequest(TraewellingRequestModel):
+    userId: str
+    expiresAt: datetime

traewelling_api-0.1.0/src/traewelling_api/api/model/response.py

@@ -0,0 +1,71 @@
+from datetime import datetime
+from typing import Union, Optional
+import uuid
+import pydantic
+import traewelling_pydantic as trwl
+import fptf_pydantic.models as fptf
+
+
+class TraewellingResponseModel(trwl.models.TraewellingModel):
+    pass
+
+
+class Meta(TraewellingResponseModel):
+    current_page: int
+    from_: int = pydantic.Field(alias="from")
+    path: str
+    per_page: int
+    to: int
+
+
+class Links(TraewellingResponseModel):
+    first: str
+    last: Optional[str] = None
+    prev: Optional[str] = None
+    next_: Optional[str] = pydantic.Field(default=None, alias="next")
+
+
+class BearerTokenResponse(TraewellingResponseModel):
+    token: str
+    expires_at: datetime
+
+
+class LikeResponse(TraewellingResponseModel):
+    count: int
+
+
+class CheckinResponse(TraewellingResponseModel):
+    status: trwl.models.Status
+    points: trwl.models.Points
+    alsoOnThisConnection: list[trwl.models.Status]
+
+
+class EventDetailsResponse(TraewellingResponseModel):
+    id: int
+    slug: str
+    totalDistance: int
+    totalDuration: int
+
+class Departure(trwl.models.TraewellingModel):
+    tripId: str
+    stop: fptf.Stop
+    when: datetime
+    plannedWhen: datetime
+    platform: str
+    plannedPlatform: str
+    direction: str
+    line: fptf.Line
+    station: trwl.models.Station
+
+
+class DepartureMetaTimes(TraewellingResponseModel):
+    now: datetime
+    prev: datetime
+    next_: datetime = pydantic.Field(alias="next")
+
+
+class DepartureMeta(TraewellingResponseModel):
+    station: trwl.models.Station
+    times: DepartureMetaTimes
+    removedLicenses: list[Union[str, trwl.models.LicenseDTO]]
+    removedCount: int

traewelling_api-0.1.0/src/traewelling_api/cli.py

@@ -0,0 +1,120 @@
+import json
+from typing import Annotated, Optional
+
+from pydantic_extra_types.coordinate import Latitude, Longitude
+
+from . import client
+import traewelling_pydantic.models as traewelling
+import typer
+from rich.console import Console
+from requests.exceptions import HTTPError
+from requests import status_codes
+
+app = typer.Typer()
+console = Console()
+
+
+@app.command("station", no_args_is_help=True)
+def get_station(
+    token: Annotated[str, typer.Option("--token", "-t", envvar="TRAEWELLING_TOKEN")],
+    station_id: Annotated[Optional[int], typer.Option("--station-id", "-i")] = None,
+    name: Annotated[Optional[str], typer.Option("--name", "-n")] = None,
+    identifier: Annotated[Optional[str], typer.Option("--identifier")] = None,
+    identifier_provider: Annotated[
+        Optional[str], typer.Option("--identifier-provider")
+    ] = None,
+    bounding_box: Annotated[
+        Optional[tuple[float, float, float, float]], typer.Option("--bounding-box")
+    ] = None,
+    with_identifiers: Annotated[bool, typer.Option("--with-identifiers")] = False,
+    as_json: Annotated[bool, typer.Option("--json", "-j", envvar="AS_JSON")] = False,
+):
+    trwl = client.TraewellingClient(token)
+
+    try: 
+        response = trwl.get_stations(
+            query=name,
+            identifier=identifier,
+            identifier_provider=identifier_provider,
+            min_lat=Latitude(bounding_box[0]) if bounding_box is not None else None,
+            max_lat=Latitude(bounding_box[1]) if bounding_box is not None else None,
+            min_lon=Longitude(bounding_box[2]) if bounding_box is not None else None,
+            max_lon=Longitude(bounding_box[3]) if bounding_box is not None else None,
+            with_identifiers=with_identifiers
+        )
+
+    except ValueError:
+        if station_id is None:
+            raise ValueError("No valid identifiers or bounding box specified")
+
+        response = trwl.get_station_by_id(station_id, with_identifiers)
+        
+
+    if as_json:
+        if response is not None:
+            if isinstance(response, list):
+                response = json.dumps([i.model_dump(mode="json") for i in response])
+            else:
+                response = response.model_dump_json()
+
+            console.print_json(response)
+        else:
+            console.print_json(None)
+    else:
+        console.print(response)
+
+
+@app.command("stations")
+def get_stations(
+    token: Annotated[str, typer.Option("--token", "-t", envvar="TRAEWELLING_TOKEN")],
+    ids: list[int],
+    with_identifiers: Annotated[bool, typer.Option("--with-identifiers")] = False,
+    as_json: Annotated[bool, typer.Option("--json", "-j", envvar="AS_JSON")] = False,
+):
+    trwl = client.TraewellingClient(token)
+    responses: list[Optional[traewelling.Station]] = []
+
+    for id in ids:
+        try:
+            responses.append(trwl.get_station_by_id(id, with_identifiers))
+        except HTTPError as error:
+            if not as_json:
+                if (
+                    error.response.status_code == status_codes.codes.forbidden
+                    or error.response.status_code == status_codes.codes.unauthorized
+                ):
+                    console.print(
+                        f"Don't have permission to query the station for ID {id}"
+                    )
+                elif error.response.status_code == status_codes.codes.too_many_requests:
+                    console.print("Too many requests")
+
+    if as_json:
+        console.print_json(
+            json.dumps(
+                [
+                    response.model_dump() if response is not None else None
+                    for response in responses
+                ]
+            )
+        )
+    else:
+        console.print(responses)
+
+
+@app.command("operators")
+def get_operators(
+    token: Annotated[str, typer.Option("--token", "-t", envvar="TRAEWELLING_TOKEN")],
+    as_json: Annotated[bool, typer.Option("--json", "-j", envvar="AS_JSON")] = False,
+):
+    trwl = client.TraewellingClient(token)
+    response = trwl.get_operators()
+
+    if as_json:
+        console.print_json(json.dumps([r.model_dump() for r in response]))
+    else:
+        console.print(response)
+
+
+if __name__ == "__main__":
+    app()

traewelling_api-0.1.0/src/traewelling_api/client.py

@@ -0,0 +1,125 @@
+import uuid
+from datetime import datetime
+from typing import Optional, Union
+
+import traewelling_pydantic.models as traewelling
+from requests.exceptions import HTTPError
+from requests.status_codes import codes as httpCode
+from pydantic_extra_types.coordinate import Latitude, Longitude
+
+from . import api
+
+
+class TraewellingClient:
+    """
+    Traewelling Client object to manage the token
+
+    Behavior Note: 404s will return None
+    """
+
+    def __init__(self, token: str):
+        self.token = token
+
+    def get_stations(
+        self,
+        identifier_provider: Optional[str] = None,
+        query: Optional[str] = None,
+        identifier: Optional[str] = None,
+        min_lat: Optional[Latitude] = None,
+        max_lat: Optional[Latitude] = None,
+        min_lon: Optional[Longitude] = None,
+        max_lon: Optional[Longitude] = None,
+        limit: int = 50,
+        with_identifiers: bool = False,
+    ) -> Optional[list[traewelling.Station]]:
+        try:
+            return api.checkin.get_stations(
+                self.token,
+                identifier=identifier,
+                identifier_provider=identifier_provider,
+                min_lat=min_lat,
+                max_lat=max_lat,
+                min_lon=min_lon,
+                max_lon=max_lon,
+                limit=limit,
+                with_identifiers=with_identifiers,
+                query=query
+            )
+        except HTTPError as error:
+            if error.response.status_code == httpCode.not_found:
+                return None
+            raise error
+
+    def get_station_by_id(
+        self,
+        station_id: Union[int, uuid.UUID],
+        with_identifiers: bool = False,
+    ) -> Optional[traewelling.Station]:
+        """
+        This request returns a single station object
+
+        :param station_id: Either the traewelling integer ID or UUID
+        :type station_id: int, uuid.UUID
+
+        :param with_identifiers: If further identifiers should be requested from Traewelling
+        :type with_identifiers: bool
+
+        :raises HTTPError: Might raise a 401, 403, or 5xx error
+
+        :return: Either returns a Station object or in case of a 404 returns None
+        :rtype: Station(optional)
+        """
+        try:
+            return api.checkin.get_stations_by_id(
+                self.token, station_id=station_id, with_identifiers=with_identifiers
+            )
+        except HTTPError as error:
+            if error.response.status_code == httpCode.not_found:
+                return None
+            raise error
+
+    def get_operators(self) -> list[traewelling.Operator]:
+        """
+        Get a list of 'all' operators.
+
+        :raises HTTPError: Might raise a 401, 403, or 5xx error
+
+        :return: Returns a list of Operator objects
+        :rtype: list[Operator]
+        """
+
+        return api.checkin.get_operators(self.token)
+
+    def get_event(self, slug: str) -> Optional[traewelling.Event]:
+        """
+        Get basic information for event
+
+        :param slug: A slug for an event
+        :type slug: str
+
+        :raises HTTPError: Might raise a 401, 403, or 5xx error
+
+        :return: Either returns an Event object or in case of a 404 returns None
+        :rtype: Event(optional)
+        """
+        try:
+            return api.events.get_event(self.token, slug=slug)
+        except HTTPError as error:
+            if error.response.status_code == httpCode.not_found:
+                return None
+            raise error
+
+    def get_events(
+        self, timestamp: datetime, only_upcoming: bool = False
+    ) -> list[traewelling.Event]:
+        """
+        Returns all active or upcoming events for the given timestamp. Default timestamp is now. If upcoming is set to true, all events ending after the timestamp are returned.
+
+        :raises HTTPError: Might raise a 401, 403, or 5xx error
+
+        :return: Returns a list of Event objects
+        :rtype: list[Event]
+        """
+        return api.events.get_events(
+            self.token, timestamp=timestamp, only_upcoming=only_upcoming
+        )

traewelling_api-0.1.0/src/traewelling_api.egg-info/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: traewelling-api
+Version: 0.1.0
+Summary: Add your description here
+License-Expression: MIT
+Project-URL: Homepage, https://codeberg.org/lambda-crime/traewelling-api
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fptf-pydantic>=0.1.0
+Requires-Dist: pydantic-extra-types>=2.11.0
+Requires-Dist: rich>=14.2.0
+Requires-Dist: textual>=7.2.0
+Requires-Dist: traewelling-pydantic>=0.2.1
+Requires-Dist: typer>=0.21.1
+Dynamic: license-file
+
+# Traewelling-API
+
+This is a simple Traewelling API wrapper.
+
+The goal is to provide an easy way to talk with the Traewelling API from Python
+
+## TODOs
+
+- add every API endpoint for Traewelling
+- add FPTF converterter for Traewelling API responses
+- add command for every API endpoint to CLI
+- [OPTIONAL] add TUI for interactive API requests

traewelling_api-0.1.0/src/traewelling_api.egg-info/SOURCES.txt

@@ -0,0 +1,38 @@
+LICENSE
+README.md
+pyproject.toml
+src/traewelling_api/__init__.py
+src/traewelling_api/cli.py
+src/traewelling_api/client.py
+src/traewelling_api.egg-info/PKG-INFO
+src/traewelling_api.egg-info/SOURCES.txt
+src/traewelling_api.egg-info/dependency_links.txt
+src/traewelling_api.egg-info/entry_points.txt
+src/traewelling_api.egg-info/requires.txt
+src/traewelling_api.egg-info/top_level.txt
+src/traewelling_api/api/__init__.py
+src/traewelling_api/api/auth.py
+src/traewelling_api/api/checkin.py
+src/traewelling_api/api/community.py
+src/traewelling_api/api/configuration_information.py
+src/traewelling_api/api/dashboard.py
+src/traewelling_api/api/events.py
+src/traewelling_api/api/generic.py
+src/traewelling_api/api/ics_tokens.py
+src/traewelling_api/api/leaderboard.py
+src/traewelling_api/api/likes.py
+src/traewelling_api/api/notifications.py
+src/traewelling_api/api/polyline.py
+src/traewelling_api/api/report.py
+src/traewelling_api/api/security.py
+src/traewelling_api/api/settings.py
+src/traewelling_api/api/statistics.py
+src/traewelling_api/api/status.py
+src/traewelling_api/api/trips.py
+src/traewelling_api/api/user.py
+src/traewelling_api/api/user_follow.py
+src/traewelling_api/api/user_hide_and_block.py
+src/traewelling_api/api/webhooks.py
+src/traewelling_api/api/model/__init__.py
+src/traewelling_api/api/model/request.py
+src/traewelling_api/api/model/response.py

traewelling_api-0.1.0/src/traewelling_api.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

traewelling_api-0.1.0/src/traewelling_api.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+traewelling-cli = traewelling_api:app

traewelling_api-0.1.0/src/traewelling_api.egg-info/requires.txt

@@ -0,0 +1,6 @@
+fptf-pydantic>=0.1.0
+pydantic-extra-types>=2.11.0
+rich>=14.2.0
+textual>=7.2.0
+traewelling-pydantic>=0.2.1
+typer>=0.21.1

traewelling_api-0.1.0/src/traewelling_api.egg-info/top_level.txt

@@ -0,0 +1 @@
+traewelling_api