population-trend 5.7.1__tar.gz → 5.8.0__tar.gz

{population_trend-5.7.1 → population_trend-5.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: population_trend
-Version: 5.7.1
+Version: 5.8.0
 Summary: A population growth model package
 Home-page: https://github.com/IslasGECI/population_trend
 Author: Ciencia de Datos • GECI

{population_trend-5.7.1 → population_trend-5.8.0}/population_trend/__init__.py

@@ -1,10 +1,10 @@
 """A population growth model package"""
 
-__version__ = "5.7.1"
+__version__ = "5.8.0"
+from .calculate_growth_rates import *  # noqa
 from .cli import *  # noqa
 from .filter_data import *  # noqa
-from .population_growth_model import *  # noqa
 from .plotter_growth_rate import *  # noqa
-from .calculate_growth_rates import *  # noqa
+from .plotter_population_trend_from_cpue import *  # noqa
+from .population_growth_model import *  # noqa
 from .regional_lambdas import *  # noqa
-from bootstrapping_tools import *  # noqa

{population_trend-5.7.1 → population_trend-5.8.0}/population_trend/cli.py

@@ -3,6 +3,9 @@ from population_trend.population_growth_model import (
     Population_Trend_Model,
     Plotter_Population_Trend_Model,
 )
+from population_trend.plotter_population_trend_from_cpue import (
+    Plotter_Population_Trend_Model_From_CPUE,
+)
 from population_trend.calculate_growth_rates import (
     Bootstrap_from_time_series_parametrizer,
     Bootstrap_from_time_series,
@@ -15,6 +18,7 @@ from population_trend.regional_lambdas import (
 from population_trend.plotter_growth_rate import Plotter_Growth_Rate
 
 import pandas as pd
+from typing_extensions import Annotated
 import typer
 import json
 import matplotlib.pyplot as plt
@@ -24,12 +28,14 @@ app = typer.Typer(help="Write filtered burrows data by species and island")
 
 @app.command(help="Write json with bootstrap intervals")
 def write_bootstrap_intervals_json(
-    data_path: str = "data/processed/gumu_guadalupe_burrows.csv",
-    blocks_length: int = 3,
-    bootstrap_number: int = 2000,
-    variable_of_interest: str = "Maxima_cantidad_nidos",
-    alpha: float = 0.05,
-    output_path: str = "reports/non-tabular/gumu_guadalupe_boostrap_intervals.json",
+    data_path: Annotated[str, typer.Option()] = "data/processed/gumu_guadalupe_burrows.csv",
+    blocks_length: Annotated[int, typer.Option()] = 3,
+    bootstrap_number: Annotated[int, typer.Option()] = 2000,
+    variable_of_interest: Annotated[str, typer.Option()] = "Maxima_cantidad_nidos",
+    alpha: Annotated[float, typer.Option()] = 0.05,
+    output_path: Annotated[
+        str, typer.Option()
+    ] = "reports/non-tabular/gumu_guadalupe_boostrap_intervals.json",
 ):
     data = pd.read_csv(data_path)
     parametrizer = Bootstrap_from_time_series_parametrizer(
@@ -45,10 +51,10 @@ def write_bootstrap_intervals_json(
 
 @app.command(help="Write csv with ouput-path")
 def write_burrows_by_species_and_island(
-    data_path: str = "data/processed/subset_burrows_data.csv",
-    species: str = "Guadalupe Murrelet",
-    island: str = "Guadalupe",
-    output_path: str = "data/processed/gumu_guadalupe_burrows.csv",
+    data_path: Annotated[str, typer.Option()] = "data/processed/subset_burrows_data.csv",
+    species: Annotated[str, typer.Option()] = "Guadalupe Murrelet",
+    island: Annotated[str, typer.Option()] = "Guadalupe",
+    output_path: Annotated[str, typer.Option()] = "data/processed/gumu_guadalupe_burrows.csv",
 ):
     data = pd.read_csv(data_path)
     filtered = filter_by_species_and_island(data, species, island)
@@ -57,35 +63,56 @@ def write_burrows_by_species_and_island(
 
 @app.command(help="Plot population trend")
 def plot_population_trend(
-    data_path: str = "",
-    intervals_path: str = "",
-    island: str = "Guadalupe",
-    variable_of_interest: str = "Maxima_cantidad_nidos",
+    data_path: Annotated[str, typer.Option()],
+    intervals_path: Annotated[str, typer.Option()],
+    island: Annotated[str, typer.Option()] = "Guadalupe",
+    variable_of_interest: Annotated[str, typer.Option()] = "Maxima_cantidad_nidos",
     output_path=None,
 ):
     fit_data = pd.read_csv(data_path)
-    with open(intervals_path, "r") as read_file:
-        intervals_json = json.load(read_file)
+    intervals_json = read_json(intervals_path)
     lambda_latex = intervals_json["lambda_latex_interval"]
 
     Modelo_Tendencia_Poblacional = Population_Trend_Model(
         fit_data, intervals_json, variable_of_interest
     )
     Graficador = Plotter_Population_Trend_Model(fit_data, Modelo_Tendencia_Poblacional)
-    Graficador.plot_smooth(Modelo_Tendencia_Poblacional)
-    Graficador.plot_model(Modelo_Tendencia_Poblacional)
+    Graficador.plot_smooth()
+    Graficador.plot_model()
     Graficador.plot_data()
     legend_mpl_object = Graficador.set_legend_location(island)
     Graficador.plot_growth_rate_interval(legend_mpl_object, lambda_latex)
     Graficador.savefig(island, output_path)
 
 
+@app.command(help="Plot population trend from CPUE")
+def plot_population_trend_from_cpue(
+    data_path: Annotated[str, typer.Option()],
+    intervals_path: Annotated[str, typer.Option()],
+    variable_of_interest: Annotated[str, typer.Option()],
+    output_path: Annotated[str, typer.Option()],
+):
+    fit_data = pd.read_csv(data_path)
+    intervals_json = read_json(intervals_path)
+    lambda_latex = intervals_json["lambda_latex_interval"]
+
+    Modelo_Tendencia_Poblacional = Population_Trend_Model(
+        fit_data, intervals_json, variable_of_interest
+    )
+    Graficador = Plotter_Population_Trend_Model_From_CPUE(fit_data, Modelo_Tendencia_Poblacional)
+    Graficador.plot_smooth()
+    Graficador.plot_model()
+    Graficador.plot_data()
+    Graficador.plot_growth_rate_interval(lambda_latex)
+    Graficador.savefig(output_path)
+
+
 @app.command(help="Write json with the regional trends")
 def write_regional_trends(
-    config_path: str = "data/processed/gumu_guadalupe_burrows.json",
-    region: str = "",
-    regional_trend_path: str = "",
-    alpha: float = 0.05,
+    config_path: Annotated[str, typer.Option()] = "data/processed/gumu_guadalupe_burrows.json",
+    region: Annotated[str, typer.Option()] = "",
+    regional_trend_path: Annotated[str, typer.Option()] = "",
+    alpha: Annotated[float, typer.Option()] = 0.05,
 ):
     concatenator = Island_Bootstrap_Distribution_Concatenator(config_path)
     concatenator.set_region(region)
@@ -96,7 +123,9 @@ def write_regional_trends(
 
 @app.command()
 def plot_growth_rate(
-    intervals_california: str = "", intervals_pacific: str = "", output_path: str = ""
+    intervals_california: Annotated[str, typer.Option()],
+    intervals_pacific: Annotated[str, typer.Option()],
+    output_path: Annotated[str, typer.Option()],
 ):
     lambdas_intervals_california = read_json(intervals_california)
     lambdas_intervals_pacific = read_json(intervals_pacific)

population_trend-5.8.0/population_trend/plotter_population_trend_from_cpue.py

@@ -0,0 +1,44 @@
+from population_trend.population_growth_model import Plotter_Population_Trend_Model
+
+import matplotlib.pyplot as plt
+
+
+class Plotter_Population_Trend_Model_From_CPUE(Plotter_Population_Trend_Model):
+    def set_labels(self):
+        plt.ylabel("CPUE", size=20)
+        plt.xlabel("Seasons", size=20)
+
+    def plot_data(self):
+        plt.plot(
+            self.plot_seasons,
+            self.data[self.interest_variable],
+            "-Dk",
+            label="Maximum CPUE",
+        )
+
+    def set_legend_location(
+        self,
+    ):
+        legend_mpl_object = plt.legend(loc="best")
+        return legend_mpl_object
+
+    def plot_growth_rate_interval(self, lambda_interval):
+        legend_mpl_object = self.set_legend_location()
+        legend_box_positions = legend_mpl_object.get_window_extent()
+        self.ax.annotate(
+            r"$\lambda =$ {}".format(lambda_interval),
+            (legend_box_positions.p0[0], legend_box_positions.p1[1] - 320),
+            xycoords="figure pixels",
+            fontsize=25,
+            color="k",
+            alpha=1,
+        )
+
+    def savefig(self, output_path):
+        self.set_x_lim()
+        self.set_y_lim()
+        self.set_labels()
+        self.set_ticks()
+        self.draw()
+        transparent_background = True
+        plt.savefig(output_path, dpi=300, transparent=transparent_background)

{population_trend-5.7.1 → population_trend-5.8.0}/population_trend/population_growth_model.py

@@ -59,53 +59,54 @@ class Plotter_Population_Trend_Model:
         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)
+        self.population_model = population_model
         self.interest_variable = population_model.interest_variable
 
-    def plot_smooth(self, Population_Trend_Model):
+    def plot_smooth(self):
         self.ax.fill_between(
             self.plot_domain,
-            Population_Trend_Model.min_model,
-            Population_Trend_Model.med_model,
+            self.population_model.min_model,
+            self.population_model.med_model,
             label="Confidence zone",
             color="powderblue",
         )
         self.ax.fill_between(
             self.plot_domain,
-            Population_Trend_Model.med_model,
-            Population_Trend_Model.max_model,
+            self.population_model.med_model,
+            self.population_model.max_model,
             color="powderblue",
         )
         self.ax.fill_between(
             self.plot_domain,
-            Population_Trend_Model.min_model,
-            Population_Trend_Model.max_model,
+            self.population_model.min_model,
+            self.population_model.max_model,
             color="powderblue",
         )
-        number_of_samples = len(Population_Trend_Model.bootstrap_distribution)
+        number_of_samples = len(self.population_model.bootstrap_distribution)
         for i in range(0, number_of_samples - 1, 10):
             self.ax.fill_between(
                 self.plot_domain,
-                Population_Trend_Model.intern_model(i),
-                Population_Trend_Model.med_model,
+                self.population_model.intern_model(i),
+                self.population_model.med_model,
                 color="powderblue",
             )
             self.ax.fill_between(
                 self.plot_domain,
-                Population_Trend_Model.intern_model(i),
-                Population_Trend_Model.intern_model(i + 1),
+                self.population_model.intern_model(i),
+                self.population_model.intern_model(i + 1),
                 color="powderblue",
             )
         self.ax.fill_between(
             self.plot_domain,
-            Population_Trend_Model.intern_model(i + 1),
-            Population_Trend_Model.med_model,
+            self.population_model.intern_model(i + 1),
+            self.population_model.med_model,
             color="powderblue",
         )
 
-    def plot_model(self, Population_Trend_Model):
+    def plot_model(self):
         plt.plot(
             self.plot_domain,
-            Population_Trend_Model.med_model,
+            self.population_model.med_model,
             label="Population growth model",
             color="b",
         )
@@ -167,15 +168,10 @@ class Plotter_Population_Trend_Model:
         self.draw()
         transparent_background = True
         if output_path is None:
-            plt.savefig(
-                "reports/figures/cormorant_population_trend_{}".format(
-                    islet.replace(" ", "_").lower()
-                ),
-                dpi=300,
-                transparent=transparent_background,
+            output_path = "reports/figures/cormorant_population_trend_{}".format(
+                islet.replace(" ", "_").lower()
             )
-        else:
-            plt.savefig(output_path, dpi=300, transparent=transparent_background)
+        plt.savefig(output_path, dpi=300, transparent=transparent_background)
 
     def set_legend_location(self, islet):
         legend_mpl_object = plt.legend(loc="best")

{population_trend-5.7.1 → population_trend-5.8.0}/population_trend/regional_lambdas.py

@@ -81,22 +81,25 @@ class Calculator_Regional_Lambdas_Intervals(Bootstrap_from_time_series):
     def get_hypotesis_statement(self):
         rounded_p_values = self._round_p_values()
         if self.p_values[1] < self.alpha:
-            return f"La población está decreciendo, $\\lambda$ CI {self.lambda_latex_interval} con una significancia $p =$ {rounded_p_values[1]}"
+            return f"La población está decreciendo, $\\lambda$ CI {self.lambda_latex_interval} con una significancia $p {rounded_p_values[1]}$"
         if self.p_values[0] < self.alpha:
-            return f"La población está creciendo, $\\lambda$ CI {self.lambda_latex_interval} con una significancia $p =$ {rounded_p_values[0]}"
-        return f"No podemos concluir si la población está creciendo o decreciendo. El valor $p$ calculado resultó mayor que $\\alpha =$ {self.alpha} para ambas hipótesis nulas. Para $\\lambda>1: p =$ {rounded_p_values[1]}; para $\\lambda<1: p =$ {rounded_p_values[0]}"
+            return f"La población está creciendo, $\\lambda$ CI {self.lambda_latex_interval} con una significancia $p {rounded_p_values[0]}$"
+        return f"No podemos concluir si la población está creciendo o decreciendo. El valor $p$ calculado resultó mayor que $\\alpha =$ {self.alpha} para ambas hipótesis nulas. Para $\\lambda>1: p {rounded_p_values[1]}$; para $\\lambda<1: p {rounded_p_values[0]}$"
 
     def _round_p_values(self):
         rounded_p_values = np.round(self.p_values, 3)
-        return [str(p_value)[1:5] if p_value >= 0.001 else "<.001" for p_value in rounded_p_values]
+        return [
+            "= " + str(p_value)[1:5] if p_value >= 0.001 else "< .001"
+            for p_value in rounded_p_values
+        ]
 
     def get_hypotesis_statement_en(self):
         rounded_p_values = self._round_p_values()
         if self.p_values[1] < self.alpha:
-            return f"The population is decreasing, $\\lambda$ CI {self.lambda_latex_interval} with a significance $p =$ {rounded_p_values[1]}"
+            return f"The population is decreasing, $\\lambda$ CI {self.lambda_latex_interval} with a significance $p {rounded_p_values[1]}$"
         if self.p_values[0] < self.alpha:
-            return f"The population is increasing, $\\lambda$ CI {self.lambda_latex_interval} with a significance $p =$ {rounded_p_values[0]}"
-        return f"We can not conclude if the population is increasing or decreasing. The calculated $p$-value is higher than the $\\alpha =$ {self.alpha} for both null hypothesis tests. For $\\lambda>1: p =$ {rounded_p_values[1]}; for $\\lambda<1: p =$ {rounded_p_values[0]}"
+            return f"The population is increasing, $\\lambda$ CI {self.lambda_latex_interval} with a significance $p {rounded_p_values[0]}$"
+        return f"We can not conclude if the population is increasing or decreasing. The calculated $p$-value is higher than the $\\alpha =$ {self.alpha} for both null hypothesis tests. For $\\lambda>1: p {rounded_p_values[1]}$; for $\\lambda<1: p {rounded_p_values[0]}$"
 
     def save_intervals(self, output_path):
         json_dict = {