agrs 0.1.3__py3-none-any.whl

agrs/__init__.py

@@ -0,0 +1,4 @@
+from .client import s2agc
+
+__all__ = ["s2agc"]
+__version__ = "0.1.2"

agrs/aggregation.py

@@ -0,0 +1,87 @@
+from typing import Dict, List, Tuple
+import numpy as np
+import pandas as pd
+
+from .config import DEFAULT_SUMMARY_STATS, DEFAULT_STAGE_BOUNDS
+
+def summarize_array(arr: np.ndarray, stats: List[str]) -> Dict[str, float]:
+    arr_flat = arr[np.isfinite(arr)].ravel()
+    if arr_flat.size == 0:
+        return {s: np.nan for s in stats}
+
+    out = {}
+    if "mean" in stats:
+        out["mean"] = float(np.mean(arr_flat))
+    if "median" in stats:
+        out["median"] = float(np.median(arr_flat))
+    if "min" in stats:
+        out["min"] = float(np.min(arr_flat))
+    if "max" in stats:
+        out["max"] = float(np.max(arr_flat))
+    if "std" in stats:
+        out["std"] = float(np.std(arr_flat))
+    return out
+
+def stage_for_fraction(
+    frac: float,
+    stage_bounds: Dict[str, Tuple[float, float]] = DEFAULT_STAGE_BOUNDS,
+) -> str:
+    for name, (lo, hi) in stage_bounds.items():
+        if lo <= frac < hi:
+            return name
+    return "other"
+
+def aggregate_field_indices(
+    field_id: str,
+    index_time_series: Dict[str, List[Dict]],
+    season_start,
+    season_end,
+    summary_stats: List[str] = None,
+    stage_bounds: Dict[str, Tuple[float, float]] = None,
+) -> pd.Series:
+    """
+    index_time_series: dict index_name -> list of dicts:
+        {"datetime": dt, "fraction": f, "array": arr_field}
+    Returns a pd.Series with columns like NDVI_early_mean, NDVI_mid_max, ...
+    """
+    if summary_stats is None:
+        summary_stats = DEFAULT_SUMMARY_STATS
+    if stage_bounds is None:
+        stage_bounds = DEFAULT_STAGE_BOUNDS
+
+    data = {
+        "field_id": field_id,
+        "season_start": season_start,
+        "season_end": season_end,
+    }
+
+    for index_name, entries in index_time_series.items():
+        # group arrays by stage
+        stage_arrays = {stage: [] for stage in stage_bounds.keys()}
+        for e in entries:
+            f = e["fraction"]
+            arr = e["array"]
+            stage = stage_for_fraction(f, stage_bounds)
+            if stage in stage_arrays:
+                stage_arrays[stage].append(arr)
+
+        # compute stats per stage
+        for stage, arr_list in stage_arrays.items():
+            if not arr_list:
+                for stat in summary_stats:
+                    col = f"{index_name}_{stage}_{stat}"
+                    data[col] = float("nan")
+                continue
+
+            # combine all arrays in stage (stack, then aggregate)
+            stacked = np.stack(arr_list, axis=0)
+            # reduce over time and space (flatten)
+            # simple approach: average over time first, then stats over space
+            mean_over_time = np.nanmean(stacked, axis=0)
+            stats_dict = summarize_array(mean_over_time, summary_stats)
+
+            for stat, val in stats_dict.items():
+                col = f"{index_name}_{stage}_{stat}"
+                data[col] = val
+
+    return pd.Series(data)

agrs/client.py

@@ -0,0 +1,143 @@
+from typing import Optional, List, Dict, Any
+from datetime import datetime
+import numpy as np
+import pandas as pd
+import geopandas as gpd
+from tqdm import tqdm
+
+from .config import DEFAULT_INDICES
+from .indices import compute_indices
+from .aggregation import aggregate_field_indices
+from .selection import (
+    select_snapshots_fractional,
+    select_snapshot_fixed_date,
+    select_top_n_cloudfree,
+)
+from .sources.planetary_computer_source import PlanetaryComputerS2Source
+from .utils import gdf_to_bbox, clip_raster_to_geom
+
+
+class s2agc:
+    def __init__(
+        self,
+        source: str = "planetary_computer",
+        max_cloud: float = 0.3,
+    ):
+        if source != "planetary_computer":
+            raise ValueError("Currently only 'planetary_computer' source is supported in MVP.")
+        self.source = PlanetaryComputerS2Source(max_cloud=max_cloud)
+
+    def get_features(
+        self,
+        fields: gpd.GeoDataFrame,
+        field_id_col: str,
+        start_date: str,
+        end_date: str,
+        crop: Optional[str] = None,
+        n_snapshots: int = 3,
+        snapshot_strategy: str = "fractional",  # 'fractional', 'fixed_date', 'top_n_cloudfree'
+        fractions: Optional[List[float]] = None,
+        target_date: Optional[str] = None,
+        indices: Optional[List[str]] = None,
+        bands: Optional[List[str]] = None,
+        stac_limit: int = 100,
+    ) -> pd.DataFrame:
+        """
+        Main entry point: returns field-level RS features for given season.
+        """
+        if indices is None:
+            indices = DEFAULT_INDICES
+
+        season_start = datetime.fromisoformat(start_date)
+        season_end = datetime.fromisoformat(end_date)
+
+        bbox = gdf_to_bbox(fields)
+        items = self.source.search_items(bbox, start_date, end_date, limit=stac_limit)
+        if not items:
+            raise RuntimeError("No Sentinel-2 items found for given area/date range.")
+
+        # Choose snapshots according to strategy
+        if snapshot_strategy == "fractional":
+            if fractions is None:
+                fractions = np.linspace(0.2, 1.0, n_snapshots).tolist()
+            chosen_items = select_snapshots_fractional(items, season_start, season_end, fractions)
+        elif snapshot_strategy == "fixed_date":
+            if target_date is None:
+                raise ValueError("target_date must be provided for 'fixed_date' strategy.")
+            dt = datetime.fromisoformat(target_date)
+            chosen_item = select_snapshot_fixed_date(items, dt)
+            chosen_items = [chosen_item] if chosen_item else []
+        elif snapshot_strategy == "top_n_cloudfree":
+            chosen_items = select_top_n_cloudfree(items, n_snapshots)
+        else:
+            raise ValueError(f"Unknown snapshot_strategy: {snapshot_strategy}")
+
+        if not chosen_items:
+            raise RuntimeError("No snapshots selected after applying strategy.")
+
+        # Determine bands to fetch: either user-defined or all required for indices
+        if bands is None:
+            # Collect all bands in assets whose keys start with 'B'
+            # (assumes items share same band set)
+            sample_assets = chosen_items[0]["assets"]
+            bands = sorted([k for k in sample_assets.keys() if k.startswith("B")])
+
+        rows = []
+
+        # Precompute time fractions for each chosen item
+        dur = (season_end - season_start).total_seconds()
+        item_meta = []
+        for it in chosen_items:
+            dt = datetime.fromisoformat(it["properties"]["datetime"].replace("Z", ""))
+            frac = (dt - season_start).total_seconds() / dur
+            frac = float(np.clip(frac, 0.0, 1.0))
+            item_meta.append((it, dt, frac))
+
+        for _, field in tqdm(fields.iterrows(), total=len(fields), desc="Fields"):
+            field_id = field[field_id_col]
+            geom = field.geometry
+
+            index_time_series: Dict[str, List[Dict[str, Any]]] = {idx: [] for idx in indices}
+
+            for it, dt, frac in item_meta:
+                # Map requested bands to asset hrefs
+                assets = it["assets"]
+                band_hrefs = {}
+                for b in bands:
+                    if b in assets:
+                        band_hrefs[b] = assets[b]["href"]
+
+                if not band_hrefs:
+                    continue
+
+                # Clip raster bands to field geometry
+                band_arrays = clip_raster_to_geom(asset_href=None, geom=geom, bands=band_hrefs)
+
+                # If no overlap (empty dict), skip this snapshot for this field
+                if not band_arrays:
+                    continue
+
+                # Compute indices
+                idx_arrays = compute_indices(band_arrays)
+
+                for idx_name in indices:
+                    if idx_name not in idx_arrays:
+                        continue
+                    index_time_series[idx_name].append(
+                        {
+                            "datetime": dt,
+                            "fraction": frac,
+                            "array": idx_arrays[idx_name],
+                        }
+                    )
+
+            # Aggregate per field
+            series = aggregate_field_indices(
+                field_id=field_id,
+                index_time_series=index_time_series,
+                season_start=season_start,
+                season_end=season_end,
+            )
+            rows.append(series)
+
+        return pd.DataFrame(rows)

agrs/config.py

@@ -0,0 +1,21 @@
+DEFAULT_INDICES = [
+    "NDVI",
+    "EVI",
+    "SAVI",
+    "NDWI",
+    "NDMI",
+    "GCI",
+    "NDRE",
+    "RECI",
+    "NBR",
+    "NBR2",
+]
+
+DEFAULT_SUMMARY_STATS = ["mean", "median", "min", "max", "std"]
+
+# Early, mid, late as fractions of season duration
+DEFAULT_STAGE_BOUNDS = {
+    "early":  (0.0, 0.33),
+    "mid":    (0.33, 0.66),
+    "late":   (0.66, 1.01),
+}

agrs/indices.py

@@ -0,0 +1,85 @@
+import numpy as np
+import logging
+from typing import Dict
+
+logger = logging.getLogger(__name__)
+
+# Helper to safely divide
+def _safe_div(numer, denom, eps=1e-6):
+    denom_safe = np.where(np.abs(denom) < eps, np.nan, denom)
+    return np.divide(numer, denom_safe)
+
+def compute_indices(bands: Dict[str, np.ndarray]) -> Dict[str, np.ndarray]:
+    """
+    Compute all supported indices from a dict of bands.
+    bands: mapping like {"B02": arr, "B03": arr, ...}
+    Returns dict of index_name -> array (same shape).
+    Skips indices if required bands missing; logs warning.
+    """
+    idx = {}
+
+    def has(*needed):
+        miss = [b for b in needed if b not in bands]
+        if miss:
+            logger.warning("Missing bands %s for index, skipping.", miss)
+            return False
+        return True
+
+    # NDVI: (NIR - RED) / (NIR + RED) = (B08 - B04) / (B08 + B04)
+    if has("B08", "B04"):
+        num = bands["B08"] - bands["B04"]
+        den = bands["B08"] + bands["B04"]
+        idx["NDVI"] = _safe_div(num, den)
+
+    # EVI: 2.5 * (NIR - RED) / (NIR + 6*RED - 7.5*BLUE + 1)
+    if has("B08", "B04", "B02"):
+        num = bands["B08"] - bands["B04"]
+        den = bands["B08"] + 6.0 * bands["B04"] - 7.5 * bands["B02"] + 1.0
+        idx["EVI"] = 2.5 * _safe_div(num, den)
+
+    # SAVI: (NIR - RED) / (NIR + RED + L) * (1 + L), L=0.5
+    if has("B08", "B04"):
+        L = 0.5
+        num = bands["B08"] - bands["B04"]
+        den = bands["B08"] + bands["B04"] + L
+        idx["SAVI"] = (1 + L) * _safe_div(num, den)
+
+    # NDWI (Gao): (NIR - SWIR) / (NIR + SWIR) = (B08 - B11) / (B08 + B11)
+    if has("B08", "B11"):
+        num = bands["B08"] - bands["B11"]
+        den = bands["B08"] + bands["B11"]
+        idx["NDWI"] = _safe_div(num, den)
+
+    # NDMI: (NIR - SWIR2) / (NIR + SWIR2) = (B08 - B12) / (B08 + B12)
+    if has("B08", "B12"):
+        num = bands["B08"] - bands["B12"]
+        den = bands["B08"] + bands["B12"]
+        idx["NDMI"] = _safe_div(num, den)
+
+    # GCI: (NIR / GREEN) - 1 = (B08 / B03) - 1
+    if has("B08", "B03"):
+        idx["GCI"] = _safe_div(bands["B08"], bands["B03"]) - 1.0
+
+    # NDRE: (NIR - RE1) / (NIR + RE1) = (B08 - B05) / (B08 + B05)
+    if has("B08", "B05"):
+        num = bands["B08"] - bands["B05"]
+        den = bands["B08"] + bands["B05"]
+        idx["NDRE"] = _safe_div(num, den)
+
+    # RECI: (NIR / RE1) - 1 = (B08 / B05) - 1
+    if has("B08", "B05"):
+        idx["RECI"] = _safe_div(bands["B08"], bands["B05"]) - 1.0
+
+    # NBR: (NIR - SWIR2) / (NIR + SWIR2) = (B08 - B12) / (B08 + B12)
+    if has("B08", "B12"):
+        num = bands["B08"] - bands["B12"]
+        den = bands["B08"] + bands["B12"]
+        idx["NBR"] = _safe_div(num, den)
+
+    # NBR2: (SWIR1 - SWIR2) / (SWIR1 + SWIR2) = (B11 - B12) / (B11 + B12)
+    if has("B11", "B12"):
+        num = bands["B11"] - bands["B12"]
+        den = bands["B11"] + bands["B12"]
+        idx["NBR2"] = _safe_div(num, den)
+
+    return idx

agrs/selection.py

@@ -0,0 +1,70 @@
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+
+def select_snapshots_fractional(
+    items: List[Dict[str, Any]],
+    season_start: datetime,
+    season_end: datetime,
+    fractions: List[float],
+) -> List[Dict[str, Any]]:
+    """
+    Select items closest to given fractions of the season duration.
+    items: list of STAC items with 'properties'['datetime'].
+    """
+    if not items:
+        return []
+
+    # Sort by time
+    items_sorted = sorted(
+        items,
+        key=lambda x: datetime.fromisoformat(x["properties"]["datetime"].replace("Z", "")),
+    )
+
+    start = season_start
+    end = season_end
+    dur = (end - start).total_seconds()
+    out = []
+
+    for f in fractions:
+        target_t = start.timestamp() + f * dur
+        best = min(
+            items_sorted,
+            key=lambda it: abs(
+                datetime.fromisoformat(it["properties"]["datetime"].replace("Z", "")).timestamp() - target_t
+            ),
+        )
+        if best not in out:
+            out.append(best)
+
+    return out
+
+def select_snapshot_fixed_date(
+    items: List[Dict[str, Any]],
+    target_date: datetime,
+) -> Optional[Dict[str, Any]]:
+    """Select single item closest to target_date."""
+    if not items:
+        return None
+    return min(
+        items,
+        key=lambda it: abs(
+            datetime.fromisoformat(it["properties"]["datetime"].replace("Z", "")) - target_date
+        ),
+    )
+
+def select_top_n_cloudfree(
+    items: List[Dict[str, Any]],
+    n: int,
+    cloud_prop_name: str = "eo:cloud_cover",
+) -> List[Dict[str, Any]]:
+    """Select N items with lowest cloud cover."""
+    if not items or n <= 0:
+        return []
+    items_with_cloud = [
+        it for it in items if cloud_prop_name in it.get("properties", {})
+    ]
+    items_sorted = sorted(
+        items_with_cloud,
+        key=lambda it: it["properties"].get(cloud_prop_name, 100.0),
+    )
+    return items_sorted[:n]

agrs/sources/planetary_computer_source.py

@@ -0,0 +1,53 @@
+from typing import List, Dict, Any, Tuple
+from datetime import datetime
+
+import planetary_computer as pc
+from pystac_client import Client
+
+
+class PlanetaryComputerS2Source:
+    """
+    Minimal Sentinel-2 L2A source backed by Microsoft Planetary Computer.
+
+    Parameters
+    ----------
+    max_cloud : float
+        Maximum allowed cloud cover fraction in [0, 1]. This is converted to
+        percentage for the STAC query (eo:cloud_cover < max_cloud * 100).
+    """
+
+    def __init__(self, max_cloud: float = 0.3) -> None:
+        self.max_cloud = float(max_cloud)
+        self._client = Client.open(
+            "https://planetarycomputer.microsoft.com/api/stac/v1",
+            modifier=pc.sign_inplace,
+        )
+
+    def search_items(
+        self,
+        bbox: Tuple[float, float, float, float],
+        start_date: str,
+        end_date: str,
+        limit: int = 100,
+    ) -> List[Dict[str, Any]]:
+        """
+        Search Sentinel-2 L2A items in Planetary Computer.
+
+        Returns a list of pystac Items converted to plain dicts.
+        """
+        datetime_range = f"{start_date}/{end_date}"
+
+        search = self._client.search(
+            collections=["sentinel-2-l2a"],
+            bbox=bbox,
+            datetime=datetime_range,
+            max_items=limit,
+            query={
+                "eo:cloud_cover": {
+                    "lt": self.max_cloud * 100.0
+                }
+            },
+        )
+
+        items = list(search.get_items())
+        return [item.to_dict() for item in items]

agrs/utils.py

@@ -0,0 +1,65 @@
+from typing import Tuple, Dict
+
+from shapely.geometry import mapping
+import geopandas as gpd
+import rasterio
+from rasterio.mask import mask
+from rasterio.warp import transform_geom
+import numpy as np
+
+
+def gdf_to_bbox(gdf: gpd.GeoDataFrame) -> Tuple[float, float, float, float]:
+    """
+    Convert a GeoDataFrame to a bounding box tuple (minx, miny, maxx, maxy).
+    """
+    bounds = gdf.total_bounds  # minx, miny, maxx, maxy
+    return tuple(bounds.tolist())
+
+
+def clip_raster_to_geom(
+    asset_href: str,
+    geom,
+    bands: Dict[str, str],
+) -> Dict[str, np.ndarray]:
+    """
+    Clip raster bands to a geometry.
+
+    Parameters
+    ----------
+    asset_href : str
+        Unused in this MVP; kept for potential future extension.
+    geom : shapely geometry
+        Geometry in EPSG:4326 (WGS84).
+    bands : dict
+        Mapping band_code -> href for each band.
+
+    Returns
+    -------
+    dict
+        Mapping band_code -> clipped numpy array (H, W).
+        If geometry does not overlap any band raster, returns {}.
+    """
+    out: Dict[str, np.ndarray] = {}
+
+    for band_code, href in bands.items():
+        with rasterio.open(href) as src:
+            # Reproject geometry from EPSG:4326 to raster CRS if needed
+            geom_geojson = [mapping(geom)]
+            if src.crs is not None and src.crs.to_string() != "EPSG:4326":
+                geom_geojson = [
+                    transform_geom("EPSG:4326", src.crs, g) for g in geom_geojson
+                ]
+
+            try:
+                arr, _ = mask(src, geom_geojson, crop=True)
+            except ValueError as e:
+                # Shapes do not overlap raster: skip this item entirely
+                if "do not overlap raster" in str(e):
+                    return {}
+                else:
+                    raise
+
+            # arr shape: (1, H, W)
+            out[band_code] = arr[0].astype("float32")
+
+    return out

agrs-0.1.3.dist-info/METADATA

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: agrs
+Version: 0.1.3
+Summary: AGRS – Agricultural Remote Sensing Library
+Home-page: https://github.com/abdelghanibelgaid/agrs
+Author: AGRS Developers
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: geopandas
+Requires-Dist: shapely
+Requires-Dist: rasterio
+Requires-Dist: pystac-client
+Requires-Dist: planetary-computer
+Requires-Dist: xarray
+Requires-Dist: tqdm
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# AGRS – Agricultural Remote Sensing Library
+[![PyPI](https://img.shields.io/pypi/v/agrs.svg?label=PyPI)](https://pypi.org/project/agrs/)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.17699363.svg)](https://doi.org/10.5281/zenodo.17699363)
+
+
+## Description
+
+AGRS is a domain-focused Python library that turns **Sentinel-2 imagery** into **agronomy-ready features** for various agricultural modeling tasks, such as yield modeling, stress analysis, and NPK recommendation.
+
+Instead of dealing with STAC queries, cloud masks, band math, and geometry clipping in every project, AGRS provides **opinionated, agriculture-centric pipelines**:
+
+- Search & fetch Sentinel-2 scenes (via Microsoft Planetary Computer STAC).
+- Compute standard indices (NDVI, EVI, SAVI, NDWI, NDMI, GCI, NDRE, RECI, NBR, NBR2).
+- Select snapshots using agronomic strategies (fractions of season, specific dates, best cloud-free scenes).
+- Aggregate to field-level features per index and **growth stage** (early/mid/late season) with statistics (mean, median, min, max, std and more).
+- Return a tidy `DataFrame` ready to join with yield, NPK, and management tables.
+
+The goal is to maximize value for agricultural ML workflows: **field trial analysis**, **site-specific NPK optimization**, and **crop monitoring**.
+
+## Key features
+
+- Sentinel-2 access via **Planetary Computer STAC API**.
+- Automatic band selection (default: all available bands) or user-defined.
+- Built-in index formulas:
+  - NDVI, EVI, SAVI, NDWI, NDMI, GCI, NDRE, RECI, NBR, NBR2
+  - Robust handling of missing bands and divide-by-zero (graceful skip + warnings).
+- Snapshot selection strategies:
+  - `fractional` – e.g., snapshots near 30%, 60%, 90% of the season.
+  - `fixed_date` – snapshot closest to a given date.
+  - `top_n_cloudfree` – N lowest-cloud scenes in the period.
+- Field-level aggregation:
+  - For each index and stage: `mean`, `median`, `min`, `max`, `std`.
+  - Early, mid, late stages defined as 0–33%, 33–66%, 66–100% of season duration.
+
+## Quick example
+
+```python
+import geopandas as gpd
+from shapely.geometry import Point
+from agrs.client import s2agc
+
+field_geom = Point(-8.0, 32.0)
+
+fields = gpd.GeoDataFrame(
+    {
+        "field_id": [1],
+        "geometry": [field_geom],
+    },
+    crs="EPSG:4326",
+)
+
+client = s2agc(
+    source="planetary_computer",
+    max_cloud=0.2,
+)
+
+features_df = client.get_features(
+    fields=fields,
+    field_id_col="field_id",
+    start_date="2018-10-01",
+    end_date="2019-06-30",
+    crop="wheat",
+    n_snapshots=4,
+    snapshot_strategy="fractional",
+    fractions=[0.3, 0.6, 0.9, 1.0],
+)
+
+print(features_df.head())

agrs-0.1.3.dist-info/RECORD

@@ -0,0 +1,13 @@
+agrs/__init__.py,sha256=jzb3ksFzdIbguvHOoNZNd6kceGGKN-IBcWCl53HzCE4,69
+agrs/aggregation.py,sha256=PKfsumW6z_lBdoMvkDn9PQ1PxxNioORlj_sA_Y99QTQ,2887
+agrs/client.py,sha256=04MvNcLdFvvVL_GVuSLCAUpyBApZV53umB-ZJaq2Rpg,5445
+agrs/config.py,sha256=SgyzuXgPSPTKfouHDf3UZbO0ybJsfgZ1HsZx_5ZZNyQ,366
+agrs/indices.py,sha256=AzDBSAq8XUDWnJizCDGuQrUDhWnoEx1ydFfo-Jvi8bM,2935
+agrs/selection.py,sha256=rtwleMr24w5phmmg92alOeoSpVhWxO6Gm_dHMY8AeMA,1939
+agrs/utils.py,sha256=1cKU0noVQqTVpNAIEDiyt6uZbibGhnfbugXDL4eL3WI,1902
+agrs/sources/planetary_computer_source.py,sha256=z5ibFVjrz-Hrtj9z0aK4ua5rBh5ikKXQQ-YMKLbUoCI,1521
+agrs-0.1.3.dist-info/licenses/LICENSE,sha256=svrXVwrP5tPtIcIWeivLVT36ndCaOoTTmGxgrM648WI,1075
+agrs-0.1.3.dist-info/METADATA,sha256=Hvpf-bN-LDeAH2cZ6a-T_UI38KKscdzlcsJasqAKtmA,3207
+agrs-0.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+agrs-0.1.3.dist-info/top_level.txt,sha256=eCWckqshAAsCBr73_QnDYujAuZfKSihBosvF2AXP6Ek,5
+agrs-0.1.3.dist-info/RECORD,,

agrs-0.1.3.dist-info/WHEEL

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

agrs-0.1.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Abdelghani Belgaid
+
+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.

agrs-0.1.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+agrs