equitable-capital-optimization-ai 0.2.0__py3-none-any.whl

equitable_capital/__init__.py

@@ -0,0 +1,25 @@
+"""Public API for the Equitable Capital Optimization research package."""
+
+from .allocation import allocate_capital, summarize_allocation
+from .data import generate_synthetic_startups
+from .explainability import explain_applicant
+from .fairness import fairness_audit, opportunity_gap
+from .modeling import (
+    ModelResult,
+    build_pipeline,
+    global_feature_importance,
+    train_model,
+)
+
+__all__ = [
+    "ModelResult",
+    "allocate_capital",
+    "build_pipeline",
+    "explain_applicant",
+    "fairness_audit",
+    "generate_synthetic_startups",
+    "global_feature_importance",
+    "opportunity_gap",
+    "summarize_allocation",
+    "train_model",
+]

equitable_capital/allocation.py

@@ -0,0 +1,96 @@
+"""Capital-allocation scenario simulation."""
+
+from __future__ import annotations
+
+import pandas as pd
+
+from .config import DEFAULT_EQUITY_WEIGHT
+
+
+def _greedy_allocate(
+    data: pd.DataFrame,
+    budget: float,
+    score_column: str,
+) -> pd.DataFrame:
+    ranked = data.sort_values(
+        [score_column, "predicted_success_probability"], ascending=False
+    ).copy()
+    remaining = float(budget)
+    allocations: list[dict] = []
+
+    for _, row in ranked.iterrows():
+        if remaining <= 0:
+            break
+        requested = float(row["requested_capital"])
+        allocated = min(requested, remaining)
+        if allocated <= 0:
+            continue
+        item = row.to_dict()
+        item["allocated_capital"] = allocated
+        allocations.append(item)
+        remaining -= allocated
+
+    return pd.DataFrame(allocations)
+
+
+def allocate_capital(
+    scored: pd.DataFrame,
+    budget: float,
+    equity_weight: float = DEFAULT_EQUITY_WEIGHT,
+) -> tuple[pd.DataFrame, pd.DataFrame]:
+    """Compare efficiency-only and equity-aware research scenarios."""
+    if budget <= 0:
+        raise ValueError("budget must be greater than zero")
+    if not 0 <= equity_weight <= 1:
+        raise ValueError("equity_weight must be between 0 and 1")
+
+    data = scored.copy()
+    data["efficiency_priority"] = (
+        data["predicted_success_probability"] / data["requested_capital"].clip(lower=1)
+    )
+
+    request_norm = data["requested_capital"] / data["requested_capital"].max()
+    data["equity_priority"] = (
+        (1 - equity_weight) * data["predicted_success_probability"]
+        + equity_weight * data["underserved_context_index"]
+        - 0.05 * request_norm
+    )
+
+    baseline = _greedy_allocate(data, budget, "efficiency_priority")
+    equitable = _greedy_allocate(data, budget, "equity_priority")
+    return baseline, equitable
+
+
+def summarize_allocation(
+    allocated: pd.DataFrame,
+    budget: float,
+) -> dict[str, float | int]:
+    """Summarize a simulated allocation result."""
+    if allocated.empty:
+        return {
+            "businesses_funded": 0,
+            "capital_allocated": 0.0,
+            "budget_utilization": 0.0,
+            "share_to_higher_barrier_contexts": 0.0,
+            "expected_successes": 0.0,
+        }
+
+    total = float(allocated["allocated_capital"].sum())
+    higher_barrier = allocated["underserved_context_index"] >= 0.5
+
+    return {
+        "businesses_funded": int(len(allocated)),
+        "capital_allocated": total,
+        "budget_utilization": total / budget if budget else 0.0,
+        "share_to_higher_barrier_contexts": float(
+            allocated.loc[higher_barrier, "allocated_capital"].sum() / total
+            if total
+            else 0.0
+        ),
+        "expected_successes": float(
+            (
+                allocated["predicted_success_probability"]
+                * (allocated["allocated_capital"] / allocated["requested_capital"])
+            ).sum()
+        ),
+    }

equitable_capital/config.py

@@ -0,0 +1,23 @@
+"""Shared project configuration and feature definitions."""
+
+RANDOM_SEED = 42
+DEFAULT_SAMPLE_SIZE = 1500
+DEFAULT_SELECTION_THRESHOLD = 0.50
+DEFAULT_EQUITY_WEIGHT = 0.30
+
+NUMERIC_FEATURES = [
+    "annual_revenue",
+    "revenue_growth_pct",
+    "cash_runway_months",
+    "employees",
+    "years_operating",
+    "debt_service_coverage",
+    "digital_adoption_score",
+    "market_demand_score",
+    "management_capacity_score",
+    "requested_capital",
+]
+
+CATEGORICAL_FEATURES = ["state", "industry"]
+MODEL_FEATURES = NUMERIC_FEATURES + CATEGORICAL_FEATURES
+TARGET = "funding_success"

equitable_capital/data.py

@@ -0,0 +1,81 @@
+"""Synthetic data generation for the research prototype."""
+
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+
+from .config import DEFAULT_SAMPLE_SIZE, RANDOM_SEED, TARGET
+
+
+def generate_synthetic_startups(
+    n: int = DEFAULT_SAMPLE_SIZE,
+    seed: int = RANDOM_SEED,
+) -> pd.DataFrame:
+    """Generate reproducible, privacy-safe synthetic small-business records."""
+    if n < 100:
+        raise ValueError("n must be at least 100 for a stable demonstration dataset")
+
+    rng = np.random.default_rng(seed)
+    states = np.array(["VA", "MD", "DC", "NC", "GA", "TX", "CA", "NY", "IL", "FL"])
+    industries = np.array(
+        [
+            "Technology",
+            "Retail",
+            "Professional Services",
+            "Food",
+            "Healthcare",
+            "Manufacturing",
+            "Education",
+            "Logistics",
+        ]
+    )
+
+    data = pd.DataFrame(
+        {
+            "startup_id": [f"BUS-{i:04d}" for i in range(1, n + 1)],
+            "state": rng.choice(states, n),
+            "industry": rng.choice(industries, n),
+            "annual_revenue": np.round(rng.lognormal(12.0, 0.9, n), 2),
+            "revenue_growth_pct": np.round(rng.normal(18, 18, n).clip(-40, 120), 2),
+            "cash_runway_months": np.round(rng.gamma(3.2, 2.0, n).clip(0.5, 24), 2),
+            "employees": rng.integers(1, 80, n),
+            "years_operating": np.round(rng.gamma(2.5, 1.8, n).clip(0.2, 20), 2),
+            "debt_service_coverage": np.round(
+                rng.normal(1.35, 0.45, n).clip(0.2, 3.5), 2
+            ),
+            "digital_adoption_score": np.round(rng.normal(62, 20, n).clip(0, 100), 1),
+            "market_demand_score": np.round(rng.normal(66, 18, n).clip(0, 100), 1),
+            "management_capacity_score": np.round(
+                rng.normal(64, 17, n).clip(0, 100), 1
+            ),
+            "requested_capital": np.round(rng.lognormal(11.3, 0.75, n), 2),
+            "rural_area": rng.binomial(1, 0.28, n),
+            "low_income_area": rng.binomial(1, 0.35, n),
+            "limited_finance_access": rng.binomial(1, 0.33, n),
+        }
+    )
+
+    data["underserved_context_index"] = np.round(
+        (
+            0.35 * data["low_income_area"]
+            + 0.30 * data["limited_finance_access"]
+            + 0.20 * data["rural_area"]
+            + 0.15 * (1 - data["digital_adoption_score"] / 100)
+        ).clip(0, 1),
+        3,
+    )
+
+    logit = (
+        -2.6
+        + 0.0000022 * data["annual_revenue"]
+        + 0.018 * data["revenue_growth_pct"]
+        + 0.075 * data["cash_runway_months"]
+        + 0.30 * data["debt_service_coverage"]
+        + 0.010 * data["market_demand_score"]
+        + 0.008 * data["management_capacity_score"]
+        - 0.0000013 * data["requested_capital"]
+    )
+    probability = 1 / (1 + np.exp(-logit))
+    data[TARGET] = rng.binomial(1, probability.clip(0.03, 0.97))
+    return data

equitable_capital/explainability.py

@@ -0,0 +1,38 @@
+"""Lightweight, transparent local explanation utilities."""
+
+from __future__ import annotations
+
+import pandas as pd
+from sklearn.pipeline import Pipeline
+
+from .config import MODEL_FEATURES, NUMERIC_FEATURES
+
+
+def explain_applicant(
+    pipeline: Pipeline,
+    applicant: pd.Series,
+    reference: pd.DataFrame,
+) -> pd.DataFrame:
+    """Estimate local directional sensitivity for numeric model features."""
+    base = applicant[MODEL_FEATURES].to_frame().T.copy()
+    base_probability = float(pipeline.predict_proba(base)[:, 1][0])
+    rows: list[dict[str, float | str]] = []
+
+    for feature in NUMERIC_FEATURES:
+        perturbed = base.copy()
+        perturbed[feature] = reference[feature].median()
+        probability = float(pipeline.predict_proba(perturbed)[:, 1][0])
+        rows.append(
+            {
+                "feature": feature,
+                "applicant_value": float(base.iloc[0][feature]),
+                "reference_median": float(reference[feature].median()),
+                "contribution_proxy": base_probability - probability,
+            }
+        )
+
+    return pd.DataFrame(rows).sort_values(
+        "contribution_proxy",
+        key=lambda series: series.abs(),
+        ascending=False,
+    )

equitable_capital/fairness.py

@@ -0,0 +1,68 @@
+"""Fairness and structural-opportunity diagnostic utilities."""
+
+from __future__ import annotations
+
+import pandas as pd
+
+from .config import DEFAULT_SELECTION_THRESHOLD
+
+
+def fairness_audit(
+    scored: pd.DataFrame,
+    threshold: float = DEFAULT_SELECTION_THRESHOLD,
+    underserved_cutoff: float = 0.50,
+) -> pd.DataFrame:
+    """Compare model outcomes across higher- and lower-barrier contexts."""
+    if not 0 <= threshold <= 1:
+        raise ValueError("threshold must be between 0 and 1")
+
+    data = scored.copy()
+    data["context_group"] = data["underserved_context_index"].ge(underserved_cutoff).map(
+        {
+            True: "Higher structural barriers",
+            False: "Lower structural barriers",
+        }
+    )
+    data["selected"] = data["predicted_success_probability"].ge(threshold).astype(int)
+
+    rows: list[dict[str, float | int | str]] = []
+    for group, frame in data.groupby("context_group", observed=True):
+        rows.append(
+            {
+                "context_group": group,
+                "n": int(len(frame)),
+                "selection_rate": float(frame["selected"].mean()),
+                "avg_predicted_success": float(
+                    frame["predicted_success_probability"].mean()
+                ),
+                "avg_requested_capital": float(frame["requested_capital"].mean()),
+                "avg_readiness_score": float(frame["capital_readiness_score"].mean()),
+            }
+        )
+
+    audit = pd.DataFrame(rows)
+    if len(audit) == 2:
+        maximum = float(audit["selection_rate"].max())
+        minimum = float(audit["selection_rate"].min())
+        ratio = minimum / maximum if maximum > 0 else 1.0
+    else:
+        ratio = 1.0
+
+    audit["selection_rate_ratio"] = ratio
+    return audit
+
+
+def opportunity_gap(scored: pd.DataFrame, cutoff: float = 0.50) -> dict[str, float]:
+    """Summarize readiness and requested-capital gaps across contexts."""
+    higher = scored[scored["underserved_context_index"] >= cutoff]
+    lower = scored[scored["underserved_context_index"] < cutoff]
+
+    return {
+        "readiness_gap_points": float(
+            lower["capital_readiness_score"].mean()
+            - higher["capital_readiness_score"].mean()
+        ),
+        "requested_capital_gap": float(
+            higher["requested_capital"].mean() - lower["requested_capital"].mean()
+        ),
+    }

equitable_capital/modeling.py

@@ -0,0 +1,122 @@
+"""Predictive modeling and model-evaluation utilities."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import pandas as pd
+from sklearn.compose import ColumnTransformer
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.metrics import (
+    accuracy_score,
+    brier_score_loss,
+    f1_score,
+    precision_score,
+    recall_score,
+    roc_auc_score,
+)
+from sklearn.model_selection import train_test_split
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import OneHotEncoder, StandardScaler
+
+from .config import (
+    CATEGORICAL_FEATURES,
+    MODEL_FEATURES,
+    NUMERIC_FEATURES,
+    RANDOM_SEED,
+    TARGET,
+)
+
+
+@dataclass(frozen=True)
+class ModelResult:
+    """Container for the trained pipeline, evaluation metrics, and scored data."""
+
+    pipeline: Pipeline
+    metrics: dict[str, float]
+    scored_data: pd.DataFrame
+
+    @property
+    def auc(self) -> float:
+        return self.metrics["roc_auc"]
+
+    @property
+    def accuracy(self) -> float:
+        return self.metrics["accuracy"]
+
+
+def build_pipeline(random_state: int = RANDOM_SEED) -> Pipeline:
+    """Build the preprocessing and Random Forest classification pipeline."""
+    preprocess = ColumnTransformer(
+        [
+            ("num", StandardScaler(), NUMERIC_FEATURES),
+            ("cat", OneHotEncoder(handle_unknown="ignore"), CATEGORICAL_FEATURES),
+        ]
+    )
+    model = RandomForestClassifier(
+        n_estimators=300,
+        max_depth=9,
+        min_samples_leaf=5,
+        class_weight="balanced",
+        random_state=random_state,
+        n_jobs=-1,
+    )
+    return Pipeline([("preprocess", preprocess), ("model", model)])
+
+
+def train_model(data: pd.DataFrame, random_state: int = RANDOM_SEED) -> ModelResult:
+    """Train the model and score the complete synthetic dataset."""
+    missing = sorted(set(MODEL_FEATURES + [TARGET]) - set(data.columns))
+    if missing:
+        raise ValueError(f"Missing required columns: {missing}")
+
+    features = data[MODEL_FEATURES].copy()
+    target = data[TARGET].astype(int)
+
+    x_train, x_test, y_train, y_test = train_test_split(
+        features,
+        target,
+        test_size=0.25,
+        stratify=target,
+        random_state=random_state,
+    )
+
+    pipeline = build_pipeline(random_state=random_state)
+    pipeline.fit(x_train, y_train)
+
+    predictions = pipeline.predict(x_test)
+    probabilities = pipeline.predict_proba(x_test)[:, 1]
+
+    metrics = {
+        "roc_auc": float(roc_auc_score(y_test, probabilities)),
+        "accuracy": float(accuracy_score(y_test, predictions)),
+        "precision": float(precision_score(y_test, predictions, zero_division=0)),
+        "recall": float(recall_score(y_test, predictions, zero_division=0)),
+        "f1": float(f1_score(y_test, predictions, zero_division=0)),
+        "brier": float(brier_score_loss(y_test, probabilities)),
+    }
+
+    scored = data.copy()
+    scored["predicted_success_probability"] = pipeline.predict_proba(features)[:, 1]
+    scored["capital_readiness_score"] = (
+        100 * scored["predicted_success_probability"]
+    ).round(1)
+
+    return ModelResult(pipeline=pipeline, metrics=metrics, scored_data=scored)
+
+
+def global_feature_importance(result: ModelResult) -> pd.DataFrame:
+    """Return transformed-model feature importances in descending order."""
+    preprocess = result.pipeline.named_steps["preprocess"]
+    model = result.pipeline.named_steps["model"]
+    feature_names = preprocess.get_feature_names_out()
+
+    importance = pd.DataFrame(
+        {"feature": feature_names, "importance": model.feature_importances_}
+    )
+    importance["feature"] = (
+        importance["feature"]
+        .str.replace("num__", "", regex=False)
+        .str.replace("cat__", "", regex=False)
+    )
+    return importance.sort_values("importance", ascending=False).reset_index(drop=True)

equitable_capital_optimization_ai-0.2.0.dist-info/METADATA

@@ -0,0 +1,267 @@
+Metadata-Version: 2.4
+Name: equitable-capital-optimization-ai
+Version: 0.2.0
+Summary: Research package for predictive capital-readiness analysis, fairness auditing, explainable AI, and equity-aware capital allocation.
+Author: Sakera Begum
+License: MIT
+Project-URL: Homepage, https://github.com/sakera023/equitable-capital-optimization-ai
+Project-URL: Repository, https://github.com/sakera023/equitable-capital-optimization-ai
+Project-URL: Issues, https://github.com/sakera023/equitable-capital-optimization-ai/issues
+Project-URL: Documentation, https://github.com/sakera023/equitable-capital-optimization-ai/tree/main/docs
+Project-URL: Publication, https://www.researchgate.net/publication/410866072_An_AI-Powered_Framework_for_Equitable_Capital_Optimization_Leveraging_Predictive_Intelligence_to_Empower_Underserved_Entrepreneurial_Ecosystems_in_the_US
+Keywords: artificial-intelligence,machine-learning,predictive-analytics,entrepreneurship,small-business,capital-allocation,fairness,responsible-ai,explainable-ai,streamlit
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+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 :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<3,>=1.26
+Requires-Dist: pandas<4,>=2.1
+Requires-Dist: plotly<8,>=5.20
+Requires-Dist: scikit-learn<2,>=1.4
+Requires-Dist: streamlit<2,>=1.40
+Provides-Extra: dev
+Requires-Dist: build<2,>=1.2; extra == "dev"
+Requires-Dist: pytest<10,>=8; extra == "dev"
+Requires-Dist: ruff<1,>=0.8; extra == "dev"
+Requires-Dist: twine<7,>=5; extra == "dev"
+Dynamic: license-file
+
+# Equitable Capital Optimization AI
+
+[![CI](https://github.com/sakera023/equitable-capital-optimization-ai/actions/workflows/ci.yml/badge.svg)](https://github.com/sakera023/equitable-capital-optimization-ai/actions/workflows/ci.yml)
+![Python](https://img.shields.io/badge/Python-3.11%2B-3776AB?logo=python&logoColor=white)
+![Streamlit](https://img.shields.io/badge/Streamlit-App-FF4B4B?logo=streamlit&logoColor=white)
+![License](https://img.shields.io/badge/License-MIT-green)
+
+A reproducible research prototype for **predictive capital-readiness analysis, model
+explainability, fairness auditing, and equity-aware capital-allocation simulation** for
+underserved U.S. entrepreneurial ecosystems.
+
+The project is inspired by:
+
+> **An AI-Powered Framework for Equitable Capital Optimization: Leveraging Predictive
+> Intelligence to Empower Underserved Entrepreneurial Ecosystems in the U.S.**
+
+Related publication:
+[ResearchGate](https://www.researchgate.net/publication/410866072_An_AI-Powered_Framework_for_Equitable_Capital_Optimization_Leveraging_Predictive_Intelligence_to_Empower_Underserved_Entrepreneurial_Ecosystems_in_the_US)
+
+## Why this project exists
+
+Access to capital is not only a prediction problem. It is also an allocation,
+transparency, and measurement problem. This repository separates those concerns into
+four independently testable components:
+
+| Component | Purpose |
+| --- | --- |
+| Predictive modeling | Estimate funding-success probability from business and market features |
+| Explainability | Show how applicant-level features influence the model locally |
+| Fairness auditing | Compare outcomes across structural-access contexts |
+| Capital allocation | Compare efficiency-only and equity-aware funding scenarios |
+
+## Responsible-use boundary
+
+> **Research and educational use only.**
+>
+> This project must not be used to make real lending, credit, investment, employment,
+> housing, insurance, benefits, or eligibility decisions.
+
+The predictive model intentionally excludes protected personal characteristics.
+Structural context indicators are used for research auditing and allocation simulation,
+not as protected-trait proxies for real-world underwriting.
+
+## Architecture
+
+```mermaid
+flowchart LR
+    A[Synthetic Business Data] --> B[Feature Pipeline]
+    B --> C[Random Forest Model]
+    C --> D[Capital Readiness Score]
+    C --> E[Local Explanation]
+    D --> F[Fairness Audit]
+    D --> G[Allocation Simulator]
+    F --> H[Research Dashboard]
+    G --> H
+    E --> H
+```
+
+See [Architecture](docs/ARCHITECTURE.md) and [Methodology](docs/METHODOLOGY.md).
+
+## Key capabilities
+
+- Reproducible synthetic U.S. small-business/startup data generation
+- Scikit-learn preprocessing and Random Forest classification pipeline
+- Holdout evaluation with ROC-AUC, accuracy, precision, recall, F1, and Brier score
+- Capital Readiness Score derived from predicted funding-success probability
+- Global feature-importance reporting
+- Applicant-level local sensitivity explanations
+- Structural-context fairness audit and selection-rate comparison
+- Efficiency-only and equity-aware capital-allocation simulation
+- Interactive Streamlit research dashboard
+- Automated tests and linting in GitHub Actions
+- Model card, citation metadata, contribution guide, and security policy
+
+## Python package
+
+The reusable research code lives in the `equitable_capital` Python package.
+
+After a release is published to PyPI, install it with:
+
+```bash
+pip install equitable-capital-optimization-ai
+```
+
+Example:
+
+```python
+from equitable_capital import (
+    allocate_capital,
+    fairness_audit,
+    generate_synthetic_startups,
+    train_model,
+)
+
+data = generate_synthetic_startups()
+result = train_model(data)
+audit = fairness_audit(result.scored_data)
+```
+
+For local development, install the repository in editable mode:
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Quick start
+
+```bash
+git clone https://github.com/sakera023/equitable-capital-optimization-ai.git
+cd equitable-capital-optimization-ai
+python -m venv .venv
+```
+
+Activate the environment.
+
+**Windows**
+
+```bash
+.venv\Scripts\activate
+```
+
+**macOS/Linux**
+
+```bash
+source .venv/bin/activate
+```
+
+Install and run:
+
+```bash
+pip install -r requirements.txt
+streamlit run app.py
+```
+
+Development checks:
+
+```bash
+pip install -r requirements-dev.txt
+ruff check src tests app.py
+python -m pytest -q
+```
+
+## Repository structure
+
+```text
+.
+├── app.py
+├── pyproject.toml
+├── requirements.txt
+├── requirements-dev.txt
+├── Makefile
+├── src/
+│   └── equitable_capital/
+│       ├── __init__.py
+│       ├── allocation.py
+│       ├── config.py
+│       ├── data.py
+│       ├── explainability.py
+│       ├── fairness.py
+│       └── modeling.py
+├── tests/
+├── docs/
+├── .github/
+├── CITATION.cff
+├── CONTRIBUTING.md
+├── SECURITY.md
+├── CHANGELOG.md
+└── LICENSE
+```
+
+## Data design
+
+The repository uses **synthetic data by default**. This avoids exposing private
+financial records, makes the project reproducible, and prevents the demonstration from
+implying real-world predictive validity.
+
+Predictive features include revenue, growth, cash runway, employees, operating history,
+debt-service coverage, digital adoption, market demand, management capacity, requested
+capital, industry, and state.
+
+## Model evaluation
+
+The application reports ROC-AUC, accuracy, precision, recall, F1 score, and Brier score.
+These metrics evaluate the synthetic demonstration only.
+
+## Fairness and equity analysis
+
+A **structural barrier index** is built from contextual variables such as low-income
+area, rural area, limited finance access, and digital adoption.
+
+The index is reserved for post-model fairness diagnostics and research simulation of
+equity-aware allocation policies. It is not included in the predictive training
+features.
+
+## Reproducibility
+
+The synthetic data generator and model pipeline use explicit random seeds. Tests verify
+data ranges, prediction bounds, allocation-budget constraints, and fairness-audit
+outputs. CI runs on every push and pull request.
+
+## Research roadmap
+
+Planned extensions include gradient-boosted model benchmarks, probability calibration,
+SHAP, temporal/geographic validation, county-level opportunity maps, Census/SBA/CDFI
+public-data integrations, constrained optimization, and uncertainty analysis.
+
+See [Research Roadmap](docs/RESEARCH_ROADMAP.md).
+
+## Citation
+
+If you use the software, cite the repository metadata in [CITATION.cff](CITATION.cff).
+If you use the associated research concept, cite the publication separately and clearly
+distinguish research findings from this software prototype.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## Security
+
+Do not publish secrets, private financial information, or real applicant records in
+issues or pull requests. See [SECURITY.md](SECURITY.md).
+
+## License
+
+MIT License. See [LICENSE](LICENSE).
+
+## Maintainer
+
+**Sakera Begum**

equitable_capital_optimization_ai-0.2.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+equitable_capital/__init__.py,sha256=ipacOoxOMfhIpfEaczJ5Wlli-qf6v49SGtWjdODvjwU,660
+equitable_capital/allocation.py,sha256=Ll2ka3NiX1Dk2fY6L3LOXXiBWveua4JDFyG8DEXGQ0U,2966
+equitable_capital/config.py,sha256=rN5yJXbv5YExFO5ggTt74zdQ_Ru0R2PbyQkwtveVFl4,581
+equitable_capital/data.py,sha256=5Msi58Kwai3Yd-lNXcc5BWTbupORxzA3X7BmjIv2L3Q,2919
+equitable_capital/explainability.py,sha256=vNx8uRVUYbPH0P-9g372CEmdryc6iLMgIJSzPPE2BPo,1225
+equitable_capital/fairness.py,sha256=qwqagtGV1ip58jst5VBqnNb2GVt9XyW68zo9R8GtmHE,2368
+equitable_capital/modeling.py,sha256=omZmIqxrjhwUyNML12eFXGUM9Ea-kJT19ULEUmT1HD8,3857
+equitable_capital_optimization_ai-0.2.0.dist-info/licenses/LICENSE,sha256=34lseBbMlsAHo4x1C5pPRwAqE9pXcsI-ALlU3aqLguA,1069
+equitable_capital_optimization_ai-0.2.0.dist-info/METADATA,sha256=-fkDfKdSbZwA2zH6aA2TgYQP26YFvZvGfUZLuF41iqA,9055
+equitable_capital_optimization_ai-0.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+equitable_capital_optimization_ai-0.2.0.dist-info/top_level.txt,sha256=j69pW2IqsDHlt81XaFj4eHXKoOzF6eBYKcdg4buSMi0,18
+equitable_capital_optimization_ai-0.2.0.dist-info/RECORD,,

equitable_capital_optimization_ai-0.2.0.dist-info/WHEEL

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

equitable_capital_optimization_ai-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sakera Begum
+
+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.

equitable_capital_optimization_ai-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+equitable_capital