openforis-whisp 0.0.1__py3-none-any.whl

openforis_whisp/reformat.py

@@ -0,0 +1,346 @@
+# !pip install pandera[io] # special version used
+import pandera as pa
+import pandas as pd
+import os
+import logging
+
+
+from openforis_whisp.logger import StdoutLogger, FileLogger
+
+from openforis_whisp.pd_schemas import data_lookup_type
+
+
+from openforis_whisp.parameters.config_runtime import (
+    DEFAULT_GEE_DATASETS_LOOKUP_TABLE_PATH,
+    DEFAULT_CONTEXT_LOOKUP_TABLE_PATH,
+)
+
+logger = StdoutLogger(__name__)
+
+
+# Dictionary to cache schema and modification times for multiple files
+cached_schema = None
+cached_file_mtimes = {}
+
+
+def validate_dataframe_using_lookups(
+    df_stats: pd.DataFrame, file_paths: list = None
+) -> pd.DataFrame:
+    """
+    Load the schema if any file in the list has changed and validate the DataFrame against the loaded schema.
+
+    Args:
+        df_stats (pd.DataFrame): The DataFrame to validate.
+        file_paths (list): List of paths to schema files.
+
+    Returns:
+        pd.DataFrame: The validated DataFrame.
+    """
+    # Load the schema
+    schema = load_schema_if_any_file_changed(file_paths)
+
+    # Validate the DataFrame
+    validated_df = validate_dataframe(df_stats, schema)
+
+    return validated_df
+
+
+# NB uses default inputs. If you want to use custom inputs, you can pass them as arguments
+def load_schema_if_any_file_changed(file_paths):
+    """Load schema only if any file in the list has changed."""
+    global cached_schema, cached_file_mtimes
+
+    if file_paths is None:
+        file_paths = [
+            DEFAULT_GEE_DATASETS_LOOKUP_TABLE_PATH,
+            DEFAULT_CONTEXT_LOOKUP_TABLE_PATH,
+        ]
+
+    # Flag to indicate if any file has changed
+    schema_needs_update = False
+
+    # Check each file's modification time
+    for file_path in file_paths:
+        current_mtime = os.path.getmtime(file_path)
+
+        # If the file is new or has been modified, mark schema for update
+        if (
+            file_path not in cached_file_mtimes
+            or current_mtime != cached_file_mtimes[file_path]
+        ):
+            print(f"File {file_path} changed, updating schema...")
+            schema_needs_update = True
+            cached_file_mtimes[
+                file_path
+            ] = current_mtime  # Update the modification time
+
+    # If any file has changed, update the schema
+    if schema_needs_update or cached_schema is None:
+        print("Creating or updating schema based on changed files...")
+        # You can combine the files as needed; here we assume one schema file
+        # If you want to handle multiple schema files differently, adjust this
+
+        # add checks on lookup inputs (i.e. a dataframe in type format: data_lookup_type)
+        combined_lookup_df: data_lookup_type = append_csvs_to_dataframe(
+            file_paths
+        )  # concatonates input lookup files
+
+        cached_schema = create_schema_from_dataframe(
+            combined_lookup_df
+        )  # create cached schema
+
+    else:
+        print("Using cached schema.")
+
+    return cached_schema
+
+
+def validate_dataframe(
+    df_stats: pd.DataFrame, schema: pa.DataFrameSchema
+) -> pd.DataFrame:
+    """Validate the DataFrame against the given schema, reorder columns to match schema order, and list missing columns.
+
+    Args:
+        schema (pa.DataFrameSchema): The schema to validate against.
+        df_stats (pd.DataFrame): The DataFrame to validate.
+        required_false (bool): If True, sets all columns in the schema as optional (required=False).
+
+    Returns:
+        pd.DataFrame: The validated DataFrame with columns ordered according to the schema, or None if validation fails.
+    """
+    log_missing_columns(df_stats, schema)
+
+    # df_stats = df_stats.reindex(schema.columns.keys(), axis=1)
+
+    # Try to automatically coerce the DataFrame to match the schema types
+    try:
+        validated_df = schema(df_stats)
+    except pa.errors.SchemaError as e:
+        print("Error during validation:", e)
+        # Return None or raise the error if validation fails
+        return None  # or raise e
+
+    # Reorder the validated DataFrame to match the schema's column order
+    validated_df = validated_df.reindex(schema.columns.keys(), axis=1)
+
+    return validated_df
+
+
+def load_schema_if_any_file_changed(file_paths):
+    """Load schema only if any file in the list has changed."""
+    global cached_schema, cached_file_mtimes
+
+    if file_paths is None:
+        file_paths = [
+            DEFAULT_GEE_DATASETS_LOOKUP_TABLE_PATH,
+            DEFAULT_CONTEXT_LOOKUP_TABLE_PATH,
+        ]
+
+    # Flag to indicate if any file has changed
+    schema_needs_update = False
+
+    # Check each file's modification time
+    for file_path in file_paths:
+        current_mtime = os.path.getmtime(file_path)
+
+        # If the file is new or has been modified, mark schema for update
+        if (
+            file_path not in cached_file_mtimes
+            or current_mtime != cached_file_mtimes[file_path]
+        ):
+            print(f"File {file_path} changed, updating schema...")
+            schema_needs_update = True
+            cached_file_mtimes[
+                file_path
+            ] = current_mtime  # Update the modification time
+
+    # If any file has changed, update the schema
+    if schema_needs_update or cached_schema is None:
+        print("Creating or updating schema based on changed files...")
+        # You can combine the files as needed; here we assume one schema file
+        # If you want to handle multiple schema files differently, adjust this
+
+        # add checks on lookup inputs (i.e. a dataframe in type format: data_lookup_type)
+        combined_lookup_df: data_lookup_type = append_csvs_to_dataframe(
+            file_paths
+        )  # concatonates input lookup files
+
+        cached_schema = create_schema_from_dataframe(
+            combined_lookup_df
+        )  # create cached schema
+
+    else:
+        print("Using cached schema.")
+
+    return cached_schema
+
+
+# example code to convert schema to JSON format if want to export (note pandera[io] required)
+# cached_schema.to_yaml(output_file_path)
+
+# loaded_schema = io.from_yaml(output_file_path)
+
+
+def append_csvs_to_dataframe(csv_paths):
+    """
+    Appends multiple CSV files into a single Pandas DataFrame.
+
+    Args:
+    - csv_paths (list of str): List of paths to CSV files to append.
+
+    Returns:
+    - pd.DataFrame: Combined DataFrame containing data from all provided CSV files.
+
+    Raises:
+    - ValueError: If any CSV file cannot be read.
+    """
+
+    combined_df = pd.DataFrame()  # Initialize an empty DataFrame
+
+    for path in csv_paths:
+        try:
+            # Read the CSV file into a DataFrame
+            df = pd.read_csv(path)
+            # Append to the combined DataFrame
+            combined_df = pd.concat([combined_df, df], ignore_index=True)
+        except Exception as e:
+            raise ValueError(f"Error reading {path}: {e}")
+
+    return combined_df
+
+
+def create_schema_from_dataframe(schema_df: pd.DataFrame) -> pa.DataFrameSchema:
+    """Create a Pandera schema from a DataFrame containing schema information."""
+
+    if schema_df.empty:
+        raise ValueError("The input DataFrame is empty.")
+
+    required_columns = ["name", "col_type", "is_nullable", "is_required"]
+    missing_columns = [col for col in required_columns if col not in schema_df.columns]
+    if missing_columns:
+        raise ValueError(f"Missing columns in schema DataFrame: {missing_columns}")
+
+    # print("Schema DataFrame columns:", schema_df.columns)
+
+    # Sort DataFrame by 'order' if it exists
+    if "order" in schema_df.columns:
+        schema_df = schema_df.sort_values(by="order")
+
+    # Remove rows where 'exclude_from_output' equals 1, if that column exists
+    if "exclude_from_output" in schema_df.columns:
+        schema_df = schema_df[schema_df["exclude_from_output"] != 1]
+
+    # Create a dictionary to hold the column schema
+    schema_dict = {}
+    for _, row in schema_df.iterrows():
+        col_name = row["name"]
+        col_type = row["col_type"]
+        is_nullable = row["is_nullable"] in (1, "1", True, "True")
+        is_required = row["is_required"] in (1, "1", True, "True")
+
+        # print(
+        #     f"Processing column: {col_name}, Type: {col_type}, Nullable: {is_nullable}, Required: {is_required}"
+        # )
+
+        # Map DataFrame types to Pandera types
+        if col_type == "int64":
+            schema_dict[col_name] = pa.Column(
+                pa.Int64, nullable=is_nullable, required=is_required
+            )
+        elif col_type == "int":
+            schema_dict[col_name] = pa.Column(
+                pa.Int, nullable=is_nullable, required=is_required
+            )
+        elif col_type == "string":
+            schema_dict[col_name] = pa.Column(
+                pa.String, nullable=is_nullable, required=is_required
+            )
+        elif col_type == "float32":
+            schema_dict[col_name] = pa.Column(
+                pa.Float32, nullable=is_nullable, required=is_required
+            )
+        elif col_type == "float64":
+            schema_dict[col_name] = pa.Column(
+                pa.Float64, nullable=is_nullable, required=is_required
+            )
+        elif col_type == "bool":
+            schema_dict[col_name] = pa.Column(
+                pa.Bool, nullable=is_nullable, required=is_required
+            )
+        else:
+            raise ValueError(f"Unsupported type: {col_type}")
+
+    # Create and return the DataFrame schema with coercion enabled
+    schema = pa.DataFrameSchema(
+        schema_dict,
+        strict=False,
+        unique_column_names=True,
+        add_missing_columns=True,
+        coerce=True,
+    )
+
+    return schema
+
+
+def setup_logger(name):
+    # Create and configure logger
+    logging.basicConfig(level=logging.INFO)
+    logger = logging.getLogger(name)
+    return logger
+
+
+def log_missing_columns(df_stats: pd.DataFrame, template_schema: pa.DataFrameSchema):
+    # Initialize the logger
+    logger = setup_logger(__name__)
+
+    # Extract the expected columns from the DataFrameSchema
+    template_columns = template_schema.columns.keys()
+    df_stats_columns = df_stats.columns
+
+    # Find missing columns
+    missing_in_template = [
+        col for col in df_stats_columns if col not in template_columns
+    ]
+    missing_in_stats = [col for col in template_columns if col not in df_stats_columns]
+
+    # Log results for missing columns in df_stats
+    if missing_in_template:
+        logger.warning(
+            f"The following columns from the results dataframe did not match any columns in the schema: \n{', '.join(missing_in_template)}"
+        )
+    else:
+        logger.info("All columns from dataframe found in the schema.")
+
+    # Log results for missing columns in template_df
+    if missing_in_stats:
+        logger.warning(
+            f"The following columns in the schema did not match any columns from the results dataframe: \n{', '.join(missing_in_stats)}"
+        )
+    else:
+        logger.info("All columns from the schema found in the results dataframe.")
+
+
+def setup_logger(name):
+    """
+    Set up a logger with a specific name to avoid duplicate logs.
+    """
+    logger = logging.getLogger(name)
+    if not logger.hasHandlers():
+        # Create handlers only if there are none
+        stdout_handler = logging.StreamHandler()
+        file_handler = logging.FileHandler("missing_columns.log")
+
+        # Set levels
+        stdout_handler.setLevel(logging.WARNING)
+        file_handler.setLevel(logging.WARNING)
+
+        # Create formatter and add it to the handlers
+        formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
+        stdout_handler.setFormatter(formatter)
+        file_handler.setFormatter(formatter)
+
+        # Add handlers to the logger
+        logger.addHandler(stdout_handler)
+        logger.addHandler(file_handler)
+
+    return logger

openforis_whisp/risk.py

@@ -0,0 +1,329 @@
+import pandas as pd
+
+from .pd_schemas import data_lookup_type
+
+from openforis_whisp.parameters.config_runtime import (
+    percent_or_ha,
+    geometry_area_column,
+    DEFAULT_GEE_DATASETS_LOOKUP_TABLE_PATH,
+)
+
+# could embed this in each function below that uses lookup_gee_datasets_df.
+lookup_gee_datasets_df: data_lookup_type = pd.read_csv(
+    DEFAULT_GEE_DATASETS_LOOKUP_TABLE_PATH
+)
+
+
+# requires lookup_gee_datasets_df
+
+
+def whisp_risk(
+    df: data_lookup_type,  # CHECK THIS
+    ind_1_pcent_threshold: float = 10,  # default values (draft decision tree and parameters)
+    ind_2_pcent_threshold: float = 10,  # default values (draft decision tree and parameters)
+    ind_3_pcent_threshold: float = 0,  # default values (draft decision tree and parameters)
+    ind_4_pcent_threshold: float = 0,  # default values (draft decision tree and parameters)
+    ind_1_input_columns: pd.Series = None,  # see lookup_gee_datasets for details
+    ind_2_input_columns: pd.Series = None,  # see lookup_gee_datasets for details
+    ind_3_input_columns: pd.Series = None,  # see lookup_gee_datasets for details
+    ind_4_input_columns: pd.Series = None,  # see lookup_gee_datasets for details
+    ind_1_name: str = "Indicator_1_treecover",
+    ind_2_name: str = "Indicator_2_commodities",
+    ind_3_name: str = "Indicator_3_disturbance_before_2020",
+    ind_4_name: str = "Indicator_4_disturbance_after_2020",
+    low_name: str = "no",
+    high_name: str = "yes",
+) -> data_lookup_type:
+    """
+    Adds the EUDR (European Union Deforestation Risk) column to the DataFrame based on indicator values.
+
+    Args:
+        df (DataFrame): Input DataFrame.
+        ind_1_pcent_threshold (int, optional): Percentage threshold for the first indicator. Defaults to 10.
+        ind_2_pcent_threshold (int, optional): Percentage threshold for the second indicator. Defaults to 10.
+        ind_3_pcent_threshold (int, optional): Percentage threshold for the third indicator. Defaults to 0.
+        ind_4_pcent_threshold (int, optional): Percentage threshold for the fourth indicator. Defaults to 0.
+        ind_1_input_columns (list, optional): List of input columns for the first indicator. Defaults to columns for the treecover theme.
+        ind_2_input_columns (list, optional): List of input columns for the second indicator. Defaults to columns for the commodities theme.
+        ind_3_input_columns (list, optional): List of input columns for the third indicator. Defaults to columns for disturbance before 2020.
+        ind_4_input_columns (list, optional): List of input columns for the fourth indicator. Defaults to columns for disturbance after 2020.
+        ind_1_name (str, optional): Name of the first indicator column. Defaults to "Indicator_1_treecover".
+        ind_2_name (str, optional): Name of the second indicator column. Defaults to "Indicator_2_commodities".
+        ind_3_name (str, optional): Name of the third indicator column. Defaults to "Indicator_3_disturbance_before_2020".
+        ind_4_name (str, optional): Name of the fourth indicator column. Defaults to "Indicator_4_disturbance_after_2020".
+        low_name (str, optional): Value shown in table if less than or equal to the threshold. Defaults to "no".
+        high_name (str, optional): Value shown in table if more than the threshold. Defaults to "yes".
+
+    Returns:
+        data_lookup_type: DataFrame with added 'EUDR_risk' column.
+    """
+
+    if ind_1_input_columns is None:
+        ind_1_input_columns = get_cols_ind_1_treecover(lookup_gee_datasets_df)
+    if ind_2_input_columns is None:
+        ind_2_input_columns = get_cols_ind_2_commodities(lookup_gee_datasets_df)
+    if ind_3_input_columns is None:
+        ind_3_input_columns = get_cols_ind_3_dist_before_2020(lookup_gee_datasets_df)
+    if ind_4_input_columns is None:
+        ind_4_input_columns = get_cols_ind_4_dist_after_2020(lookup_gee_datasets_df)
+
+    # Check range of values
+    check_range(ind_1_pcent_threshold)
+    check_range(ind_2_pcent_threshold)
+    check_range(ind_3_pcent_threshold)
+    check_range(ind_4_pcent_threshold)
+
+    input_cols = [
+        ind_1_input_columns,
+        ind_2_input_columns,
+        ind_3_input_columns,
+        ind_4_input_columns,
+    ]
+    thresholds = [
+        ind_1_pcent_threshold,
+        ind_2_pcent_threshold,
+        ind_3_pcent_threshold,
+        ind_4_pcent_threshold,
+    ]
+    names = [ind_1_name, ind_2_name, ind_3_name, ind_4_name]
+    [check_range(threshold) for threshold in thresholds]
+
+    df_w_indicators = add_indicators(
+        df,
+        input_cols,
+        thresholds,
+        names,
+        low_name,
+        high_name,
+    )
+
+    df_w_indicators_and_risk = add_eudr_risk_col(
+        df=df_w_indicators,
+        ind_1_name=ind_1_name,
+        ind_2_name=ind_2_name,
+        ind_3_name=ind_3_name,
+        ind_4_name=ind_4_name,
+    )
+
+    return df_w_indicators_and_risk
+
+
+def add_eudr_risk_col(
+    df: data_lookup_type,
+    ind_1_name: str,
+    ind_2_name: str,
+    ind_3_name: str,
+    ind_4_name: str,
+) -> data_lookup_type:
+    """
+    Adds the EUDR (European Union Deforestation Risk) column to the DataFrame based on indicator values.
+
+    Args:
+        df (DataFrame): Input DataFrame.
+        ind_1_name (str): Name of first indicator column.
+        ind_2_name (str): Name of second indicator column.
+        ind_3_name (str): Name of third indicator column.
+        ind_4_name (str): Name of fourth indicator column.
+
+    Returns:
+        DataFrame: DataFrame with added 'EUDR_risk' column.
+    """
+
+    for index, row in df.iterrows():
+        # If any of the first three indicators suggest low risk, set EUDR_risk to "low"
+        if (
+            row[ind_1_name] == "no"
+            or row[ind_2_name] == "yes"
+            or row[ind_3_name] == "yes"
+        ):
+            df.at[index, "EUDR_risk"] = "low"
+        # If none of the first three indicators suggest low risk and Indicator 4 suggests no risk, set EUDR_risk to "more_info_needed"
+        elif row[ind_4_name] == "no":
+            df.at[index, "EUDR_risk"] = "more_info_needed"
+        # If none of the above conditions are met, set EUDR_risk to "high"
+        else:
+            df.at[index, "EUDR_risk"] = "high"
+
+    return df
+
+
+def add_indicators(
+    df: data_lookup_type,
+    input_cols: list[str],
+    thresholds: list[float],
+    names: list[str],
+    low_name: str = "no",
+    high_name: str = "yes",
+) -> data_lookup_type:
+    for input_col, threshold, name in zip(input_cols, thresholds, names):
+        df = add_indicator_column(
+            df=df,
+            input_columns=input_col,
+            threshold=threshold,
+            new_column_name=name,
+            low_name=low_name,
+            high_name=high_name,
+        )
+
+    return df
+
+
+def add_indicator_column(
+    df: data_lookup_type,
+    input_columns: list[str],
+    threshold: float,
+    new_column_name: str,
+    low_name: str = "yes",
+    high_name: str = "no",
+    sum_comparison: bool = False,
+) -> data_lookup_type:
+    """
+    Add a new column to the DataFrame based on the specified columns, threshold, and comparison sign.
+
+    Parameters:
+        df (data_lookup_type): The pandas DataFrame to which the column will be added.
+        input_columns (list): List of column names to check for threshold.
+        threshold (float): The threshold value to compare against.
+        new_column_name (str): The name of the new column to be added.
+        The '>' sign is used for comparisons.
+        When 'sum comparison' == True, then the threshold is compared to the sum of all those listed in 'input_columns', as opposed to when Flalse, when each column in the list is compared to the threshold individually
+        low_name (str): The name for the value when below or equal to threshold (default is 'no').
+        high_name (str): The name for the value when above threshold (default is 'yes').
+        sum_comparison (bool): If True, sum all values in input_columns and compare to threshold (default is False).
+
+    Returns:
+        data_lookup_type: The DataFrame with the new column added.
+    """
+    # Create a new column and initialize with low_name
+    new_column = pd.Series(low_name, index=df.index, name=new_column_name)
+
+    # Default behavior: use '>' for single column comparison
+    if sum_comparison:
+        # Sum all values in specified columns and compare to threshold
+        sum_values = df[input_columns].sum(axis=1)
+        new_column[sum_values > threshold] = high_name
+    else:
+        # Check if any values in specified columns are above the threshold and update the new column accordingly
+        for col in input_columns:
+            # So that threshold is always in percent, if outputs are in ha, the code converts to percent (based on dividing by the geometry_area_column column.
+            # Clamping is needed due to differences in decimal places (meaning input values may go just over 100)
+            if percent_or_ha == "ha":
+                val_to_check = clamp(
+                    ((df[col] / df[geometry_area_column]) * 100), 0, 100
+                )
+            else:
+                val_to_check = df[col]
+            new_column[val_to_check > threshold] = high_name
+
+    # Concatenate the new column to the DataFrame
+    df = pd.concat([df, new_column], axis=1)
+    return df
+
+
+def get_cols_ind_1_treecover(lookup_gee_datasets_df):
+    """
+    Generate a list of dataset names for the treecover theme, excluding those marked for exclusion.
+
+    Args:
+    lookup_gee_datasets_df (pd.DataFrame): DataFrame containing dataset information.
+
+    Returns:
+    list: List of dataset names set to be used in the risk calculations for the treecover theme, excluding those marked for exclusion.
+    """
+    lookup_gee_datasets_df = lookup_gee_datasets_df[
+        lookup_gee_datasets_df["exclude_from_output"] != 1
+    ]
+    return list(
+        lookup_gee_datasets_df["name"][
+            (lookup_gee_datasets_df["use_for_risk"] == 1)
+            & (lookup_gee_datasets_df["theme"] == "treecover")
+        ]
+    )
+
+
+def get_cols_ind_2_commodities(lookup_gee_datasets_df):
+    """
+    Generate a list of dataset names for the commodities theme, excluding those marked for exclusion.
+
+    Args:
+    lookup_gee_datasets_df (pd.DataFrame): DataFrame containing dataset information.
+
+    Returns:
+    list: List of dataset names set to be used in the risk calculations for the commodities theme, excluding those marked for exclusion.
+    """
+    lookup_gee_datasets_df = lookup_gee_datasets_df[
+        lookup_gee_datasets_df["exclude_from_output"] != 1
+    ]
+    return list(
+        lookup_gee_datasets_df["name"][
+            (lookup_gee_datasets_df["use_for_risk"] == 1)
+            & (lookup_gee_datasets_df["theme"] == "commodities")
+        ]
+    )
+
+
+def get_cols_ind_3_dist_before_2020(lookup_gee_datasets_df):
+    """
+    Generate a list of dataset names for the disturbance before 2020 theme, excluding those marked for exclusion.
+
+    Args:
+    lookup_gee_datasets_df (pd.DataFrame): DataFrame containing dataset information.
+
+    Returns:
+    list: List of dataset names set to be used in the risk calculations for the disturbance before 2020 theme, excluding those marked for exclusion.
+    """
+    lookup_gee_datasets_df = lookup_gee_datasets_df[
+        lookup_gee_datasets_df["exclude_from_output"] != 1
+    ]
+    return list(
+        lookup_gee_datasets_df["name"][
+            (lookup_gee_datasets_df["use_for_risk"] == 1)
+            & (lookup_gee_datasets_df["theme"] == "disturbance_before")
+        ]
+    )
+
+
+def get_cols_ind_4_dist_after_2020(lookup_gee_datasets_df):
+    """
+    Generate a list of dataset names for the disturbance after 2020 theme, excluding those marked for exclusion.
+
+    Args:
+    lookup_gee_datasets_df (pd.DataFrame): DataFrame containing dataset information.
+
+    Returns:
+    list: List of dataset names set to be used in the risk calculations  for the disturbance after 2020 theme, excluding those marked for exclusion.
+    """
+    lookup_gee_datasets_df = lookup_gee_datasets_df[
+        lookup_gee_datasets_df["exclude_from_output"] != 1
+    ]
+    return list(
+        lookup_gee_datasets_df["name"][
+            (lookup_gee_datasets_df["use_for_risk"] == 1)
+            & (lookup_gee_datasets_df["theme"] == "disturbance_after")
+        ]
+    )
+
+
+def clamp(
+    value: float | pd.Series, min_val: float, max_val: float
+) -> float | pd.Series:
+    """
+    Clamp a value or a Pandas Series within a specified range.
+
+    Args:
+        value (float | pd.Series): The value or series to be clamped.
+        min_val (float): The minimum value of the range.
+        max_val (float): The maximum value of the range.
+
+    Returns:
+        float | pd.Series: The clamped value or series within the range.
+    """
+    if isinstance(value, pd.Series):
+        return value.clip(lower=min_val, upper=max_val)
+    else:
+        return max(min_val, min(value, max_val))
+
+
+def check_range(value: float) -> None:
+    if not (0 <= value <= 100):
+        raise ValueError("Value must be between 0 and 100.")