moveq-core 0.1.0__tar.gz

moveq_core-0.1.0/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, moveq contributors
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

moveq_core-0.1.0/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: moveq-core
+Version: 0.1.0
+Summary: Core algorithms for transport-equity analysis: Gini, Palma, Concentration Index, and weighted composite scoring.
+Author-email: Soura <martisoura@gmail.com>
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://github.com/SVamseekar/moveq
+Project-URL: Documentation, https://github.com/SVamseekar/moveq/blob/main/docs/index.md
+Project-URL: Repository, https://github.com/SVamseekar/moveq
+Project-URL: Issues, https://github.com/SVamseekar/moveq/issues
+Project-URL: Changelog, https://github.com/SVamseekar/moveq/blob/main/CHANGELOG.md
+Keywords: transport,equity,accessibility,inequality,gini,palma,concentration-index
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Provides-Extra: frames
+Requires-Dist: pandas>=2.0; extra == "frames"
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Dynamic: license-file
+
+# moveq-core
+
+Pure NumPy algorithms for measuring transport equity.
+
+[![PyPI](https://img.shields.io/pypi/v/moveq-core.svg)](https://pypi.org/project/moveq-core/)
+[![Python versions](https://img.shields.io/pypi/pyversions/moveq-core.svg)](https://pypi.org/project/moveq-core/)
+[![License](https://img.shields.io/pypi/l/moveq-core.svg)](https://github.com/SVamseekar/moveq/blob/main/LICENSE)
+
+- **Population-weighted Gini coefficient** via numerical Lorenz curve integration
+- **Palma ratio** (top 10% highest-service vs bottom 40% lowest-service population)
+- **Wagstaff Concentration Index** via fractional-rank weighted covariance
+- **Weighted composite scoring** with dynamic missing-term renormalization
+
+No I/O, no database, no framework lock-in: pass NumPy arrays, get numbers back.
+
+Most applications should install the umbrella package instead:
+
+```bash
+pip install moveq
+```
+
+## Installation
+
+Requires Python 3.10+.
+
+```bash
+pip install moveq-core
+```
+
+Pandas DataFrame helpers:
+
+```bash
+pip install "moveq-core[frames]"
+```
+
+## Quickstart
+
+```python
+import numpy as np
+from moveq_core import (
+    compute_gini,
+    compute_palma_ratio,
+    compute_concentration_index,
+    compute_score,
+)
+
+service = np.array([10.0, 20.0, 5.0, 50.0, 8.0])
+population = np.array([1000, 800, 1200, 300, 900])
+deprivation_rank = np.array([1, 3, 2, 5, 4])  # 1 = most deprived
+
+gini = compute_gini(service, population)
+palma = compute_palma_ratio(service, population)
+ci = compute_concentration_index(service, deprivation_rank, population)
+
+score_res = compute_score(
+    terms={"coverage": 0.75, "evening": 0.50, "night": None},
+    weights={"coverage": 0.50, "evening": 0.30, "night": 0.20},
+)
+print(f"Score: {score_res.score:.1f} ({score_res.note})")
+```
+
+### DataFrame helpers (`moveq_core.frames`)
+
+```python
+import pandas as pd
+from moveq_core.frames import compute_vulnerability_index, identify_multiply_deprived
+
+df = pd.DataFrame({
+    "unemployment_pct": [5.0, 12.0, 20.0],
+    "no_car_pct": [10.0, 30.0, 60.0],
+    "elderly_pct": [15.0, 25.0, 35.0],
+})
+
+vulnerability = compute_vulnerability_index(
+    df, ["unemployment_pct", "no_car_pct", "elderly_pct"]
+)
+flagged = identify_multiply_deprived(
+    df, ["unemployment_pct", "no_car_pct", "elderly_pct"], min_factors=2
+)
+```
+
+## Documentation
+
+- [Methodology](https://github.com/SVamseekar/moveq/blob/main/docs/methodology.md)
+- [API reference](https://github.com/SVamseekar/moveq/blob/main/docs/api_reference.md)
+- [Source repository](https://github.com/SVamseekar/moveq)
+- [Changelog](https://github.com/SVamseekar/moveq/blob/main/CHANGELOG.md)
+
+## License
+
+[BSD 3-Clause](https://github.com/SVamseekar/moveq/blob/main/LICENSE).

moveq_core-0.1.0/README.md

@@ -0,0 +1,91 @@
+# moveq-core
+
+Pure NumPy algorithms for measuring transport equity.
+
+[![PyPI](https://img.shields.io/pypi/v/moveq-core.svg)](https://pypi.org/project/moveq-core/)
+[![Python versions](https://img.shields.io/pypi/pyversions/moveq-core.svg)](https://pypi.org/project/moveq-core/)
+[![License](https://img.shields.io/pypi/l/moveq-core.svg)](https://github.com/SVamseekar/moveq/blob/main/LICENSE)
+
+- **Population-weighted Gini coefficient** via numerical Lorenz curve integration
+- **Palma ratio** (top 10% highest-service vs bottom 40% lowest-service population)
+- **Wagstaff Concentration Index** via fractional-rank weighted covariance
+- **Weighted composite scoring** with dynamic missing-term renormalization
+
+No I/O, no database, no framework lock-in: pass NumPy arrays, get numbers back.
+
+Most applications should install the umbrella package instead:
+
+```bash
+pip install moveq
+```
+
+## Installation
+
+Requires Python 3.10+.
+
+```bash
+pip install moveq-core
+```
+
+Pandas DataFrame helpers:
+
+```bash
+pip install "moveq-core[frames]"
+```
+
+## Quickstart
+
+```python
+import numpy as np
+from moveq_core import (
+    compute_gini,
+    compute_palma_ratio,
+    compute_concentration_index,
+    compute_score,
+)
+
+service = np.array([10.0, 20.0, 5.0, 50.0, 8.0])
+population = np.array([1000, 800, 1200, 300, 900])
+deprivation_rank = np.array([1, 3, 2, 5, 4])  # 1 = most deprived
+
+gini = compute_gini(service, population)
+palma = compute_palma_ratio(service, population)
+ci = compute_concentration_index(service, deprivation_rank, population)
+
+score_res = compute_score(
+    terms={"coverage": 0.75, "evening": 0.50, "night": None},
+    weights={"coverage": 0.50, "evening": 0.30, "night": 0.20},
+)
+print(f"Score: {score_res.score:.1f} ({score_res.note})")
+```
+
+### DataFrame helpers (`moveq_core.frames`)
+
+```python
+import pandas as pd
+from moveq_core.frames import compute_vulnerability_index, identify_multiply_deprived
+
+df = pd.DataFrame({
+    "unemployment_pct": [5.0, 12.0, 20.0],
+    "no_car_pct": [10.0, 30.0, 60.0],
+    "elderly_pct": [15.0, 25.0, 35.0],
+})
+
+vulnerability = compute_vulnerability_index(
+    df, ["unemployment_pct", "no_car_pct", "elderly_pct"]
+)
+flagged = identify_multiply_deprived(
+    df, ["unemployment_pct", "no_car_pct", "elderly_pct"], min_factors=2
+)
+```
+
+## Documentation
+
+- [Methodology](https://github.com/SVamseekar/moveq/blob/main/docs/methodology.md)
+- [API reference](https://github.com/SVamseekar/moveq/blob/main/docs/api_reference.md)
+- [Source repository](https://github.com/SVamseekar/moveq)
+- [Changelog](https://github.com/SVamseekar/moveq/blob/main/CHANGELOG.md)
+
+## License
+
+[BSD 3-Clause](https://github.com/SVamseekar/moveq/blob/main/LICENSE).

moveq_core-0.1.0/pyproject.toml

@@ -0,0 +1,55 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "moveq-core"
+version = "0.1.0"
+description = "Core algorithms for transport-equity analysis: Gini, Palma, Concentration Index, and weighted composite scoring."
+readme = "README.md"
+license = "BSD-3-Clause"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+authors = [
+    { name = "Soura", email = "martisoura@gmail.com" },
+]
+keywords = [
+    "transport",
+    "equity",
+    "accessibility",
+    "inequality",
+    "gini",
+    "palma",
+    "concentration-index",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering",
+]
+dependencies = [
+    "numpy>=1.24",
+]
+
+[project.optional-dependencies]
+frames = ["pandas>=2.0"]
+test = ["pytest>=7"]
+
+[project.urls]
+Homepage = "https://github.com/SVamseekar/moveq"
+Documentation = "https://github.com/SVamseekar/moveq/blob/main/docs/index.md"
+Repository = "https://github.com/SVamseekar/moveq"
+Issues = "https://github.com/SVamseekar/moveq/issues"
+Changelog = "https://github.com/SVamseekar/moveq/blob/main/CHANGELOG.md"
+
+[tool.setuptools.packages.find]
+where = ["src"]

moveq_core-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

moveq_core-0.1.0/src/moveq_core/__init__.py

@@ -0,0 +1,16 @@
+"""moveq-core — pure algorithms for transport-equity analysis."""
+
+from moveq_core.equity import compute_concentration_index, compute_gini, compute_palma_ratio
+from moveq_core.score import ScoreComponent, ScoreResult, clip01, compute_score
+
+__all__ = [
+    "compute_gini",
+    "compute_palma_ratio",
+    "compute_concentration_index",
+    "compute_score",
+    "clip01",
+    "ScoreComponent",
+    "ScoreResult",
+]
+
+__version__ = "0.1.0"

moveq_core-0.1.0/src/moveq_core/equity.py

@@ -0,0 +1,112 @@
+"""Population-weighted inequality measures for transport-equity analysis.
+
+Three measures, one shared idea: service is a resource, population is the
+weight, and we ask how unevenly the resource is spread across the weight.
+
+    Gini                 — overall inequality via the Lorenz curve, in [0, 1]
+    Palma ratio          — top-10% mean service / bottom-40% mean service
+    Concentration Index  — inequality correlated with a rank (e.g. deprivation),
+                            in [-1, 1]; positive = pro-rich, negative = pro-poor
+
+NumPy 2.x guard: uses ``trapezoid`` with a fallback to the removed ``trapz``.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+_trapezoid = getattr(np, "trapezoid", getattr(np, "trapz", None))
+if _trapezoid is None:
+    raise ImportError("NumPy has neither 'trapezoid' nor 'trapz' — unsupported version")
+
+
+def compute_gini(values: np.ndarray, weights: np.ndarray) -> float:
+    """Population-weighted Gini coefficient via Lorenz curve area.
+
+    Args:
+        values: Service level per areal unit (e.g. trips per neighbourhood).
+        weights: Population weight per unit.
+
+    Returns:
+        Gini coefficient in [0, 1]. 0 = perfect equality, 1 = maximum inequality.
+    """
+    values = np.asarray(values, dtype=float)
+    weights = np.asarray(weights, dtype=float)
+
+    order = np.argsort(values)
+    values = values[order]
+    weights = weights[order]
+
+    cum_pop = np.cumsum(weights) / weights.sum()
+    cum_service = np.cumsum(values * weights) / (values * weights).sum()
+
+    cum_pop = np.concatenate([[0], cum_pop])
+    cum_service = np.concatenate([[0], cum_service])
+
+    lorenz_area = _trapezoid(cum_service, cum_pop)
+    return float(1 - 2 * lorenz_area)
+
+
+def compute_palma_ratio(values: np.ndarray, weights: np.ndarray) -> float:
+    """Palma ratio: mean service in the top 10% / mean service in the bottom 40%.
+
+    Args:
+        values: Service level per areal unit.
+        weights: Population weight per unit.
+
+    Returns:
+        Palma ratio. Higher = more unequal. ``inf`` if the bottom 40% has zero
+        mean service.
+    """
+    values = np.asarray(values, dtype=float)
+    weights = np.asarray(weights, dtype=float)
+
+    order = np.argsort(values)
+    values = values[order]
+    weights = weights[order]
+
+    cum_pop_frac = np.cumsum(weights) / weights.sum()
+
+    bottom_mask = cum_pop_frac <= 0.40
+    top_mask = cum_pop_frac > 0.90
+
+    bottom_mean = (
+        np.average(values[bottom_mask], weights=weights[bottom_mask]) if bottom_mask.sum() > 0 else 0.0
+    )
+    top_mean = np.average(values[top_mask], weights=weights[top_mask]) if top_mask.sum() > 0 else 0.0
+
+    return float(top_mean / bottom_mean) if bottom_mean > 0 else float("inf")
+
+
+def compute_concentration_index(
+    service: np.ndarray, rank: np.ndarray, population: np.ndarray
+) -> float:
+    """Wagstaff Concentration Index (CI) via the covariance method.
+
+    Positive CI = service concentrated in areas with a higher rank value
+    (e.g. less deprived, if rank is a deprivation rank). Negative CI = service
+    concentrated in lower-rank (e.g. more deprived) areas.
+
+    Args:
+        service: Service level per areal unit.
+        rank: Ranking variable per unit (e.g. deprivation rank; 1 = most
+            deprived, higher = less deprived).
+        population: Population weight per unit.
+
+    Returns:
+        Concentration Index in [-1, 1].
+    """
+    service = np.asarray(service, dtype=float)
+    rank = np.asarray(rank, dtype=float)
+    population = np.asarray(population, dtype=float)
+
+    total_pop = population.sum()
+    order = np.argsort(rank)
+    pop_sorted = population[order]
+    frac_rank = (np.cumsum(pop_sorted) - 0.5 * pop_sorted) / total_pop
+
+    service_sorted = service[order]
+
+    mean_service = np.average(service_sorted, weights=pop_sorted)
+    cov = np.average((service_sorted - mean_service) * (frac_rank - 0.5), weights=pop_sorted)
+    return float(2 * cov / mean_service) if mean_service > 0 else 0.0

moveq_core-0.1.0/src/moveq_core/frames.py

@@ -0,0 +1,54 @@
+"""DataFrame convenience helpers. Requires the ``frames`` extra (pandas).
+
+Kept separate from :mod:`moveq_core.equity` so the core numpy-only API has
+no pandas dependency.
+"""
+
+from __future__ import annotations
+
+try:
+    import pandas as pd
+except ImportError as exc:  # pragma: no cover
+    raise ImportError(
+        "moveq_core.frames requires pandas — install with `pip install \"moveq-core[frames]\"`"
+    ) from exc
+
+
+def compute_vulnerability_index(df: "pd.DataFrame", factors: list[str]) -> "pd.Series":
+    """Equal-weighted 0-100 vulnerability index across the given factor columns.
+
+    Each factor is min-max normalised to 0-100 before averaging, so factors
+    on different scales (a score, a percentage, a rate) contribute equally.
+
+    Args:
+        df: Frame containing the factor columns.
+        factors: Column names to combine (e.g. deprivation score, no-car %,
+            elderly %, disability %, unemployment rate).
+
+    Returns:
+        Series of vulnerability scores (0-100), rounded to 2 decimals.
+    """
+    normalised = pd.DataFrame(index=df.index)
+    for col in factors:
+        mn, mx = df[col].min(), df[col].max()
+        normalised[col] = (df[col] - mn) / (mx - mn) * 100 if mx > mn else 0.0
+    return normalised.mean(axis=1).round(2)
+
+
+def identify_multiply_deprived(df: "pd.DataFrame", factors: list[str], min_factors: int = 3) -> "pd.Series":
+    """Flag rows in the worst tertile on at least ``min_factors`` of the given factors.
+
+    Args:
+        df: Frame containing the factor columns.
+        factors: Column names where a higher value means more deprived.
+        min_factors: Minimum number of factors a row must be in the worst
+            tertile on to be flagged.
+
+    Returns:
+        Boolean Series — True where the row is multiply-deprived.
+    """
+    worst_tertile = pd.DataFrame(index=df.index)
+    for col in factors:
+        threshold = df[col].quantile(2 / 3)
+        worst_tertile[col] = df[col] >= threshold
+    return worst_tertile.sum(axis=1) >= min_factors

moveq_core-0.1.0/src/moveq_core/score.py

@@ -0,0 +1,148 @@
+"""Configurable weighted composite score (0-100) with graceful missing-term handling.
+
+The pattern: define named terms in [0, 1], each with a design weight. Score
+is ``100 * sum(weight * value)``. If a term is missing (``None``), it is
+dropped and the remaining weights are renormalised — the score never
+silently treats a missing input as zero.
+
+Unlike a fixed formula, weights and labels are supplied by the caller, so
+the same engine works for any composite indicator (a bus-access score, a
+walkability score, a service-quality score, ...).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+def clip01(value: float) -> float:
+    return max(0.0, min(1.0, float(value)))
+
+
+@dataclass(frozen=True)
+class ScoreComponent:
+    id: str
+    label: str
+    design_weight: float
+    weight_used: float
+    value: float | None
+    missing: bool
+
+
+@dataclass(frozen=True)
+class ScoreResult:
+    score: float | None
+    components: list[ScoreComponent]
+    dropped: list[str]
+    n_areas: int | None
+    note: str | None
+    context: dict[str, str] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "score": None if self.score is None else round(self.score, 1),
+            "components": [
+                {
+                    "id": c.id,
+                    "label": c.label,
+                    "design_weight": c.design_weight,
+                    "weight_used": c.weight_used,
+                    "value": None if c.value is None else round(c.value, 4),
+                    "missing": c.missing,
+                }
+                for c in self.components
+            ],
+            "dropped": list(self.dropped),
+            "n_areas": self.n_areas,
+            "note": self.note,
+            "context": dict(self.context),
+        }
+
+
+def compute_score(
+    terms: dict[str, float | None],
+    weights: dict[str, float],
+    *,
+    labels: dict[str, str] | None = None,
+    n_areas: int | None = None,
+    context: dict[str, str] | None = None,
+    empty_note: str = "No score for this cut — required inputs are missing.",
+) -> ScoreResult:
+    """Compute a weighted composite score from 0-1 terms (``None`` = missing).
+
+    Args:
+        terms: Mapping of term id to a value in [0, 1], or ``None`` if the
+            term has no data for this cut.
+        weights: Mapping of term id to its design weight. Keys must be a
+            superset of ``terms``' keys that matter to the score.
+        labels: Optional human-readable label per term id, used in notes.
+        n_areas: Optional count of areal units backing this score.
+        context: Optional free-form context (e.g. region, filter) carried
+            through to the result for traceability.
+        empty_note: Note returned when every term is missing.
+    """
+    labels = labels or {k: k for k in weights}
+    context = context or {}
+
+    present: list[tuple[str, float, float]] = []
+    dropped: list[str] = []
+    for key, design_w in weights.items():
+        raw = terms.get(key)
+        if raw is None:
+            dropped.append(key)
+            continue
+        present.append((key, design_w, clip01(raw)))
+
+    if not present:
+        components = [
+            ScoreComponent(
+                id=k, label=labels.get(k, k), design_weight=w, weight_used=0.0, value=None, missing=True
+            )
+            for k, w in weights.items()
+        ]
+        return ScoreResult(
+            score=None,
+            components=components,
+            dropped=list(weights),
+            n_areas=n_areas or 0,
+            note=empty_note,
+            context=context,
+        )
+
+    weight_sum = sum(w for _, w, _ in present)
+    components = []
+    weighted = 0.0
+    present_ids = {k for k, _, _ in present}
+    for key, design_w in weights.items():
+        if key not in present_ids:
+            components.append(
+                ScoreComponent(
+                    id=key, label=labels.get(key, key), design_weight=design_w,
+                    weight_used=0.0, value=None, missing=True,
+                )
+            )
+            continue
+        value = next(v for k, _, v in present if k == key)
+        used = design_w / weight_sum
+        weighted += used * value
+        components.append(
+            ScoreComponent(
+                id=key, label=labels.get(key, key), design_weight=design_w,
+                weight_used=used, value=value, missing=False,
+            )
+        )
+
+    note = None
+    if dropped:
+        dropped_labels = ", ".join(labels.get(k, k).split(" (")[0].lower() for k in dropped)
+        note = f"{dropped_labels} not in this cut — weights renormalised."
+
+    return ScoreResult(
+        score=100.0 * weighted,
+        components=components,
+        dropped=dropped,
+        n_areas=n_areas,
+        note=note,
+        context=context,
+    )

moveq_core-0.1.0/src/moveq_core.egg-info/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: moveq-core
+Version: 0.1.0
+Summary: Core algorithms for transport-equity analysis: Gini, Palma, Concentration Index, and weighted composite scoring.
+Author-email: Soura <martisoura@gmail.com>
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://github.com/SVamseekar/moveq
+Project-URL: Documentation, https://github.com/SVamseekar/moveq/blob/main/docs/index.md
+Project-URL: Repository, https://github.com/SVamseekar/moveq
+Project-URL: Issues, https://github.com/SVamseekar/moveq/issues
+Project-URL: Changelog, https://github.com/SVamseekar/moveq/blob/main/CHANGELOG.md
+Keywords: transport,equity,accessibility,inequality,gini,palma,concentration-index
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Provides-Extra: frames
+Requires-Dist: pandas>=2.0; extra == "frames"
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Dynamic: license-file
+
+# moveq-core
+
+Pure NumPy algorithms for measuring transport equity.
+
+[![PyPI](https://img.shields.io/pypi/v/moveq-core.svg)](https://pypi.org/project/moveq-core/)
+[![Python versions](https://img.shields.io/pypi/pyversions/moveq-core.svg)](https://pypi.org/project/moveq-core/)
+[![License](https://img.shields.io/pypi/l/moveq-core.svg)](https://github.com/SVamseekar/moveq/blob/main/LICENSE)
+
+- **Population-weighted Gini coefficient** via numerical Lorenz curve integration
+- **Palma ratio** (top 10% highest-service vs bottom 40% lowest-service population)
+- **Wagstaff Concentration Index** via fractional-rank weighted covariance
+- **Weighted composite scoring** with dynamic missing-term renormalization
+
+No I/O, no database, no framework lock-in: pass NumPy arrays, get numbers back.
+
+Most applications should install the umbrella package instead:
+
+```bash
+pip install moveq
+```
+
+## Installation
+
+Requires Python 3.10+.
+
+```bash
+pip install moveq-core
+```
+
+Pandas DataFrame helpers:
+
+```bash
+pip install "moveq-core[frames]"
+```
+
+## Quickstart
+
+```python
+import numpy as np
+from moveq_core import (
+    compute_gini,
+    compute_palma_ratio,
+    compute_concentration_index,
+    compute_score,
+)
+
+service = np.array([10.0, 20.0, 5.0, 50.0, 8.0])
+population = np.array([1000, 800, 1200, 300, 900])
+deprivation_rank = np.array([1, 3, 2, 5, 4])  # 1 = most deprived
+
+gini = compute_gini(service, population)
+palma = compute_palma_ratio(service, population)
+ci = compute_concentration_index(service, deprivation_rank, population)
+
+score_res = compute_score(
+    terms={"coverage": 0.75, "evening": 0.50, "night": None},
+    weights={"coverage": 0.50, "evening": 0.30, "night": 0.20},
+)
+print(f"Score: {score_res.score:.1f} ({score_res.note})")
+```
+
+### DataFrame helpers (`moveq_core.frames`)
+
+```python
+import pandas as pd
+from moveq_core.frames import compute_vulnerability_index, identify_multiply_deprived
+
+df = pd.DataFrame({
+    "unemployment_pct": [5.0, 12.0, 20.0],
+    "no_car_pct": [10.0, 30.0, 60.0],
+    "elderly_pct": [15.0, 25.0, 35.0],
+})
+
+vulnerability = compute_vulnerability_index(
+    df, ["unemployment_pct", "no_car_pct", "elderly_pct"]
+)
+flagged = identify_multiply_deprived(
+    df, ["unemployment_pct", "no_car_pct", "elderly_pct"], min_factors=2
+)
+```
+
+## Documentation
+
+- [Methodology](https://github.com/SVamseekar/moveq/blob/main/docs/methodology.md)
+- [API reference](https://github.com/SVamseekar/moveq/blob/main/docs/api_reference.md)
+- [Source repository](https://github.com/SVamseekar/moveq)
+- [Changelog](https://github.com/SVamseekar/moveq/blob/main/CHANGELOG.md)
+
+## License
+
+[BSD 3-Clause](https://github.com/SVamseekar/moveq/blob/main/LICENSE).

moveq_core-0.1.0/src/moveq_core.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+src/moveq_core/__init__.py
+src/moveq_core/equity.py
+src/moveq_core/frames.py
+src/moveq_core/score.py
+src/moveq_core.egg-info/PKG-INFO
+src/moveq_core.egg-info/SOURCES.txt
+src/moveq_core.egg-info/dependency_links.txt
+src/moveq_core.egg-info/requires.txt
+src/moveq_core.egg-info/top_level.txt
+tests/test_equity.py
+tests/test_frames.py
+tests/test_score.py

moveq_core-0.1.0/src/moveq_core.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

moveq_core-0.1.0/src/moveq_core.egg-info/requires.txt

@@ -0,0 +1,7 @@
+numpy>=1.24
+
+[frames]
+pandas>=2.0
+
+[test]
+pytest>=7

moveq_core-0.1.0/src/moveq_core.egg-info/top_level.txt

@@ -0,0 +1 @@
+moveq_core

moveq_core-0.1.0/tests/test_equity.py

@@ -0,0 +1,63 @@
+import numpy as np
+import pytest
+
+from moveq_core import compute_concentration_index, compute_gini, compute_palma_ratio
+
+
+def test_gini_perfect_equality_is_zero():
+    values = np.array([10.0, 10.0, 10.0, 10.0])
+    weights = np.array([100.0, 100.0, 100.0, 100.0])
+    assert compute_gini(values, weights) == pytest.approx(0.0, abs=1e-9)
+
+
+def test_gini_extreme_inequality_approaches_one():
+    # All service in one unit, none anywhere else.
+    values = np.array([0.0, 0.0, 0.0, 100.0])
+    weights = np.array([100.0, 100.0, 100.0, 100.0])
+    gini = compute_gini(values, weights)
+    assert 0.7 < gini < 1.0
+
+
+def test_gini_is_order_invariant():
+    values_a = np.array([5.0, 20.0, 1.0, 50.0])
+    weights_a = np.array([900.0, 800.0, 1200.0, 300.0])
+    order = [3, 1, 0, 2]
+    gini_a = compute_gini(values_a, weights_a)
+    gini_b = compute_gini(values_a[order], weights_a[order])
+    assert gini_a == pytest.approx(gini_b, abs=1e-9)
+
+
+def test_palma_ratio_equal_service_is_one():
+    values = np.array([10.0] * 10)
+    weights = np.array([100.0] * 10)
+    assert compute_palma_ratio(values, weights) == pytest.approx(1.0, abs=1e-9)
+
+
+def test_palma_ratio_top_heavy_is_greater_than_one():
+    values = np.array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 100.0])
+    weights = np.array([100.0] * 10)
+    assert compute_palma_ratio(values, weights) > 1.0
+
+
+def test_concentration_index_pro_rich_when_service_rises_with_rank():
+    service = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
+    rank = np.array([1, 2, 3, 4, 5])  # higher rank = less deprived
+    population = np.array([100.0, 100.0, 100.0, 100.0, 100.0])
+    ci = compute_concentration_index(service, rank, population)
+    assert ci > 0
+
+
+def test_concentration_index_pro_poor_when_service_falls_with_rank():
+    service = np.array([5.0, 4.0, 3.0, 2.0, 1.0])
+    rank = np.array([1, 2, 3, 4, 5])
+    population = np.array([100.0, 100.0, 100.0, 100.0, 100.0])
+    ci = compute_concentration_index(service, rank, population)
+    assert ci < 0
+
+
+def test_concentration_index_flat_service_is_zero():
+    service = np.array([3.0, 3.0, 3.0, 3.0, 3.0])
+    rank = np.array([1, 2, 3, 4, 5])
+    population = np.array([100.0, 100.0, 100.0, 100.0, 100.0])
+    ci = compute_concentration_index(service, rank, population)
+    assert ci == pytest.approx(0.0, abs=1e-9)

moveq_core-0.1.0/tests/test_frames.py

@@ -0,0 +1,74 @@
+import numpy as np
+import pandas as pd
+import pytest
+
+from moveq_core.frames import compute_vulnerability_index, identify_multiply_deprived
+
+
+def test_vulnerability_index_basic():
+    df = pd.DataFrame({
+        "deprivation": [10.0, 20.0, 30.0],
+        "no_car_pct": [0.0, 50.0, 100.0],
+        "unemployment": [5.0, 10.0, 15.0],
+    })
+    # For each column:
+    # row 0: (10-10)/(30-10)=0%, (0-0)/(100-0)=0%, (5-5)/(15-5)=0% -> mean 0.0
+    # row 1: (20-10)/20=50%, (50-0)/100=50%, (10-5)/10=50% -> mean 50.0
+    # row 2: (30-10)/20=100%, (100-0)/100=100%, (15-5)/10=100% -> mean 100.0
+    vuln = compute_vulnerability_index(df, ["deprivation", "no_car_pct", "unemployment"])
+
+    assert len(vuln) == 3
+    assert vuln.iloc[0] == 0.0
+    assert vuln.iloc[1] == 50.0
+    assert vuln.iloc[2] == 100.0
+
+
+def test_vulnerability_index_constant_column():
+    df = pd.DataFrame({
+        "constant_factor": [5.0, 5.0, 5.0],
+        "variable_factor": [0.0, 50.0, 100.0],
+    })
+    # constant_factor is normalized to 0.0 because mx == mn
+    # row 0: (0 + 0) / 2 = 0.0
+    # row 1: (0 + 50) / 2 = 25.0
+    # row 2: (0 + 100) / 2 = 50.0
+    vuln = compute_vulnerability_index(df, ["constant_factor", "variable_factor"])
+    assert vuln.iloc[0] == 0.0
+    assert vuln.iloc[1] == 25.0
+    assert vuln.iloc[2] == 50.0
+
+
+def test_vulnerability_index_single_factor():
+    df = pd.DataFrame({"factor": [10.0, 30.0]})
+    vuln = compute_vulnerability_index(df, ["factor"])
+    assert vuln.iloc[0] == 0.0
+    assert vuln.iloc[1] == 100.0
+
+
+def test_identify_multiply_deprived():
+    # 4 rows, 3 factors
+    df = pd.DataFrame({
+        "f1": [1.0, 2.0, 3.0, 4.0],
+        "f2": [10.0, 20.0, 30.0, 40.0],
+        "f3": [100.0, 200.0, 300.0, 400.0],
+        "f4": [1000.0, 2000.0, 3000.0, 4000.0],
+    })
+    # Quantile(2/3):
+    # Rows 2 and 3 should be >= 2/3 quantile across all factors
+    flagged_3 = identify_multiply_deprived(df, ["f1", "f2", "f3", "f4"], min_factors=3)
+    assert not flagged_3.iloc[0]
+    assert not flagged_3.iloc[1]
+    assert flagged_3.iloc[2]
+    assert flagged_3.iloc[3]
+
+
+def test_identify_multiply_deprived_custom_min_factors():
+    df = pd.DataFrame({
+        "f1": [1.0, 2.0, 3.0],
+        "f2": [1.0, 1.0, 3.0],
+        "f3": [1.0, 1.0, 1.0],
+    })
+    flagged_1 = identify_multiply_deprived(df, ["f1", "f2", "f3"], min_factors=1)
+    assert isinstance(flagged_1, pd.Series)
+    assert flagged_1.dtype == bool
+    assert flagged_1.iloc[2]

moveq_core-0.1.0/tests/test_score.py

@@ -0,0 +1,52 @@
+import pytest
+
+from moveq_core import compute_score
+
+WEIGHTS = {"coverage": 0.40, "evening": 0.25, "frequency": 0.20, "gap": 0.15}
+LABELS = {
+    "coverage": "Share within 400m",
+    "evening": "Evening service share",
+    "frequency": "Weekday frequency",
+    "gap": "Deprivation-service gap",
+}
+
+
+def test_full_terms_gives_expected_score():
+    terms = {"coverage": 1.0, "evening": 1.0, "frequency": 1.0, "gap": 1.0}
+    result = compute_score(terms, WEIGHTS, labels=LABELS)
+    assert result.score == pytest.approx(100.0)
+    assert result.dropped == []
+
+
+def test_missing_term_is_dropped_and_weights_renormalised():
+    terms = {"coverage": 1.0, "evening": 1.0, "frequency": None, "gap": 1.0}
+    result = compute_score(terms, WEIGHTS, labels=LABELS)
+    assert result.dropped == ["frequency"]
+    # Remaining weights (0.40 + 0.25 + 0.15 = 0.80) renormalise to sum to 1.
+    used = sum(c.weight_used for c in result.components if not c.missing)
+    assert used == pytest.approx(1.0)
+    assert result.score == pytest.approx(100.0)
+    assert result.note is not None
+
+
+def test_all_terms_missing_returns_none_score():
+    terms = {"coverage": None, "evening": None, "frequency": None, "gap": None}
+    result = compute_score(terms, WEIGHTS, labels=LABELS)
+    assert result.score is None
+    assert result.dropped == list(WEIGHTS)
+
+
+def test_values_are_clipped_to_unit_interval():
+    terms = {"coverage": 1.5, "evening": -0.5, "frequency": 0.5, "gap": 0.5}
+    result = compute_score(terms, WEIGHTS, labels=LABELS)
+    values = {c.id: c.value for c in result.components}
+    assert values["coverage"] == 1.0
+    assert values["evening"] == 0.0
+
+
+def test_to_dict_rounds_score():
+    terms = {"coverage": 0.333333, "evening": 1.0, "frequency": 1.0, "gap": 1.0}
+    result = compute_score(terms, WEIGHTS, labels=LABELS)
+    d = result.to_dict()
+    assert isinstance(d["score"], float)
+    assert d["score"] == round(d["score"], 1)