b3alien 0.0.1__py3-none-any.whl

b3alien/b3cube/__init__.py

@@ -0,0 +1,23 @@
+"""
+
+Biodiversity data cube functions
+========================================
+
+"""
+
+from .b3cube import OccurrenceCube
+from .b3cube import plot_richness
+from .b3cube import cumulative_species
+from .b3cube import calculate_rate
+from .b3cube import get_survey_effort
+
+__all__ = [
+    "plot_richness",
+    "cumulative_species",
+    "plot_cumsum",
+    "filter_multiple_cells",
+    "filter_multiple_occ",
+    "calculate_rate",
+    "get_survey_effort"
+    # purposely exclude OccurrenceCube
+]

b3alien/b3cube/b3cube.py

@@ -0,0 +1,511 @@
+import geopandas as gpd
+import pandas as pd
+import xarray as xr
+import sparse
+import dask.array as da
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib
+matplotlib.use("Agg")
+import shapely
+from shapely import geos
+import gcsfs
+
+"""
+
+Create a class object of the occurrence cube
+
+"""
+class OccurrenceCube():
+
+    """
+        Load a GeoParquet file (local or from GCS) into a sparse xarray cube.
+
+        Parameters
+        ----------
+        filepath : str
+            Path to the GeoParquet file (e.g. 'gs://bucket/file.parquet').
+        dims : list or tuple, optional
+            Dimension names. Default is ['time', 'cell', 'species'].
+        coords : dict, optional
+            Optional coordinates to assign to the cube.
+        index_col : str or list, optional
+            Column(s) to use for reshaping if needed.
+            
+
+        Returns
+        -------
+        b3cube.OccurrenceCube
+            A sparse data cube loaded from the GeoParquet file.
+            self.df contains a geopandas.DataFrame
+            self.data a sparse xarray.Xarray
+    """
+
+    def __init__(self, filepath: str, dims=None, coords=None, index_col=None):
+       
+        self.filepath = filepath
+        self.dims = dims or ("time", "cell", "species")
+        self.coords = coords
+        self.index_col = index_col
+
+        # Load GeoParquet
+        self.df = self._load_geoparquet(filepath)
+        
+        # Create cube
+        self.data = self._create_xcube(self.df)
+
+    def _load_geoparquet(self, path):
+        """
+        Load a GeoParquet file from local disk or GCS using GeoPandas.
+        """
+        if path.startswith("gs://"):
+            fs = gcsfs.GCSFileSystem()
+            with fs.open(path) as f:
+                gdf = gpd.read_parquet(f)
+        else:
+            gdf = gpd.read_parquet(path)
+
+        if 'geometry' not in gdf.columns:
+            raise ValueError("The input file must contain a 'geometry' column.")
+
+        # Ensure geometry is parsed and valid
+        gdf["geometry"] = gdf["geometry"].apply(wkt.loads) if gdf["geometry"].dtype == object else gdf["geometry"]
+        gdf = gdf.set_geometry("geometry")
+
+        return gdf
+
+    def _create_xcube(self, df):
+        """
+        Convert a GeoDataFrame into a sparse xarray cube with geometry metadata.
+        """
+        # Convert to categorical
+        df["yearmonth"] = pd.Categorical(df["yearmonth"])
+        df["cellCode"] = pd.Categorical(df["cellCode"])
+        df["specieskey"] = pd.Categorical(df["specieskey"])
+
+        # Align geometries with cell categories
+        cell_categories = df["cellCode"].cat.categories
+        geometry_per_cell = df.drop_duplicates("cellCode").set_index("cellCode").loc[cell_categories]["geometry"]
+
+        # Encode to integers
+        time_codes = df["yearmonth"].cat.codes.values
+        cell_codes = df["cellCode"].cat.codes.values
+        species_codes = df["specieskey"].cat.codes.values
+
+        # Build sparse cube
+        sparse_cube = sparse.COO(
+            coords=[time_codes, cell_codes, species_codes],
+            data=df["occurrences"].astype("float32").values,
+            shape=(
+                df["yearmonth"].cat.categories.size,
+                df["cellCode"].cat.categories.size,
+                df["specieskey"].cat.categories.size
+            )
+        )
+
+        # Create xarray DataArray
+        cube = xr.DataArray(
+            sparse_cube,
+            dims=self.dims,
+            coords={
+                self.dims[0]: df["yearmonth"].cat.categories,
+                self.dims[1]: df["cellCode"].cat.categories,
+                self.dims[2]: df["specieskey"].cat.categories,
+                "geometry": (self.dims[1], geometry_per_cell.values)
+            },
+            name="occurrences"
+        )
+
+        return cube
+
+    def _species_richness(self, normalized=False):
+        # 1. Binary presence
+        presence = (self.data > 0)
+
+        # 2. Collapse time dimension using logical OR → was the species *ever* seen in this cell?
+        presence_any_time = presence.any(dim="time")  # shape: (cell, species)
+
+        # 3. Sum species per cell (species richness)
+        species_richness = presence_any_time.sum(dim="species")  # shape: (cell,)
+
+        total_occurrences = self.data.sum(dim=["time", "species"])
+
+        if normalized == False:
+            # 4. Get the non-zero values and indices
+            coords = species_richness.data.coords  # (1D arrays of indices)
+            values = species_richness.data.data    # the richness values
+
+            # 5. Convert integer cell indices to real labels (from .coords['cell'])
+            cell_labels = species_richness.coords["cell"].values
+
+            richness_df = pd.DataFrame({
+                "cell": cell_labels[coords[0]],
+                "richness": values
+            })
+
+            self.richness = richness_df
+
+        else:
+            epsilon = 1e-6
+            normalized_richness = species_richness / (total_occurrences + epsilon)
+
+            coords = normalized_richness.data.coords
+            values = normalized_richness.data.data
+            cell_labels = normalized_richness.coords["cell"].values
+
+            # Build a DataFrame
+            norm_df = pd.DataFrame({
+                "cell": cell_labels[coords[0]],
+                "normalized_richness": values
+            })
+
+            self.richness = norm_df
+
+    def _filter_species(self, speciesKey):
+
+        self.df = self.df[self.df['specieskey'].eq(speciesKey)]
+        self.data = self.data.sel(species=speciesKey)
+
+def plot_richness(richness_df, gdf_from_gcs, geom='cellCode'):
+    """
+        Create a plot of the species richness dataframe.
+
+        Parameters
+        ----------
+        richness_df : pandas.DataFrame
+            Datagrame containing the species richness per grid cell.
+        gdf_from_gcs : geopandas.Dataframe
+            GeoDataFrame containing the species occurrence cuve.
+        geom : str, optional
+            Name of the geometry column in the GeoDataFrame. Default is 'cellCode'
+            
+        Returns
+        -------
+        matplotlib.plot
+            A plot of the species richness.
+    """
+
+    gdf_plot = pd.merge(richness_df, gdf_from_gcs, left_on='cell', right_on=geom)
+
+    gdf_plot = gpd.GeoDataFrame(gdf_plot, geometry="geometry", crs=gdf_from_gcs.crs)
+
+    fig, ax = plt.subplots(figsize=(10, 10))
+    gdf_plot.plot(
+        column="richness",
+        cmap="viridis",
+        legend=True,
+        linewidth=0.1,
+        edgecolor="grey",
+        ax=ax
+    )
+    ax.set_title("Species Richness per QDGC Cell")
+    ax.axis("off")
+    plt.show()
+
+
+def cumulative_species(cube, species_to_keep):
+
+    """
+        Calculate the cumulative number of species in a OccurrenceCube.
+
+        Parameters
+        ----------
+        cube : b3alien.b3cube.OccurrenceCube
+            Species OccurrenceCube from GBIF.
+        species_to_keep : numpy.array
+            Array of GBIF speciesKeys that need to be taken into account to calculate the cumulative species number of a cube.
+        geom : str, optional
+            
+        Returns
+        -------
+        df1 : pandas.DataFrame
+            Sparse dataframe that still contains the cumulative sum per grid cell.
+        df2 : pandas.DataFrame
+            Cumulative dataframe cell independent.
+    """
+    
+    # Wrap sparse array in Dask array with one or more chunks
+    dask_sparse_array = da.from_array(cube.data.data, chunks=(100, 100, 1000))  # tune chunking for your use case
+
+    # Replace data in cube
+    cube_dask_sparse = cube.data.copy(data=dask_sparse_array)
+
+    species_mask = cube_dask_sparse["species"].isin(species_to_keep)
+    filtered_cube = cube_dask_sparse.where(species_mask, drop=True)
+
+    # Grab the underlying sparse.COO object from Dask
+    sparse_block = filtered_cube.data.compute()  # Warning: loads full filtered cube into RAM!
+
+    # Extract sparse coordinates
+    coords = sparse_block.coords  # shape: (ndim, nnz)
+    data = sparse_block.data      # non-zero values
+
+    # Map indices to labels
+    time_labels = filtered_cube.coords["time"].values
+    species_labels = filtered_cube.coords["species"].values
+    cell_labels = filtered_cube.coords["cell"].values
+
+    # Use the sparse indices to create a DataFrame
+    df_sparse = pd.DataFrame({
+        "time": time_labels[coords[0]],
+        "cell": cell_labels[coords[1]],
+        "species": species_labels[coords[2]],
+        "occurrences": sparse_block.data
+    })
+
+    # Drop duplicates and compute cumulative species count
+    df_sparse = df_sparse.drop_duplicates()
+    df_sparse["seen"] = 1
+    df_time = (
+        df_sparse.groupby("time")["species"]
+        .nunique()
+        .cumsum()
+        .reset_index(name="cumulative_species")
+    )
+
+    df_time["time"] = pd.to_datetime(df_time["time"], format="%Y-%M", errors="coerce")
+
+    # fix to have the real cumsum
+    # Step 1: Remove duplicates (species × time)
+    df_sparse_unique = df_sparse[["time", "species"]].drop_duplicates()
+
+    # Step 2: Sort by time
+    df_sparse_unique = df_sparse_unique.sort_values("time")
+
+    # Step 3: Track cumulative species using a set
+    seen_species = set()
+    cumulative = []
+
+    for time, group in df_sparse_unique.groupby("time"):
+        new_species = set(group["species"])
+        seen_species.update(new_species)
+        cumulative.append((time, len(seen_species)))
+
+    # Step 4: Create cumulative DataFrame
+    df_cumulative = pd.DataFrame(cumulative, columns=["time", "cumulative_species"])
+    df_cumulative["time"] = pd.to_datetime(df_cumulative["time"], format="%Y-%M", errors="coerce")
+
+    return df_sparse, df_cumulative
+
+def plot_cumsum(df_cumulative):
+    """
+        Create a plot of the cumulative number of species.
+
+        Parameters
+        ----------
+        df_cumulative : pandas.DataFrame
+            Datagrame containing the cumulative number over tume.
+            
+        Returns
+        -------
+        matplotlib.plot
+            A plot of the cumulative number of species.
+    """
+    
+    plt.figure(figsize=(10, 5))
+    plt.plot(df_cumulative["time"], df_cumulative["cumulative_species"], marker="o")
+    plt.title("Cumulative Unique Species Over Time")
+    plt.xlabel("Time")
+    plt.ylabel("Unique Species Observed")
+    plt.xticks(rotation=45)
+    plt.grid(True)
+    plt.tight_layout()
+    plt.show()
+
+
+def filter_multiple_cells(df_sparse):
+    """
+        Only count a species established when it is present in more than one cell.
+
+        Parameters
+        ----------
+        df_sparse : pandas.DataFrame
+            Datagrame containing the species richness per grid cell.
+            
+        Returns
+        -------
+        pandas.DataFrame
+            Cumulative species when in multiple cells.
+    """
+    # Ensure cell is in your DataFrame
+    assert "cell" in df_sparse.columns
+
+    # 1. Count unique cells per (time, species)
+    species_cell_counts = (
+        df_sparse.groupby(["time", "species"])["cell"]
+        .nunique()
+        .reset_index(name="cell_count")
+    )
+
+    # 2. Keep only species seen in at least 2 cells
+    species_multi_cell = species_cell_counts[species_cell_counts["cell_count"] >= 2]
+
+    # 3. Track cumulative set of species across time
+    species_multi_cell = species_multi_cell.sort_values("time")
+
+    seen_species = set()
+    cumulative = []
+
+    for time, group in species_multi_cell.groupby("time"):
+        new_species = set(group["species"])
+        seen_species.update(new_species)
+        cumulative.append((time, len(seen_species)))
+
+    df_cumulative_cells = pd.DataFrame(cumulative, columns=["time", "cumulative_species_2cells"])
+
+    return df_cumulative_cells
+
+def filter_multiple_occ(df_sparse):
+    """
+        Only count a species established when there are multiple occurrences in a cell.
+
+        Parameters
+        ----------
+        df_sparse : pandas.DataFrame
+            Datagrame containing the species richness per grid cell.
+            
+        Returns
+        -------
+        pandas.DataFrame
+            Cumulative species when multiple occurrences in a cell.
+    """
+    # Ensure 'occurrences' and 'cell' are present
+    assert "occurrences" in df_sparse.columns and "cell" in df_sparse.columns
+
+    # 1. Total occurrences per (time, species, cell)
+    species_cell_occ = (
+        df_sparse.groupby(["time", "species", "cell"])["occurrences"]
+        .sum()
+        .reset_index()
+    )
+
+    # 2. Filter for species that had ≥ 2 occurrences in any cell
+    species_with_2occ = (
+        species_cell_occ[species_cell_occ["occurrences"] >= 2]
+        .drop_duplicates(subset=["time", "species"])
+    )
+
+    # 3. Cumulative species count logic
+    species_with_2occ = species_with_2occ.sort_values("time")
+
+    seen_species = set()
+    cumulative = []
+
+    for time, group in species_with_2occ.groupby("time"):
+        new_species = set(group["species"])
+        seen_species.update(new_species)
+        cumulative.append((time, len(seen_species)))
+
+    df_cumulative_occ = pd.DataFrame(cumulative, columns=["time", "cumulative_species_2occ"])
+
+    return df_cumulative_occ
+
+def calculate_rate(df_cumulative):
+    """
+       Calculate the rate of establishment from the cumulative distribution.
+
+        Parameters
+        ----------
+        df_cumulative : pandas.DataFrame
+            Datagrame containing the cumulative distribution.
+            
+        Returns
+        -------
+        s1 : pandas.Series
+            Series of the time axis.
+        s2 : pandas.Series
+            Series of the rate of establishment.
+    """
+    # --- Processing GBIF data (Monthly) to get an approximate annual rate ---
+    df_cumulative["time"] = pd.to_datetime(df_cumulative["time"])
+    df_cumulative_rate = df_cumulative.sort_values(by="time").copy()
+
+    # Group data by year and calculate the total species difference for each year
+    annual_data = df_cumulative_rate.groupby(df_cumulative_rate['time'].dt.year).agg(
+        cumulative_species=('cumulative_species', 'last'),  # Get the last cumulative species value for the year
+        first_time=('time', 'first')  # Get the first timestamp for the year
+    )
+
+    # Calculate annual rate using the grouped data
+    annual_rate_gbif = []
+    annual_time_gbif = []
+
+    for i in range(1, len(annual_data)):
+        current_year_data = annual_data.iloc[i]
+        previous_year_data = annual_data.iloc[i - 1]
+
+        species_diff = current_year_data['cumulative_species'] - previous_year_data['cumulative_species']
+        time_diff_years = (current_year_data['first_time'] - previous_year_data['first_time']).days / 365.25
+
+        annual_rate = species_diff / time_diff_years
+        annual_rate_gbif.append(annual_rate)
+        annual_time_gbif.append(current_year_data.name)  # Year is the index after groupby
+
+    annual_time_gbif = [int(year) for year in annual_time_gbif]
+
+    # Convert the lists to Pandas Series for easier plotting
+    annual_rate_gbif_series = pd.Series(annual_rate_gbif)
+    annual_time_gbif_series = pd.Series(annual_time_gbif)
+
+    return annual_time_gbif, annual_rate_gbif
+
+
+def get_survey_effort(cube, dateFormat='%Y-%m', calc_type='total'):
+    """
+        Estimate the survey effort in an OccurrenceCube.
+
+        Parameters
+        ----------
+        cube : b3alien.b3cube.OccurrenceCube
+            Species OccurrenceCube from GBIF.
+        dateFormat : str, optional
+            Dateformat stored in the OccurrenceCube. Default is '%Y-%m'
+        calc_type : str, optional
+            Type of survey effort to be calculated. 
+                'distinct' : total number of distinct observers
+                'total' : total number of occurrences
+                Default is total.
+            
+        Returns
+        -------
+        df : pandas.DataFrame
+            Dataframe containing time and the chosen measurement for survey effort.
+    """
+    
+
+    if calc_type == 'distinct':
+        # Group by 'yearmonth' and sum
+        distinct_observers_over_time = cube.df.groupby('yearmonth', observed=True)['distinctobservers'].sum()
+
+        # Convert the index to datetime (if it's not already)
+        distinct_observers_over_time.index = pd.to_datetime(
+            distinct_observers_over_time.index, format=dateFormat, errors='coerce'
+        )
+
+        # Resample to yearly frequency using new 'YE' standard
+        distinct_observers_yearly = distinct_observers_over_time.resample('YE').sum()
+
+        # Filter for years from 1900 onward
+        distinct_observers_filtered = distinct_observers_yearly[distinct_observers_yearly.index.year >= 1900]
+
+        # Convert to DataFrame
+        df = distinct_observers_filtered.reset_index()
+        df.columns = ['date', 'distinct_observers']  # Rename columns for clarity
+
+        return df
+
+    else:
+
+        total_occurrences_over_time = cube.data.sum(dim=['cell', 'species'])
+
+        # Convert the time coordinates to datetime objects if they aren't already
+        total_occurrences_over_time['time'] = pd.to_datetime(total_occurrences_over_time['time'].values, format=dateFormat, errors='coerce')
+        df = pd.DataFrame({
+            'time': total_occurrences_over_time['time'].values,
+            'total_occurrences': total_occurrences_over_time.data.data
+        })
+
+        # (Optional) Drop rows with invalid or missing time
+        df = df.dropna(subset=['time'])
+
+        return df

b3alien/griis/__init__.py

@@ -0,0 +1,14 @@
+"""
+
+GRIIS checklist functions
+=========================
+
+"""
+
+from .griis import CheckList
+from .griis import get_speciesKey
+from .griis import do_taxon_matching
+from .griis import read_checklist
+from .griis import split_event_date
+
+__all__ = ["get_speciesKey", "do_taxon_matching", "read_checklist", "split_event_date"]

b3alien/griis/griis.py

@@ -0,0 +1,198 @@
+import pandas as pd
+from tqdm import tqdm
+tqdm.pandas()  # enables .progress_apply
+from pygbif import species
+import numpy as np
+
+class CheckList():
+
+    """
+        Load a GRIIS checklist from GBIF.
+
+        Parameters
+        ----------
+        filepath : str
+            Path to the distribution.txt file of the checklist.
+
+        Returns
+        -------
+        griis.Checklist
+            A checklist object containing the list of species.
+    """
+
+    def __init__(self, filePath: str):
+        self.filePath = filePath
+
+        # Create cube
+        self.species = self._load_GRIIS(filePath)
+
+    def _load_GRIIS(self, filePath):
+        
+        df_merged = pd.read_csv(filePath, sep="\t")
+        species_to_keep = df_merged["speciesKey"].unique()
+        species_to_keep = np.where(species_to_keep == 'Uncertain', -1, species_to_keep)
+        species_to_keep = species_to_keep.astype(int)
+
+        return species_to_keep
+        
+
+def get_speciesKey(sciname):
+    """
+        Match text strings with the GBIF taxonomic backbone.
+
+        Parameters
+        ----------
+        sciname : str
+            Text string of a scientific name
+
+        Returns
+        -------
+        speciesKey: an integer speciesKey number
+    """
+    result = species.name_backbone(sciname, strict=True)
+    try:
+        speciesKey = result["speciesKey"]
+    except KeyError:
+        speciesKey = "Uncertain"
+    return speciesKey
+
+def split_event_date(eventDate):
+    """
+        Interprete the event date as introduction date and date of last seen,
+        when this information is available in the checklist.
+
+        Parameters
+        ----------
+        eventDate : str
+            Text string of eventDate
+
+        Returns
+        -------
+        pd.Series
+            A series containing introduction date ('intro') and date last seen ('outro')
+    """
+    if isinstance(eventDate, str):
+        parts = eventDate.strip().split('/')
+        if len(parts) == 2:
+            intro = parts[0]
+            outro = parts[1]
+        else:
+            intro = outro = np.nan
+        return pd.Series([intro, outro])
+    else:
+        return pd.Series([np.nan, np.nan])
+
+
+def do_taxon_matching(dirPath):
+    """
+        Match keys between taxon.txt and distribution.txt
+
+        Parameters
+        ----------
+        dirPath : str
+            Path to the directory of the checklist
+
+        Returns
+        -------
+        Saves a new checklist file 'merged_distr.txt' in the checklist directory
+    """
+
+    taxon = dirPath + "taxon.txt"
+    distribution = dirPath + "distribution.txt"
+
+    df_t = pd.read_csv(taxon, sep="\t")
+    df_dist = pd.read_csv(distribution, sep="\t")
+
+    # Now apply this on the whole dataframe
+
+    df_t["speciesKey"] = df_t["scientificName"].progress_apply(get_speciesKey)
+
+    df_merged = df_dist.merge(df_t[['id', 'speciesKey']], on='id', how='left')
+    df_merged.to_csv(dirPath + 'merged_distr.txt', sep='\t', index=False)
+
+# The rest assumes already a merged dataset
+def read_checklist(filePath, cl_type='detailed', locality='Belgium'):
+    
+    distribution = filePath + "distribution.txt"
+
+    df_cl = pd.read_csv(distribution, sep='\t', low_memory=False)
+
+    df_cl["speciesKey"] = df_cl["id"].str.rsplit("/", n=1).str[-1].astype("int64")
+
+
+    if cl_type == 'detailed':
+
+        species_to_keep = df_cl["speciesKey"].astype("int64").unique()
+    
+        # 1. Filter rows where locality == 'Belgium' and eventDate is not missing
+        df = df_cl[df_cl["locality"] == locality].copy()
+        df = df[df["eventDate"].notna()]
+
+
+
+        df[["introDate", "outroDate"]] = df["eventDate"].apply(split_event_date)
+
+        df["introDate"] = pd.to_datetime(df["introDate"], format="%Y", errors="coerce")
+        df["outroDate"] = pd.to_datetime(df["outroDate"], format="%Y", errors="coerce")
+
+
+        # 3. Clean rows with missing introDate
+        df_intro = df.dropna(subset=["introDate"]).copy()
+
+        # 4. Group by introDate and count species
+        in_species = (
+            df_intro.groupby("introDate", sort=True)["id"]
+            .count()
+            .reset_index(name="nspec")
+        )
+
+        # 5. Cumulative sum
+        in_species["cumn"] = in_species["nspec"].cumsum()
+
+        # 6. Clean outro side and count outgoing species
+        df_outro = df.dropna(subset=["outroDate"]).copy()
+
+        out_species = (
+            df_outro.groupby("outroDate", sort=True)["id"]
+            .count()
+            .reset_index(name="nspeco")
+        )
+
+        # 7. Merge intro and outro on date
+        n_species = pd.merge(in_species, out_species, how="outer", left_on="introDate", right_on="outroDate")
+
+        # 8. Replace NaNs with 0
+        n_species["nspec"] = n_species["nspec"].fillna(0).astype(int)
+        n_species["nspeco"] = n_species["nspeco"].fillna(0).astype(int)
+
+        # 9. Net species present at each time step
+        n_species["total"] = n_species["nspec"] - n_species["nspeco"]
+
+        # 10. Final frame with total species over time
+        tot_species = n_species[["introDate", "total"]].copy()
+
+        # 11. Optional: sort and compute cumulative total over time
+        tot_species = tot_species.sort_values("introDate")
+        tot_species["cumulative_total"] = tot_species["total"].cumsum()
+
+        return tot_species
+
+    else:
+        taxon = filePath + "taxon.txt"
+        distribution = filePath + "distribution.txt"
+
+        df_t = pd.read_csv(taxon, sep="\t")
+        df_dist = pd.read_csv(distribution, sep="\t")
+
+
+        # Now apply this on the whole dataframe
+
+        df_t["speciesKey"] = df_t["scientificName"].apply(get_speciesKey)
+
+        df_merged = df_dist.merge(df_t[['id', 'speciesKey']], on='id', how='left')
+
+        species_to_keep = df_merged["speciesKey"].unique()
+        species_to_keep = np.where(species_to_keep == 'Uncertain', -1, species_to_keep)
+        species_to_keep = species_to_keep.astype(int)
+
+        return species_to_keep

b3alien/simulation/__init__.py

@@ -0,0 +1,11 @@
+"""
+
+Simulation functions
+====================
+
+
+"""
+
+from .simulation import simulate_solow_costello
+
+__all__ = ["simulate_solow_costello"]

b3alien/simulation/simulation.py

@@ -0,0 +1,126 @@
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from scipy.optimize import minimize
+from scipy.optimize import fmin
+
+def count_m(t, params):
+    """Calculates the mean, mu, from Solow and Costello (2004)."""
+    m0 = params[0]
+    m1 = params[1]
+    m = np.exp(m0 + m1 * t)
+    return m
+
+def count_pi(s, t, params):
+    """Calculates the variable pi from Solow and Costello (2004)."""
+    pi0 = params[2]
+    pi1 = params[3]
+    pi2 = params[4]
+    exponent = np.clip(pi0 + pi1 * t + pi2 * np.exp(t - s), -700, 700)
+    num = np.exp(exponent)
+    pi = np.divide(num, (1 + num), out=np.zeros_like(num), where=(1 + num) != 0)
+    pi = np.where(np.isinf(num), 1, pi)
+    return pi
+
+def count_p(t, params):
+    """Calculates the value p from Solow and Costello (2004).
+    It uses matrix coding for efficiency.
+    """
+    S = np.tile(np.arange(1, t + 1), (t, 1))
+    thing = 1 - count_pi(S, S.T, params)
+    thing[t - 1, :] = 1
+    up = np.triu(np.ones_like(thing), 1)
+    thing2 = np.tril(thing) + up
+    product = np.prod(thing2, axis=0)
+    pst = product * count_pi(np.arange(1, t + 1), t, params)
+    return pst
+
+def count_lambda(params, N):
+    """
+    This function calculates lambda from Solow and Costello, 2004.
+    params is a vector of parameters
+    """
+    lambda_result = np.zeros(N)
+    for t in range(1, N + 1):
+        S = np.arange(1, t + 1)
+        Am = count_m(S, params)
+        Ap = count_p(t, params)
+        lambda_result[t - 1] = np.dot(Am, Ap)
+    return lambda_result
+
+def count_log_like(params, restrict, num_discov):
+    """
+    This function file calculates the log likelihood function for Solow and
+    Costello (2004).  It takes into account any possible restrictions (See
+    below)
+
+    params is a vector of parameters
+    restrict is a vector (same size as params) that places restrictions on the
+    parameters. If restrict[i]=99, then there is no restriction for the ith
+    parameter. If restrict[i]=0 (for example) then the restriction is exactly
+    that.
+    """
+
+    f = np.where(restrict != 99)[0]
+    g = np.where(restrict == 99)[0]
+    new_params = params.copy()
+    new_params[g] = params[g]
+    new_params[f] = restrict[f]
+
+    summand2 = np.zeros_like(num_discov, dtype=float)
+    lambda_values = np.zeros_like(num_discov, dtype=float)
+
+    for t in range(1, len(num_discov) + 1):
+        S = np.arange(1, t + 1)
+        Am = count_m(S, new_params)
+        Ap = count_p(t, new_params)
+        lambda_t = np.dot(Am, Ap)
+        lambda_values[t - 1] = lambda_t
+        summand2[t - 1] = num_discov[t - 1] * np.log(lambda_t) - lambda_t if lambda_t > 0 else -lambda_t
+
+    LL = -np.sum(summand2)
+    return LL, lambda_values
+
+
+def simulate_solow_costello(annual_time_gbif, annual_rate_gbif, vis=False): 
+    """
+        Solow-Costello simulation of the rate of establishment.
+
+        Parameters
+        ----------
+        annual_time_gbif : pandas.Series
+            Time series of the rate of establishment.
+        annual_rate_gbif : pandas.Series
+            Rates corresponding to the time series.
+        vis : bool, optional
+            Create a plot of the simulation. Default is False.
+            
+        Returns
+        -------
+        C1: numpy.Series
+            Result of the simulation.
+    """
+
+    #  global num_discov;  #  No need for global, pass as argument
+    num_discov = pd.Series(annual_rate_gbif).T   #  Load and transpose
+    T = pd.Series(annual_time_gbif) #np.arange(1851, 1996)  #  Create the time period
+    #  options = optimset('TolFun',.01,'TolX',.01);  #  Tolerance is handled differently in scipy
+
+    guess = np.array([-1.1106, 0.0135, -1.4534, 0.1, 0.1])  #  Initial guess
+    constr = 99 * np.ones_like(guess)  #  Constraint vector
+
+    vec1 = fmin(lambda x: count_log_like(x, constr, num_discov)[0], guess, xtol=0.01, ftol=0.01)
+    val1 = count_log_like(vec1, constr, num_discov)[0]  #  Get the function value at the minimum
+
+
+    C1 = count_lambda(vec1, len(num_discov))  #  Calculate the mean of Y
+
+    if vis:
+        #  Create the plot
+        plt.plot(T, np.cumsum(num_discov), 'k-', T, np.cumsum(C1), 'k--')
+        plt.legend(['Discoveries', 'Unrestricted'])
+        plt.xlabel('Time')
+        plt.ylabel('Cumulative Discovery')
+        plt.show()
+
+    return C1

b3alien/utils.py

@@ -0,0 +1,73 @@
+"""
+Additional utilities
+
+"""
+import pandas as pd
+import geopandas as gpd
+import pyarrow
+
+
+def detect_runtime():
+    """
+    Detects the runtime environment where the code is executed.
+
+    Returns:
+        str: One of "Jupyter Notebook", "IPython Terminal", or "Standard Python Script"
+    """
+    try:
+        from IPython import get_ipython
+        shell = get_ipython().__class__.__name__
+        if shell == 'ZMQInteractiveShell':
+            return "Jupyter Notebook"
+        elif shell == 'TerminalInteractiveShell':
+            return "IPython Terminal"
+        else:
+            return "Other IPython"
+    except (ImportError, AttributeError, NameError):
+        return "Standard Python Script"
+
+def in_jupyter():
+    """Returns True if running inside a Jupyter Notebook or Lab."""
+    return detect_runtime() == "Jupyter Notebook"
+
+def in_ipython():
+    """Returns True if running inside any IPython shell (not standard Python)."""
+    return detect_runtime() != "Standard Python Script"
+
+def in_script():
+    """Returns True if running in a standard Python script (non-interactive)."""
+    return detect_runtime() == "Standard Python Script"
+
+def to_geoparquet(csvFile, geoFile, leftID=eqdcellcode, rightID=cellCode, exportPath='./data/export.parquet'):
+    """
+       Convert a GBIF cube download into a GeoParquet file, using the geometry of a GPKG
+
+        Parameters
+        ----------
+        csvFile : str
+            Path to the GBIF cube csv file.
+        geoFile : str
+            Path to the GeoPackage file.
+        leftID : str, optional
+            Column name within the GBIF cube to match the geometry. Default is 'edqcellcode'.
+        rightID : str, optional
+            Column name within the GeoPackage geometry. Default is 'cellCode'
+        exportPath : str, optional
+            Path to which the GeoParquet file needs to be exported.
+
+        Returns
+        -------
+        A GeoParquet file at the location of exportPath
+    """
+
+    data = pd.read_csv(csvFile, sep='\t')
+    geoRef = gpd.read_file(geoFile, engine='pyogrio', use_arrow=True, crs="EPSG:4326")
+
+    test_merge = pd.merge(data, qdgc_ref, left_on=leftID, right_on=rightID)
+
+    gdf = gpd.GeoDataFrame(test_merge, geometry='geometry')
+    if gdf.crs is None:
+        gdf.set_crs(crs, inplace=True) 
+
+    gdf.to_parquet(exportPath, engine="pyarrow", index=False)
+

b3alien/visualisation/__init__.py

@@ -0,0 +1,13 @@
+"""
+
+Visualisation of Data Cubes and the resulting simulations
+=========================================================
+
+"""
+
+
+from .b3gee import initialize
+from .b3gee import gdf_to_ee_featurecollection
+from .visualisation import visualize_ee_layers
+
+__all__ = ["initialize", "gdf_to_ee_featurecollection", "visualize_ee_layers"]

b3alien/visualisation/b3gee.py

@@ -0,0 +1,35 @@
+import ee
+import json
+
+def initialize(project):
+    """
+        Inititialise a Google project
+
+        Parameters
+        ----------
+        project : str
+            Name of your Google project
+    """
+    try:
+        ee.Initialize()
+    except Exception as e:
+        ee.Authenticate()
+        ee.Initialize(project=project)
+
+def gdf_to_ee_featurecollection(gdf):
+    """
+        Transform a GeoDataFrame in to an Earth Engine Feature collection
+
+        Parameters
+        ----------
+        gdf : geopandas.DataFrame
+            Species OccurrenceCube from GBIF.
+            
+        Returns
+        -------
+        ee.FeatureCollection
+    """
+    geojson = json.loads(gdf.to_json())
+    return ee.FeatureCollection(geojson)
+
+

b3alien/visualisation/visualisation.py

@@ -0,0 +1,68 @@
+import ee
+import geemap
+import folium
+import tempfile
+import webbrowser
+
+def add_ee_layer(self, ee_object, vis_params, name):
+    try:
+        if isinstance(ee_object, ee.image.Image):
+            map_id_dict = ee_object.getMapId(vis_params)
+            folium.raster_layers.TileLayer(
+                tiles=map_id_dict['tile_fetcher'].url_format,
+                attr='Google Earth Engine',
+                name=name,
+                overlay=True,
+                control=True
+            ).add_to(self)
+        elif isinstance(ee_object, ee.featurecollection.FeatureCollection):
+            # Style the FeatureCollection (example with color)
+            styled_fc = ee_object.style(**(vis_params or {'color': 'FF0000'}))
+            map_id_dict = styled_fc.getMapId({})
+            folium.raster_layers.TileLayer(
+                tiles=map_id_dict['tile_fetcher'].url_format,
+                attr='Google Earth Engine',
+                name=name,
+                overlay=True,
+                control=True
+            ).add_to(self)
+        else:
+            raise TypeError(f"Unsupported ee object type: {type(ee_object)}")
+    except Exception as e:
+        print("Could not add layer:", e)
+
+
+
+# Patch Folium to support EE layers
+def patch_folium():
+    folium.Map.add_ee_layer = add_ee_layer
+
+
+def visualize_ee_layers(layers, center=[0, 0], zoom=2, save_path=None, show=True):
+    """
+    Visualize multiple Earth Engine layers on a folium map.
+
+    Parameters:
+        layers: List of (ee_object, vis_params, layer_name)
+        center: Center [lat, lon] for map
+        zoom: Zoom level
+        save_path: Optional filepath to save the HTML map
+        show: If True, opens the map in the browser
+    """
+    m = folium.Map(location=center, zoom_start=zoom)
+
+    for ee_object, vis_params, name in layers:
+        m.add_ee_layer(ee_object, vis_params, name)
+
+    folium.LayerControl().add_to(m)
+
+    if save_path:
+        m.save(save_path)
+        print(f"Map saved to {save_path}")
+        if show:
+            webbrowser.open(f"file://{os.path.abspath(save_path)}")
+    else:
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".html") as f:
+            m.save(f.name)
+            if show:
+                webbrowser.open(f.name)

b3alien-0.0.1.dist-info/METADATA

@@ -0,0 +1,225 @@
+Metadata-Version: 2.4
+Name: b3alien
+Version: 0.0.1
+Summary: Calculating the CBD target 6.1 indicator from occurrence cubes
+Author-email: Maarten Trekels <maarten.trekels@plantentuinmeise.be>
+License: MIT
+Project-URL: homepage, https://github.com/mtrekels/b3alien
+Project-URL: repository, https://github.com/mtrekels/b3alien
+Project-URL: documentation, https://b3alien.readthedocs.io/
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohappyeyeballs>=2.6.1
+Requires-Dist: aiohttp>=3.11.18
+Requires-Dist: aiosignal>=1.3.2
+Requires-Dist: alabaster>=1.0.0
+Requires-Dist: appdirs>=1.4.4
+Requires-Dist: asttokens>=3.0.0
+Requires-Dist: async-timeout>=5.0.1
+Requires-Dist: attrs>=25.3.0
+Requires-Dist: backports.tarfile>=1.2.0
+Requires-Dist: bqplot>=0.12.44
+Requires-Dist: branca>=0.8.1
+Requires-Dist: build>=1.2.2.post1
+Requires-Dist: cachetools>=5.5.2
+Requires-Dist: cattrs>=24.1.3
+Requires-Dist: certifi>=2025.4.26
+Requires-Dist: cffi>=1.17.1
+Requires-Dist: charset-normalizer>=3.4.2
+Requires-Dist: click>=8.1.8
+Requires-Dist: cloudpickle>=3.1.1
+Requires-Dist: colour>=0.1.5
+Requires-Dist: comm>=0.2.2
+Requires-Dist: contourpy>=1.3.2
+Requires-Dist: coverage>=7.8.0
+Requires-Dist: cryptography>=44.0.3
+Requires-Dist: cycler>=0.12.1
+Requires-Dist: dask>=2025.4.1
+Requires-Dist: decorator>=5.2.1
+Requires-Dist: docutils>=0.21.2
+Requires-Dist: earthengine-api>=1.5.13
+Requires-Dist: eerepr>=0.1.1
+Requires-Dist: exceptiongroup>=1.2.2
+Requires-Dist: executing>=2.2.0
+Requires-Dist: folium>=0.19.5
+Requires-Dist: fonttools>=4.57.0
+Requires-Dist: frozenlist>=1.6.0
+Requires-Dist: fsspec>=2025.3.2
+Requires-Dist: future>=1.0.0
+Requires-Dist: gcsfs>=2025.3.2
+Requires-Dist: geemap>=0.35.3
+Requires-Dist: geocoder>=1.38.1
+Requires-Dist: geojson-rewind>=1.1.0
+Requires-Dist: geomet>=1.1.0
+Requires-Dist: geopandas>=1.0.1
+Requires-Dist: google-api-core>=2.24.2
+Requires-Dist: google-api-python-client>=2.169.0
+Requires-Dist: google-auth>=2.39.0
+Requires-Dist: google-auth-httplib2>=0.2.0
+Requires-Dist: google-auth-oauthlib>=1.2.2
+Requires-Dist: google-cloud-core>=2.4.3
+Requires-Dist: google-cloud-storage>=3.1.0
+Requires-Dist: google-crc32c>=1.7.1
+Requires-Dist: google-resumable-media>=2.7.2
+Requires-Dist: googleapis-common-protos>=1.70.0
+Requires-Dist: httplib2>=0.22.0
+Requires-Dist: id>=1.5.0
+Requires-Dist: idna>=3.10
+Requires-Dist: imagesize>=1.4.1
+Requires-Dist: importlib_metadata>=8.7.0
+Requires-Dist: iniconfig>=2.1.0
+Requires-Dist: ipyevents>=2.0.2
+Requires-Dist: ipyfilechooser>=0.6.0
+Requires-Dist: ipyleaflet>=0.19.2
+Requires-Dist: ipython>=8.36.0
+Requires-Dist: ipytree>=0.2.2
+Requires-Dist: ipywidgets>=8.1.6
+Requires-Dist: jaraco.classes>=3.4.0
+Requires-Dist: jaraco.context>=6.0.1
+Requires-Dist: jaraco.functools>=4.1.0
+Requires-Dist: jedi>=0.19.2
+Requires-Dist: jeepney>=0.9.0
+Requires-Dist: Jinja2>=3.1.6
+Requires-Dist: jupyter-leaflet>=0.19.2
+Requires-Dist: jupyterlab_widgets>=3.0.14
+Requires-Dist: keyring>=25.6.0
+Requires-Dist: kiwisolver>=1.4.8
+Requires-Dist: llvmlite>=0.44.0
+Requires-Dist: locket>=1.0.0
+Requires-Dist: markdown-it-py>=3.0.0
+Requires-Dist: MarkupSafe>=3.0.2
+Requires-Dist: matplotlib>=3.10.1
+Requires-Dist: matplotlib-inline>=0.1.7
+Requires-Dist: mdit-py-plugins>=0.4.2
+Requires-Dist: mdurl>=0.1.2
+Requires-Dist: more-itertools>=10.7.0
+Requires-Dist: multidict>=6.4.3
+Requires-Dist: myst-parser>=4.0.1
+Requires-Dist: narwhals>=1.37.1
+Requires-Dist: nh3>=0.2.21
+Requires-Dist: numba>=0.61.2
+Requires-Dist: numpy>=2.2.5
+Requires-Dist: oauthlib>=3.2.2
+Requires-Dist: packaging>=25.0
+Requires-Dist: pandas>=2.2.3
+Requires-Dist: parso>=0.8.4
+Requires-Dist: partd>=1.4.2
+Requires-Dist: pexpect>=4.9.0
+Requires-Dist: pillow>=11.2.1
+Requires-Dist: platformdirs>=4.3.7
+Requires-Dist: plotly>=6.0.1
+Requires-Dist: pluggy>=1.5.0
+Requires-Dist: prompt_toolkit>=3.0.51
+Requires-Dist: propcache>=0.3.1
+Requires-Dist: proto-plus>=1.26.1
+Requires-Dist: protobuf>=6.30.2
+Requires-Dist: ptyprocess>=0.7.0
+Requires-Dist: pure_eval>=0.2.3
+Requires-Dist: pyarrow>=20.0.0
+Requires-Dist: pyasn1>=0.6.1
+Requires-Dist: pyasn1_modules>=0.4.2
+Requires-Dist: pycparser>=2.22
+Requires-Dist: pygbif>=0.6.5
+Requires-Dist: Pygments>=2.19.1
+Requires-Dist: pyogrio>=0.10.0
+Requires-Dist: pyparsing>=3.2.3
+Requires-Dist: pyperclip>=1.9.0
+Requires-Dist: pyproj>=3.7.1
+Requires-Dist: pyproject_hooks>=1.2.0
+Requires-Dist: pyshp>=2.3.1
+Requires-Dist: pytest>=8.3.5
+Requires-Dist: pytest-cov>=6.1.1
+Requires-Dist: python-box>=7.3.2
+Requires-Dist: python-dateutil>=2.9.0.post0
+Requires-Dist: pytz>=2025.2
+Requires-Dist: PyYAML>=6.0.2
+Requires-Dist: ratelim>=0.1.6
+Requires-Dist: readme_renderer>=44.0
+Requires-Dist: requests>=2.32.3
+Requires-Dist: requests-cache>=1.2.1
+Requires-Dist: requests-oauthlib>=2.0.0
+Requires-Dist: requests-toolbelt>=1.0.0
+Requires-Dist: rfc3986>=2.0.0
+Requires-Dist: rich>=14.0.0
+Requires-Dist: rsa>=4.9.1
+Requires-Dist: scipy>=1.15.2
+Requires-Dist: scooby>=0.10.1
+Requires-Dist: SecretStorage>=3.3.3
+Requires-Dist: shapely>=2.1.0
+Requires-Dist: six>=1.17.0
+Requires-Dist: snowballstemmer>=3.0.0.1
+Requires-Dist: sparse>=0.16.0
+Requires-Dist: Sphinx>=8.1.3
+Requires-Dist: sphinx-rtd-theme>=3.0.2
+Requires-Dist: sphinxcontrib-applehelp>=2.0.0
+Requires-Dist: sphinxcontrib-devhelp>=2.0.0
+Requires-Dist: sphinxcontrib-htmlhelp>=2.1.0
+Requires-Dist: sphinxcontrib-jquery>=4.1
+Requires-Dist: sphinxcontrib-jsmath>=1.0.1
+Requires-Dist: sphinxcontrib-qthelp>=2.0.0
+Requires-Dist: sphinxcontrib-serializinghtml>=2.0.0
+Requires-Dist: stack-data>=0.6.3
+Requires-Dist: tdqm>=0.0.1
+Requires-Dist: tomli>=2.2.1
+Requires-Dist: toolz>=1.0.0
+Requires-Dist: tqdm>=4.67.1
+Requires-Dist: traitlets>=5.14.3
+Requires-Dist: traittypes>=0.2.1
+Requires-Dist: twine>=6.1.0
+Requires-Dist: typing_extensions>=4.13.2
+Requires-Dist: tzdata>=2025.2
+Requires-Dist: uritemplate>=4.1.1
+Requires-Dist: url-normalize>=2.2.1
+Requires-Dist: urllib3>=2.4.0
+Requires-Dist: wcwidth>=0.2.13
+Requires-Dist: widgetsnbextension>=4.0.14
+Requires-Dist: xarray>=2025.4.0
+Requires-Dist: xyzservices>=2025.4.0
+Requires-Dist: yarl>=1.20.0
+Requires-Dist: zipp>=3.21.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Dynamic: license-file
+
+# b3alien: a Python package to calculate the Target 6.1 headline indicator of the CBD
+
+
+## Introduction
+
+The historic Kunming-Montreal Global Biodiversity
+Framework, which supports the achievement of the
+Sustainable Development Goals and builds on the
+Convention on Biological Diversity’s (CBD) previous
+Strategic Plans, sets out an ambitious pathway to reach
+the global vision of a world living in harmony with nature
+by 2050. Among the Framework’s key elements are 23
+targets for 2030. In order to track the progress on the
+targets, a number of indicators were agreed upon for
+each target. The B3ALIEN software provides a technical
+solution to track Target 6: “Reduce the Introduction of
+Invasive Alien Species by 50% and Minimize Their
+Impact.” It mainly focusses on the headline indicator: rate
+of invasive alien species establishment, but can provide
+input to some of the complementary indicators.
+
+Decision makers at local, regional, national and
+international levels need accurate and reliable
+information about status, trends, threats, and they need
+data presented in an actionable and understandable
+format, with measures of uncertainty. Furthermore, we
+need synthesized data products that can be combined
+with other environmental data, such as climate, soil
+chemistry, land use, altitude... B3ALIEN is built upon the
+concept of data cubes developed in the Horizon Europe
+Biodiversity Building Blocks for Policy project (b-
+cubed.eu). It uses the solid foundations of the GBIF
+infrastructure, where tools such as the GBIF Taxonomic
+Backbone and the Global Registry of Introduced and
+Invasive Species are available by default. Readily available occurrence data is used to determine and estimate
+accurately the rate of introduction of alien species..
+
+## Architecture
+
+put schema here

b3alien-0.0.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+b3alien/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+b3alien/utils.py,sha256=4gyPatTcOY9uD9hZdcBgEpDVL2H9qEihoabmOiBgbTY,2361
+b3alien/b3cube/__init__.py,sha256=oAJXCVhF88Rkl5Z_Fn28WKThwxu63ZDrbOEe_Kpq7TQ,487
+b3alien/b3cube/b3cube.py,sha256=tVmaGPxXJX3YR-joX3W8q7tFuxF8OHflFH5SKKin-dY,17351
+b3alien/griis/__init__.py,sha256=jp_pTU7hPntJBBBOiCBKNdNC37zZ7ggpBARXu8zowKc,321
+b3alien/griis/griis.py,sha256=9M1g3fp-PmJFe32Eg3EB45S9yyvewSXp74FNGbAcboo,5926
+b3alien/simulation/__init__.py,sha256=YEU2Uot9gD8NUseC9xxtpJ5E1JBLcB4AQhtNgV9UELE,140
+b3alien/simulation/simulation.py,sha256=rSl8Lr3-i27WKpJEkymgPXCp-VaAoFATqIMoCtL7RPE,4276
+b3alien/visualisation/__init__.py,sha256=smoKdeDgfZFdNfQnOFwekUY94vGV5LSePlRR1p45TsM,331
+b3alien/visualisation/b3gee.py,sha256=FIANrsk_d451OeKY3fUWAHy7Z3P1hf9t6PX9K6ryYVY,733
+b3alien/visualisation/visualisation.py,sha256=Pvl8e62y4AlkiYKDi0__9XHXTJXvR7AUHtQhiAmygjU,2249
+b3alien-0.0.1.dist-info/licenses/LICENSE,sha256=OpaLK4BvTJYb7yT8EDbVlAZQP6DkkrNUXzPvosajAeE,1077
+b3alien-0.0.1.dist-info/METADATA,sha256=ZSDq_IDMp1gOvXRSX3wvWHyqdsoRy1oGvrKDshdi9fA,8005
+b3alien-0.0.1.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+b3alien-0.0.1.dist-info/top_level.txt,sha256=Pvcrm6IMnotsQRwRY2z9XT_ooE-bRZHaZK7DJmkcYrw,8
+b3alien-0.0.1.dist-info/RECORD,,

b3alien-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.4.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

b3alien-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Botanic Garden Meise
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

b3alien-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+b3alien