geocif 0.1.51__tar.gz → 0.1.52__tar.gz

{geocif-0.1.51/geocif.egg-info → geocif-0.1.52}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: geocif
-Version: 0.1.51
+Version: 0.1.52
 Summary: Models to visualize and forecast crop conditions and yields
 Home-page: https://ritviksahajpal.github.io/yield_forecasting/
 Author: Ritvik Sahajpal

{geocif-0.1.51 → geocif-0.1.52}/geocif/analysis.py

@@ -165,7 +165,6 @@ class Geoanalysis:
         df_metrics = self._process_metrics(df_metrics)
 
         self._plot_metrics(df_metrics)
-
         df_regional_metrics_by_year = self._compute_regional_metrics(
             df, by="Harvest Year"
         )
@@ -177,9 +176,9 @@ class Geoanalysis:
         self._store_results(
             df_metrics, df_regional_metrics, df_regional_metrics_by_year
         )
-
         df_national_yield = self._compute_national_yield(df)
         self._plot_national_yield(df_national_yield)
+        self._plot_regional_yield_scatter(df)
 
         return df_metrics, df_regional_metrics, df_national_yield
 
@@ -250,12 +249,15 @@ class Geoanalysis:
         else:
             return df.groupby(cols).apply(self.regional_metrics).reset_index()
 
-    def _select_top_years(self, df_regional_metrics):
-        return (
-            df_regional_metrics.groupby(["Country", "Region"])
-            .apply(lambda x: self.select_top_N_years(x, 10))
-            .reset_index(drop=True)
-        )
+    def _select_top_years(self, df_regional_metrics, top_N=-1):
+        if top_N == -1:
+            return df_regional_metrics
+        else:
+            return (
+                df_regional_metrics.groupby(["Country", "Region"])
+                .apply(lambda x: self.select_top_N_years(x, 10))
+                .reset_index(drop=True)
+            )
 
     def _average_mape(self, df_regional_metrics):
         cols = [
@@ -338,18 +340,29 @@ class Geoanalysis:
 
             con.commit()
 
-    def _compute_national_yield(self, df):
-        # Compute observed and predicted national yield by multiplying Yield (tn per ha) by Area (ha)
+    def _compute_national_yield(self, df_region):
+        # Define column names
         observed = "Observed Yield (tn per ha)"
         predicted = "Predicted Yield (tn per ha)"
         area_ha = "Area (ha)"
 
-        df.loc[:, observed] = df[observed] * df[area_ha]
-        df.loc[:, predicted] = df[predicted] * df[area_ha]
+        df_tmp = df_region.copy()
+
+        # Fill
+        df_tmp[area_ha] = df_tmp.groupby("Country")[area_ha].transform(lambda x: x.fillna(x.median()))
+
+        # Log that we are filling missing values with the median
+        self.logger.info(
+            f"Filling missing values in {area_ha} with the median for each country"
+        )
+
+        # Compute observed and predicted national yield by multiplying Yield (tn per ha) by Area (ha)
+        df_tmp[observed] = df_tmp[observed] * df_tmp[area_ha]
+        df_tmp[predicted] = df_tmp[predicted] * df_tmp[area_ha]
 
         # Group by Country and Harvest Year, then sum the National Yield and Area
         df_national_yield = (
-            df.groupby(["Country", "Harvest Year"])
+            df_tmp.groupby(["Country", "Harvest Year"])
             .agg({observed: "sum", predicted: "sum", area_ha: "sum"})
             .reset_index()
         )
@@ -364,53 +377,116 @@ class Geoanalysis:
 
         return df_national_yield
 
-    def _plot_national_yield(self, df_national_yield, use_different_colors=True):
-        from sklearn.metrics import (
-            mean_squared_error,
-            r2_score,
-            mean_absolute_percentage_error,
-        )
+    def _plot_regional_yield_scatter(self, df):
+        """
+        Plot observed vs predicted yield for all regions and all years.
+        """
+        from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_percentage_error
 
-        x = df_national_yield["Harvest Year"]
-        y_observed = df_national_yield["Observed Yield (tn per ha)"]
-        y_predicted = df_national_yield["Predicted Yield (tn per ha)"]
+        # Ensure 'Harvest Year' is numeric
+        df["Harvest Year"] = pd.to_numeric(df["Harvest Year"], errors="coerce")
 
+        # Extract data
+        y_observed = df["Observed Yield (tn per ha)"]
+        y_predicted = df["Predicted Yield (tn per ha)"]
+        years = df["Harvest Year"]
+
+        # Generate colors for years
+        cmap = plt.cm.viridis  # Colormap for years
+        norm = plt.Normalize(vmin=years.min(), vmax=years.max())  # Normalize years to colormap
+        colors = [cmap(norm(year)) for year in years]
+
+        # Create the plot
         with plt.style.context("science"):
-            plt.figure(figsize=(10, 6))
+            fig, ax = plt.subplots(figsize=(10, 6))
+
+            # Add gridlines
+            ax.grid(True, linestyle="--", alpha=0.5)
+
+            # Scatter plot with colors representing years
+            scatter = ax.scatter(y_observed, y_predicted, color=colors, s=50)
 
-            import palettable as pal
+            # Add 1:1 diagonal line
+            max_yield = max(y_observed.max(), y_predicted.max()) * 1.25
+            ax.plot([0, max_yield], [0, max_yield], color="gray", linestyle="--")
+
+            # Calculate and display metrics
+            rmse = np.sqrt(mean_squared_error(y_observed, y_predicted))
+            mape = mean_absolute_percentage_error(y_observed, y_predicted)
+            r2 = r2_score(y_observed, y_predicted)
+
+            textstr = f"RMSE: {rmse:.2f} tn/ha\nMAPE: {mape:.2%}\n$r^2$: {r2:.2f}"
+            ax.annotate(
+                textstr,
+                xy=(0.05, 0.95),
+                xycoords="axes fraction",
+                fontsize=12,
+                verticalalignment="top",
+            )
 
-            colors = pal.tableau.Tableau_20.mpl_colors
-            colors = colors[: len(x)]
+            # Set axis limits and labels
+            ax.set_xlabel("Observed Yield (tn/ha)")
+            ax.set_ylabel("Predicted Yield (tn/ha)")
+            ax.set_xlim(0, max_yield)
+            ax.set_ylim(0, max_yield)
 
-            # Add dashed gray grid lines with alpha=0.5
-            plt.grid(True, linestyle="--", alpha=0.5)
+            # Add colorbar for years
+            sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)
+            sm.set_array([])
+            cbar = fig.colorbar(sm, ax=ax, aspect=50, pad=0.02)
+            cbar.set_label("Harvest Year")
 
-            for i in range(len(x)):
-                plt.scatter(y_observed[i], y_predicted[i], color=colors[i], label=x[i])
+            # Set equispaced ticks for exactly 5 points
+            ticks = np.linspace(years.min(), years.max(), 5, dtype=int)  # 5 equispaced ticks
+            cbar.set_ticks(ticks)
+            cbar.ax.set_yticklabels([str(tick) for tick in ticks])
+
+            plt.tight_layout()
+
+            # Save the plot
+            fname = f"scatter_all_regions_{self.country}_{self.crop}.png"
+            plt.savefig(self.dir_analysis / fname, dpi=250)
+            plt.close()
+
+    def _plot_national_yield(self, df_national_yield):
+        from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_percentage_error
+
+        # Ensure 'Harvest Year' is numeric
+        df_national_yield["Harvest Year"] = pd.to_numeric(df_national_yield["Harvest Year"], errors="coerce")
+
+        # Extract data
+        x = df_national_yield["Harvest Year"]
+        y_observed = df_national_yield["Observed Yield (tn per ha)"]
+        y_predicted = df_national_yield["Predicted Yield (tn per ha)"]
+
+        # Generate colors for years
+        cmap = plt.cm.viridis  # Colormap for years
+        norm = plt.Normalize(vmin=x.min(), vmax=x.max())  # Normalize years to colormap
+        colors = [cmap(norm(year)) for year in x]
+
+        # Create the plot
+        with plt.style.context("science"):
+            fig, ax = plt.subplots(figsize=(10, 6))  # Explicitly define axes
 
-            # X and Y-axis range from 0 to the maximum observed/predicted yield * 1.1
             max_yield = max(y_observed.max(), y_predicted.max()) * 1.25
-            plt.xlim(0, max_yield)
-            plt.ylim(0, max_yield)
 
-            # Add a line diagonally representing 1:1
-            plt.plot([0, max_yield], [0, max_yield], color="gray", linestyle="--")
+            # Add gridlines
+            ax.grid(True, linestyle="--", alpha=0.5)
 
-            # Calculate metrics
+            # Scatter plot with uniform size and dynamic colors
+            for year, obs, pred, color in zip(x, y_observed, y_predicted, colors):
+                ax.scatter(obs, pred, color=color, s=50, label=year)
+
+            # Add 1:1 diagonal line
+            ax.plot([0, max_yield], [0, max_yield], color="gray", linestyle="--")
+
+            # Calculate and display metrics
             rmse = np.sqrt(mean_squared_error(y_observed, y_predicted))
             mape = mean_absolute_percentage_error(y_observed, y_predicted)
             r2 = r2_score(y_observed, y_predicted)
 
-            # Annotate metrics
-            textstr = "\n".join(
-                (
-                    f"RMSE: {rmse:.2f} tn/ha",
-                    f"MAPE: {mape:.2%}",
-                    f"R²: {r2:.2f}",
-                )
-            )
-            plt.gca().annotate(
+            textstr = f"RMSE: {rmse:.2f} tn/ha\nMAPE: {mape:.2%}\nr²: {r2:.2f}"
+            ax.annotate(
                 textstr,
                 xy=(0.05, 0.95),
                 xycoords="axes fraction",
@@ -418,17 +494,26 @@ class Geoanalysis:
                 verticalalignment="top",
             )
 
-            plt.xlabel("Observed Yield (tn/ha)")
-            plt.ylabel("Predicted Yield (tn/ha)")
-            # Place legend outside the plot to the right without a border
-            plt.legend(
-                title="Year",
-                bbox_to_anchor=(1.05, 1),
-                loc="upper left",
-                edgecolor="none",
-            )
+            # Set axis limits and labels
+            ax.set_xlabel("Observed Yield (tn/ha)")
+            ax.set_ylabel("Predicted Yield (tn/ha)")
+            ax.set_xlim(0, max_yield)
+            ax.set_ylim(0, max_yield)
+
+            # Add legend for years
+            sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)
+            sm.set_array([])
+            cbar = fig.colorbar(sm, ax=ax, aspect=50, pad=0.02)  # Specify the axis explicitly
+            cbar.set_label("Harvest Year")
+
+            # Set equispaced ticks for exactly 5 points
+            ticks = np.linspace(x.min(), x.max(), 5, dtype=int)  # 5 equispaced ticks
+            cbar.set_ticks(ticks)
+            cbar.ax.set_yticklabels([str(tick) for tick in ticks])
+
             plt.tight_layout()
 
+            # Save the plot
             fname = f"scatter_{self.country}_{self.crop}.png"
             plt.savefig(self.dir_analysis / fname, dpi=250)
             plt.close()
@@ -535,7 +620,11 @@ class Geoanalysis:
                 "ADM1_NAME" if self.admin_zone == "admin_1" else "ADM2_NAME"
             )
             analysis_years = df_model["Harvest Year"].unique()
-            for idx, year in enumerate(tqdm(analysis_years, desc="Map")):
+            pbar = tqdm(analysis_years, leave=False)
+            for idx, year in enumerate(pbar):
+                pbar.set_description(f"Map {year}")
+                pbar.update()
+
                 df_harvest_year = df_model[df_model["Harvest Year"] == year]
 
                 for time_period in tqdm(
@@ -563,12 +652,12 @@ class Geoanalysis:
                             cmap=pal.scientific.sequential.Bamako_20_r,
                             series="sequential",
                             show_bg=False,
-                            annotate_regions=False,
+                            annotate_regions=True,
                             annotate_region_column=annotate_region_column,
                             loc_legend="lower left",
                         )
                     #
-                    #                 #     """ Unique regions """
+                    """ Unique regions """
                     fname = f"{self.country}_{self.crop}_region_ID.png"
                     col = "Region_ID"
                     df_model[col] = df_model[col].astype(int) + 1
@@ -578,27 +667,28 @@ class Geoanalysis:
                             int(key): key
                             for key in df_time_period["Region_ID"].unique()
                         }
-                        plot.plot_df_shpfile(
-                            self.dg,  # dataframe containing adm1 name and polygon
-                            df_model,  # dataframe containing information that will be mapped
-                            dict_lup=dict_region,
-                            merge_col="Country Region",  # Column on which to merge
-                            name_country=countries,  # Plot global map
-                            name_col=col,  # Which column to plot
-                            dir_out=self.dir_plot / str(year),  # Output directory
-                            fname=fname,  # Output file name
-                            label=f"Region Cluster\n{self.crop.title()}",
-                            vmin=df_model[col].min(),
-                            vmax=df_model[col].max(),
-                            cmap=pal.tableau.Tableau_20.mpl_colors,
-                            series="qualitative",
-                            show_bg=False,
-                            alpha_feature=1,
-                            use_key=True,
-                            annotate_regions=False,
-                            annotate_region_column=annotate_region_column,
-                            loc_legend="lower left",
-                        )
+
+                        # plot.plot_df_shpfile(
+                        #     self.dg,  # dataframe containing adm1 name and polygon
+                        #     df_model,  # dataframe containing information that will be mapped
+                        #     dict_lup=dict_region,
+                        #     merge_col="Country Region",  # Column on which to merge
+                        #     name_country=countries,  # Plot global map
+                        #     name_col=col,  # Which column to plot
+                        #     dir_out=self.dir_plot / str(year),  # Output directory
+                        #     fname=fname,  # Output file name
+                        #     label=f"Region Cluster\n{self.crop.title()}",
+                        #     vmin=df_model[col].min(),
+                        #     vmax=df_model[col].max(),
+                        #     cmap=pal.tableau.Tableau_20.mpl_colors,
+                        #     series="qualitative",
+                        #     show_bg=False,
+                        #     alpha_feature=1,
+                        #     use_key=True,
+                        #     annotate_regions=True,
+                        #     annotate_region_column=annotate_region_column,
+                        #     loc_legend="lower left",
+                        # )
                     #                     breakpoint()
 
                     # """ Anomaly """
@@ -619,7 +709,7 @@ class Geoanalysis:
                     #     cmap=pal.cartocolors.diverging.Geyser_5_r,
                     #     series="sequential",
                     #     show_bg=False,
-                    #     annotate_regions=False,
+                    #     annotate_regions=True,
                     #     annotate_region_column=annotate_region_column,
                     #     loc_legend="lower left",
                     # )
@@ -640,7 +730,7 @@ class Geoanalysis:
                         cmap=pal.scientific.sequential.Bamako_20_r,
                         series="sequential",
                         show_bg=False,
-                        annotate_regions=False,
+                        annotate_regions=True,
                         annotate_region_column=annotate_region_column,
                         loc_legend="lower left",
                     )
@@ -661,32 +751,32 @@ class Geoanalysis:
                     #     cmap=pal.scientific.sequential.Bamako_20_r,
                     #     series="sequential",
                     #     show_bg=False,
-                    #     annotate_regions=False,
+                    #     annotate_regions=True,
                     #     annotate_region_column=annotate_region_column,
                     #     loc_legend="lower left",
                     # )
 
                     # Area
                     # breakpoint()
-                    # if df_time_period["Area (ha)"].notna().all():
-                    #     fname = f"{self.country}_{self.crop}_{year}_area.png"
-                    #     plot.plot_df_shpfile(
-                    #         self.dg,  # dataframe containing adm1 name and polygon
-                    #         df_time_period,  # dataframe containing information that will be mapped
-                    #         merge_col="Country Region",  # Column on which to merge
-                    #         name_country=country,  # Plot global map
-                    #         name_col="Area (ha)",  # Which column to plot
-                    #         dir_out=self.plot_dir / str(year),  # Output directory
-                    #         fname=fname,  # Output file name
-                    #         label=f"{self.predicted}\n{self.crop.title()}, {time_period}",
-                    #         vmin=df_time_period[self.predicted].min(),
-                    #         vmax=df_time_period[self.predicted].max(),
-                    #         cmap=pal.scientific.sequential.Bamako_20_r,
-                    #         series="sequential",
-                    #         show_bg=False,
-                    #         annotate_regions=True,
-                    #         loc_legend="lower left",
-                    #     )
+                    if df_time_period["Area (ha)"].notna().all():
+                        fname = f"{self.country}_{self.crop}_{year}_area.png"
+                        plot.plot_df_shpfile(
+                            self.dg,  # dataframe containing adm1 name and polygon
+                            df_time_period,  # dataframe containing information that will be mapped
+                            merge_col="Country Region",  # Column on which to merge
+                            name_country=countries,  # Plot global map
+                            name_col="Area (ha)",  # Which column to plot
+                            dir_out=self.dir_plot / str(year),  # Output directory
+                            fname=fname,  # Output file name
+                            label=f"Area (ha)\n{self.crop.title()}, {time_period}",
+                            vmin=df_time_period["Area (ha)"].min(),
+                            vmax=df_time_period["Area (ha)"].max(),
+                            cmap=pal.scientific.sequential.Bamako_20_r,
+                            series="sequential",
+                            show_bg=False,
+                            annotate_regions=True,
+                            loc_legend="lower left",
+                        )
 
     def plot_metric(self, df, metric="$r^2$"):
         with plt.style.context("science"):
@@ -788,10 +878,20 @@ class Geoanalysis:
                         "name_shapefile": name_shapefile,
                     }
 
+        shp_file = self.parser.get(country, "boundary_file")
         self.dg = gpd.read_file(
-            self.dir_shapefiles / "adm_shapefile.shp",
+            self.dir_shapefiles / shp_file,
             engine="pyogrio",
         )
+        self.admin_col_name = self.parser.get(country, "admin_col_name")
+
+        # If ADMIN0 or ADM0_NAME is not in the shapefile, then add ADM0_NAME
+        if "ADMIN0" or "ADM0_NAME" not in self.dg.columns:
+            self.dg.loc[:, "ADMIN0"] = country.title().replace("_", " ")
+        # if ADMIN1 or ADM1_NAME is not in the shapefile, then rename admin_col_name to ADM1_NAME
+        if "ADMIN1" or "ADM1_NAME" not in self.dg.columns:
+            if admin_zone == "admin_1":
+                self.dg.rename(columns={self.admin_col_name: "ADMIN1"}, inplace=True)
 
         # Hack rename Tanzania to United Republic of Tanzania
         self.dg["ADMIN0"] = self.dg["ADMIN0"].replace(
@@ -813,9 +913,10 @@ class Geoanalysis:
         self.dg["Country Region"] = self.dg["Country Region"].str.cat(
             self.dg["ADM1_NAME"], sep=" "
         )
-        self.dg.loc[self.dg["ADM2_NAME"].notna(), "Country Region"] = (
-            self.dg["ADM0_NAME"] + " " + self.dg["ADM2_NAME"]
-        )
+        if "ADM2_NAME" in self.dg.columns:
+            self.dg.loc[self.dg["ADM2_NAME"].notna(), "Country Region"] = (
+                self.dg["ADM0_NAME"] + " " + self.dg["ADM2_NAME"]
+            )
         # Make it lower case
         self.dg["Country Region"] = (
             self.dg["Country Region"].str.lower().replace("_", " ")
@@ -937,7 +1038,7 @@ class RegionalMapper(Geoanalysis):
             df_tmp = df_model[
                 (df_model["% of total Area (ha)"] < 0.5)
                 & (df_model["Mean Absolute Percentage Error"] > 100)
-            ]
+                ]
 
             df_model = df_model.drop(df_tmp.index)
 
@@ -947,7 +1048,6 @@ class RegionalMapper(Geoanalysis):
                     sns.histplot(
                         group_data["Mean Absolute Percentage Error"],
                         label=label,
-                        # clip=(0, None),
                     )
 
                 # Plot a dashed gray line at x=20
@@ -958,6 +1058,17 @@ class RegionalMapper(Geoanalysis):
                 plt.ylabel("Frequency")
                 plt.legend(title="Country", title_fontsize="13")
 
+                # Adding the title at the top-right corner
+                plt.text(
+                    0.95, 0.95,  # Coordinates in axes fraction
+                    f"Model: {model}",
+                    transform=plt.gca().transAxes,
+                    fontsize=14,
+                    verticalalignment="top",
+                    horizontalalignment="right",
+                    bbox=dict(facecolor="white", alpha=0.6, edgecolor="none")
+                )
+
                 plt.tight_layout()
                 plt.savefig(self.dir_analysis / f"mape_histogram_{model}.png", dpi=250)
                 plt.close()
@@ -983,13 +1094,14 @@ class RegionalMapper(Geoanalysis):
 
             df_model = df_model.drop(df_tmp.index)
 
-            fname = f"mape_{self.crop}_{df_model['Model'].iloc[0]}.png"
             col = "Mean Absolute Percentage Error"
             countries = df_model["Country"].unique().tolist()
             countries = [country.title().replace("_", " ") for country in countries]
+            crop = df_model["Crop"].unique()[0].title().replace('_', ' ')
             df = df_model[df_model["Country"].isin(countries)]
             self.dg = self.dg[self.dg["ADM0_NAME"].isin(countries)]
 
+            fname = f"mape_{crop}_{df_model['Model'].iloc[0]}.png"
             plot.plot_df_shpfile(
                 self.dg,
                 df,
@@ -1004,7 +1116,7 @@ class RegionalMapper(Geoanalysis):
                 cmap=pal.scientific.sequential.Bamako_20_r,
                 series="sequential",
                 show_bg=False,
-                annotate_regions=False,
+                annotate_regions=True,
                 loc_legend="lower left",
             )
 
@@ -1028,8 +1140,7 @@ class RegionalMapper(Geoanalysis):
             # Draw a dashed gray line at y=20
             plt.axhline(y=20, color="gray", linestyle="--")
 
-            plt.title("Mean Absolute Percentage Error by Year")
-            plt.xlabel("Year")
+            plt.xlabel("")
             plt.ylabel("Mean Absolute Percentage Error (%)")
             plt.xticks(rotation=0)
 

{geocif-0.1.51 → geocif-0.1.52}/geocif/indices_runner_v2.py

@@ -47,7 +47,8 @@ class cei_runner(base.BaseGeo):
 
         self.dir_input = Path(self.parser.get("PATHS", "dir_input"))
         self.base_dir = Path(
-            r"D:\Users\ritvik\projects\GEOGLAM\Output\countries\nepal"
+            #r"D:\Users\ritvik\projects\GEOGLAM\Output\countries\nepal"
+            r"/gpfs/data1/cmongp1/GEOGLAM/Output/countries/nepal"
         )  # Path(self.parser.get("PATHS", "dir_crop_inputs"))
         self.do_parallel = self.parser.getboolean("DEFAULT", "do_parallel")
 

{geocif-0.1.51 → geocif-0.1.52}/geocif/ml/feature_selection.py

@@ -310,6 +310,7 @@ def select_features(X, y, method="RFE", min_features_to_select=3, threshold_nan=
         # Get the selected feature names
         selected_features = X.columns[selected_features].tolist()
 
+    # print(selected_features)
     # Filter the dataset for selected features
     X_filtered = X.loc[:, selected_features]
 

{geocif-0.1.51 → geocif-0.1.52}/geocif/playground/aa.py

@@ -1,3 +1,53 @@
+from great_tables import GT, html
+import pandas as pd
+
+# Data from the user-provided table
+data = {
+    "province": ["Bagmati", "Koshi", "Madhesh", "Gandaki", "Lumbini", "Karnali", "Sudurpashchim"],
+    "2023 prediction": [3.738, 3.708, 3.583, 3.726, 3.291, 3.124, 2.607],
+    "Avg (2018-2022) - MOA": [3.858, 3.712, 3.668, 3.764, 3.771, 3.371, 3.399],
+    "2024 prediction": [3.807, 3.666, 3.691, 3.757, 3.427, 2.827, 2.567],
+}
+
+# Create a DataFrame
+df = pd.DataFrame(data)
+
+# Create a styled table
+styled_table = (
+    GT(df)
+    .tab_header(
+        title="Predictions and Historical Averages by Province",
+        subtitle="Yield predictions for 2023, averages from 2018-2022, and predictions for 2024"
+    )
+    .cols_label(
+        province="Province",
+        **{
+            "2023 prediction": html("2023<br>Prediction"),
+            "Avg (2018-2022) - MOA": html("Avg<br>(2018-2022)<br>MOA"),
+            "2024 prediction": html("2024<br>Prediction")
+        }
+    )
+    .cols_width(
+        province="2%",  # Narrow province column
+        **{
+            "2023 prediction": "4%",
+            "Avg (2018-2022) - MOA": "5%",
+            "2024 prediction": "4%"
+        }
+    )
+)
+
+# Save as a PDF
+styled_table.save(
+    file="predictions_table.pdf",
+    scale=1.0,  # Keep the scale reasonable
+    web_driver="chrome",  # Requires Chrome installed
+    window_size=(1200, 800),  # Adjust window size to make the table compact
+)
+
+print("Table saved as predictions_table.pdf")
+
+breakpoint()
 import pandas as pd
 import numpy as np
 import os

{geocif-0.1.51 → geocif-0.1.52/geocif.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: geocif
-Version: 0.1.51
+Version: 0.1.52
 Summary: Models to visualize and forecast crop conditions and yields
 Home-page: https://ritviksahajpal.github.io/yield_forecasting/
 Author: Ritvik Sahajpal

{geocif-0.1.51 → geocif-0.1.52}/setup.py

@@ -50,6 +50,6 @@ setup(
     test_suite="tests",
     tests_require=test_requirements,
     url="https://ritviksahajpal.github.io/yield_forecasting/",
-    version="0.1.51",
+    version="0.1.52",
     zip_safe=False,
 )