rle-python 0.2.0__py3-none-any.whl

rle/core/eoo.py

@@ -0,0 +1,243 @@
+"""Extent of Occurrence (EOO) computation for RLE assessments.
+
+Provides the ``EOO`` class hierarchy and the ``make_eoo()`` helper for
+computing EOO from a local ``Ecosystems`` instance. Earth Engine EOO support
+lives in the optional ``rle-python-gee`` package.
+"""
+
+from abc import ABC, abstractmethod
+
+from rle.core.ecosystems import (
+    Ecosystems,
+    EcosystemKind,
+)
+
+
+class EOONotComputedError(Exception):
+    """Raised when accessing EOO results before compute() has been called."""
+
+    def __init__(self):
+        super().__init__(
+            "EOO has not been computed yet. "
+            "Call .compute() to run the computation."
+        )
+
+
+class EOO(ABC):
+    """Base class for Extent of Occurrence computations.
+
+    Subclasses implement ``_compute()`` to calculate the convex hull
+    geometry and area.
+    """
+
+    def __init__(self, ecosystems: Ecosystems):
+        self._ecosystems = ecosystems
+        self._computed = False
+        self._geometry = None
+        self._area_km2: float | None = None
+        self._crs = None
+
+    @abstractmethod
+    def _compute(self) -> None:
+        """Run the EOO computation.
+
+        Must store results so that ``_load_geometry()`` and
+        ``_load_area_km2()`` can retrieve them.
+        """
+        ...
+
+    @abstractmethod
+    def _load_geometry(self):
+        """Return the computed convex hull geometry."""
+        ...
+
+    @abstractmethod
+    def _load_area_km2(self) -> float:
+        """Return the EOO area in km²."""
+        ...
+
+    def compute(self) -> "EOO":
+        """Run the EOO computation. Returns self for method chaining."""
+        self._compute()
+        self._computed = True
+        self._geometry = None
+        self._area_km2 = None
+        return self
+
+    @property
+    def geometry(self):
+        """The convex hull geometry. Raises EOONotComputedError if not computed."""
+        if not self._computed:
+            raise EOONotComputedError()
+        if self._geometry is None:
+            self._geometry = self._load_geometry()
+        return self._geometry
+
+    @property
+    def area_km2(self) -> float:
+        """EOO area in km²."""
+        if not self._computed:
+            raise EOONotComputedError()
+        if self._area_km2 is None:
+            self._area_km2 = self._load_area_km2()
+        return self._area_km2
+
+    # -- export / visualization ----------------------------------------------
+
+    def to_geodataframe(self):
+        """Return the convex hull as a single-row GeoDataFrame."""
+        import geopandas as gpd
+
+        return gpd.GeoDataFrame(
+            {"area_km2": [self.area_km2]},
+            geometry=[self.geometry],
+            crs=self._crs,
+        )
+
+    def to_gdf_for_viz(self, *, get_fill_color=None, get_line_color=None, **_):
+        """Return (gdf, style_dict) for static-image fallback rendering."""
+        if get_fill_color is None:
+            get_fill_color = [255, 0, 0, 40]
+        if get_line_color is None:
+            get_line_color = [255, 0, 0, 255]
+        return self.to_geodataframe(), {"fill": get_fill_color, "edge": get_line_color}
+
+    def to_layer(self, *, get_fill_color=None, get_line_color=None):
+        """Return a lonboard PolygonLayer of the EOO convex hull."""
+        gdf = self.to_geodataframe()
+        if gdf.geometry.is_empty.all():
+            return []
+
+        try:
+            from lonboard import PolygonLayer
+        except ImportError:
+            raise ImportError(
+                "lonboard is required for visualization. "
+                "Install it with: pip install rle-python[viz]"
+            ) from None
+
+        if get_fill_color is None:
+            get_fill_color = [255, 0, 0, 40]
+        if get_line_color is None:
+            get_line_color = [255, 0, 0, 255]
+
+        return [PolygonLayer.from_geopandas(
+            gdf,
+            get_fill_color=get_fill_color,
+            get_line_color=get_line_color,
+            line_width_min_pixels=2,
+        )]
+
+    def to_map(self, **kwargs):
+        """Return a lonboard Map showing the EOO convex hull."""
+        try:
+            from lonboard import Map
+        except ImportError:
+            raise ImportError(
+                "lonboard is required for visualization. "
+                "Install it with: pip install rle-python[viz]"
+            ) from None
+
+        return Map(layers=self.to_layer(), **kwargs)
+
+    # -- display -------------------------------------------------------------
+
+    def __repr__(self) -> str:
+        if not self._computed:
+            return f"{type(self).__name__}(not computed)"
+        return (
+            f"{type(self).__name__}("
+            f"area_km2={self.area_km2:,.0f})"
+        )
+
+    def _repr_html_(self) -> str:
+        if not self._computed:
+            return (
+                f"<b>{type(self).__name__}</b><br>"
+                f"<i>Not computed — call .compute() to run</i>"
+            )
+        return (
+            f"<b>{type(self).__name__}</b><br>"
+            f"EOO: {self.area_km2:,.0f} km²"
+        )
+
+
+class EOOVectorLocal(EOO):
+    """EOO from a local vector dataset (GeoDataFrame, GeoJSON, GeoParquet)."""
+
+    def _compute(self) -> None:
+        import geopandas as gpd
+
+        gdf = self._ecosystems.to_geodataframe()
+
+        self._crs = gdf.crs or "EPSG:4326"
+
+        # Union all geometries, then compute convex hull
+        union = gdf.geometry.union_all()
+        hull = union.convex_hull
+
+        # Degenerate inputs (single point, collinear points, empty) produce
+        # Point/LineString/GeometryCollection which lonboard cannot render.
+        geom_type = hull.geom_type if hull is not None and not hull.is_empty else None
+        if geom_type not in ("Polygon", "MultiPolygon"):
+            from shapely import Polygon
+            if hull is None or hull.is_empty:
+                hull = Polygon()
+            else:
+                hull = hull.buffer(0.0001)
+
+        self._computed_geometry = hull
+
+        # Compute area in km² using equal-area projection (ESRI:54034)
+        hull_gdf = gpd.GeoDataFrame(geometry=[hull], crs=self._crs)
+        hull_ea = hull_gdf.to_crs("ESRI:54034")
+        self._computed_area = hull_ea.geometry.iloc[0].area / 1e6
+
+    def _load_geometry(self):
+        return self._computed_geometry
+
+    def _load_area_km2(self) -> float:
+        return self._computed_area
+
+
+# ---------------------------------------------------------------------------
+# Factory
+# ---------------------------------------------------------------------------
+
+
+def make_eoo(data, **kwargs) -> EOO:
+    """Create an EOO from an ``Ecosystems`` instance.
+
+    Call ``.compute()`` to run the computation before accessing results.
+
+    Args:
+        data: An ``Ecosystems`` instance. For local vector data this returns
+            an :class:`EOOVectorLocal`. Earth Engine ecosystems require the
+            ``rle-python-gee`` package; construct the EE EOO backend
+            explicitly from ``rle.gee``.
+        **kwargs: Additional arguments passed to the backend constructor.
+
+    Returns:
+        An EOO instance. Call .compute() to run the computation.
+
+    Example:
+        >>> from rle.core import Ecosystems
+        >>> eco = Ecosystems.from_file("ecosystems.geojson", ecosystem_column="ECO_NAME")
+        >>> eoo = make_eoo(eco).compute()
+        >>> print(eoo.area_km2)
+    """
+    if isinstance(data, Ecosystems):
+        kind = data.kind
+        if kind == EcosystemKind.VECTOR_LOCAL:
+            return EOOVectorLocal(data, **kwargs)
+        if kind in (EcosystemKind.EE_FEATURE_COLLECTION, EcosystemKind.EE_IMAGE):
+            raise ValueError(
+                f"EOO for {kind.value} requires the 'rle-python-gee' package. "
+                f"Install it and construct the Earth Engine EOO backend from rle.gee."
+            )
+        raise ValueError(f"EOO not yet supported for {kind.value}")
+
+    raise TypeError(
+        "make_eoo expects an Ecosystems instance. Construct one first, e.g. "
+        "Ecosystems.from_file(path, ecosystem_column=...) or a backend from rle.gee."
+    )

rle/core/registry.py

@@ -0,0 +1,62 @@
+"""Backend discovery for the ``rle`` namespace.
+
+Backend distributions (e.g. ``rle-python-gee``) advertise their data-access
+backends through an ``rle.backends`` entry point. Each entry point is a
+callable returning one or more :class:`BackendInfo` records.
+
+This registry is for *discovery and introspection* only (e.g. the ``rle
+backends`` CLI command). Backends are constructed explicitly by importing
+their classes — there is no auto-dispatch here.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from importlib.metadata import entry_points
+from typing import Callable, Optional
+
+_GROUP = "rle.backends"
+
+
+@dataclass(frozen=True)
+class BackendInfo:
+    """Describes a single data-access backend.
+
+    Attributes:
+        name: Stable identifier, e.g. ``"gee-feature-collection"``.
+        cls: The backend class (an ``Ecosystems``/``AOOGrid``/``EOO`` subclass).
+        capability: One of ``"ecosystems"``, ``"aoo"``, ``"eoo"``.
+        distribution: The distribution that provides it, e.g. ``"rle-python-gee"``.
+        can_handle: Optional predicate for a future URI/data dispatcher.
+    """
+
+    name: str
+    cls: type
+    capability: str
+    distribution: str = ""
+    can_handle: Optional[Callable[[object], bool]] = None
+
+
+def iter_backends() -> list[BackendInfo]:
+    """Return every backend advertised by installed ``rle.backends`` entry points.
+
+    Entry points whose callable fails to load or run are skipped silently so a
+    broken optional backend never breaks discovery of the others.
+    """
+    infos: list[BackendInfo] = []
+    for ep in entry_points(group=_GROUP):
+        try:
+            factory = ep.load()
+            result = factory()
+        except Exception:
+            continue
+        if isinstance(result, (list, tuple)):
+            infos.extend(r for r in result if isinstance(r, BackendInfo))
+        elif isinstance(result, BackendInfo):
+            infos.append(result)
+    return infos
+
+
+def list_backends() -> list[str]:
+    """Return the names of all installed backends, sorted."""
+    return sorted(b.name for b in iter_backends())

rle/core/rle.py

@@ -0,0 +1,71 @@
+# https://iucnrle.org/rle-categ-and-criteria
+rle_criteria = {
+    "A": {
+        "description": "Reduction in geographic distribution",
+        "threshold": 0.5
+    },
+    "B": {
+        "description": "Restricted geographic distribution",
+        "threshold": 0.5
+    },
+    "C": {
+        "description": "Environmental degradation",
+        "threshold": 0.5
+    },
+    "D": {
+        "description": "Disruption of biotic processes and interactions",
+        "threshold": 0.5
+    },
+    "E": {
+        "description": "Quantitative analysis that estimates the probability of ecosystem collapse",
+        "threshold": 0.5
+    }
+}
+
+# Source: https://iucnrle.org/rle-categ-and-criteria
+rle_categories = [
+    {
+        "name": "Collapsed",
+        "abbreviation": "CO",
+        "threatened": True,
+        "background_color": "black",
+    },
+    {
+        "name": "Critically Endangered",
+        "abbreviation": "CR",
+        "threatened": True,
+        "background_color": "red",
+    },
+    {
+        "name": "Endangered",
+        "abbreviation": "EN",
+        "threatened": True,
+        "background_color": "orange",
+    },
+    {
+        "name": "Vulnerable",
+        "abbreviation": "VU",
+        "threatened": True,
+        "background_color": "yellow",
+    },
+    {
+        "name": "Near Threatened",
+        "abbreviation": "NT",
+        "background_color": "green",
+    },
+    {
+        "name": "Least Concern",
+        "abbreviation": "LC",
+        "background_color": "darkgreen",
+    },
+    {
+        "name": "Data Deficient",
+        "abbreviation": "DD",
+        "background_color": "lightgray",    
+    },
+    {
+        "name": "Not Evaluated",
+        "abbreviation": "NE",
+        "background_color": "white",
+    }
+]

rle/core/viz.py

@@ -0,0 +1,183 @@
+"""Visualization helpers that gracefully fall back to static images.
+
+The main entry point is :func:`smart_map`, which attempts to build an
+interactive :class:`lonboard.Map`. If any layer construction raises a
+``max_features`` / "too many" :class:`ValueError`, it falls back to rendering
+the same data as a static matplotlib PNG so that documents (e.g. Quarto
+notebooks) still render instead of failing.
+"""
+from __future__ import annotations
+
+from typing import Any, Iterable, Sequence
+
+import numpy as np
+
+
+_FALLBACK_MARKERS = ("max_features", "too many")
+
+
+def _is_fallback_error(exc: BaseException) -> bool:
+    msg = str(exc)
+    return any(marker in msg for marker in _FALLBACK_MARKERS)
+
+
+def _normalize_specs(specs: Iterable[Any]) -> list[tuple[str, Any, dict | None]]:
+    """Normalize heterogeneous spec entries to a uniform internal shape.
+
+    Each returned entry is one of:
+      - ("source", datasource, kwargs_dict) — has .to_layer() / .to_gdf_for_viz()
+      - ("layer", prebuilt_lonboard_layer, None)
+    """
+    normalized: list[tuple[str, Any, dict | None]] = []
+    for entry in specs:
+        if isinstance(entry, tuple) and len(entry) == 2 and isinstance(entry[1], dict):
+            normalized.append(("source", entry[0], entry[1]))
+        elif hasattr(entry, "to_layer"):
+            normalized.append(("source", entry, {}))
+        else:
+            normalized.append(("layer", entry, None))
+    return normalized
+
+
+def smart_map(
+    specs: Sequence[Any],
+    *,
+    view_state: dict | None = None,
+    title: str | None = None,
+    figsize: tuple[float, float] = (8, 8),
+):
+    """Build an interactive ``lonboard.Map`` or fall back to a static PNG.
+
+    Args:
+        specs: Iterable of layer specs. Each entry may be:
+            - a datasource with ``.to_layer()`` (uses default styling)
+            - a ``(datasource, kwargs)`` tuple forwarded to ``.to_layer(**kwargs)``
+            - a pre-built lonboard layer (passed through as-is)
+        view_state: Optional initial view state forwarded to ``lonboard.Map``.
+        title: Optional title rendered on the static fallback image.
+        figsize: Matplotlib figsize for the static fallback.
+
+    Returns:
+        ``lonboard.Map`` on success, or ``IPython.display.Image`` (PNG) on
+        fallback. Both render inline in Jupyter / Quarto.
+    """
+    normalized = _normalize_specs(specs)
+
+    try:
+        layers: list = []
+        for kind, obj, kwargs in normalized:
+            if kind == "source":
+                layers.extend(obj.to_layer(**(kwargs or {})))
+            else:
+                layers.append(obj)
+    except ValueError as e:
+        if not _is_fallback_error(e):
+            raise
+        return _static_fallback(normalized, title=title, figsize=figsize)
+
+    from lonboard import Map
+
+    map_kwargs = {}
+    if view_state is not None:
+        map_kwargs["view_state"] = view_state
+    return Map(layers=layers, **map_kwargs)
+
+
+def _static_fallback(
+    normalized: list[tuple[str, Any, dict | None]],
+    *,
+    title: str | None,
+    figsize: tuple[float, float],
+):
+    import io
+
+    import matplotlib.pyplot as plt
+    from IPython.display import Image
+
+    fig, ax = plt.subplots(figsize=figsize)
+
+    skipped = 0
+    for kind, obj, kwargs in normalized:
+        if kind != "source":
+            skipped += 1
+            continue
+        if not hasattr(obj, "to_gdf_for_viz"):
+            skipped += 1
+            continue
+        gdf, style = obj.to_gdf_for_viz(**(kwargs or {}))
+        if gdf is None or len(gdf) == 0:
+            continue
+        _plot_gdf(ax, gdf, style)
+
+    ax.set_aspect("equal")
+    ax.set_xlabel("Longitude")
+    ax.set_ylabel("Latitude")
+    if title:
+        ax.set_title(title)
+    if skipped:
+        ax.text(
+            0.99, 0.01,
+            f"{skipped} pre-built layer(s) omitted in static view",
+            transform=ax.transAxes, ha="right", va="bottom",
+            fontsize=8, color="gray",
+        )
+
+    buf = io.BytesIO()
+    fig.tight_layout()
+    fig.savefig(buf, format="png", dpi=120, bbox_inches="tight")
+    plt.close(fig)
+    return Image(data=buf.getvalue(), format="png")
+
+
+def _plot_gdf(ax, gdf, style):
+    """Plot a GeoDataFrame onto ``ax`` using lonboard-style color kwargs."""
+    from pyproj import CRS
+
+    if gdf.crs is not None and CRS.from_user_input(gdf.crs).to_epsg() != 4326:
+        gdf = gdf.to_crs("EPSG:4326")
+
+    fill = _lonboard_color_to_mpl(style.get("fill"), len(gdf))
+    edge = _lonboard_color_to_mpl(style.get("edge"), len(gdf))
+
+    plot_kwargs: dict[str, Any] = {"ax": ax, "linewidth": 0.5}
+    if fill is not None:
+        plot_kwargs["color"] = fill
+    if edge is not None:
+        plot_kwargs["edgecolor"] = edge
+    gdf.plot(**plot_kwargs)
+
+
+def _lonboard_color_to_mpl(color, n_rows: int):
+    """Convert lonboard-style RGB(A) colors to matplotlib-friendly floats.
+
+    Accepts:
+      - None (returned as-is)
+      - list/tuple of 3 or 4 ints (0-255) → single matplotlib RGBA tuple
+      - ndarray shape (N, 3 or 4) uint8/int → array of RGBA tuples (0-1 floats)
+    """
+    if color is None:
+        return None
+    arr = np.asarray(color)
+    if arr.ndim == 1:
+        rgba = _rgba_from_bytes(arr)
+        return rgba
+    if arr.ndim == 2:
+        if arr.shape[0] != n_rows:
+            return None
+        if np.issubdtype(arr.dtype, np.integer) or arr.max() > 1.0:
+            arr = arr.astype(float) / 255.0
+        if arr.shape[1] == 3:
+            alpha = np.ones((arr.shape[0], 1))
+            arr = np.concatenate([arr, alpha], axis=1)
+        return arr
+    return None
+
+
+def _rgba_from_bytes(arr: np.ndarray) -> tuple[float, float, float, float]:
+    vals = [float(v) for v in arr.tolist()]
+    if len(vals) == 3:
+        vals.append(255.0)
+    r, g, b, a = vals[:4]
+    if max(vals) > 1.0:
+        r, g, b, a = r / 255.0, g / 255.0, b / 255.0, a / 255.0
+    return (r, g, b, a)

rle_python-0.2.0.dist-info/METADATA

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: rle-python
+Version: 0.2.0
+Summary: Core tools for IUCN Red List of Ecosystems analysis with local and cloud data access
+Project-URL: Homepage, https://rle-assessment.github.io/rle-python/
+Project-URL: Documentation, https://rle-assessment.github.io/rle-python/
+Project-URL: Repository, https://github.com/RLE-Assessment/rle-python
+Project-URL: Issues, https://github.com/RLE-Assessment/rle-python/issues
+Author-email: Tyler Erickson <tyler@vorgeo.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: AOO,EOO,IUCN,RLE,Red List of Ecosystems,biodiversity,ecology,geospatial
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: GIS
+Requires-Python: <3.13,>=3.11
+Requires-Dist: fsspec
+Requires-Dist: geopandas>=1.1.3
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: pandas
+Requires-Dist: pyarrow
+Requires-Dist: pyproj
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: rasterio>=1.3.0
+Requires-Dist: rasterstats
+Requires-Dist: rioxarray
+Requires-Dist: shapely>=2
+Requires-Dist: typer>=0.20.0
+Provides-Extra: aws
+Requires-Dist: s3fs; extra == 'aws'
+Provides-Extra: gcs
+Requires-Dist: gcsfs; extra == 'gcs'
+Provides-Extra: viz
+Requires-Dist: lonboard; extra == 'viz'
+Requires-Dist: matplotlib>=3.9.0; extra == 'viz'
+Description-Content-Type: text/markdown
+
+# rle-python
+
+Core tools for **IUCN Red List of Ecosystems (RLE)** analysis.
+
+`rle-python` provides the RLE data model and assessment business logic
+(Extent of Occurrence, Area of Occupancy grids, ecosystem code assignment,
+criteria/categories) together with **local and cloud-file data access** — it
+has no Earth Engine dependency.
+
+Everything imports under the shared `rle` namespace:
+
+```python
+from rle.core import Ecosystems, make_aoo_grid, make_eoo
+
+eco = Ecosystems.from_file("ecosystems.geojson", ecosystem_column="ECO_NAME")
+aoo = make_aoo_grid(eco).compute()
+print(aoo.cell_count, aoo.aoo_km2)
+
+eoo = make_eoo(eco).compute()
+print(eoo.area_km2)
+```
+
+## Installation
+
+```bash
+pip install rle-python            # local files
+pip install rle-python[gcs]       # + gs:// GeoParquet (gcsfs)
+pip install rle-python[aws]       # + s3:// GeoParquet (s3fs)
+pip install rle-python[viz]       # + interactive maps (lonboard) / static fallback
+```
+
+## Optional backends
+
+Additional data sources are provided by separate distributions that install
+into the same `rle` namespace and register themselves for discovery:
+
+```bash
+pip install rle-python-gee        # Google Earth Engine backends -> rle.gee
+```
+
+```python
+from rle.gee import GeeEcosystems
+eco = GeeEcosystems("projects/my-project/assets/ecosystems")
+```
+
+List the backends available in your environment:
+
+```bash
+rle backends
+```
+
+## Layout
+
+`rle-python` ships the `rle.core` package under a PEP 420 namespace (`rle/`),
+so multiple `rle-*` distributions can coexist without conflict.

rle_python-0.2.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+rle/core/__init__.py,sha256=UMRyfBaTAaZMLzlHE-k8WRS6gqPtRCPCLA6HAL3rmFY,1843
+rle/core/_entrypoints.py,sha256=L9if3ON2aRz7xRlRLIoGA6mXlQ6GAMXQ1zaqFl7myT8,1333
+rle/core/aoo.py,sha256=mR7sCWNG0RlpM42BXUCr0vXcwfPyBd_VHqgeEed-WJU,29730
+rle/core/aoo_grid.py,sha256=F5WzEbZ5RcYcjjbaGOeMz8EdlQ5B6tRwjhHw8DV6_Hc,1934
+rle/core/cli.py,sha256=2zTjmTPlEgTphIBiAf8tn2MSk9K1SuZVrGZVbxzfEt0,1250
+rle/core/ecosystem_codes.py,sha256=Ybb5cNqW0kt8ljt1ayfTwMfgiRRL_LBp_LE-CGcnMdw,3840
+rle/core/ecosystems.py,sha256=ynzi_tELB7194UoVkrpmVvuQ_xBZjpxim897Ligd9-U,26867
+rle/core/eoo.py,sha256=2p4lRvyezY6EZDDYVBX7kI9dAjGDxRjr0GwnZHh-Pj8,8030
+rle/core/registry.py,sha256=7KprFt9vg0tkgvafTJD6NtD6BtWoei3cSG0bmJIz-_I,2106
+rle/core/rle.py,sha256=-3PosA-gqqVIcVlE2YHbbGHXVnJjQfWOzhF-Ah2zBCI,1731
+rle/core/viz.py,sha256=iH7kfVjjaD__ywU2r5HfT7PlNWSS0mE1fxe7jncLwHE,5889
+rle_python-0.2.0.dist-info/METADATA,sha256=nI5QKjkr1fA6-S2izNzhTReDEhlB3BKoQpn2KZKeaGw,3111
+rle_python-0.2.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+rle_python-0.2.0.dist-info/entry_points.txt,sha256=mIPm-a2k-v17XI-X7ZZ91Ml5UkT0_O2tZyEv-sP2Ex4,95
+rle_python-0.2.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+rle_python-0.2.0.dist-info/RECORD,,

rle_python-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

rle_python-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+rle = rle.core.cli:app
+
+[rle.backends]
+core = rle.core._entrypoints:register