ObjectNat 1.2.2__py3-none-any.whl → 1.3.0__py3-none-any.whl

objectnat/methods/isochrones/isochrones.py

@@ -31,33 +31,44 @@ def get_accessibility_isochrone_stepped(
     """
     Calculate stepped accessibility isochrones for a single point with specified intervals.
 
-    Parameters:
-        isochrone_type (Literal["radius", "ways", "separate"]):
+    Args:
+        isochrone_type:
             Visualization method for stepped isochrones:
-            - "radius": Voronoi-based in circular buffers
-            - "ways": Voronoi-based in road network polygons
-            - "separate": Circular buffers for each step
+
+            - ``"radius"``: Voronoi-based in circular buffers
+            - ``"ways"``: Voronoi-based in road network polygons
+            - ``"separate"``: Circular buffers for each step
+
         point (gpd.GeoDataFrame):
             Single source point for isochrone calculation (uses first geometry if multiple provided).
+
         weight_value (float):
             Maximum travel time (minutes) or distance (meters) threshold.
-        weight_type (Literal["time_min", "length_meter"]):
+
+        weight_type:
             Type of weight calculation:
+
             - "time_min": Time-based in minutes
             - "length_meter": Distance-based in meters
+
         nx_graph (nx.Graph):
             NetworkX graph representing the transportation network.
+
         step (float, optional):
             Interval between isochrone steps. Defaults to:
+
             - 100 meters for distance-based
             - 1 minute for time-based
+
         **kwargs: Additional parameters:
+
             - buffer_factor: Size multiplier for buffers (default: 0.7)
             - road_buffer_size: Buffer size for road edges in meters (default: 5)
 
     Returns:
-        (tuple[gpd.GeoDataFrame, gpd.GeoDataFrame | None, gpd.GeoDataFrame | None]):
+        tuple[gpd.GeoDataFrame, gpd.GeoDataFrame | None, gpd.GeoDataFrame | None]:
             Tuple containing:
+
             - stepped_isochrones: GeoDataFrame with stepped polygons and distance/time attributes
             - pt_stops: Public transport stops within isochrones (if available)
             - pt_routes: Public transport routes within isochrones (if available)
@@ -150,29 +161,38 @@ def get_accessibility_isochrones(
         - 'radius': Circular buffer-based isochrones
         - 'ways': Road network-based isochrones
 
-    Parameters:
-        isochrone_type (Literal["radius", "ways"]):
+    Args:
+        isochrone_type:
             Type of isochrone to calculate:
+
             - "radius": Creates circular buffers around reachable nodes
             - "ways": Creates polygons based on reachable road network
+
         points (gpd.GeoDataFrame):
             GeoDataFrame containing source points for isochrone calculation.
+
         weight_value (float):
             Maximum travel time (minutes) or distance (meters) threshold.
-        weight_type (Literal["time_min", "length_meter"]):
+
+        weight_type:
             Type of weight calculation:
+
             - "time_min": Time-based accessibility in minutes
             - "length_meter": Distance-based accessibility in meters
+
         nx_graph (nx.Graph):
             NetworkX graph representing the transportation network.
             Must contain CRS and speed attributes for time calculations.
+
         **kwargs: Additional parameters:
+
             - buffer_factor: Size multiplier for buffers (default: 0.7)
             - road_buffer_size: Buffer size for road edges in meters (default: 5)
 
     Returns:
-        (tuple[gpd.GeoDataFrame, gpd.GeoDataFrame | None, gpd.GeoDataFrame | None]):
+        tuple[gpd.GeoDataFrame, gpd.GeoDataFrame | None, gpd.GeoDataFrame | None]:
             Tuple containing:
+
             - isochrones: GeoDataFrame with calculated isochrone polygons
             - pt_stops: Public transport stops within isochrones (if available)
             - pt_routes: Public transport routes within isochrones (if available)

objectnat/methods/noise/__init__.py

@@ -1,3 +1,3 @@
-from .noise_simulation import simulate_noise
-from .noise_reduce import dist_to_target_db, green_noise_reduce_db
-from .noise_simulation_simplified import calculate_simplified_noise_frame
+from .noise_simulation import simulate_noise
+from .noise_reduce import dist_to_target_db, green_noise_reduce_db
+from .noise_simulation_simplified import calculate_simplified_noise_frame

objectnat/methods/noise/noise_init_data.py

@@ -1,10 +1,10 @@
-import pandas as pd
-
-data = {
-    30: {63: 0, 125: 0.0002, 250: 0.0009, 500: 0.003, 1000: 0.0075, 2000: 0.014, 4000: 0.025, 8000: 0.064},
-    20: {63: 0, 125: 0.0003, 250: 0.0011, 500: 0.0028, 1000: 0.0052, 2000: 0.0096, 4000: 0.025, 8000: 0.083},
-    10: {63: 0, 125: 0.0004, 250: 0.001, 500: 0.002, 1000: 0.0039, 2000: 0.01, 4000: 0.035, 8000: 0.125},
-    0: {63: 0, 125: 0.0004, 250: 0.0008, 500: 0.0017, 1000: 0.0049, 2000: 0.017, 4000: 0.058, 8000: 0.156},
-}
-
-air_resist_ratio = pd.DataFrame(data)
+import pandas as pd
+
+data = {
+    30: {63: 0, 125: 0.0002, 250: 0.0009, 500: 0.003, 1000: 0.0075, 2000: 0.014, 4000: 0.025, 8000: 0.064},
+    20: {63: 0, 125: 0.0003, 250: 0.0011, 500: 0.0028, 1000: 0.0052, 2000: 0.0096, 4000: 0.025, 8000: 0.083},
+    10: {63: 0, 125: 0.0004, 250: 0.001, 500: 0.002, 1000: 0.0039, 2000: 0.01, 4000: 0.035, 8000: 0.125},
+    0: {63: 0, 125: 0.0004, 250: 0.0008, 500: 0.0017, 1000: 0.0049, 2000: 0.017, 4000: 0.058, 8000: 0.156},
+}
+
+air_resist_ratio = pd.DataFrame(data)

objectnat/methods/noise/noise_reduce.py

@@ -1,155 +1,155 @@
-import numpy as np
-from scipy.optimize import fsolve
-
-from objectnat import config
-
-from .noise_init_data import air_resist_ratio
-
-logger = config.logger
-
-
-def get_air_resist_ratio(temp, freq, check_temp_freq=False):
-    if check_temp_freq:
-        if temp > max(air_resist_ratio.columns) or temp < min(air_resist_ratio.columns):
-            logger.warning(
-                f"The specified temperature of {temp}°C is outside the tabulated data range. "
-                f"The air resistance coefficient for these values may be inaccurate. "
-                f"Recommended temperature range: {min(air_resist_ratio.columns)}°C "
-                f"to {max(air_resist_ratio.columns)}°C."
-            )
-
-        if freq > max(air_resist_ratio.index) or freq < min(air_resist_ratio.index):
-            logger.warning(
-                f"The specified geometric mean frequency of {freq} Hz is outside the tabulated data range."
-                f" The air resistance coefficient for these values may be inaccurate."
-                f" Recommended frequency range: {min(air_resist_ratio.index)} Hz to {max(air_resist_ratio.index)} Hz."
-            )
-
-    def get_nearest_values(array, value):
-        sorted_array = sorted(array)
-        if value in sorted_array:
-            return [value]
-        if value > max(sorted_array):
-            return [sorted_array[-1]]
-        if value < min(sorted_array):
-            return [sorted_array[0]]
-
-        for i, val in enumerate(sorted_array):
-            if value < val:
-                return sorted_array[max(i - 1, 0)], sorted_array[i]
-        return sorted_array[-2], sorted_array[-1]
-
-    nearest_temp = get_nearest_values(air_resist_ratio.columns, temp)
-    nearest_freq = get_nearest_values(air_resist_ratio.index, freq)
-
-    if len(nearest_temp) == 1 and len(nearest_freq) == 1:
-        return air_resist_ratio.loc[nearest_freq[0], nearest_temp[0]]
-
-    if len(nearest_temp) == 2 and len(nearest_freq) == 2:
-        freq1, freq2 = nearest_freq
-        temp1, temp2 = nearest_temp
-
-        coef_temp1_freq1 = air_resist_ratio.loc[freq1, temp1]
-        coef_temp1_freq2 = air_resist_ratio.loc[freq2, temp1]
-        coef_temp2_freq1 = air_resist_ratio.loc[freq1, temp2]
-        coef_temp2_freq2 = air_resist_ratio.loc[freq2, temp2]
-
-        weight_temp1 = (temp2 - temp) / (temp2 - temp1)
-        weight_temp2 = (temp - temp1) / (temp2 - temp1)
-        weight_freq1 = (freq2 - freq) / (freq2 - freq1)
-        weight_freq2 = (freq - freq1) / (freq2 - freq1)
-
-        coef_freq1 = coef_temp1_freq1 * weight_temp1 + coef_temp2_freq1 * weight_temp2
-        coef_freq2 = coef_temp1_freq2 * weight_temp1 + coef_temp2_freq2 * weight_temp2
-
-        final_coef = coef_freq1 * weight_freq1 + coef_freq2 * weight_freq2
-
-        return final_coef
-
-    if len(nearest_temp) == 2 and len(nearest_freq) == 1:
-        temp1, temp2 = nearest_temp
-        freq1 = nearest_freq[0]
-
-        coef_temp1 = air_resist_ratio.loc[freq1, temp1]
-        coef_temp2 = air_resist_ratio.loc[freq1, temp2]
-
-        weight_temp1 = (temp2 - temp) / (temp2 - temp1)
-        weight_temp2 = (temp - temp1) / (temp2 - temp1)
-
-        return coef_temp1 * weight_temp1 + coef_temp2 * weight_temp2
-
-    if len(nearest_temp) == 1 and len(nearest_freq) == 2:
-        temp1 = nearest_temp[0]
-        freq1, freq2 = nearest_freq
-
-        coef_freq1 = air_resist_ratio.loc[freq1, temp1]
-        coef_freq2 = air_resist_ratio.loc[freq2, temp1]
-
-        weight_freq1 = (freq2 - freq) / (freq2 - freq1)
-        weight_freq2 = (freq - freq1) / (freq2 - freq1)
-
-        return coef_freq1 * weight_freq1 + coef_freq2 * weight_freq2
-
-
-def dist_to_target_db(
-    init_noise_db, target_noise_db, geometric_mean_freq_hz, air_temperature, return_desc=False, check_temp_freq=False
-) -> float | str:
-    """
-    Calculates the distance required for a sound wave to decay from an initial noise level to a target noise level,
-    based on the geometric mean frequency of the sound and the air temperature. Optionally, can return a description
-    of the sound propagation behavior.
-
-    Args:
-        init_noise_db (float): The initial noise level of the source in decibels (dB). This is the starting sound
-            intensity.
-        target_noise_db (float): The target noise level in decibels (dB), representing the level to which the sound
-            decays over distance.
-        geometric_mean_freq_hz (float): The geometric mean frequency of the sound (in Hz). This frequency influences
-            the attenuation of sound over distance. Higher frequencies decay faster than lower ones.
-        air_temperature (float): The temperature of the air in degrees Celsius. This influences the air's resistance
-            to sound propagation.
-        return_desc (bool, optional): If set to `True`, the function will return a description of the sound decay
-            process instead of the calculated distance.
-        check_temp_freq (bool, optional): If `True`, the function will check whether the temperature and frequency
-            are within valid ranges.
-
-    Returns:
-        float or str: If `return_desc` is `False`, the function returns the distance (in meters) over which the sound
-        decays from `init_noise_db` to `target_noise_db`. If `return_desc` is `True`, a descriptive string is returned
-        explaining the calculation and the conditions.
-    """
-
-    def equation(r):
-        return l - l_ist + 20 * np.log10(r) + k * r
-
-    l_ist = init_noise_db
-    l = target_noise_db
-    k = get_air_resist_ratio(air_temperature, geometric_mean_freq_hz, check_temp_freq)
-    initial_guess = 1
-    r_solution = fsolve(equation, initial_guess)
-    if return_desc:
-        string = (
-            f"Noise level of {init_noise_db} dB "
-            f"with a geometric mean frequency of {geometric_mean_freq_hz} Hz "
-            f"at an air temperature of {air_temperature}°C decays to {target_noise_db} dB "
-            f"over a distance of {r_solution[0]} meters. Air resistance coefficient: {k}."
-        )
-        return string
-    return r_solution[0]
-
-
-def green_noise_reduce_db(geometric_mean_freq_hz, r_tree) -> float:
-    """
-    Calculates the amount of noise reduction (in dB) provided by vegetation of a given thickness at a specified
-    geometric mean frequency. The function models the reduction based on the interaction of the sound with trees or
-    vegetation.
-
-    Args:
-        geometric_mean_freq_hz (float): The geometric mean frequency of the sound (in Hz).
-        r_tree (float): The thickness or density of the vegetation (in meters).
-
-    Returns:
-        float: The noise reduction (in dB) achieved by the vegetation. This value indicates how much quieter the sound
-        will be after passing through or interacting with the vegetation of the specified thickness.
-    """
-    return round(0.08 * r_tree * ((geometric_mean_freq_hz ** (1 / 3)) / 8), 1)
+import numpy as np
+from scipy.optimize import fsolve
+
+from objectnat import config
+
+from .noise_init_data import air_resist_ratio
+
+logger = config.logger
+
+
+def get_air_resist_ratio(temp, freq, check_temp_freq=False):
+    if check_temp_freq:
+        if temp > max(air_resist_ratio.columns) or temp < min(air_resist_ratio.columns):
+            logger.warning(
+                f"The specified temperature of {temp}°C is outside the tabulated data range. "
+                f"The air resistance coefficient for these values may be inaccurate. "
+                f"Recommended temperature range: {min(air_resist_ratio.columns)}°C "
+                f"to {max(air_resist_ratio.columns)}°C."
+            )
+
+        if freq > max(air_resist_ratio.index) or freq < min(air_resist_ratio.index):
+            logger.warning(
+                f"The specified geometric mean frequency of {freq} Hz is outside the tabulated data range."
+                f" The air resistance coefficient for these values may be inaccurate."
+                f" Recommended frequency range: {min(air_resist_ratio.index)} Hz to {max(air_resist_ratio.index)} Hz."
+            )
+
+    def get_nearest_values(array, value):
+        sorted_array = sorted(array)
+        if value in sorted_array:
+            return [value]
+        if value > max(sorted_array):
+            return [sorted_array[-1]]
+        if value < min(sorted_array):
+            return [sorted_array[0]]
+
+        for i, val in enumerate(sorted_array):
+            if value < val:
+                return sorted_array[max(i - 1, 0)], sorted_array[i]
+        return sorted_array[-2], sorted_array[-1]
+
+    nearest_temp = get_nearest_values(air_resist_ratio.columns, temp)
+    nearest_freq = get_nearest_values(air_resist_ratio.index, freq)
+
+    if len(nearest_temp) == 1 and len(nearest_freq) == 1:
+        return air_resist_ratio.loc[nearest_freq[0], nearest_temp[0]]
+
+    if len(nearest_temp) == 2 and len(nearest_freq) == 2:
+        freq1, freq2 = nearest_freq
+        temp1, temp2 = nearest_temp
+
+        coef_temp1_freq1 = air_resist_ratio.loc[freq1, temp1]
+        coef_temp1_freq2 = air_resist_ratio.loc[freq2, temp1]
+        coef_temp2_freq1 = air_resist_ratio.loc[freq1, temp2]
+        coef_temp2_freq2 = air_resist_ratio.loc[freq2, temp2]
+
+        weight_temp1 = (temp2 - temp) / (temp2 - temp1)
+        weight_temp2 = (temp - temp1) / (temp2 - temp1)
+        weight_freq1 = (freq2 - freq) / (freq2 - freq1)
+        weight_freq2 = (freq - freq1) / (freq2 - freq1)
+
+        coef_freq1 = coef_temp1_freq1 * weight_temp1 + coef_temp2_freq1 * weight_temp2
+        coef_freq2 = coef_temp1_freq2 * weight_temp1 + coef_temp2_freq2 * weight_temp2
+
+        final_coef = coef_freq1 * weight_freq1 + coef_freq2 * weight_freq2
+
+        return final_coef
+
+    if len(nearest_temp) == 2 and len(nearest_freq) == 1:
+        temp1, temp2 = nearest_temp
+        freq1 = nearest_freq[0]
+
+        coef_temp1 = air_resist_ratio.loc[freq1, temp1]
+        coef_temp2 = air_resist_ratio.loc[freq1, temp2]
+
+        weight_temp1 = (temp2 - temp) / (temp2 - temp1)
+        weight_temp2 = (temp - temp1) / (temp2 - temp1)
+
+        return coef_temp1 * weight_temp1 + coef_temp2 * weight_temp2
+
+    if len(nearest_temp) == 1 and len(nearest_freq) == 2:
+        temp1 = nearest_temp[0]
+        freq1, freq2 = nearest_freq
+
+        coef_freq1 = air_resist_ratio.loc[freq1, temp1]
+        coef_freq2 = air_resist_ratio.loc[freq2, temp1]
+
+        weight_freq1 = (freq2 - freq) / (freq2 - freq1)
+        weight_freq2 = (freq - freq1) / (freq2 - freq1)
+
+        return coef_freq1 * weight_freq1 + coef_freq2 * weight_freq2
+
+
+def dist_to_target_db(
+    init_noise_db, target_noise_db, geometric_mean_freq_hz, air_temperature, return_desc=False, check_temp_freq=False
+) -> float | str:
+    """
+    Calculates the distance required for a sound wave to decay from an initial noise level to a target noise level,
+    based on the geometric mean frequency of the sound and the air temperature. Optionally, can return a description
+    of the sound propagation behavior.
+
+    Args:
+        init_noise_db (float): The initial noise level of the source in decibels (dB). This is the starting sound
+            intensity.
+        target_noise_db (float): The target noise level in decibels (dB), representing the level to which the sound
+            decays over distance.
+        geometric_mean_freq_hz (float): The geometric mean frequency of the sound (in Hz). This frequency influences
+            the attenuation of sound over distance. Higher frequencies decay faster than lower ones.
+        air_temperature (float): The temperature of the air in degrees Celsius. This influences the air's resistance
+            to sound propagation.
+        return_desc (bool, optional): If set to `True`, the function will return a description of the sound decay
+            process instead of the calculated distance.
+        check_temp_freq (bool, optional): If `True`, the function will check whether the temperature and frequency
+            are within valid ranges.
+
+    Returns:
+        float or str: If `return_desc` is `False`, the function returns the distance (in meters) over which the sound
+        decays from `init_noise_db` to `target_noise_db`. If `return_desc` is `True`, a descriptive string is returned
+        explaining the calculation and the conditions.
+    """
+
+    def equation(r):
+        return l - l_ist + 20 * np.log10(r) + k * r
+
+    l_ist = init_noise_db
+    l = target_noise_db
+    k = get_air_resist_ratio(air_temperature, geometric_mean_freq_hz, check_temp_freq)
+    initial_guess = 1
+    r_solution = fsolve(equation, initial_guess)
+    if return_desc:
+        string = (
+            f"Noise level of {init_noise_db} dB "
+            f"with a geometric mean frequency of {geometric_mean_freq_hz} Hz "
+            f"at an air temperature of {air_temperature}°C decays to {target_noise_db} dB "
+            f"over a distance of {r_solution[0]} meters. Air resistance coefficient: {k}."
+        )
+        return string
+    return r_solution[0]
+
+
+def green_noise_reduce_db(geometric_mean_freq_hz, r_tree) -> float:
+    """
+    Calculates the amount of noise reduction (in dB) provided by vegetation of a given thickness at a specified
+    geometric mean frequency. The function models the reduction based on the interaction of the sound with trees or
+    vegetation.
+
+    Args:
+        geometric_mean_freq_hz (float): The geometric mean frequency of the sound (in Hz).
+        r_tree (float): The thickness or density of the vegetation (in meters).
+
+    Returns:
+        float: The noise reduction (in dB) achieved by the vegetation. This value indicates how much quieter the sound
+        will be after passing through or interacting with the vegetation of the specified thickness.
+    """
+    return round(0.08 * r_tree * ((geometric_mean_freq_hz ** (1 / 3)) / 8), 1)

objectnat/methods/noise/noise_simulation.py

@@ -35,7 +35,7 @@ def simulate_noise(
     """
     Simulates noise propagation from a set of source points considering obstacles, trees, and environmental factors.
 
-    Parameters:
+    Args:
         source_points (gpd.GeoDataFrame):
             A GeoDataFrame with one or more point geometries representing noise sources.
             Optionally, it can include 'source_noise_db' and 'geometric_mean_freq_hz' columns for per-point simulation.
@@ -53,32 +53,33 @@ def simulate_noise(
             frequencies. It's recommended to use values between 63 Hz and 8000 Hz; values outside this range will be
             clamped to the nearest boundary for the sound absorption coefficient calculation.
 
-    Optional kwargs:
-        - absorb_ratio_column (str, optional): The name of the column in the `obstacles` GeoDataFrame that contains the
+    Keyword Args:
+        absorb_ratio_column (str, optional): The name of the column in the `obstacles` GeoDataFrame that contains the
             sound absorption coefficients for each obstacle. Default is None. If not specified, all obstacles will have
             the `standart_absorb_ratio`.
-        - standart_absorb_ratio (float, optional): The default sound absorption coefficient to use for obstacles without
+        standart_absorb_ratio (float, optional): The default sound absorption coefficient to use for obstacles without
             specified values in the `absorb_ratio_column`. Default is 0.05, which is a typical value for concrete walls.
-        - trees (gpd.GeoDataFrame, optional): A GeoDataFrame containing trees or dense vegetation along the sound wave's
+        trees (gpd.GeoDataFrame, optional): A GeoDataFrame containing trees or dense vegetation along the sound wave's
             path. Trees will scatter and absorb sound waves.
-        - tree_resolution (int, optional): A resolution parameter for simulating tree interactions with sound waves.
+        tree_resolution (int, optional): A resolution parameter for simulating tree interactions with sound waves.
             Recommended values are between 2 and 16, with higher values providing more accurate simulation results.
-        - air_temperature (float, optional): The air temperature in degrees Celsius. The recommended range is from 0 to
+        air_temperature (float, optional): The air temperature in degrees Celsius. The recommended range is from 0 to
             30 degrees Celsius, as temperatures outside this range will be clipped. Temperature affects the sound
             propagation in the air.
-        - target_noise_db (float, optional): The target noise level (in dB) for the simulation. Default is 40 dB.
+        target_noise_db (float, optional): The target noise level (in dB) for the simulation. Default is 40 dB.
             Lower values may not be relevant for further analysis, as they are near the threshold of human hearing.
-        - db_sim_step (float, optional): The step size in decibels for the noise simulation. Default is 1. For more
+        db_sim_step (float, optional): The step size in decibels for the noise simulation. Default is 1. For more
             precise analysis, this can be adjusted. If the difference between `source_noise_db` and `target_noise_db`
             is not divisible by the step size, the function will raise an error.
-        - reflection_n (int, optional): The maximum number of reflections (bounces) to simulate for each sound wave.
+        reflection_n (int, optional): The maximum number of reflections (bounces) to simulate for each sound wave.
             Recommended values are between 1 and 3. Larger values will result in longer simulation times.
-        - dead_area_r (float, optional): A debugging parameter that defines the radius of the "dead zone" for reflections.
+        dead_area_r (float, optional): A debugging parameter that defines the radius of the "dead zone" for reflections.
             Points within this area will not generate reflections. This is useful to prevent the algorithm from getting
             stuck in corners or along building walls.
-        - use_parallel (bool, optional): Whether to use ProcessPool for task distribution or not. Default is True.
+        use_parallel (bool, optional): Whether to use ProcessPool for task distribution or not. Default is True.
+
     Returns:
-        (gpd.GeoDataFrame): A GeoDataFrame containing the noise simulation results, including noise levels and geometries
+        gpd.GeoDataFrame: A GeoDataFrame containing the noise simulation results, including noise levels and geometries
             of the affected areas. Each point's simulation results will be merged into a single GeoDataFrame.
     """
     # Obstacles args

objectnat/methods/noise/noise_simulation_simplified.py

@@ -31,9 +31,10 @@ def calculate_simplified_noise_frame(
     Args:
         noise_sources (gpd.GeoDataFrame): A GeoDataFrame containing geometries of noise sources (Point, LineString,
             or Polygon). Each feature must have the following two columns:
-                - 'source_noise_db': Initial sound level at the source, in decibels (dB).
-                - 'geometric_mean_freq_hz': Characteristic sound frequency (Hz) used to model distance-based
-                  attenuation.
+
+            - 'source_noise_db': Initial sound level at the source, in decibels (dB).
+            - 'geometric_mean_freq_hz': Characteristic sound frequency (Hz) used to model distance-based attenuation.
+
             Values in 'source_noise_db' must not exceed the physical maximum of 194 dB. Missing or NaN values in
             required fields will raise an error.
 
@@ -45,21 +46,21 @@ def calculate_simplified_noise_frame(
             attenuation model of sound in the atmosphere. Temperatures significantly outside the typical 0–30°C
             range may lead to inaccurate results.
 
-    Optional kwargs:
-        - target_noise_db (float, optional): The minimum sound level threshold (in dB) to be modeled. Any value below
+    Keyword Args:
+        target_noise_db (float, optional): The minimum sound level threshold (in dB) to be modeled. Any value below
             this threshold is considered insignificant and will be excluded from the resulting noise frame.
             Default is 40 dB.
-        - db_sim_step (float, optional): The simulation step size (in dB) used to discretize sound levels into
+        db_sim_step (float, optional): The simulation step size (in dB) used to discretize sound levels into
             spatial layers. Default is 5. Smaller values produce more detailed output but increase computation time.
-        - linestring_point_radius (float, optional): The spacing radius (in meters) used when converting LineString
+        linestring_point_radius (float, optional): The spacing radius (in meters) used when converting LineString
             geometries into distributed point sources for simulation. Default is 30. Reducing this value improves
             detail along long lines.
-        - polygon_point_radius (float, optional): The point spacing (in meters) for distributing sources within
+        polygon_point_radius (float, optional): The point spacing (in meters) for distributing sources within
             Polygon geometries. Default is 15. Points are sampled across the polygon’s surface and perimeter to
             represent the full sound-emitting area.
 
     Returns:
-        (gpd.GeoDataFrame): A GeoDataFrame representing simplified noise distribution areas. The output geometries
+        gpd.GeoDataFrame: A GeoDataFrame representing simplified noise distribution areas. The output geometries
             are polygons where each polygon is associated with the maximum sound level (in dB) present in that area,
             as derived from overlapping source zones. The resulting data is dissolved by noise level and returned in
             the original coordinate reference system (CRS) of the input sources.

objectnat/methods/point_clustering/__init__.py

@@ -1 +1 @@
-from .cluster_points_in_polygons import get_clusters_polygon
+from .cluster_points_in_polygons import get_clusters_polygon

objectnat/methods/point_clustering/cluster_points_in_polygons.py

@@ -39,7 +39,7 @@ def get_clusters_polygon(
     Generate cluster polygons for given points based on a specified minimum distance and minimum points per cluster.
     Optionally, calculate the relative ratio between types of points within the clusters.
 
-    Parameters:
+    Args:
         points (gpd.GeoDataFrame):
             GeoDataFrame containing the points to be clustered.
             Must include a 'service_code' column for service ratio calculations.
@@ -47,13 +47,13 @@ def get_clusters_polygon(
             Minimum distance between points to be considered part of the same cluster. Defaults to 100.
         min_point (int, optional):
             Minimum number of points required to form a cluster. Defaults to 5.
-        method (Literal["DBSCAN", "HDBSCAN"], optional):
+        method:
             The clustering method to use. Must be either "DBSCAN" or "HDBSCAN". Defaults to "HDBSCAN".
         service_code_column (str, optional):
             Column, containing service type for relative ratio in clasterized polygons. Defaults to "service_code".
 
     Returns:
-        (tuple[gpd.GeoDataFrame, gpd.GeoDataFrame]):
+        tuple[gpd.GeoDataFrame, gpd.GeoDataFrame]:
             A tuple containing the clustered polygons GeoDataFrame and the original points GeoDataFrame with cluster labels.
     """
     if method not in ["DBSCAN", "HDBSCAN"]:

objectnat/methods/provision/__init__.py

@@ -1 +1 @@
-from .provision import clip_provision, get_service_provision, recalculate_links
+from .provision import clip_provision, get_service_provision, recalculate_links