population-trend 2.0.2__tar.gz → 3.1.0__tar.gz

{population_trend-2.0.2 → population_trend-3.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: population_trend
-Version: 2.0.2
+Version: 3.1.0
 Summary: A template Python module
 Home-page: https://github.com/IslasGECI/population_trend
 Author: Ciencia de Datos • GECI
@@ -8,7 +8,7 @@ Author-email: ciencia.datos@islas.org.mx
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
-Requires-Dist: bootstrapping-tools==1.1.1
+Requires-Dist: bootstrapping-tools==2.0.0
 Requires-Dist: geci-plots
 Requires-Dist: typer
 

{population_trend-2.0.2 → population_trend-3.1.0}/population_trend/__init__.py

@@ -1,6 +1,8 @@
 """A template Python module"""
 
-__version__ = "2.0.2"
+__version__ = "3.1.0"
 from .cli import *  # noqa
 from .filter_data import *  # noqa
 from .population_growth_model import *  # noqa
+from .calculate_growth_rates import *  # noqa
+from bootstrapping_tools import *  # noqa

population_trend-3.1.0/population_trend/calculate_growth_rates.py

@@ -0,0 +1,206 @@
+from bootstrapping_tools import (
+    lambda_calculator,
+    power_law,
+    bootstrap_from_time_series,
+    get_bootstrap_deltas,
+    generate_latex_interval_string,
+    calculate_p_values,
+)
+from matplotlib.ticker import MaxNLocator
+
+import json
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+def do_nothing():
+    pass
+
+
+def fit_population_model(seasons_series, data_series):
+    parameters = lambda_calculator(seasons_series, data_series)
+    model = power_law(
+        seasons_series - seasons_series.iloc[0],
+        parameters[0],
+        parameters[1],
+    )
+    return model
+
+
+def calculate_porcentual_diff(x, y):
+    return 100 * (x - y) / y
+
+
+def generate_number_and_season_string(number, season):
+    return "{} ({})".format(
+        number,
+        season,
+    )
+
+
+def calculate_seasons_intervals(seasons):
+    years = []
+    first_index = 0
+    for index in np.where(np.diff(seasons) != 1)[0]:
+        if seasons[first_index] == seasons[index]:
+            years.append(f"{seasons[index]}")
+        else:
+            years.append(f"{seasons[first_index]}-{seasons[index]}")
+        first_index = index + 1
+    years.append(f"{seasons[first_index]}-{seasons[-1]}")
+    return years
+
+
+def calculate_interest_numbers(cantidad_nidos, model):
+    first_number = generate_number_and_season_string(
+        cantidad_nidos["Maxima_cantidad_nidos"].iloc[0],
+        cantidad_nidos["Temporada"].iloc[0],
+    )
+    first_number_calculated = generate_number_and_season_string(
+        model.iloc[0], cantidad_nidos["Temporada"].iloc[0]
+    )
+    last_number = "{{{:,.0f}}} ({})".format(
+        cantidad_nidos["Maxima_cantidad_nidos"].iloc[-1],
+        int(cantidad_nidos["Temporada"].iloc[-1]),
+    )
+    last_number_calculated = generate_number_and_season_string(
+        model.iloc[-1],
+        cantidad_nidos["Temporada"].iloc[-1],
+    )
+    return first_number, first_number_calculated, last_number, last_number_calculated
+
+
+def calculate_percent_diff_in_seasons(cantidad_nidos, model):
+    if cantidad_nidos["Maxima_cantidad_nidos"].iloc[0] == 0:
+        porcentaje_cambio = calculate_porcentual_diff(model.iloc[-1], model.iloc[0])
+    else:
+        porcentaje_cambio = calculate_porcentual_diff(
+            model.iloc[-1], cantidad_nidos["Maxima_cantidad_nidos"].iloc[0]
+        )
+    return porcentaje_cambio
+
+
+class Bootstrap_from_time_series_parameterizer:
+    def __init__(self, blocks_length=3, N=2000):
+        self.parameters = dict(
+            dataframe=None,
+            column_name="Maxima_cantidad_nidos",
+            N=N,
+            return_distribution=True,
+            blocks_length=blocks_length,
+        )
+
+    def set_data(self, data):
+        self.parameters["dataframe"] = data
+
+
+Bootstrap = dict(
+    default=Bootstrap_from_time_series_parameterizer(),
+    testing=Bootstrap_from_time_series_parameterizer(blocks_length=2, N=100),
+)
+
+
+class Bootstrap_from_time_series:
+    def __init__(self, bootstrap_parametrizer):
+        self.parameters = bootstrap_parametrizer.parameters
+        self.lambdas_distribution, self.intervals = self._calculate_distribution_and_interval()
+        self.season_series = self.parameters["dataframe"]["Temporada"]
+        self.data_series = self.parameters["dataframe"][self.parameters["column_name"]]
+        self.lambdas = [interval[0] for interval in self.intervals]
+
+    def get_distribution(self):
+        return self.lambdas_distribution
+
+    def _calculate_distribution_and_interval(self):
+        lambdas_distribution, intervals = bootstrap_from_time_series(**self.parameters)
+        return lambdas_distribution, intervals
+
+    def get_inferior_central_and_superior_limit(self):
+        inferior_limit, central, superior_limit = get_bootstrap_deltas(
+            self.lambdas, **{"decimals": 2}
+        )
+        return inferior_limit, central, superior_limit
+
+    def get_lambda_interval_latex_string(self):
+        lambda_latex_string = generate_latex_interval_string(self.lambdas, **{"decimals": 2})
+        return lambda_latex_string
+
+    def generate_season_interval(self):
+        return "({}-{})".format(
+            self.season_series.min(axis=0),
+            self.season_series.max(axis=0),
+        )
+
+    def get_monitored_seasons(self):
+        monitored_seasons = np.sort(self.season_series.astype(int).unique())
+        if len(monitored_seasons) == 1:
+            return f"{monitored_seasons[0]}"
+        else:
+            seasons_intervals = calculate_seasons_intervals(monitored_seasons)
+            return ",".join(seasons_intervals)
+
+    def xxfit_population_model(self):
+        parameters = lambda_calculator(self.season_series, self.data_series)
+        model = power_law(
+            self.season_series - self.season_series.iloc[0],
+            parameters[0],
+            parameters[1],
+        )
+        return model
+
+    def save_intervals(self, output_path):
+        json_dict = {
+            "intervals": list(self.intervals),
+            "lambda_latex_interval": self.get_lambda_interval_latex_string(),
+        }
+        with open(output_path, "w") as file:
+            json.dump(json_dict, file)
+
+
+def calculate_growth_rates_table(bootstrap: Bootstrap_from_time_series_parameterizer):
+    bootstraper = Bootstrap_from_time_series(bootstrap)
+    df = bootstrap.parameters["dataframe"]
+    model = bootstraper.xxfit_population_model()
+    inferior_limit, central, superior_limit = bootstraper.get_inferior_central_and_superior_limit()
+    lambda_latex_string = bootstraper.get_lambda_interval_latex_string()
+    bootstrap_distribution = bootstraper.get_distribution()
+    lambdas_distribution = [interval[0] for interval in bootstrap_distribution]
+    p_value_mayor, p_value_menor = calculate_p_values(lambdas_distribution)
+    intervalo = bootstraper.generate_season_interval()
+    monitored_seasons = bootstraper.get_monitored_seasons()
+    porcentaje_cambio = calculate_percent_diff_in_seasons(df, model)
+    (
+        first_number,
+        _,
+        last_number,
+        last_number_calculated,
+    ) = calculate_interest_numbers(df, model)
+    return [
+        intervalo,
+        first_number,
+        last_number,
+        last_number_calculated,
+        lambda_latex_string,
+        df["Latitud"].iloc[0],
+        central,
+        f"-{inferior_limit}",
+        f"+{superior_limit}",
+        f"{{{int(porcentaje_cambio):,}}}",
+        p_value_mayor,
+        p_value_menor,
+        monitored_seasons,
+    ]
+
+
+def set_axis_plot_config(ax):
+    ax.xaxis.set_major_locator(MaxNLocator(integer=True))
+    ax.spines["right"].set_visible(False)
+    ax.spines["top"].set_visible(False)
+    plt.yticks(rotation=90, size=20)
+    locs_x, labels_x = plt.xticks()
+    locs_y, labels_y = plt.yticks()
+    plt.xticks(locs_x[1:], size=20)
+    plt.xlim(locs_x[0], locs_x[-1])
+    plt.ylim(0, locs_y[-1])
+    plt.xlabel("Año", size=20, labelpad=10)
+    plt.ylabel("Cantidad de parejas reproductoras", size=20)

{population_trend-2.0.2 → population_trend-3.1.0}/population_trend/cli.py

@@ -37,15 +37,15 @@ def plot_population_trend(
     lambda_latex = intervals_json["lambda_latex_interval"]
 
     Modelo_Tendencia_Poblacional = Population_Trend_Model(fit_data, intervals, variable_of_interest)
-    Graficador = Plotter_Population_Trend_Model()
+    Graficador = Plotter_Population_Trend_Model(fit_data)
     Graficador.plot_smooth(Modelo_Tendencia_Poblacional)
     Graficador.plot_model(Modelo_Tendencia_Poblacional)
-    Graficador.plot_data(Modelo_Tendencia_Poblacional, fit_data[variable_of_interest])
+    Graficador.plot_data(variable_of_interest)
     legend_mpl_object = Graficador.set_legend_location(island)
-    Graficador.set_x_lim(Modelo_Tendencia_Poblacional)
+    Graficador.set_x_lim()
     Graficador.set_y_lim(fit_data[variable_of_interest])
     Graficador.set_labels()
-    Graficador.set_ticks(Modelo_Tendencia_Poblacional)
+    Graficador.set_ticks()
     Graficador.draw()
     Graficador.plot_growth_rate_interval(legend_mpl_object, lambda_latex)
     Graficador.savefig(island, output_path)

{population_trend-2.0.2 → population_trend-3.1.0}/population_trend/population_growth_model.py

@@ -4,12 +4,17 @@ from bootstrapping_tools import power_law, lambda_calculator
 import matplotlib.pyplot as plt
 
 
-def resample_seasons(df):
+def normalize_seasons(df):
     first_season = int(df.Temporada.min())
     last_season = int(df.Temporada.max())
     return np.linspace(first_season, last_season, last_season - first_season + 1).astype(int)
 
 
+def calculate_model_domain(data):
+    last_value = data.Temporada.max() - data.Temporada.min()
+    return np.linspace(0, last_value, 100)
+
+
 def calculate_upper_limit(data_interest_variable):
     upper_limit = roundup(
         data_interest_variable.max() * 1.2,
@@ -21,36 +26,36 @@ def calculate_upper_limit(data_interest_variable):
 class Population_Trend_Model:
     def __init__(self, fit_data, intervals, interest_variable):
         self.intervals = intervals
-        self.plot_seasons = fit_data["Temporada"][:] - fit_data["Temporada"].iloc[0] + 1
-        self.ticks_text = resample_seasons(fit_data)
-        self.ticks_positions = ticks_positions_array(self.ticks_text)
-        self.time_to_model = np.linspace(
-            self.ticks_positions.min(), self.ticks_positions.max(), 100
-        )
+        self.model_domain = calculate_model_domain(fit_data)
         self.initial_population = lambda_calculator(
             fit_data["Temporada"], fit_data[interest_variable]
         )[1]
 
     @property
     def model_min(self):
-        return power_law(self.time_to_model, self.intervals[0], self.initial_population)
+        return power_law(self.model_domain, self.intervals[0], self.initial_population)
 
     @property
     def model_med(self):
-        return power_law(self.time_to_model, self.intervals[1], self.initial_population)
+        return power_law(self.model_domain, self.intervals[1], self.initial_population)
 
     @property
     def model_max(self):
-        return power_law(self.time_to_model, self.intervals[2], self.initial_population)
+        return power_law(self.model_domain, self.intervals[2], self.initial_population)
 
 
 class Plotter_Population_Trend_Model:
-    def __init__(self):
+    def __init__(self, data):
         self.fig, self.ax = geci_plot()
+        self.data = data
+        self.plot_seasons = self.data["Temporada"][:] - self.data["Temporada"].iloc[0] + 1
+        self.ticks_text = normalize_seasons(self.data)
+        self.ticks_positions = ticks_positions_array(self.ticks_text)
+        self.plot_domain = np.linspace(self.ticks_positions.min(), self.ticks_positions.max(), 100)
 
     def plot_smooth(self, Population_Trend_Model):
         self.ax.fill_between(
-            Population_Trend_Model.time_to_model,
+            self.plot_domain,
             Population_Trend_Model.model_min,
             Population_Trend_Model.model_max,
             alpha=0.2,
@@ -60,17 +65,17 @@ class Plotter_Population_Trend_Model:
 
     def plot_model(self, Population_Trend_Model):
         plt.plot(
-            Population_Trend_Model.time_to_model,
+            self.plot_domain,
             Population_Trend_Model.model_med,
             label="Population growth model",
             color="b",
         )
         return self.fig
 
-    def plot_data(self, Population_Trend_Model, fit_data):
+    def plot_data(self, variable_to_bootstrap):
         plt.plot(
-            Population_Trend_Model.plot_seasons,
-            fit_data,
+            self.plot_seasons,
+            self.data[variable_to_bootstrap],
             "-Dk",
             label="Active Nests",
         )
@@ -92,20 +97,20 @@ class Plotter_Population_Trend_Model:
             calculate_upper_limit(fit_data),
         )
 
-    def set_x_lim(self, Population_Trend_Model):
+    def set_x_lim(self):
         plt.xlim(
-            Population_Trend_Model.ticks_positions.min() - 0.2,
-            Population_Trend_Model.ticks_positions.max(),
+            self.ticks_positions.min() - 0.2,
+            self.ticks_positions.max(),
         )
 
     def set_labels(self):
         plt.ylabel("Number of breeding pairs", size=20)
         plt.xlabel("Seasons", size=20)
 
-    def set_ticks(self, Population_Trend_Model):
+    def set_ticks(self):
         plt.xticks(
-            Population_Trend_Model.ticks_positions,
-            Population_Trend_Model.ticks_text,
+            self.ticks_positions,
+            self.ticks_text,
             rotation=90,
             size=20,
         )

{population_trend-2.0.2 → population_trend-3.1.0}/pyproject.toml

@@ -10,7 +10,7 @@ description-file = "README.md"
 home-page = "https://github.com/IslasGECI/population_trend"
 module = "population_trend"
 requires = [
-	"bootstrapping-tools==1.1.1",
+	"bootstrapping-tools==2.0.0",
 	"geci-plots",
 	"typer"
 ]