internal.geolocation.distance

Distance calculation modules.

 1"""Distance calculation modules."""
 2
 3from geopy.distance import geodesic  # type: ignore[import-untyped]
 4from pydantic import BaseModel
 5
 6from .types import LocationModel
 7
 8
 9class DistanceBoxModel(BaseModel):
10    """Safe distance box for database query."""
11
12    lat_max: float
13    lat_min: float
14    lon_max: float
15    lon_min: float
16
17
18def dist_safe_box(loc: LocationModel, dist: int) -> DistanceBoxModel:
19    """Calculate safe box for database query.
20
21    Args:
22      loc: start point coordinates
23      dist: distance from the point
24
25    Returns:
26        safe box borders
27    """
28    loc_dist = geodesic(dist)
29    loc_point = tuple(loc.model_dump().values())
30    return DistanceBoxModel(
31        lat_max=loc_dist.destination(loc_point, 0).latitude,
32        lat_min=loc_dist.destination(loc_point, 180).latitude,
33        lon_max=loc_dist.destination(loc_point, 90).longitude,
34        lon_min=loc_dist.destination(loc_point, 270).longitude,
35    )
36
37
38def get_distance(from_loc: LocationModel, to_loc: LocationModel) -> float:
39    """Geographical distance between two points.
40
41    Args:
42      from_loc: from point
43      to_loc: to point
44
45    Returns:
46      distance between points in kilometers
47
48    Raises:
49      ValueError: if failed to get distance
50    """
51    dist = geodesic(
52        tuple(from_loc.model_dump().values()), tuple(to_loc.model_dump().values())
53    )
54    if type(dist) is not geodesic:
55        raise ValueError("failed to calculate distance")
56    return float(dist.km)
class DistanceBoxModel(pydantic.main.BaseModel): 
10class DistanceBoxModel(BaseModel):
11    """Safe distance box for database query."""
12
13    lat_max: float
14    lat_min: float
15    lon_max: float
16    lon_min: float

Safe distance box for database query.

lat_max: float = PydanticUndefined
lat_min: float = PydanticUndefined
lon_max: float = PydanticUndefined
lon_min: float = PydanticUndefined
def dist_safe_box( loc: internal.geolocation.types.LocationModel, dist: int) -> DistanceBoxModel: 
19def dist_safe_box(loc: LocationModel, dist: int) -> DistanceBoxModel:
20    """Calculate safe box for database query.
21
22    Args:
23      loc: start point coordinates
24      dist: distance from the point
25
26    Returns:
27        safe box borders
28    """
29    loc_dist = geodesic(dist)
30    loc_point = tuple(loc.model_dump().values())
31    return DistanceBoxModel(
32        lat_max=loc_dist.destination(loc_point, 0).latitude,
33        lat_min=loc_dist.destination(loc_point, 180).latitude,
34        lon_max=loc_dist.destination(loc_point, 90).longitude,
35        lon_min=loc_dist.destination(loc_point, 270).longitude,
36    )

Calculate safe box for database query.

Arguments:
  • loc: start point coordinates
  • dist: distance from the point
Returns:

safe box borders

def get_distance( from_loc: internal.geolocation.types.LocationModel, to_loc: internal.geolocation.types.LocationModel) -> float: 
39def get_distance(from_loc: LocationModel, to_loc: LocationModel) -> float:
40    """Geographical distance between two points.
41
42    Args:
43      from_loc: from point
44      to_loc: to point
45
46    Returns:
47      distance between points in kilometers
48
49    Raises:
50      ValueError: if failed to get distance
51    """
52    dist = geodesic(
53        tuple(from_loc.model_dump().values()), tuple(to_loc.model_dump().values())
54    )
55    if type(dist) is not geodesic:
56        raise ValueError("failed to calculate distance")
57    return float(dist.km)

Geographical distance between two points.

Arguments:
  • from_loc: from point
  • to_loc: to point
Returns:

distance between points in kilometers

Raises:
  • ValueError: if failed to get distance