pyBADA 0.1.3__py3-none-any.whl → 0.1.4__py3-none-any.whl

pyBADA/geodesic.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 """
 Geodesic calculation module
 """
@@ -15,15 +14,14 @@ from math import (
     pi,
     log,
     log2,
-    acos,
 )
 from pyBADA.aircraft import Airplane as airplane
-from pyBADA import conversions as conv
 from pyBADA import constants as const
 
 
 class Haversine:
-    """This class implements the geodesic calculations on sherical earth (ignoring ellipsoidal effects).
+    """This class implements the geodesic calculations on sherical earth
+    (ignoring ellipsoidal effects).
 
     .. note::
             https://www.movable-type.co.uk/scripts/latlong.html
@@ -34,10 +32,12 @@ class Haversine:
 
     @staticmethod
     def distance(LAT_init, LON_init, LAT_final, LON_final):
-        """Calculate the great-circle distance between two points on the Earth's surface using the haversine formula.
+        """Calculate the great-circle distance between two points on the
+        Earth's surface using the haversine formula.
 
-        The great-circle distance is the shortest distance between two points over the Earth's surface,
-        ignoring elevation changes (i.e., hills or mountains).
+        The great-circle distance is the shortest distance between two points
+        over the Earth's surface, ignoring elevation changes (i.e., hills or
+        mountains).
 
         :param LAT_init: Initial latitude in degrees.
         :param LON_init: Initial longitude in degrees.
@@ -68,12 +68,15 @@ class Haversine:
 
     @staticmethod
     def destinationPoint(LAT_init, LON_init, distance, bearing):
-        """Calculate the destination point given an initial point, distance, and bearing.
+        """Calculate the destination point given an initial point, distance,
+        and bearing.
 
-        Given an initial latitude and longitude, this function calculates the destination point
-        after traveling the specified distance along the given initial bearing (direction).
+        Given an initial latitude and longitude, this function calculates the
+        destination point after traveling the specified distance along the
+        given initial bearing (direction).
 
-        Note that the bearing may vary along the path, but this calculation assumes a constant bearing.
+        Note that the bearing may vary along the path, but this calculation
+        assumes a constant bearing.
 
         :param LAT_init: Initial latitude in degrees.
         :param LON_init: Initial longitude in degrees.
@@ -83,7 +86,8 @@ class Haversine:
         :type LON_init: float
         :type distance: float
         :type bearing: float
-        :returns: Tuple containing the destination latitude and longitude in degrees.
+        :returns: Tuple containing the destination latitude and longitude in
+            degrees.
         :rtype: (float, float)
         """
 
@@ -108,10 +112,12 @@ class Haversine:
 
     @staticmethod
     def bearing(LAT_init, LON_init, LAT_final, LON_final):
-        """Calculate the initial bearing between two points along a great-circle path.
+        """Calculate the initial bearing between two points along a great-
+        circle path.
 
-        The initial bearing (forward azimuth) is the direction one would need to travel
-        in a straight line along the great-circle arc from the start point to the end point.
+        The initial bearing (forward azimuth) is the direction one would need
+        to travel in a straight line along the great-circle arc from the start
+        point to the end point.
 
         This bearing is measured clockwise from true north.
 
@@ -140,20 +146,21 @@ class Haversine:
         return bearing
 
 
-class Vincenty(object):
-    """This class implements the vincenty calculations of geodesics on the ellipsoid-model earth
+class Vincenty:
+    """This class implements the vincenty calculations of geodesics on the
+    ellipsoid-model earth.
 
     .. note::
             https://www.movable-type.co.uk/scripts/latlong-vincenty.html
-
     """
 
     @staticmethod
     def distance_bearing(LAT_init, LON_init, LAT_final, LON_final):
-        """Calculate the geodesic distance, initial bearing, and final bearing between two points on the Earth's surface.
+        """Calculate the geodesic distance, initial bearing, and final bearing
+        between two points on the Earth's surface.
 
-        This method uses the Vincenty formula to account for the Earth's ellipsoidal shape, providing accurate
-        calculations for long distances.
+        This method uses the Vincenty formula to account for the Earth's
+        ellipsoidal shape, providing accurate calculations for long distances.
 
         :param LAT_init: Initial latitude in degrees.
         :param LON_init: Initial longitude in degrees.
@@ -163,7 +170,8 @@ class Vincenty(object):
         :type LON_init: float
         :type LAT_final: float
         :type LON_final: float
-        :returns: Tuple containing distance in meters, initial bearing in degrees, and final bearing in degrees.
+        :returns: Tuple containing distance in meters, initial bearing in
+            degrees, and final bearing in degrees.
         :rtype: (float, float, float)
         """
 
@@ -277,10 +285,12 @@ class Vincenty(object):
 
     @staticmethod
     def distance(LAT_init, LON_init, LAT_final, LON_final):
-        """Calculate the geodesic distance between two latitude/longitude points on the Earth's surface.
+        """Calculate the geodesic distance between two latitude/longitude
+        points on the Earth's surface.
 
-        This method uses an accurate ellipsoidal model (Vincenty's formula) for calculating the distance,
-        which is particularly useful for long distances across the globe.
+        This method uses an accurate ellipsoidal model (Vincenty's formula)
+        for calculating the distance, which is particularly useful for long
+        distances across the globe.
 
         :param LAT_init: Initial latitude in degrees.
         :param LON_init: Initial longitude in degrees.
@@ -301,10 +311,12 @@ class Vincenty(object):
 
     @staticmethod
     def bearing_initial(LAT_init, LON_init, LAT_final, LON_final):
-        """Calculate the initial bearing (forward azimuth) from the initial point to the final point.
+        """Calculate the initial bearing (forward azimuth) from the initial
+        point to the final point.
 
-        This function returns the initial bearing that, if followed in a straight line along a great-circle path,
-        will take you from the start point to the end point.
+        This function returns the initial bearing that, if followed in a
+        straight line along a great-circle path, will take you from the start
+        point to the end point.
 
         :param LAT_init: Initial latitude in degrees.
         :param LON_init: Initial longitude in degrees.
@@ -325,10 +337,12 @@ class Vincenty(object):
 
     @staticmethod
     def bearing_final(LAT_init, LON_init, LAT_final, LON_final):
-        """Calculate the final bearing (reverse azimuth) from the final point to the initial point.
+        """Calculate the final bearing (reverse azimuth) from the final point
+        to the initial point.
 
-        This function calculates the final bearing at the destination point, which is the direction one
-        would need to take to return to the initial point along the great-circle path.
+        This function calculates the final bearing at the destination point,
+        which is the direction one would need to take to return to the initial
+        point along the great-circle path.
 
         :param LAT_init: Initial latitude in degrees.
         :param LON_init: Initial longitude in degrees.
@@ -349,7 +363,8 @@ class Vincenty(object):
 
     @staticmethod
     def destinationPoint_finalBearing(LAT_init, LON_init, distance, bearing):
-        """Calculate the destination point and final bearing given an initial point, distance, and bearing.
+        """Calculate the destination point and final bearing given an initial
+        point, distance, and bearing.
 
         This method calculates the latitude and longitude of the destination point after traveling a specified
         distance along the given bearing from the starting point. It also returns the final bearing at the
@@ -449,20 +464,24 @@ class Vincenty(object):
 
     @staticmethod
     def destinationPoint(LAT_init, LON_init, distance, bearing):
-        """Calculate the destination point after traveling a specified distance on a given bearing.
+        """Calculate the destination point after traveling a specified
+        distance on a given bearing.
 
-        This method returns the latitude and longitude of the destination point after traveling the given
-        distance on the specified initial bearing, following a great-circle path.
+        This method returns the latitude and longitude of the destination
+        point after traveling the given distance on the specified initial
+        bearing, following a great-circle path.
 
         :param LAT_init: Initial latitude in degrees.
         :param LON_init: Initial longitude in degrees.
-        :param distance: Distance to be traveled from the initial point in meters.
+        :param distance: Distance to be traveled from the initial point in
+            meters.
         :param bearing: Initial bearing (direction) in degrees.
         :type LAT_init: float
         :type LON_init: float
         :type distance: float
         :type bearing: float
-        :returns: Tuple containing the destination latitude and longitude in degrees.
+        :returns: Tuple containing the destination latitude and longitude in
+            degrees.
         :rtype: (float, float)
         """
 
@@ -473,22 +492,22 @@ class Vincenty(object):
         return (dest[0], dest[1])
 
 
-class RhumbLine(object):
-    """This class implements the rhumb line (loxodrome) calculations of geodesics on the ellipsoid-model earth
+class RhumbLine:
+    """This class implements the rhumb line (loxodrome) calculations of
+    geodesics on the ellipsoid-model earth.
 
     .. note::
             https://github.com/SpyrosMouselinos/distancly/blob/master/distancly/rhumbline.py
-
     """
 
     @staticmethod
     def simple_project(latitiude: float) -> float:
-        """
-        Applies a projection to the latitude for use in rhumbline calculations.
+        """Applies a projection to the latitude for use in rhumbline
+        calculations.
 
-        The projection is based on the Mercator projection, where latitudes are projected
-        to account for the curvature of the Earth. This formula ensures that the calculations
-        along the rhumbline are accurate.
+        The projection is based on the Mercator projection, where latitudes
+        are projected to account for the curvature of the Earth. This formula
+        ensures that the calculations along the rhumbline are accurate.
 
         :param latitiude: Latitude in radians.
         :return: The projected latitude in radians.
@@ -498,13 +517,15 @@ class RhumbLine(object):
 
     @staticmethod
     def distance(LAT_init, LON_init, LAT_final, LON_final) -> float:
-        """
-        Calculates the rhumbline distance between two geographical points in meters.
+        """Calculates the rhumbline distance between two geographical points
+        in meters.
 
-        The rhumbline is a path of constant bearing that crosses all meridians at the same angle,
-        unlike a great-circle route which is the shortest distance between two points on the Earth's surface.
+        The rhumbline is a path of constant bearing that crosses all meridians
+        at the same angle, unlike a great-circle route which is the shortest
+        distance between two points on the Earth's surface.
 
-        This method adjusts for longitudes that span more than half of the globe.
+        This method adjusts for longitudes that span more than half of the
+        globe.
 
         :param LAT_init: Initial latitude in degrees.
         :param LON_init: Initial longitude in degrees.
@@ -544,11 +565,12 @@ class RhumbLine(object):
 
     @staticmethod
     def bearing(LAT_init, LON_init, LAT_final, LON_final) -> float:
-        """
-        Calculates the rhumbline bearing from the initial point to the final point.
+        """Calculates the rhumbline bearing from the initial point to the
+        final point.
 
-        This returns the constant bearing (direction) required to travel along a rhumbline
-        between the two points. The bearing is adjusted for longitudes that cross the 180-degree meridian.
+        This returns the constant bearing (direction) required to travel along
+        a rhumbline between the two points. The bearing is adjusted for
+        longitudes that cross the 180-degree meridian.
 
         :param LAT_init: Initial latitude in degrees.
         :param LON_init: Initial longitude in degrees.
@@ -578,17 +600,20 @@ class RhumbLine(object):
 
     @staticmethod
     def destinationPoint(LAT_init, LON_init, bearing, distance) -> tuple:
-        """
-        Calculates the destination point given an initial point, a bearing, and a distance traveled.
+        """Calculates the destination point given an initial point, a bearing,
+        and a distance traveled.
 
-        This method computes the final latitude and longitude after traveling along a rhumbline
-        for a given distance in meters from the initial point at a constant bearing.
+        This method computes the final latitude and longitude after traveling
+        along a rhumbline for a given distance in meters from the initial
+        point at a constant bearing.
 
         :param LAT_init: Initial latitude in degrees.
         :param LON_init: Initial longitude in degrees.
         :param bearing: The constant bearing in degrees.
-        :param distance: The distance to travel from the initial point in meters.
-        :return: A tuple containing the destination latitude and longitude in degrees.
+        :param distance: The distance to travel from the initial point in
+            meters.
+        :return: A tuple containing the destination latitude and longitude in
+            degrees.
         """
 
         lat_a = radians(LAT_init)
@@ -626,17 +651,19 @@ class RhumbLine(object):
     def loxodromic_mid_point(
         LAT_init, LON_init, LAT_final, LON_final
     ) -> tuple:
-        """
-        Calculates the midpoint along a rhumbline between two geographical points.
+        """Calculates the midpoint along a rhumbline between two geographical
+        points.
 
-        The midpoint is calculated using the rhumbline path between the initial and final points.
-        This takes into account the Earth's curvature by projecting the latitudes.
+        The midpoint is calculated using the rhumbline path between the
+        initial and final points. This takes into account the Earth's
+        curvature by projecting the latitudes.
 
         :param LAT_init: Initial latitude in degrees.
         :param LON_init: Initial longitude in degrees.
         :param LAT_final: Final latitude in degrees.
         :param LON_final: Final longitude in degrees.
-        :return: A tuple representing the midpoint's latitude and longitude in degrees.
+        :return: A tuple representing the midpoint's latitude and longitude in
+            degrees.
         """
 
         lat_a = radians(LAT_init)
@@ -670,18 +697,21 @@ class RhumbLine(object):
     def loxodromic_power_interpolation(
         LAT_init, LON_init, LAT_final, LON_final, n_points: int
     ) -> list:
-        """
-        Generates a specified number of points between two geographical locations along a rhumbline path.
+        """Generates a specified number of points between two geographical
+        locations along a rhumbline path.
 
-        This method recursively calculates intermediate points between two points on the Earth's surface,
-        following a constant bearing rhumbline path. The number of points should be a power of 2 minus 1.
+        This method recursively calculates intermediate points between two
+        points on the Earth's surface, following a constant bearing rhumbline
+        path. The number of points should be a power of 2 minus 1.
 
         :param LAT_init: Initial latitude in degrees.
         :param LON_init: Initial longitude in degrees.
         :param LAT_final: Final latitude in degrees.
         :param LON_final: Final longitude in degrees.
-        :param n_points: Number of intermediate points to generate. Must be a power of 2 minus 1.
-        :return: A list of tuples, where each tuple represents an interpolated point's latitude and longitude in degrees.
+        :param n_points: Number of intermediate points to generate. Must be a
+            power of 2 minus 1.
+        :return: A list of tuples, where each tuple represents an interpolated
+            point's latitude and longitude in degrees.
         """
 
         n_points = int(n_points)
@@ -718,8 +748,8 @@ class RhumbLine(object):
         return decoupled_points
 
 
-class Turn(object):
-    """This class implements the calculations of geodesics turns"""
+class Turn:
+    """This class implements the calculations of geodesics turns."""
 
     @staticmethod
     def destinationPoint_finalBearing(
@@ -732,11 +762,14 @@ class Turn(object):
         directionOfTurn,
         centerPoint=None,
     ):
-        """Calculates the destination point and final bearing after traveling for a given time with a specified turn.
+        """Calculates the destination point and final bearing after traveling
+        for a given time with a specified turn.
 
-        This function computes the aircraft's final position and bearing after making a turn at a specified rate
-        of turn, direction, and true airspeed (TAS). If TAS is zero, the aircraft rotates in place. The calculation
-        accounts for turning radius and bank angle.
+        This function computes the aircraft's final position and bearing
+        after making a turn at a specified rate of turn, direction, and
+        true airspeed (TAS). If TAS is zero, the aircraft rotates in
+        place. The calculation accounts for turning radius and bank
+        angle.
 
         :param LAT_init: Initial latitude [deg].
         :param LON_init: Initial longitude [deg].
@@ -745,7 +778,8 @@ class Turn(object):
         :param TAS: True Airspeed (TAS) [m/s].
         :param rateOfTurn: Rate of turn [deg/s].
         :param directionOfTurn: Direction of turn ('LEFT' or 'RIGHT').
-        :param centerPoint: Optional latitude and longitude of the rotation center (defaults to None) [deg, deg].
+        :param centerPoint: Optional latitude and longitude of the
+            rotation center (defaults to None) [deg, deg].
         :type LAT_init: float.
         :type LON_init: float.
         :type timeOfTurn: float.
@@ -754,7 +788,8 @@ class Turn(object):
         :type rateOfTurn: float.
         :type directionOfTurn: str.
         :type centerPoint: tuple(float, float).
-        :returns: Destination point's latitude, longitude, and final bearing [deg, deg, deg].
+        :returns: Destination point's latitude, longitude, and final
+            bearing [deg, deg, deg].
         :rtype: tuple(float, float, float).
         """
 
@@ -826,10 +861,12 @@ class Turn(object):
 
     @staticmethod
     def distance(rateOfTurn, TAS, timeOfTurn):
-        """Calculates the distance traveled during a turn based on the rate of turn, true airspeed, and time.
+        """Calculates the distance traveled during a turn based on the rate of
+        turn, true airspeed, and time.
 
-        This function computes the total distance traveled during a constant turn, based on the aircraft's rate
-        of turn, true airspeed, and the duration of the turn.
+        This function computes the total distance traveled during a constant
+        turn, based on the aircraft's rate of turn, true airspeed, and the
+        duration of the turn.
 
         :param rateOfTurn: Rate of turn [deg/s].
         :param TAS: True Airspeed (TAS) [m/s].

pyBADA/magnetic.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 """
 Magnetic declination module
 """
@@ -51,7 +50,8 @@ class Grid:
 
         :param LAT_target: Target latitude to search for.
         :type LAT_target: float
-        :return: The closest latitude from the grid or None if the target is out of bounds.
+        :return: The closest latitude from the grid or None if the target is
+            out of bounds.
         :rtype: float or None
         """
 
@@ -79,7 +79,8 @@ class Grid:
 
         :param LON_target: Target longitude to search for.
         :type LON_target: float
-        :return: The closest longitude from the grid or None if the target is out of bounds.
+        :return: The closest longitude from the grid or None if the target is
+            out of bounds.
         :rtype: float or None
         """
 
@@ -103,13 +104,15 @@ class Grid:
         return closest
 
     def getClosestIdx(self, LAT_target, LON_target):
-        """Finds the index of the closest grid point for a given latitude and longitude.
+        """Finds the index of the closest grid point for a given latitude and
+        longitude.
 
         :param LAT_target: Target latitude.
         :param LON_target: Target longitude.
         :type LAT_target: float
         :type LON_target: float
-        :return: Index of the closest point in the grid or None if no point is found.
+        :return: Index of the closest point in the grid or None if no point is
+            found.
         :rtype: int or None
         """
 
@@ -134,13 +137,15 @@ class Grid:
         return None
 
     def getMagneticDeclination(self, LAT_target, LON_target):
-        """Returns the magnetic declination for the closest grid point to the target coordinates.
+        """Returns the magnetic declination for the closest grid point to the
+        target coordinates.
 
         :param LAT_target: Target latitude.
         :param LON_target: Target longitude.
         :type LAT_target: float
         :type LON_target: float
-        :return: Magnetic declination at the closest grid point or None if no point is found.
+        :return: Magnetic declination at the closest grid point or None if no
+            point is found.
         :rtype: float or None
         """
 

pyBADA/trajectoryPrediction.py

@@ -1,10 +1,8 @@
-# -*- coding: utf-8 -*-
 """
 Basic calculations for the Trajectory Prediction (TP) using BADA
 """
 
 from pyBADA import atmosphere as atm
-from pyBADA import conversions as conv
 from math import exp
 
 
@@ -86,14 +84,17 @@ def cruiseFuelConsumption(AC, altitude, M, deltaTemp):
 def breguetLeducInitialMass(
     AC, distance, GS, cruiseFuelFlow, payload, fuelReserve
 ):
-    """
-    Calculate the estimated initial mass required for the aircraft using the Breguet Leduc formula.
+    """Calculate the estimated initial mass required for the aircraft using
+    the Breguet Leduc formula.
 
-    :param AC: Aircraft object (instance of Bada3Aircraft, Bada4Aircraft, or BadaHAircraft).
+    :param AC: Aircraft object (instance of Bada3Aircraft, Bada4Aircraft, or
+        BadaHAircraft).
     :param distance: Flight distance in meters.
-    :param GS: Ground speed in m/s (assumed equal to true airspeed under no-wind conditions).
+    :param GS: Ground speed in m/s (assumed equal to true airspeed under no-
+        wind conditions).
     :param cruiseFuelFlow: Fuel flow rate during cruise in kg/s.
-    :param payload: Payload percentage (of the maximum payload mass) to be used.
+    :param payload: Payload percentage (of the maximum payload mass) to be
+        used.
     :param fuelReserve: Fuel reserve time in seconds.
     :type AC: object
     :type distance: float
@@ -132,16 +133,20 @@ def getInitialMass(
     flightPlanInitialMass=None,
     deltaTemp=0,
 ):
-    """Calculates the estimated initial aircraft mass assumig cruise phase, combining flight plan data, aircraft envelope constraints,
-    and an exponential fuel consumption model inspired by the Breguet Leduc formula.
+    """Calculates the estimated initial aircraft mass assumig cruise phase,
+    combining flight plan data, aircraft envelope constraints, and an
+    exponential fuel consumption model inspired by the Breguet Leduc formula.
 
-    :param AC: Aircraft object (instance of Bada3Aircraft, Bada4Aircraft, BadaEAircraft, or BadaHAircraft).
+    :param AC: Aircraft object (instance of Bada3Aircraft, Bada4Aircraft,
+        BadaEAircraft, or BadaHAircraft).
     :param distance: Distance to be flown in meters.
     :param altitude: Cruising altitude in meters.
     :param M: Mach number at cruising altitude.
     :param payload: Percentage of the maximum payload mass (default is 60%).
-    :param fuelReserve: Fuel reserve time in seconds (default is 3600 seconds, or 1 hour).
-    :param flightPlanInitialMass: Optional initial mass from a flight plan, in kg.
+    :param fuelReserve: Fuel reserve time in seconds (default is 3600 seconds,
+        or 1 hour).
+    :param flightPlanInitialMass: Optional initial mass from a flight plan, in
+        kg.
     :param deltaTemp: Temperature deviation from standard atmosphere.
     :type AC: object
     :type distance: float
@@ -159,7 +164,6 @@ def getInitialMass(
     if flightPlanInitialMass is not None:
         initialMass = flightPlanInitialMass
     else:
-
         # in case of no wind, the ground speed is the same as true airspeed
         [theta, delta, sigma] = atm.atmosphereProperties(
             h=altitude, DeltaTemp=deltaTemp

{pybada-0.1.3.dist-info → pybada-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyBADA
-Version: 0.1.3
+Version: 0.1.4
 Summary: pyBADA
 Project-URL: Homepage, https://github.com/eurocontrol-bada/pybada
 Author-email: Henrich Glaser-Opitz <henrich.glaser-opitz@eurocontrol.int>
@@ -16,14 +16,13 @@ Requires-Dist: scipy>=1.15.2
 Requires-Dist: simplekml>=1.3.6
 Requires-Dist: xlsxwriter>=3.2.2
 Provides-Extra: dev
-Requires-Dist: black==25.1.0; extra == 'dev'
 Requires-Dist: build; extra == 'dev'
-Requires-Dist: flake8==7.1.2; extra == 'dev'
 Requires-Dist: folium==0.19.5; extra == 'dev'
 Requires-Dist: matplotlib==3.10.1; extra == 'dev'
 Requires-Dist: pre-commit==4.1.0; extra == 'dev'
 Requires-Dist: pytest==8.3.5; extra == 'dev'
 Requires-Dist: readthedocs-sphinx-search>=0.3.2; extra == 'dev'
+Requires-Dist: ruff==0.11.5; extra == 'dev'
 Requires-Dist: sphinx-gallery==0.19.0; extra == 'dev'
 Requires-Dist: sphinx-rtd-theme==3.0.2; extra == 'dev'
 Requires-Dist: sphinx==8.2.3; extra == 'dev'
@@ -32,6 +31,7 @@ Description-Content-Type: text/markdown
 
 # pyBADA
 
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 <a href="https://github.com/eurocontrol-bada/pybada/blob/main/LICENCE.txt"><img alt="License: EUPL" src="https://img.shields.io/badge/license-EUPL-3785D1.svg"></a>
 <a href="https://pypi.org/project/pyBADA"><img alt="Released on PyPi" src="https://img.shields.io/pypi/v/pyBADA.svg"></a>
 ![Python 3.12](https://img.shields.io/badge/Python-3.12-3776AB.svg?logo=python&logoColor=white)
@@ -54,7 +54,7 @@ Examples, the user manual and the API reference can be found at the [pyBADA docu
 # Clone the repository
 git clone https://github.com/eurocontrol-bada/pybada
 
-# Optionally, set up a virtual env and activate it
+# Set up a virtual env and activate it
 python3 -m venv env
 source env/bin/activate
 
@@ -62,9 +62,18 @@ source env/bin/activate
 pip install .
 # Install a couple of packages for formatting, linting and building the docs
 pip install .[dev]
+# Install pre-commit
+pre-commit install
 
 # Run unit tests
 python3 -m pytest tests/
+
+# Format code
+ruff format
+
+# Lint code
+ruff check
+
 # Build the docs
 cd docs
 make html
@@ -78,6 +87,6 @@ You won't receive support for it, but you can pass the flag `--ignore-requires-p
 
 ## License
 
-BADA and pyBADA are developed and maintained by [EUROCONTROL](https://www.eurocontrol.int/).
+BADA and pyBADA are developed and maintained by [EUROCONTROL](https://www.eurocontrol.int/model/bada).
 
 This project is released under the European Union Public License v1.2 - see the [LICENSE](https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12) file for details.

{pybada-0.1.3.dist-info → pybada-0.1.4.dist-info}/RECORD

@@ -1,17 +1,17 @@
-pyBADA/TCL.py,sha256=hg7yQ5IFOk7agauA6x_1qOtIzc8mobbx7oxpZEEoH9s,373505
+pyBADA/TCL.py,sha256=K6L_E0BchttNDWrAfDfuHWk3-ux7mvgeONpr2OkQNgw,373689
 pyBADA/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyBADA/aircraft.py,sha256=n9pKxQOgsCxZmwMg1_jUV-qX8uuIwpGbaV5-xN0AJmk,13033
-pyBADA/atmosphere.py,sha256=7hfKcpEkUQpp9M-3Xahb_4Ab29mDrRJoIkxIIiAtaLs,10778
-pyBADA/bada3.py,sha256=BKcccf_dpRDj8fMRpFyO6nvYICgHzMrwLSvysYeO1hI,185997
-pyBADA/bada4.py,sha256=BlrxZgCqVpfEXBBeeUCI6S_WrjgOBI7m7uC0l0DmLFc,219163
-pyBADA/badaH.py,sha256=iVyCPfOJoVrq3WaIgjRdZ9R-7EtIDWEDGgE549lkVo0,150698
-pyBADA/configuration.py,sha256=fWLO6a8NGseTh8cpv-NfA0LhG2LNBBn6mJtajyKmhkA,6458
-pyBADA/constants.py,sha256=BybxdQqNbirheEbCiyMrjo3d1_iUl3rBE1rUkubD8e0,976
-pyBADA/conversions.py,sha256=31Dj4lxTQMSIs1_9DdSXlPSYfPJY4j5DuioHK9Qf2ac,3320
-pyBADA/flightTrajectory.py,sha256=kDPIsib7nX2-GvrkVgJqN3m2mcxH2SiLutTsbxdyM1k,38156
-pyBADA/geodesic.py,sha256=Y0yqTH2LlCkkzSTsuV5b4UFaZePg_giKTRSSiwnFOTc,30454
-pyBADA/magnetic.py,sha256=vgWH837hKZNUC7Kg1uy7jYLQZLL9qfZPx-aeQ0ITzu8,4956
-pyBADA/trajectoryPrediction.py,sha256=dWnu9e8fzGvwoLyPw0btoWTZcxWdt3_cMvVpocVfghQ,6957
+pyBADA/aircraft.py,sha256=VTXMyTm9Gw-EQpNTL9Q8-Mzp2wXE9S2mjJLHvSF-AZs,13009
+pyBADA/atmosphere.py,sha256=audmiVJR1fdraeorWBpYqQTlFn_uZVRWcC9ex-Nr9Jw,11348
+pyBADA/bada3.py,sha256=hpKX4abW16ocRe2RjOvE7Codo5ljWy6Wm3eXFvos8J4,186306
+pyBADA/bada4.py,sha256=PjP26gEn45Ebajm4TR9FhKMUDQuIlBXOANSCjeS7NsY,222266
+pyBADA/badaH.py,sha256=rF7gE5-tsemGDKwkUpiPazw5vdLpMkBNuXpI_22z0S8,153349
+pyBADA/configuration.py,sha256=66OCBBYJhXF4quCHDK47YA9yOftuPdrbvbn88P-531E,6505
+pyBADA/constants.py,sha256=zJhiLcG49Ab2i-c_mHNCmfLpecmQozvIOjX71aVB5KE,952
+pyBADA/conversions.py,sha256=grIokt50KOTaINsmMDWyCJvMpt-_U3FgC9ZNg_aqC1g,3252
+pyBADA/flightTrajectory.py,sha256=XEbohC3NGLaDymSLyqyzM9h3D6Tzns2iHLx9uGAMs-U,38483
+pyBADA/geodesic.py,sha256=jTEphU_H9D10lgi1Pm77OSsT7icApniaNtSSVHTjZXo,30721
+pyBADA/magnetic.py,sha256=O5Ki4ViSqvznl08gZRM90mBbkkpAMR6PR0hKc-FY8yg,4996
+pyBADA/trajectoryPrediction.py,sha256=jC-FxEhD3C_hP5nRutZndYtrat14NIKMVG30Aiq0XJ4,6945
 pyBADA/data/magneticDeclinationGridData.json,sha256=ffmLcxdDwFwJqV4WPyMM5SWt60tMj8xsLh5IHYkpO3U,5390918
 pyBADA/aircraft/BADA3/DUMMY/BADA.GPF,sha256=1Am9yU8v9nnIpvJt-XhJRz4APOkRzfNPujKAy3UCYg0,9831
 pyBADA/aircraft/BADA3/DUMMY/BZJT__.APF,sha256=wGyXK-ro1S6YhC4wp2nMQKi0JGYLvTunNjO6x_YbhW4,2523
@@ -90,8 +90,8 @@ pyBADA/aircraft/BADAH/DUMMY/DUMH/DUMH_ISA.PTF,sha256=aEthZF1xztp6QSHYEwU5tH4HF8x
 pyBADA/aircraft/BADAH/DUMMY/DUMH/LRC.OPT,sha256=7WecIu4kfw5nM_ADih06Hb8pCoxLVsEdHHJTqQrx4hg,10123
 pyBADA/aircraft/BADAH/DUMMY/DUMH/MEC.OPT,sha256=yKczjH6lZqTplmcV79tZLvwXmHM2F9bYoB2gIM8hBpg,10123
 pyBADA/aircraft/BADAH/DUMMY/DUMH/MRC.OPT,sha256=fTGqt0P9xgt9Q4sKPlL0CZi9aj73prAPlXj1dpWHSOk,10123
-pybada-0.1.3.dist-info/METADATA,sha256=jyPJfkCop55o-rs-pvBsgC4T_tHwolwguLOIbBB_nVg,3181
-pybada-0.1.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pybada-0.1.3.dist-info/licenses/AUTHORS,sha256=iCKpU7CHp2sB4u5hkS2WyMJHLzL0gfMm-bobd7QDmzE,108
-pybada-0.1.3.dist-info/licenses/LICENCE.txt,sha256=RpvAZSjULHvoTR_esTlucJ08-zdQydnoqQLbqOh9Ub8,13826
-pybada-0.1.3.dist-info/RECORD,,
+pybada-0.1.4.dist-info/METADATA,sha256=k2Cw0Hv96AneCh1db80ENgUDtwaVkva9yJzcwXrvtCg,3382
+pybada-0.1.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pybada-0.1.4.dist-info/licenses/AUTHORS,sha256=iCKpU7CHp2sB4u5hkS2WyMJHLzL0gfMm-bobd7QDmzE,108
+pybada-0.1.4.dist-info/licenses/LICENCE.txt,sha256=RpvAZSjULHvoTR_esTlucJ08-zdQydnoqQLbqOh9Ub8,13826
+pybada-0.1.4.dist-info/RECORD,,