enforce pep8

Author: dakk

README.md

@@ -26,7 +26,7 @@ performs a wind forecast analysis for the specified time and location (usually s
 and returns a tuple with true wind direction (`twd`) expressed in degrees and true wind speed (`tws`) expressed in meters per second or `None` if running out of temporal/geographic grib scope.
 
 ```python
-def getWindAt(t, lat, lon)
+def get_wind_at(t, lat, lon)
     # wind forecast analysys implementation
     # speed is in m/s, direction in degrees
     ...
@@ -93,11 +93,11 @@ routing_obj = Routing(
     LinearBestIsoRouter,            # specify a router type
     polar_obj,                      # the polar object for a specific sail boat
     track,                          # the list of track points (lat,lon)
-    getWindAt,                      # the function that returns (twd,tws) for a specified (datetime, lat, lon)
+    get_wind_at,                      # the function that returns (twd,tws) for a specified (datetime, lat, lon)
     start,                          # the start datetime
     start_position = (37.8, 4.8)    # the start location (lat lon, optional, the first track point if undefined)
-    pointValidity = point_validity  # the point validity function (optional)
-    lineValidity = line_validity    # the line validity function (optional)
+    point_validity = point_validity  # the point validity function (optional)
+    line_validity = line_validity    # the line validity function (optional)
 )
 ```
 
@@ -126,10 +126,10 @@ res.path         # the list of route waypoints
 ### Export path as geojson
 The path could be exported as a geojson object for cartographic representation
 ```python
-from weatherrouting.utils import pathAsGeojson
+from weatherrouting.utils import path_as_geojson
 import json
 
-json.dumps(pathAsGeojson(res.path))
+json.dumps(path_as_geojson(res.path))
 ```
 
 

docs/source/generated/weatherrouting.routers.router.rst

@@ -30,7 +30,7 @@ weatherrouting.routers.router
 
    .. autosummary::
 
-      RoutingNoWindException
+      RoutingNoWindError
 
 
 

docs/source/generated/weatherrouting.routing.rst

@@ -13,7 +13,7 @@ weatherrouting.routing
 
    .. autosummary::
 
-      listRoutingAlgorithms
+      list_routing_algorithms
 
 
 

docs/source/generated/weatherrouting.utils.rst

@@ -16,15 +16,15 @@ weatherrouting.utils
       cfbinomiale
       km2nm
       lossodromic
-      maxReachDistance
+      max_reach_distance
       nm2km
       ortodromic
       ortodromic2
-      pathAsGeojson
-      pointDistance
+      path_as_geojson
+      point_distance
       reduce180
       reduce360
-      routagePointDistance
+      routage_point_distance
 
 
 

scripts/replace_latlon_tests.py

@@ -36,25 +36,25 @@
 # measurement.bearing(start,end)
 
 
-def routagePointDistance(latA: float, lonA: float, distance: float, hdg: float):
-    """Returns the point from (latA, lonA) to the given (distance, hdg)"""
+def routage_point_distance(lat_a: float, lon_a: float, distance: float, hdg: float):
+    """Returns the point from (lat_a, lon_a) to the given (distance, hdg)"""
     d = distance
 
-    p = latlon.LatLon(latlon.Latitude(latA), latlon.Longitude(lonA))
+    p = latlon.LatLon(latlon.Latitude(lat_a), latlon.Longitude(lon_a))
     of = p.offset(math.degrees(hdg), d).to_string("D")
     return (float(of[0]), float(of[1]))
 
 
-def ortodromic(latA: float, lonA: float, latB: float, lonB: float):
-    p1 = latlon.LatLon(latlon.Latitude(latA), latlon.Longitude(lonA))
-    p2 = latlon.LatLon(latlon.Latitude(latB), latlon.Longitude(lonB))
+def ortodromic(lat_a: float, lon_a: float, lat_b: float, lon_b: float):
+    p1 = latlon.LatLon(latlon.Latitude(lat_a), latlon.Longitude(lon_a))
+    p2 = latlon.LatLon(latlon.Latitude(lat_b), latlon.Longitude(lon_b))
 
     return (p1.distance(p2), math.radians(p1.heading_initial(p2)))
 
 
-def lossodromic(latA: float, lonA: float, latB: float, lonB: float):
-    p1 = latlon.LatLon(latlon.Latitude(latA), latlon.Longitude(lonA))
-    p2 = latlon.LatLon(latlon.Latitude(latB), latlon.Longitude(lonB))
+def lossodromic(lat_a: float, lon_a: float, lat_b: float, lon_b: float):
+    p1 = latlon.LatLon(latlon.Latitude(lat_a), latlon.Longitude(lon_a))
+    p2 = latlon.LatLon(latlon.Latitude(lat_b), latlon.Longitude(lon_b))
 
     return (p1.distance(p2, ellipse="sphere"), math.radians(p1.heading_initial(p2)))
 
@@ -81,5 +81,5 @@ def lossodromic(latA: float, lonA: float, latB: float, lonB: float):
 g = geod.Direct(-32.06, 115.74, 225, 20000e3)
 print(g)
 
-g = routagePointDistance(-32.06, 115.74, 20000, math.radians(225))
+g = routage_point_distance(-32.06, 115.74, 20000, math.radians(225))
 print(g)

setup.py

@@ -16,7 +16,7 @@
 
 setup(
     name="weatherrouting",
-    version="0.1.13",
+    version="0.2",
     description="Weather routing library for sailing",
     author="Davide Gessa",
     setup_requires="setuptools",

tests/linearbestisorouter_test.py

@@ -24,7 +24,7 @@
 from weatherrouting.routers.linearbestisorouter import LinearBestIsoRouter
 
 from .mock_grib import MockGrib
-from .mock_point_validity import MockPointValidity
+from .mock_point_validity import MockpointValidity
 
 polar_bavaria38 = weatherrouting.Polar(
     os.path.join(os.path.dirname(__file__), "data/bavaria38.pol")
@@ -38,7 +38,7 @@ def heading(y, x):
     return (90 - a + 360) % 360
 
 
-# class TestRouting_straigth_upwind(unittest.TestCase):
+# class TestRoutingStraigthUpwind(unittest.TestCase):
 #     def test_step(self):
 #         base_step = [
 #             [1, 0],
@@ -57,14 +57,14 @@ def heading(y, x):
 #             base_end = [base_start[0] + s[0], base_start[1] + s[1]]
 #             head = heading(*s)
 #             print("TEST UPWIND TWD", head, "step", s)
-#             pvmodel = MockPointValidity([base_start, base_end])
+#             pvmodel = MockpointValidity([base_start, base_end])
 #             routing_obj = weatherrouting.Routing(
 #                 LinearBestIsoRouter,
 #                 polar_bavaria38,
 #                 [base_start, base_end],
 #                 MockGrib(10, head, 0),
 #                 datetime.datetime.fromisoformat("2021-04-02T12:00:00"),
-#                 lineValidity=pvmodel.line_validity,
+#                 line_validity=pvmodel.line_validity,
 #             )
 #             res = None
 #             i = 0
@@ -75,28 +75,28 @@ def heading(y, x):
 
 #             path_to_end = res.path
 #             if not base_gjs:
-#                 base_gjs = weatherrouting.utils.pathAsGeojson(path_to_end)
+#                 base_gjs = weatherrouting.utils.path_as_geojson(path_to_end)
 #             else:
-#                 base_gjs["features"] += weatherrouting.utils.pathAsGeojson(path_to_end)[
+#                 base_gjs["features"] += weatherrouting.utils.path_as_geojson(path_to_end)[
 #                     "features"
 #                 ]
 #             gjs = json.dumps(base_gjs)
 
 #         print(gjs)
 
 
-class TestRouting_lowWind_noIsland(unittest.TestCase):
+class TestRoutingLowWindNoIsland(unittest.TestCase):
     def setUp(self):
         grib = MockGrib(2, 180, 0.1)
         self.track = [(5, 38), (5.2, 38.2)]
-        island_route = MockPointValidity(self.track)
+        island_route = MockpointValidity(self.track)
         self.routing_obj = weatherrouting.Routing(
             LinearBestIsoRouter,
             polar_bavaria38,
             self.track,
             grib,
             datetime.datetime.fromisoformat("2021-04-02T12:00:00"),
-            pointValidity=island_route.point_validity,
+            point_validity=island_route.point_validity,
         )
 
     def test_step(self):
@@ -115,26 +115,26 @@ def test_step(self):
             res.time, datetime.datetime.fromisoformat("2021-04-02 18:00:00")
         )
 
-        gj = weatherrouting.utils.pathAsGeojson(path_to_end)
+        gj = weatherrouting.utils.path_as_geojson(path_to_end)
 
         self.assertEqual(len(gj["features"]), 8)
         self.assertEqual(
             gj["features"][-1]["properties"]["end-timestamp"], "2021-04-02 18:00:00"
         )
 
 
-class TestRouting_lowWind_mockIsland_5(unittest.TestCase):
+class TestRoutingLowWindMockIsland5(unittest.TestCase):
     def setUp(self):
         grib = MockGrib(2, 180, 0.1)
         self.track = [(5, 38), (5.2, 38.2)]
-        island_route = MockPointValidity(self.track, factor=5)
+        island_route = MockpointValidity(self.track, factor=5)
         self.routing_obj = weatherrouting.Routing(
             LinearBestIsoRouter,
             polar_bavaria38,
             self.track,
             grib,
             datetime.datetime.fromisoformat("2021-04-02T12:00:00"),
-            pointValidity=island_route.point_validity,
+            point_validity=island_route.point_validity,
         )
 
     def test_step(self):
@@ -149,18 +149,18 @@ def test_step(self):
         self.assertEqual(not res.path, False)
 
 
-class checkRoute_mediumWind_mockIsland_8(unittest.TestCase):
+class CheckRouteMediumWindMockIsland8(unittest.TestCase):
     def setUp(self):
         grib = MockGrib(5, 45, 0.5)
         self.track = [(5, 38), (4.6, 37.6)]
-        island_route = MockPointValidity(self.track, factor=8)
+        island_route = MockpointValidity(self.track, factor=8)
         self.routing_obj = weatherrouting.Routing(
             LinearBestIsoRouter,
             polar_bavaria38,
             self.track,
             grib,
             datetime.datetime.fromisoformat("2021-04-02T12:00:00"),
-            lineValidity=island_route.line_validity,
+            line_validity=island_route.line_validity,
         )
 
     def test_step(self):
@@ -175,18 +175,18 @@ def test_step(self):
         self.assertEqual(not res.path, False)
 
 
-class checkRoute_highWind_mockIsland_3(unittest.TestCase):
+class CheckRouteHighWindMockIsland3(unittest.TestCase):
     def setUp(self):
         grib = MockGrib(10, 270, 0.5)
         self.track = [(5, 38), (5.5, 38.5)]
-        island_route = MockPointValidity(self.track, factor=3)
+        island_route = MockpointValidity(self.track, factor=3)
         self.routing_obj = weatherrouting.Routing(
             LinearBestIsoRouter,
             polar_bavaria38,
             self.track,
             grib,
             datetime.datetime.fromisoformat("2021-04-02T12:00:00"),
-            lineValidity=island_route.line_validity,
+            line_validity=island_route.line_validity,
         )
 
     def test_step(self):
@@ -201,7 +201,7 @@ def test_step(self):
         self.assertEqual(not res.path, False)
 
 
-class checkRoute_out_of_scope(unittest.TestCase):
+class CheckRouteOutOfScope(unittest.TestCase):
     def setUp(self):
         grib = MockGrib(
             10,
@@ -210,14 +210,14 @@ def setUp(self):
             out_of_scope=datetime.datetime.fromisoformat("2021-04-02T15:00:00"),
         )
         self.track = [(5, 38), (5.5, 38.5)]
-        island_route = MockPointValidity(self.track, factor=3)
+        island_route = MockpointValidity(self.track, factor=3)
         self.routing_obj = weatherrouting.Routing(
             LinearBestIsoRouter,
             polar_bavaria38,
             self.track,
             grib,
             datetime.datetime.fromisoformat("2021-04-02T12:00:00"),
-            lineValidity=island_route.line_validity,
+            line_validity=island_route.line_validity,
         )
 
     def test_step(self):
@@ -232,11 +232,11 @@ def test_step(self):
         self.assertEqual(not res.path, False)
 
 
-class checkRoute_multipoint(unittest.TestCase):
+class CheckRouteMultipoint(unittest.TestCase):
     def setUp(self):
         grib = MockGrib(10, 270, 0.5)
         self.track = [(5, 38), (5.3, 38.3), (5.6, 38.6)]
-        # island_route = MockPointValidity(self.track, factor=3)
+        # island_route = MockpointValidity(self.track, factor=3)
         self.routing_obj = weatherrouting.Routing(
             LinearBestIsoRouter,
             polar_bavaria38,
@@ -257,18 +257,18 @@ def test_step(self):
         self.assertEqual(not res.path, False)
 
 
-class TestRouting_custom_step(unittest.TestCase):
+class TestRoutingCustomStep(unittest.TestCase):
     def setUp(self):
         grib = MockGrib(2, 180, 0.1)
         self.track = [(5, 38), (5.2, 38.2)]
-        island_route = MockPointValidity(self.track, factor=5)
+        island_route = MockpointValidity(self.track, factor=5)
         self.routing_obj = weatherrouting.Routing(
             LinearBestIsoRouter,
             polar_bavaria38,
             self.track,
             grib,
             datetime.datetime.fromisoformat("2021-04-02T12:00:00"),
-            pointValidity=island_route.point_validity,
+            point_validity=island_route.point_validity,
         )
 
     def test_step(self):

tests/mock_grib.py

@@ -47,7 +47,7 @@ def twd_var(self, t=None):
             random.random() * self.fuzziness - self.fuzziness / 2
         )
 
-    def getWindAt(self, t, lat, lon) -> Optional[Tuple[float, float]]:
+    def get_wind_at(self, t, lat, lon) -> Optional[Tuple[float, float]]:
         """
         Returns a tuple containing direction in degree and speed in m/s
         """

tests/mock_point_validity.py

@@ -15,19 +15,19 @@
 import weatherrouting
 
 
-class MockPointValidity:
+class MockpointValidity:
     def __init__(self, track, factor=4):
         self.mean_point = (
             (track[0][1] + track[1][1]) / 2,
             (track[0][0] + track[1][0]) / 2,
         )
         self.mean_island = (
-            weatherrouting.utils.pointDistance(*(track[0] + track[1])) / factor
+            weatherrouting.utils.point_distance(*(track[0] + track[1])) / factor
         )
 
     def point_validity(self, y, x):
         if (
-            weatherrouting.utils.pointDistance(x, y, *(self.mean_point))
+            weatherrouting.utils.point_distance(x, y, *(self.mean_point))
             < self.mean_island
         ):
             return False
@@ -36,7 +36,7 @@ def point_validity(self, y, x):
 
     def line_validity(self, y1, x1, y2, x2):
         if (
-            weatherrouting.utils.pointDistance(x1, y2, *(self.mean_point))
+            weatherrouting.utils.point_distance(x1, y2, *(self.mean_point))
             < self.mean_island
         ):
             return False