sparpartner 0.1.0__tar.gz

sparpartner-0.1.0/LICENSE

@@ -0,0 +1,4 @@
+Copyright (c) 2026 Your Henry. All Rights Reserved.
+
+Contact the author at osas2henry@gmail.com with questions or requests
+regarding use of this software.

sparpartner-0.1.0/PKG-INFO

@@ -0,0 +1,227 @@
+Metadata-Version: 2.4
+Name: sparpartner
+Version: 0.1.0
+Summary: Deterministic, benchmark-driven stratified sampler for train/test prep.
+Author: Henry
+Author-email: Henry <osas2henry@gmail.com>
+License: All Rights Reserved
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=1.3
+Dynamic: author
+Dynamic: license-file
+Dynamic: requires-python
+
+# sparpartner
+
+A deterministic stratified sampler for train/test prep. It doesn't
+split your data randomly, it deliberately finds the rows that most
+resemble a benchmark case, so you can hold those out as a genuine
+test set and train on everything else.
+
+## Why this exists
+
+A random train/test split assumes the test set should look
+statistically like the train set. That's the wrong question if
+what you actually want to know is: **does the model generalize past
+one specific profile, or did it just memorize the neighborhood
+around it?**
+
+`sparpartner` answers that by ranking every row in your data by how
+closely it resembles a benchmark ("bench_marks") you define, then
+sorting on that resemblance. You then slice the sorted frame
+yourself:
+
+- **Lookalikes as test, the rest as train**: train on rows *unlike*
+  the benchmark, test on the rows that *are* like it. This is the
+  harder, more honest check: it tells you whether the model actually
+  learned something general, or only performs well near cases it's
+  already seen a lot of.
+- **Lookalikes as train, the rest as test**: the reverse, if you
+  want to check the opposite direction.
+
+`sparpartner` only produces the ranking. The actual train/test cut
+is a plain slice on your side (see [Usage](#usage) below).
+
+## Where the idea comes from
+
+Two unrelated places, both about comparing something against a
+reference on purpose rather than at random:
+
+**A boxer preparing for a match.** A fighter in camp doesn't spar
+with whoever's free in the gym, they specifically look for a
+sparring partner who moves, reaches, and hits like the opponent
+they're about to face. Training against a random partner tells you
+nothing about how you'll actually do; training against someone who
+resembles the real threat does. `sparpartner` applies that same
+logic to a model: instead of a random holdout, it finds the rows
+that resemble the toughest, most relevant "opponent" profile and
+holds those back as the real test, so what's left to train on is
+everything *unlike* that opponent, and the test genuinely checks
+whether the model can handle the match it's actually walking into.
+
+**Astrology's approach to comparing a chart to a reference.** Reading
+a chart against a benchmark isn't a single yes/no match, it's
+several weighted dimensions (sun sign, moon sign, rising, houses,
+and so on) each compared individually, then combined into one
+overall resemblance reading. No single dimension decides the
+outcome alone; the composite is what matters. That's the same shape
+`sparpartner` uses: several weighted signals, each scored
+independently against a benchmark, summed into one composite
+`_score` rather than a single all-or-nothing match.
+
+## How the scoring works
+
+You give it:
+
+- `df`: your data
+- `bench_marks`: a dict of `{column_name: benchmark_value}`, one
+  entry per signal you care about
+- `custom_weights`: a list of `[column_name, weight]` pairs, saying
+  which columns matter and how much
+
+For each weighted column, `sparpartner` auto-detects the column's
+type and scores every row's distance to the benchmark on a 0–1
+scale (1.0 = exact match, 0.0 = as far as possible):
+
+| Detected type | How distance is measured |
+|---|---|
+| **numeric** | `abs(value - bench)`, capped by the column's own max observed distance from bench |
+| **date** | both sides converted to "age in days" relative to the benchmark date, capped by the column's own max observed age |
+| **string** | exact match = 1, anything else = 0 |
+
+Date detection is automatic, it only treats a column as a date if
+its values look date-shaped (contain a separator like `-`, `/`, `.`
+or a recognizable month name) **and** parse successfully at least
+98% of the time. Bare numeric-looking strings (e.g. `"12345"`) are
+never mistaken for dates, and object-dtype columns of digit strings
+are treated as exact-match strings, not numbers. Only a real
+numeric dtype gets the numeric path.
+
+Each column's 0–1 score is multiplied by its weight and summed into
+one raw score per row, then divided by the total weight so the
+final `_score` always lands in the 0–1 range, however many signals
+or weights you used.
+
+### Tie-breaking
+
+Rows that land on the exact same `_score` aren't left to random or
+arbitrary order. Ties are broken by the per-signal score of the
+**highest-weight** signal first, then the next-highest, cascading
+down the weighted signal list until the tie resolves. Signals that
+share the same weight are compared in the order they appear in
+`custom_weights`. The tie-break always sorts in the same direction
+as the main score (see `look_alike` below). Only if every signal is
+exhausted and rows are still tied does it fall back to original row
+order.
+
+## `look_alike`
+
+Controls sort direction:
+
+- `look_alike=True` (default): highest `_score` (closest to
+  benchmark) sorted to the **top**.
+- `look_alike=False`: highest `_score` sorted to the **bottom**,
+  farthest-from-benchmark rows come first.
+
+## Usage
+
+### Sample usage
+
+```python
+import pandas as pd
+from sparpartner import sample
+
+df = pd.DataFrame({
+    "id": [1, 2, 3, 4, 5],
+    "age": [25, 30, 47, 52, 33],
+    "signup_date": ["2023-01-15", "2023-03-02", "2022-11-20", "2023-01-10", "2023-06-01"],
+    "country": ["US", "US", "CA", "US", "MX"],
+})
+
+bench_marks = {
+    "age": 30,
+    "signup_date": "2023-01-01",
+    "country": "US",
+}
+
+custom_weights = [
+    ["age", 2],
+    ["signup_date", 1],
+    ["country", 1],
+]
+
+result = sample(
+    df,
+    bench_marks,
+    custom_weights,
+    look_alike=True,      # True = most similar rows first
+    show_progress=True,   # prints the full scoring breakdown
+    return_score=True,    # keep _score columns in the output
+    drop_nan=True,
+)
+
+print(result)
+```
+
+`age=30`, `signup_date="2023-01-01"`, and `country="US"` closely
+match row `id=1` (age 25, close date, US), so with
+`look_alike=True` that row lands at or near the top of the sorted
+output. Flip `look_alike=False` to instead surface the rows that
+look *least* like the benchmark (e.g. the Mexico row with the
+furthest signup date).
+
+```python
+# --- post-sample: turn the ranking into an actual train/test split ---
+# Re-run with look_alike=False so lookalikes sort to the BOTTOM of `result`.
+ranked = sample(df, bench_marks, custom_weights, look_alike=False)
+
+# Slice however large you want the test set to be, e.g. the bottom 30%:
+cut = int(len(ranked) * 0.7)
+train = ranked.iloc[:cut]   # non-lookalikes
+test = ranked.iloc[cut:]    # lookalikes, the harder, honest test set
+```
+
+### Parameters
+
+| Name | Type | Default | What it does |
+|---|---|---|---|
+| `df` | DataFrame | required | Must contain a column for every name in `custom_weights` |
+| `bench_marks` | dict | required | `{column_name: benchmark_value}` |
+| `custom_weights` | list of `[name, weight]` | required | Which columns to score and how much each contributes |
+| `look_alike` | bool | `True` | `True` = lookalikes sorted to top; `False` = sorted to bottom |
+| `show_progress` | bool | `False` | Prints a full readout: header, per-column type/cap/sample scores, sort direction, top/bottom ranked rows with weighted contributions, and a health check flagging any signal that isn't adding useful separation |
+| `return_score` | bool | `False` | If `True`, keeps `_score` and `_score_<name>` columns in the result instead of dropping them |
+| `drop_nan` | bool | `True` | If `True`, drops any row with a NaN component score (e.g. missing value or unparseable date) after printing a sanity check of what was dropped and why |
+
+### Validation
+
+`custom_weights` is validated upfront, before any scoring starts, and
+raises `ValueError` if:
+
+- a column name isn't a string, or doesn't exist in `df`
+- a column name has no matching entry in `bench_marks`
+- the same column name appears more than once
+- a weight isn't numeric (bools are rejected too, a `bool` is
+  technically an `int` in Python but was never meant as a weight)
+- a weight is `NaN`
+
+## A couple of things worth knowing
+
+- **Zero-variance columns**: if every row (including the benchmark)
+  has the same value for a signal, there's nothing to measure
+  distance against, that signal scores every row 1.0 rather than
+  dividing by zero.
+- **Negative total weight**: if your weights sum to ≤ 0, the
+  normalization step is skipped and `_score` is left as the raw
+  weighted sum instead of being silently divided by a non-positive
+  number.
+- **Object-dtype numeric strings**: a column of strings like
+  `"100"`, `"200"` (object dtype, no separator) is scored as an
+  exact-match string column, *not* auto-converted to numeric. Only
+  genuine numeric dtypes (`int`, `float`) get the numeric distance
+  path.

sparpartner-0.1.0/README.md

@@ -0,0 +1,209 @@
+# sparpartner
+
+A deterministic stratified sampler for train/test prep. It doesn't
+split your data randomly, it deliberately finds the rows that most
+resemble a benchmark case, so you can hold those out as a genuine
+test set and train on everything else.
+
+## Why this exists
+
+A random train/test split assumes the test set should look
+statistically like the train set. That's the wrong question if
+what you actually want to know is: **does the model generalize past
+one specific profile, or did it just memorize the neighborhood
+around it?**
+
+`sparpartner` answers that by ranking every row in your data by how
+closely it resembles a benchmark ("bench_marks") you define, then
+sorting on that resemblance. You then slice the sorted frame
+yourself:
+
+- **Lookalikes as test, the rest as train**: train on rows *unlike*
+  the benchmark, test on the rows that *are* like it. This is the
+  harder, more honest check: it tells you whether the model actually
+  learned something general, or only performs well near cases it's
+  already seen a lot of.
+- **Lookalikes as train, the rest as test**: the reverse, if you
+  want to check the opposite direction.
+
+`sparpartner` only produces the ranking. The actual train/test cut
+is a plain slice on your side (see [Usage](#usage) below).
+
+## Where the idea comes from
+
+Two unrelated places, both about comparing something against a
+reference on purpose rather than at random:
+
+**A boxer preparing for a match.** A fighter in camp doesn't spar
+with whoever's free in the gym, they specifically look for a
+sparring partner who moves, reaches, and hits like the opponent
+they're about to face. Training against a random partner tells you
+nothing about how you'll actually do; training against someone who
+resembles the real threat does. `sparpartner` applies that same
+logic to a model: instead of a random holdout, it finds the rows
+that resemble the toughest, most relevant "opponent" profile and
+holds those back as the real test, so what's left to train on is
+everything *unlike* that opponent, and the test genuinely checks
+whether the model can handle the match it's actually walking into.
+
+**Astrology's approach to comparing a chart to a reference.** Reading
+a chart against a benchmark isn't a single yes/no match, it's
+several weighted dimensions (sun sign, moon sign, rising, houses,
+and so on) each compared individually, then combined into one
+overall resemblance reading. No single dimension decides the
+outcome alone; the composite is what matters. That's the same shape
+`sparpartner` uses: several weighted signals, each scored
+independently against a benchmark, summed into one composite
+`_score` rather than a single all-or-nothing match.
+
+## How the scoring works
+
+You give it:
+
+- `df`: your data
+- `bench_marks`: a dict of `{column_name: benchmark_value}`, one
+  entry per signal you care about
+- `custom_weights`: a list of `[column_name, weight]` pairs, saying
+  which columns matter and how much
+
+For each weighted column, `sparpartner` auto-detects the column's
+type and scores every row's distance to the benchmark on a 0–1
+scale (1.0 = exact match, 0.0 = as far as possible):
+
+| Detected type | How distance is measured |
+|---|---|
+| **numeric** | `abs(value - bench)`, capped by the column's own max observed distance from bench |
+| **date** | both sides converted to "age in days" relative to the benchmark date, capped by the column's own max observed age |
+| **string** | exact match = 1, anything else = 0 |
+
+Date detection is automatic, it only treats a column as a date if
+its values look date-shaped (contain a separator like `-`, `/`, `.`
+or a recognizable month name) **and** parse successfully at least
+98% of the time. Bare numeric-looking strings (e.g. `"12345"`) are
+never mistaken for dates, and object-dtype columns of digit strings
+are treated as exact-match strings, not numbers. Only a real
+numeric dtype gets the numeric path.
+
+Each column's 0–1 score is multiplied by its weight and summed into
+one raw score per row, then divided by the total weight so the
+final `_score` always lands in the 0–1 range, however many signals
+or weights you used.
+
+### Tie-breaking
+
+Rows that land on the exact same `_score` aren't left to random or
+arbitrary order. Ties are broken by the per-signal score of the
+**highest-weight** signal first, then the next-highest, cascading
+down the weighted signal list until the tie resolves. Signals that
+share the same weight are compared in the order they appear in
+`custom_weights`. The tie-break always sorts in the same direction
+as the main score (see `look_alike` below). Only if every signal is
+exhausted and rows are still tied does it fall back to original row
+order.
+
+## `look_alike`
+
+Controls sort direction:
+
+- `look_alike=True` (default): highest `_score` (closest to
+  benchmark) sorted to the **top**.
+- `look_alike=False`: highest `_score` sorted to the **bottom**,
+  farthest-from-benchmark rows come first.
+
+## Usage
+
+### Sample usage
+
+```python
+import pandas as pd
+from sparpartner import sample
+
+df = pd.DataFrame({
+    "id": [1, 2, 3, 4, 5],
+    "age": [25, 30, 47, 52, 33],
+    "signup_date": ["2023-01-15", "2023-03-02", "2022-11-20", "2023-01-10", "2023-06-01"],
+    "country": ["US", "US", "CA", "US", "MX"],
+})
+
+bench_marks = {
+    "age": 30,
+    "signup_date": "2023-01-01",
+    "country": "US",
+}
+
+custom_weights = [
+    ["age", 2],
+    ["signup_date", 1],
+    ["country", 1],
+]
+
+result = sample(
+    df,
+    bench_marks,
+    custom_weights,
+    look_alike=True,      # True = most similar rows first
+    show_progress=True,   # prints the full scoring breakdown
+    return_score=True,    # keep _score columns in the output
+    drop_nan=True,
+)
+
+print(result)
+```
+
+`age=30`, `signup_date="2023-01-01"`, and `country="US"` closely
+match row `id=1` (age 25, close date, US), so with
+`look_alike=True` that row lands at or near the top of the sorted
+output. Flip `look_alike=False` to instead surface the rows that
+look *least* like the benchmark (e.g. the Mexico row with the
+furthest signup date).
+
+```python
+# --- post-sample: turn the ranking into an actual train/test split ---
+# Re-run with look_alike=False so lookalikes sort to the BOTTOM of `result`.
+ranked = sample(df, bench_marks, custom_weights, look_alike=False)
+
+# Slice however large you want the test set to be, e.g. the bottom 30%:
+cut = int(len(ranked) * 0.7)
+train = ranked.iloc[:cut]   # non-lookalikes
+test = ranked.iloc[cut:]    # lookalikes, the harder, honest test set
+```
+
+### Parameters
+
+| Name | Type | Default | What it does |
+|---|---|---|---|
+| `df` | DataFrame | required | Must contain a column for every name in `custom_weights` |
+| `bench_marks` | dict | required | `{column_name: benchmark_value}` |
+| `custom_weights` | list of `[name, weight]` | required | Which columns to score and how much each contributes |
+| `look_alike` | bool | `True` | `True` = lookalikes sorted to top; `False` = sorted to bottom |
+| `show_progress` | bool | `False` | Prints a full readout: header, per-column type/cap/sample scores, sort direction, top/bottom ranked rows with weighted contributions, and a health check flagging any signal that isn't adding useful separation |
+| `return_score` | bool | `False` | If `True`, keeps `_score` and `_score_<name>` columns in the result instead of dropping them |
+| `drop_nan` | bool | `True` | If `True`, drops any row with a NaN component score (e.g. missing value or unparseable date) after printing a sanity check of what was dropped and why |
+
+### Validation
+
+`custom_weights` is validated upfront, before any scoring starts, and
+raises `ValueError` if:
+
+- a column name isn't a string, or doesn't exist in `df`
+- a column name has no matching entry in `bench_marks`
+- the same column name appears more than once
+- a weight isn't numeric (bools are rejected too, a `bool` is
+  technically an `int` in Python but was never meant as a weight)
+- a weight is `NaN`
+
+## A couple of things worth knowing
+
+- **Zero-variance columns**: if every row (including the benchmark)
+  has the same value for a signal, there's nothing to measure
+  distance against, that signal scores every row 1.0 rather than
+  dividing by zero.
+- **Negative total weight**: if your weights sum to ≤ 0, the
+  normalization step is skipped and `_score` is left as the raw
+  weighted sum instead of being silently divided by a non-positive
+  number.
+- **Object-dtype numeric strings**: a column of strings like
+  `"100"`, `"200"` (object dtype, no separator) is scored as an
+  exact-match string column, *not* auto-converted to numeric. Only
+  genuine numeric dtypes (`int`, `float`) get the numeric distance
+  path.

sparpartner-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sparpartner"
+version = "0.1.0"
+description = "Deterministic, benchmark-driven stratified sampler for train/test prep."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "All Rights Reserved" }
+authors = [
+    { name = "Henry", email = "osas2henry@gmail.com" }
+]
+dependencies = [
+    "pandas>=1.3"
+]
+classifiers = [
+    "License :: Other/Proprietary License",
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]

sparpartner-0.1.0/setup.cfg

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

sparpartner-0.1.0/setup.py

@@ -0,0 +1,22 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="sparpartner",
+    version="0.1.0",
+    description="Deterministic, benchmark-driven stratified sampler for train/test prep.",
+    long_description=open("README.md", encoding="utf-8").read(),
+    long_description_content_type="text/markdown",
+    author="Henry",
+    author_email="osas2henry@gmail.com",
+    license="Proprietary",
+    packages=find_packages(),
+    install_requires=[
+        "pandas>=1.3",
+    ],
+    python_requires=">=3.8",
+    classifiers=[
+        "License :: Other/Proprietary License",
+        "Programming Language :: Python :: 3",
+        "Operating System :: OS Independent",
+    ],
+)

sparpartner-0.1.0/sparpartner/__init__.py

@@ -0,0 +1,22 @@
+"""
+sparpartner
+============
+
+Type-aware benchmark scoring / stratified sampler for train-test prep.
+
+Guards against overfitting by letting you deliberately hold out the
+rows that most resemble a benchmark case (rather than a random split),
+so a model trained on the rest can be tested against its true
+"opponent" instead of an easy, self-similar sample.
+
+Usage
+-----
+    from sparpartner import sample
+
+    result = sample(df, bench_marks, custom_weights, look_alike=True)
+"""
+
+from .main import sample
+
+__all__ = ["sample"]
+__version__ = "0.1.0"

sparpartner-0.1.0/sparpartner/main.py

@@ -0,0 +1,474 @@
+import re
+import warnings
+import pandas as pd
+
+
+# Values must look date-shaped (contain a date separator or month name)
+# before we even attempt pd.to_datetime — this stops bare digit strings
+# like "2023", "12345" (zip codes), or plain IDs from being mistaken
+# for dates just because to_datetime happens to be able to parse them.
+_MONTH_NAMES = (
+    r"jan(?:uary)?|feb(?:ruary)?|mar(?:ch)?|apr(?:il)?|may|jun(?:e)?|"
+    r"jul(?:y)?|aug(?:ust)?|sep(?:t(?:ember)?)?|oct(?:ober)?|"
+    r"nov(?:ember)?|dec(?:ember)?"
+)
+_DATE_LIKE_PATTERN = re.compile(
+    rf"[-/.]|\b(?:{_MONTH_NAMES})\b", re.IGNORECASE
+)
+
+
+def _looks_date_shaped(series, min_fraction=0.9):
+    """
+    True only if at least `min_fraction` of the column's non-null
+    values contain a date separator (-, /, .) or a recognizable month
+    name/abbreviation. Bare digit strings ("2023", "12345", plain IDs)
+    don't match this and are never even sent to pd.to_datetime, so
+    they can't be misdetected as dates just because to_datetime is
+    lenient enough to parse them.
+    """
+    non_null = series.dropna().astype(str)
+    if len(non_null) == 0:
+        return False
+    return non_null.str.contains(_DATE_LIKE_PATTERN).mean() >= min_fraction
+
+
+# =============================================================================
+# INPUT VALIDATION
+# =============================================================================
+
+def _validate_custom_weights(df, bench_marks, custom_weights):
+    """
+    Validates custom_weights, a list of [name, weight] pairs, against
+    df and bench_marks — run once, upfront, before any scoring loop
+    starts, so bad input fails fast instead of partway through.
+
+    Raises ValueError if:
+      - a name (index 0 of the pair) is not a string
+      - a name doesn't match a column in df
+      - a name has no matching entry in bench_marks
+      - the same name appears more than once (duplicate signal —
+        ambiguous which weight/bench should apply, and it would
+        silently double-count that column's contribution to _score)
+      - a weight (index 1 of the pair) is not numeric — bools are
+        rejected too (bool is technically an int subclass in Python
+        but was never intended as a weight), and NaN floats are
+        rejected since they'd silently poison every row's _score
+    """
+    seen = set()
+    duplicates = set()
+    for pair in custom_weights:
+        name, weight = pair[0], pair[1]
+
+        if not isinstance(name, str):
+            raise ValueError(
+                f"sparpartner: signal name must be a string, got {type(name).__name__}: {name!r}"
+            )
+
+        if name not in df.columns:
+            raise ValueError(f"sparpartner: column {name!r} not found in df")
+
+        if name not in bench_marks:
+            raise ValueError(f"sparpartner: no bench_marks entry for {name!r}")
+
+        if name in seen:
+            duplicates.add(name)
+        seen.add(name)
+
+        is_numeric = isinstance(weight, (int, float)) and not isinstance(weight, bool)
+        if not is_numeric:
+            raise ValueError(
+                f"sparpartner: weight for {name!r} must be numeric (int or float), "
+                f"got {type(weight).__name__}: {weight!r}"
+            )
+        if isinstance(weight, float) and pd.isna(weight):
+            raise ValueError(f"sparpartner: weight for {name!r} is NaN — must be a real number")
+
+    if duplicates:
+        raise ValueError(
+            f"sparpartner: duplicate signal name(s) in custom_weights: {sorted(duplicates)}"
+        )
+
+
+# =============================================================================
+# TYPE DETECTION + NUMERIC CONVERSION
+# =============================================================================
+
+def _to_numeric_series(series, bench_value):
+    """
+    Given a column and its benchmark value, returns (col_numeric,
+    bench_numeric, kind) — both values reduced to plain numbers so the
+    same distance formula works regardless of dtype, plus `kind` so
+    the caller knows exactly which path was taken (needed to pick the
+    right cap — re-guessing dtype after this point is unreliable for
+    date-strings stored as object dtype).
+
+    - numeric dtype  -> used as-is; bench_numeric = float(bench_value)
+                        kind = "numeric"
+    - date/datetime  -> both column and bench converted to "age in
+                         days" relative to the benchmark date, so the
+                         benchmark itself always lands on 0. col dtype
+                         is auto-detected either from actual dtype, or
+                         by first requiring the column's string values
+                         look date-shaped (contain a separator like
+                         -/. or a month name — bare digit strings like
+                         "2023" or a zip code never qualify) and then
+                         successfully parsing with pd.to_datetime for
+                         essentially every value (>=98%).
+                         kind = "date"
+    - string/object   -> 1 if the cell equals bench_value exactly,
+                         else 0; bench_numeric = 1 (a perfect match
+                         scores as touching the benchmark exactly).
+                         kind = "string"
+    """
+    # --- date/datetime path ---
+    is_datetime_dtype = pd.api.types.is_datetime64_any_dtype(series)
+    parsed_as_date = None
+    if not is_datetime_dtype and not pd.api.types.is_numeric_dtype(series):
+        if _looks_date_shaped(series):
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore", UserWarning)
+                parsed_as_date = pd.to_datetime(series, errors="coerce")
+            # only treat as a date column if parsing worked for
+            # essentially every value — otherwise this is a real
+            # string column that happened to partially parse
+            if parsed_as_date.notna().mean() < 0.98:
+                parsed_as_date = None
+
+    if is_datetime_dtype or parsed_as_date is not None:
+        col_dt = series if is_datetime_dtype else parsed_as_date
+        col_dt = pd.to_datetime(col_dt, errors="coerce")
+        bench_dt = pd.to_datetime(bench_value)
+
+        col_numeric = (col_dt - bench_dt).dt.days.abs().astype(float)
+        bench_numeric = 0.0
+        return col_numeric, bench_numeric, "date"
+
+    # --- numeric path ---
+    if pd.api.types.is_numeric_dtype(series):
+        return series.astype(float), float(bench_value), "numeric"
+
+    # --- string/exact-match path ---
+    col_numeric = (series == bench_value).astype(float)
+    bench_numeric = 1.0
+    return col_numeric, bench_numeric, "string"
+
+
+# =============================================================================
+# PROGRESS DISPLAY  (pure print — no logic, no return values)
+# =============================================================================
+
+def _progress_header(bench_marks, custom_weights, look_alike, row_count):
+    total_weight = sum(w for _, w in custom_weights)
+    title = "SPARPARTNER, type-aware benchmark scoring"
+    print(f"\n{title}")
+    print("-" * len(title))
+    look_alike_note = ("highest score sorted UP, lookalikes on top" if look_alike
+                        else "highest score sorted DOWN, lookalikes pushed to bottom")
+    print(f"  {'rows in pool':<16} = {row_count}")
+    print(f"  {'look_alike':<16} = {look_alike}  ({look_alike_note})")
+
+    signals_title = "SIGNALS"
+    print(f"\n  {signals_title}")
+    print(f"  {'-' * len(signals_title)}")
+    for name, weight in custom_weights:
+        bench = bench_marks.get(name, "<!! MISSING !!>")
+        print(f"    {name:<20} weight={weight:<6} bench={bench!r}")
+    print(f"\n  {'total weight':<16} = {total_weight}")
+
+
+def _progress_column(name, weight, kind, bench_value, cap, distance, score):
+    title = f"[{name}]  detected type = {kind}"
+    print(f"\n  {title}")
+    print(f"  {'-' * len(title)}")
+    print(f"    {'bench':<20} = {bench_value!r}")
+    print(f"    {'weight':<20} = {weight}")
+    print(f"    {'cap':<20} = {cap}"
+          + ("  [!] cap <= 0, every row will score 1.0 for this signal (no variance to score against)"
+             if cap is not None and not pd.isna(cap) and cap <= 0 else ""))
+    n_perfect = int((distance == 0).sum())
+    print(f"    {'exact matches':<20} = {n_perfect}/{len(distance)} rows")
+    print(f"    {'sample distances':<20} : {distance.head(3).round(4).tolist()}")
+    print(f"    {'sample scores':<20} : {score.head(3).round(4).tolist()}")
+
+
+def _progress_sort_apply(df_before, look_alike, sort_cols, n=5):
+    ascending = not look_alike
+    direction = ("descending, closest-to-benchmark scores first"
+                 if look_alike else
+                 "ascending, farthest-from-benchmark scores first")
+    title = f"APPLYING look_alike SORT (look_alike={look_alike})"
+    print(f"\n  {title}")
+    print(f"  {'-' * len(title)}")
+    print(f"    {'sort call':<20} : df.sort_values(_score + {len(sort_cols) - 1} tie-break signal(s), ascending={ascending})")
+    print(f"    {'direction':<20} : {direction}")
+    tie_break_names = sort_cols[1:]
+    if not tie_break_names:
+        tie_break_display = "(none, single signal)"
+    else:
+        shown = tie_break_names[:3]
+        remaining = len(tie_break_names) - len(shown)
+        tie_break_display = ", ".join(shown) + (f", ... (+{remaining} more)" if remaining > 0 else "")
+    print(f"    {'tie-break order':<20} : {tie_break_display}")
+    before = df_before["_score"].round(4).tolist()
+    print(f"    {'before sort':<20} : {before[:n]}")
+
+
+def _progress_sort_glimpse(df, look_alike, n=5):
+    scores = df["_score"].round(4).tolist()
+    head = scores[:n]
+    tail = scores[-n:]
+    print(f"    {'after sort (head)':<20} : {head}")
+    print(f"    {'after sort (tail)':<20} : {tail}")
+
+
+def _progress_top_rows(df, custom_weights, look_alike, n=5):
+    label = "TOP" if look_alike else "BOTTOM (farthest from benchmark)"
+    title = f"{label} {n} ROWS AFTER SCORING"
+    print(f"\n  {title}")
+    print(f"  {'-' * len(title)}")
+    display_cols = [c for c in df.columns if not c.startswith("_score")]
+    id_col = "id" if "id" in df.columns else display_cols[0]
+    for i in range(min(n, len(df))):
+        row = df.iloc[i]
+        print(f"\n    #{i+1}  [{row.get(id_col, '?')}]  total _score = {row['_score']:.4f}")
+        for name, weight in custom_weights:
+            comp_key = f"_score_{name}"
+            if comp_key in df.columns:
+                comp_score = row[comp_key]
+                contribution = comp_score * weight
+                print(f"      {name:<20} score={comp_score:.4f}  x  weight={weight:<6} =  {contribution:.4f}")
+
+
+def _progress_health_check(df, custom_weights, bench_marks):
+    title = "HEALTH CHECK"
+    print(f"\n  {title}")
+    print(f"  {'-' * len(title)}")
+    for name, weight in custom_weights:
+        comp_key = f"_score_{name}"
+        if comp_key not in df.columns:
+            continue
+        avg_score = df[comp_key].mean()
+        quality = "high quality" if avg_score > 0.7 else "moderate" if avg_score > 0.4 else "low quality"
+        print(f"    {name:<20} avg score={avg_score:.4f}  ({quality})")
+        if avg_score == 0.0:
+            print(f"      [!] ZERO rows are close to bench={bench_marks[name]!r} for {name!r}, "
+                  f"this signal is contributing nothing useful to ranking.")
+
+    dist_title = "OVERALL SCORE DISTRIBUTION"
+    print(f"\n  {dist_title}")
+    print(f"  {'-' * len(dist_title)}")
+    print(f"    {'min _score':<20} = {df['_score'].min():.4f}")
+    print(f"    {'max _score':<20} = {df['_score'].max():.4f}")
+    print(f"    {'mean _score':<20} = {df['_score'].mean():.4f}")
+
+
+def _progress_drop_nan(df, score_cols, nan_mask):
+    title = "DROP_NAN CHECK"
+    n_dropped = int(nan_mask.sum())
+    print(f"\n  {title}")
+    print(f"  {'-' * len(title)}")
+    print(f"    {'rows scanned':<20} = {len(df)}")
+    print(f"    {'rows with NaN':<20} = {n_dropped}")
+    print(f"    {'rows kept':<20} = {len(df) - n_dropped}")
+    if n_dropped:
+        offending = [c for c in score_cols if df[c].isna().any()]
+        print(f"    {'NaN found in':<20} = {offending}")
+
+
+def _progress_normalize(raw_scores, normalized_scores, total_weight):
+    title = "NORMALIZE CHECK"
+    print(f"\n  {title}")
+    print(f"  {'-' * len(title)}")
+    print(f"    {'total weight':<20} = {total_weight}")
+    print(f"    {'formula':<20} : _score = raw_score / total_weight")
+    n = min(5, len(raw_scores))
+    raw_label = f"raw (first {n})"
+    norm_label = f"normalized (first {n})"
+    print(f"    {raw_label:<20} = {raw_scores.head(n).round(4).tolist()}")
+    print(f"    {norm_label:<20} = {normalized_scores.head(n).round(4).tolist()}")
+    print(f"    {'min normalized':<20} = {normalized_scores.min():.4f}")
+    print(f"    {'max normalized':<20} = {normalized_scores.max():.4f}")
+
+
+def _progress_normalize_skip(total_weight):
+    title = "NORMALIZE CHECK"
+    print(f"\n  {title}")
+    print(f"  {'-' * len(title)}")
+    print(f"    {'total weight':<20} = {total_weight}")
+    print(f"    [!] total weight <= 0. skipping normalization, _score left as raw sum")
+
+
+# =============================================================================
+# SPARPARTNER
+# =============================================================================
+
+def sample(df, bench_marks, custom_weights, look_alike=True, show_progress=False, return_score=False, drop_nan=True):
+    """
+    Stratified sampler for train/test prep — guards against overfitting
+    by letting you deliberately hold out the rows that most resemble a
+    benchmark case (rather than a random split), so a model trained on
+    the rest can be tested against its true "opponent" instead of an
+    easy, self-similar sample.
+
+    Type-aware scoring: mirrors the reference file's
+    fixed_distance_score, closest to the benchmark scores highest.
+
+    For each [name, weight] in custom_weights, looks up bench_marks[name]
+    and detects the column's type automatically:
+      - numeric column   -> distance = abs(value - bench), cap = the
+                             column's own max observed distance from
+                             bench (so a bench of 0 or a negative
+                             number still scores correctly — the
+                             farthest row from bench scores 0, bench
+                             itself scores 1, regardless of bench's
+                             own magnitude)
+      - date column       -> value and bench both converted to "age in
+                             days" relative to the benchmark date
+                             (benchmark itself = 0), cap = the column's
+                             own max observed age (so scores stay in
+                             a sane 0-1 range regardless of the actual
+                             day-count magnitude)
+      - string column     -> 1 if exact match to bench else 0, cap = 1
+
+    score = clip(1 - distance / cap, 0, 1)  — same formula as the
+    reference file's fixed_distance_score.
+
+    Each column's score is multiplied by its weight and summed into
+    one raw score per row, then divided by the total weight so the
+    final "_score" always lands in 0-1 regardless of how many signals
+    or what weights were used (1.0 = perfect lookalike across every
+    signal, 0.0 = as far as possible on every signal). A "NORMALIZE
+    CHECK" print always runs — regardless of show_progress — showing
+    the total weight and a few raw-vs-normalized score examples so
+    this step is easy to sanity-check.
+
+    look_alike : bool, default True.
+      True  -> highest _score sorted to the TOP — rows that look most
+               like the benchmark (lookalikes) come first.
+      False -> highest _score sorted to the BOTTOM instead — rows
+               farthest from the benchmark come first.
+
+    Tie-breaking: rows that land on the exact same "_score" are not
+    left to pandas' stable sort alone. They're broken next by the
+    per-signal score (_score_<name>, the 0-1 value before weighting)
+    of the highest-weight signal in custom_weights; if still tied,
+    the next-highest-weight signal is checked, cascading down the
+    weight-sorted signal list until the tie breaks. Signals sharing
+    the same weight are compared in the order they appear in
+    custom_weights. Every tie-break column sorts in the same
+    direction as "_score" itself — a higher per-signal score wins
+    under look_alike=True, a lower one wins under look_alike=False.
+    Only if every signal is exhausted and rows are still tied does
+    the order fall back to pandas' stable sort (original row order).
+
+    Parameters
+    ----------
+    df : DataFrame
+        Must contain a column for every name in custom_weights.
+    bench_marks : dict
+        {column_name: benchmark_value} — one entry per weighted signal.
+    custom_weights : list[[name, weight]]
+        Which columns to score and how much each contributes.
+    look_alike : bool, default True
+        See above.
+    show_progress : bool, default False
+        If True, prints a client-centric readout: a header naming every
+        signal/weight/benchmark, a per-column breakdown of detected
+        type + cap + sample distances/scores as it scores, a sort-apply
+        readout showing the sort_values call being made plus scores
+        before and after, so the look_alike direction is visible as
+        it's applied, the top (or bottom) N ranked
+        rows with each signal's value x weight contribution spelled
+        out, and a final health check flagging any signal that isn't
+        contributing useful separation.
+    return_score : bool, default False
+        If True, keeps the "_score" and per-signal "_score_<name>"
+        columns in the returned DataFrame. If False (default), those
+        columns are dropped before returning — they're still used
+        internally for sorting and (if show_progress) for the
+        progress readout, just not included in the result.
+    drop_nan : bool, default True
+        If True, after scoring, any row with a NaN in any per-signal
+        "_score_<name>" column is dropped (e.g. from a missing value
+        in a signal column, or a date that failed to parse). A sanity
+        print always runs first — regardless of show_progress —
+        reporting rows scanned, rows with NaN, rows kept, and which
+        signal(s) had the NaN, before the drop happens. If False, rows
+        with NaN scores are kept and will carry a NaN "_score".
+
+    Returns
+    -------
+    df — a copy of the input, sorted by _score (direction depends on
+    look_alike), with the "_score" (and per-signal "_score_<name>")
+    columns included only if return_score is True.
+    """
+    _validate_custom_weights(df, bench_marks, custom_weights)
+
+    df = df.copy()
+    df["_score"] = 0.0
+
+    if show_progress:
+        _progress_header(bench_marks, custom_weights, look_alike, len(df))
+
+    for name, weight in custom_weights:
+        bench_value = bench_marks[name]
+        col_numeric, bench_numeric, kind = _to_numeric_series(df[name], bench_value)
+
+        distance = (col_numeric - bench_numeric).abs()
+        cap = distance.max() if kind in ("date", "numeric") else bench_numeric
+
+        if cap is None or pd.isna(cap) or cap <= 0:
+            score = pd.Series(1.0, index=df.index)
+        else:
+            score = (1.0 - (distance / cap)).clip(0.0, 1.0)
+
+        df[f"_score_{name}"] = score
+        df["_score"] += score * weight
+
+        if show_progress:
+            _progress_column(name, weight, kind, bench_value, cap, distance, score)
+
+    if drop_nan:
+        score_cols = [f"_score_{name}" for name, _ in custom_weights]
+        nan_mask = df[score_cols].isna().any(axis=1)
+        _progress_drop_nan(df, score_cols, nan_mask)
+        if nan_mask.any():
+            df = df[~nan_mask].reset_index(drop=True)
+
+    total_weight = sum(w for _, w in custom_weights)
+    if total_weight > 0:
+        raw_scores = df["_score"].copy()
+        df["_score"] = df["_score"] / total_weight
+        _progress_normalize(raw_scores, df["_score"], total_weight)
+    else:
+        _progress_normalize_skip(total_weight)
+
+    # Tie-break: rows with an identical "_score" are ordered next by the
+    # per-signal score (_score_<name>, the 0-1 value before weighting) of
+    # the highest-weight signal, then the next-highest weight, and so on,
+    # cascading through custom_weights sorted by descending weight until
+    # the tie breaks or the signals run out (any remaining tie then falls
+    # back to pandas' stable sort, i.e. original row order). Signals that
+    # share the same weight are compared in the order they appear in
+    # custom_weights. Every tie-break column sorts in the same direction
+    # as "_score" itself, so a higher per-signal score wins under
+    # look_alike=True and a lower one wins under look_alike=False.
+    tie_break_signals = sorted(custom_weights, key=lambda pair: -pair[1])
+    sort_cols = ["_score"] + [f"_score_{name}" for name, _ in tie_break_signals]
+    ascending = not look_alike
+
+    if show_progress:
+        _progress_sort_apply(df, look_alike, sort_cols)
+
+    df = df.sort_values(sort_cols, ascending=ascending).reset_index(drop=True)
+
+    if show_progress:
+        _progress_sort_glimpse(df, look_alike)
+        _progress_top_rows(df, custom_weights, look_alike)
+        _progress_health_check(df, custom_weights, bench_marks)
+
+    if not return_score:
+        score_cols = [c for c in df.columns if c == "_score" or c.startswith("_score_")]
+        df = df.drop(columns=score_cols)
+
+    return df

sparpartner-0.1.0/sparpartner.egg-info/PKG-INFO

@@ -0,0 +1,227 @@
+Metadata-Version: 2.4
+Name: sparpartner
+Version: 0.1.0
+Summary: Deterministic, benchmark-driven stratified sampler for train/test prep.
+Author: Henry
+Author-email: Henry <osas2henry@gmail.com>
+License: All Rights Reserved
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=1.3
+Dynamic: author
+Dynamic: license-file
+Dynamic: requires-python
+
+# sparpartner
+
+A deterministic stratified sampler for train/test prep. It doesn't
+split your data randomly, it deliberately finds the rows that most
+resemble a benchmark case, so you can hold those out as a genuine
+test set and train on everything else.
+
+## Why this exists
+
+A random train/test split assumes the test set should look
+statistically like the train set. That's the wrong question if
+what you actually want to know is: **does the model generalize past
+one specific profile, or did it just memorize the neighborhood
+around it?**
+
+`sparpartner` answers that by ranking every row in your data by how
+closely it resembles a benchmark ("bench_marks") you define, then
+sorting on that resemblance. You then slice the sorted frame
+yourself:
+
+- **Lookalikes as test, the rest as train**: train on rows *unlike*
+  the benchmark, test on the rows that *are* like it. This is the
+  harder, more honest check: it tells you whether the model actually
+  learned something general, or only performs well near cases it's
+  already seen a lot of.
+- **Lookalikes as train, the rest as test**: the reverse, if you
+  want to check the opposite direction.
+
+`sparpartner` only produces the ranking. The actual train/test cut
+is a plain slice on your side (see [Usage](#usage) below).
+
+## Where the idea comes from
+
+Two unrelated places, both about comparing something against a
+reference on purpose rather than at random:
+
+**A boxer preparing for a match.** A fighter in camp doesn't spar
+with whoever's free in the gym, they specifically look for a
+sparring partner who moves, reaches, and hits like the opponent
+they're about to face. Training against a random partner tells you
+nothing about how you'll actually do; training against someone who
+resembles the real threat does. `sparpartner` applies that same
+logic to a model: instead of a random holdout, it finds the rows
+that resemble the toughest, most relevant "opponent" profile and
+holds those back as the real test, so what's left to train on is
+everything *unlike* that opponent, and the test genuinely checks
+whether the model can handle the match it's actually walking into.
+
+**Astrology's approach to comparing a chart to a reference.** Reading
+a chart against a benchmark isn't a single yes/no match, it's
+several weighted dimensions (sun sign, moon sign, rising, houses,
+and so on) each compared individually, then combined into one
+overall resemblance reading. No single dimension decides the
+outcome alone; the composite is what matters. That's the same shape
+`sparpartner` uses: several weighted signals, each scored
+independently against a benchmark, summed into one composite
+`_score` rather than a single all-or-nothing match.
+
+## How the scoring works
+
+You give it:
+
+- `df`: your data
+- `bench_marks`: a dict of `{column_name: benchmark_value}`, one
+  entry per signal you care about
+- `custom_weights`: a list of `[column_name, weight]` pairs, saying
+  which columns matter and how much
+
+For each weighted column, `sparpartner` auto-detects the column's
+type and scores every row's distance to the benchmark on a 0–1
+scale (1.0 = exact match, 0.0 = as far as possible):
+
+| Detected type | How distance is measured |
+|---|---|
+| **numeric** | `abs(value - bench)`, capped by the column's own max observed distance from bench |
+| **date** | both sides converted to "age in days" relative to the benchmark date, capped by the column's own max observed age |
+| **string** | exact match = 1, anything else = 0 |
+
+Date detection is automatic, it only treats a column as a date if
+its values look date-shaped (contain a separator like `-`, `/`, `.`
+or a recognizable month name) **and** parse successfully at least
+98% of the time. Bare numeric-looking strings (e.g. `"12345"`) are
+never mistaken for dates, and object-dtype columns of digit strings
+are treated as exact-match strings, not numbers. Only a real
+numeric dtype gets the numeric path.
+
+Each column's 0–1 score is multiplied by its weight and summed into
+one raw score per row, then divided by the total weight so the
+final `_score` always lands in the 0–1 range, however many signals
+or weights you used.
+
+### Tie-breaking
+
+Rows that land on the exact same `_score` aren't left to random or
+arbitrary order. Ties are broken by the per-signal score of the
+**highest-weight** signal first, then the next-highest, cascading
+down the weighted signal list until the tie resolves. Signals that
+share the same weight are compared in the order they appear in
+`custom_weights`. The tie-break always sorts in the same direction
+as the main score (see `look_alike` below). Only if every signal is
+exhausted and rows are still tied does it fall back to original row
+order.
+
+## `look_alike`
+
+Controls sort direction:
+
+- `look_alike=True` (default): highest `_score` (closest to
+  benchmark) sorted to the **top**.
+- `look_alike=False`: highest `_score` sorted to the **bottom**,
+  farthest-from-benchmark rows come first.
+
+## Usage
+
+### Sample usage
+
+```python
+import pandas as pd
+from sparpartner import sample
+
+df = pd.DataFrame({
+    "id": [1, 2, 3, 4, 5],
+    "age": [25, 30, 47, 52, 33],
+    "signup_date": ["2023-01-15", "2023-03-02", "2022-11-20", "2023-01-10", "2023-06-01"],
+    "country": ["US", "US", "CA", "US", "MX"],
+})
+
+bench_marks = {
+    "age": 30,
+    "signup_date": "2023-01-01",
+    "country": "US",
+}
+
+custom_weights = [
+    ["age", 2],
+    ["signup_date", 1],
+    ["country", 1],
+]
+
+result = sample(
+    df,
+    bench_marks,
+    custom_weights,
+    look_alike=True,      # True = most similar rows first
+    show_progress=True,   # prints the full scoring breakdown
+    return_score=True,    # keep _score columns in the output
+    drop_nan=True,
+)
+
+print(result)
+```
+
+`age=30`, `signup_date="2023-01-01"`, and `country="US"` closely
+match row `id=1` (age 25, close date, US), so with
+`look_alike=True` that row lands at or near the top of the sorted
+output. Flip `look_alike=False` to instead surface the rows that
+look *least* like the benchmark (e.g. the Mexico row with the
+furthest signup date).
+
+```python
+# --- post-sample: turn the ranking into an actual train/test split ---
+# Re-run with look_alike=False so lookalikes sort to the BOTTOM of `result`.
+ranked = sample(df, bench_marks, custom_weights, look_alike=False)
+
+# Slice however large you want the test set to be, e.g. the bottom 30%:
+cut = int(len(ranked) * 0.7)
+train = ranked.iloc[:cut]   # non-lookalikes
+test = ranked.iloc[cut:]    # lookalikes, the harder, honest test set
+```
+
+### Parameters
+
+| Name | Type | Default | What it does |
+|---|---|---|---|
+| `df` | DataFrame | required | Must contain a column for every name in `custom_weights` |
+| `bench_marks` | dict | required | `{column_name: benchmark_value}` |
+| `custom_weights` | list of `[name, weight]` | required | Which columns to score and how much each contributes |
+| `look_alike` | bool | `True` | `True` = lookalikes sorted to top; `False` = sorted to bottom |
+| `show_progress` | bool | `False` | Prints a full readout: header, per-column type/cap/sample scores, sort direction, top/bottom ranked rows with weighted contributions, and a health check flagging any signal that isn't adding useful separation |
+| `return_score` | bool | `False` | If `True`, keeps `_score` and `_score_<name>` columns in the result instead of dropping them |
+| `drop_nan` | bool | `True` | If `True`, drops any row with a NaN component score (e.g. missing value or unparseable date) after printing a sanity check of what was dropped and why |
+
+### Validation
+
+`custom_weights` is validated upfront, before any scoring starts, and
+raises `ValueError` if:
+
+- a column name isn't a string, or doesn't exist in `df`
+- a column name has no matching entry in `bench_marks`
+- the same column name appears more than once
+- a weight isn't numeric (bools are rejected too, a `bool` is
+  technically an `int` in Python but was never meant as a weight)
+- a weight is `NaN`
+
+## A couple of things worth knowing
+
+- **Zero-variance columns**: if every row (including the benchmark)
+  has the same value for a signal, there's nothing to measure
+  distance against, that signal scores every row 1.0 rather than
+  dividing by zero.
+- **Negative total weight**: if your weights sum to ≤ 0, the
+  normalization step is skipped and `_score` is left as the raw
+  weighted sum instead of being silently divided by a non-positive
+  number.
+- **Object-dtype numeric strings**: a column of strings like
+  `"100"`, `"200"` (object dtype, no separator) is scored as an
+  exact-match string column, *not* auto-converted to numeric. Only
+  genuine numeric dtypes (`int`, `float`) get the numeric distance
+  path.

sparpartner-0.1.0/sparpartner.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+sparpartner/__init__.py
+sparpartner/main.py
+sparpartner.egg-info/PKG-INFO
+sparpartner.egg-info/SOURCES.txt
+sparpartner.egg-info/dependency_links.txt
+sparpartner.egg-info/requires.txt
+sparpartner.egg-info/top_level.txt

sparpartner-0.1.0/sparpartner.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sparpartner-0.1.0/sparpartner.egg-info/requires.txt

@@ -0,0 +1 @@
+pandas>=1.3

sparpartner-0.1.0/sparpartner.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+dist
+sparpartner