jevkit-core 0.2.0__py3-none-any.whl

jevkit_core/__init__.py

@@ -0,0 +1,28 @@
+"""Shared substrate for the jevkit packages.
+
+Nothing here calls the jev API. This package holds the pieces every other
+jevkit tool needs: canonical digests, the `.jevl` record format, a uniform
+view of a question, and token budget estimation.
+"""
+
+from .answers import NOUL_THRESHOLD, Answer, parse_answer, parse_answers
+from .canonical import canonical_json, digest, record_id, request_id
+from .question import (Question, flatten_text, normalize_question,
+                       normalize_questions)
+from .record import (FORMAT_VERSION, Record, RecordFormatError, append_record,
+                     load_cassette, read_records, write_records)
+from .tokens import (STATE_BUDGET, TOTAL_BUDGET, BudgetReport, check_budget,
+                     estimate_tokens)
+
+__version__ = "0.2.0"
+
+__all__ = [
+    "Answer", "parse_answer", "parse_answers", "NOUL_THRESHOLD",
+    "canonical_json", "digest", "record_id", "request_id",
+    "Question", "flatten_text", "normalize_question", "normalize_questions",
+    "Record", "RecordFormatError", "FORMAT_VERSION",
+    "read_records", "write_records", "append_record", "load_cassette",
+    "estimate_tokens", "check_budget", "BudgetReport",
+    "TOTAL_BUDGET", "STATE_BUDGET",
+    "__version__",
+]

jevkit_core/answers.py

@@ -0,0 +1,151 @@
+"""A uniform view of a jev answer, and how it compares to a ground-truth label.
+
+`drift`, `calibrate`, and `bench` all need the same three things from an answer:
+what it predicted, how much probability sat on a given outcome, and whether it
+matched a label. Those live here so the three packages agree on the definitions
+rather than each inventing its own.
+
+The vocabulary is deliberately narrow:
+
+- **predicted** is the outcome the answer selects. For a Choice it is the option
+  key. For a Noul it is ``True`` when ``noul`` clears the threshold. For a Score
+  it is the index of the most probable level, which is *not* the same as
+  rounding ``score``.
+- **confidence** is what the API returned, and Nouls do not have one. A Noul's
+  distance from 0.5 is a different quantity and is exposed separately as
+  ``decisiveness`` rather than pretending it is the same number.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+__all__ = ["Answer", "parse_answer", "parse_answers", "NOUL_THRESHOLD"]
+
+NOUL_THRESHOLD = 0.5
+
+
+@dataclass
+class Answer:
+    """Normalized view over one answer from the API."""
+
+    id: str
+    type: str
+    raw: dict[str, Any]
+
+    # -- what it said ------------------------------------------------------
+
+    @property
+    def probabilities(self) -> dict[str, float]:
+        """Outcome -> probability.
+
+        Choice returns its options. Score returns its level indices as strings.
+        Noul has no distribution from the API, so the two-outcome distribution
+        it implies is synthesized here.
+        """
+        if self.type == "noul":
+            p = float(self.raw.get("noul", 0.0))
+            return {"true": p, "false": 1.0 - p}
+        probs = self.raw.get("probabilities") or {}
+        return {str(k): float(v) for k, v in probs.items()}
+
+    @property
+    def confidence(self) -> float | None:
+        """As returned by the API. ``None`` for a Noul, which carries none."""
+        value = self.raw.get("confidence")
+        return None if value is None else float(value)
+
+    @property
+    def decisiveness(self) -> float:
+        """How far from maximally uncertain this answer is, on 0..1.
+
+        For a Noul this is ``|noul - 0.5| * 2``. This is *not* confidence and is
+        not comparable to the API's confidence across question types; it exists
+        so Nouls can be thresholded on something with a defined meaning.
+        """
+        if self.type == "noul":
+            return abs(float(self.raw.get("noul", 0.0)) - NOUL_THRESHOLD) * 2.0
+        conf = self.confidence
+        return 0.0 if conf is None else conf
+
+    def predicted(self, *, noul_threshold: float = NOUL_THRESHOLD) -> Any:
+        """The outcome this answer selects."""
+        if self.type == "noul":
+            return float(self.raw.get("noul", 0.0)) >= noul_threshold
+        if self.type == "choice":
+            return self.raw.get("choice")
+        if self.type == "score":
+            probs = self.probabilities
+            if not probs:
+                return None
+            best = max(probs, key=lambda k: probs[k])
+            try:
+                return int(best)
+            except ValueError:
+                return best
+        return None
+
+    @property
+    def score(self) -> float | None:
+        """The probability-weighted score, for a Score answer."""
+        if self.type != "score":
+            return None
+        value = self.raw.get("score")
+        return None if value is None else float(value)
+
+    # -- how it compares to a label ---------------------------------------
+
+    def _label_key(self, label: Any) -> str:
+        if self.type == "noul":
+            return "true" if bool(label) else "false"
+        return str(label)
+
+    def probability_of(self, label: Any) -> float:
+        """Probability this answer assigned to ``label``.
+
+        Returns 0.0 for an outcome the question never offered, which is the
+        honest reading: the model could not have selected it.
+        """
+        return self.probabilities.get(self._label_key(label), 0.0)
+
+    def is_correct(self, label: Any, *, noul_threshold: float = NOUL_THRESHOLD) -> bool:
+        predicted = self.predicted(noul_threshold=noul_threshold)
+        if self.type == "noul":
+            return bool(predicted) is bool(label)
+        if self.type == "score":
+            try:
+                return int(predicted) == int(label)  # type: ignore[arg-type]
+            except (TypeError, ValueError):
+                return predicted == label
+        return predicted == label
+
+    @property
+    def top_probability(self) -> float:
+        """Probability mass on the predicted outcome."""
+        probs = self.probabilities
+        return max(probs.values()) if probs else 0.0
+
+
+def parse_answer(qid: str, raw: Any) -> Answer:
+    if not isinstance(raw, dict):
+        raise ValueError(f"answer {qid!r}: expected an object, got {type(raw).__name__}")
+    atype = raw.get("type")
+    if atype not in ("choice", "score", "noul"):
+        # Infer from shape when the API response omits the discriminator.
+        if "choice" in raw:
+            atype = "choice"
+        elif "noul" in raw:
+            atype = "noul"
+        elif "score" in raw:
+            atype = "score"
+        else:
+            raise ValueError(
+                f"answer {qid!r}: cannot determine type; expected a 'type' field or one "
+                f"of 'choice'/'score'/'noul'"
+            )
+    return Answer(id=qid, type=atype, raw=raw)
+
+
+def parse_answers(answers: dict[str, Any]) -> dict[str, Answer]:
+    return {qid: parse_answer(qid, raw) for qid, raw in answers.items()}

jevkit_core/canonical.py

@@ -0,0 +1,57 @@
+"""RFC 8785 JSON Canonicalization, and the digests jevkit builds on it."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+from typing import Any
+
+__all__ = ["canonical_json", "digest", "request_id", "record_id"]
+
+
+def _check_finite(value: Any) -> None:
+    if isinstance(value, float) and not math.isfinite(value):
+        raise ValueError(f"cannot canonicalize non-finite number: {value!r}")
+    if isinstance(value, dict):
+        for v in value.values():
+            _check_finite(v)
+    elif isinstance(value, (list, tuple)):
+        for v in value:
+            _check_finite(v)
+
+
+def canonical_json(value: Any) -> bytes:
+    """Serialize to RFC 8785 canonical form.
+
+    Object keys sorted by code point, no insignificant whitespace, UTF-8.
+    NaN and Infinity are rejected rather than emitted as invalid JSON.
+    """
+    _check_finite(value)
+    return json.dumps(
+        value,
+        sort_keys=True,
+        separators=(",", ":"),
+        ensure_ascii=False,
+        allow_nan=False,
+    ).encode("utf-8")
+
+
+def digest(value: Any) -> str:
+    """`sha256:<hex>` over the canonical form of ``value``."""
+    return "sha256:" + hashlib.sha256(canonical_json(value)).hexdigest()
+
+
+def request_id(state: Any, questions: dict[str, Any]) -> str:
+    """Digest of state + questions, with no model.
+
+    This is what pairs a golden-set record with its replay on a different
+    model version, since the full record id includes the model and would
+    therefore differ.
+    """
+    return digest({"questions": questions, "state": state})
+
+
+def record_id(model: str, state: Any, questions: dict[str, Any]) -> str:
+    """Digest of model + state + questions. The record's ``id`` field."""
+    return digest({"model": model, "questions": questions, "state": state})

jevkit_core/question.py

@@ -0,0 +1,124 @@
+"""A uniform view of a jev question.
+
+Questions reach jevkit in three shapes: plain dicts as sent to the HTTP API,
+SDK objects (``Choice``/``Score``/``Noul``), and whatever a user's own helper
+produces. Every jevkit tool wants the same few facts out of them, so they are
+normalized once here rather than re-sniffed in each package.
+
+``instructions`` and ``criteria`` both accept JSON structure, not just
+strings, so the normalized form keeps the raw value and exposes the flattened
+text separately for anything doing textual analysis.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Iterator
+
+__all__ = ["Question", "QuestionType", "normalize_question", "normalize_questions",
+           "flatten_text"]
+
+QuestionType = str  # "choice" | "score" | "noul"
+
+_VALID_TYPES = ("choice", "score", "noul")
+
+
+def flatten_text(value: Any) -> str:
+    """Collapse a string / dict / list into one string for textual analysis.
+
+    Dict keys are included: in a Choice, the keys are the option names and
+    carry meaning the model sees.
+    """
+    if value is None:
+        return ""
+    if isinstance(value, str):
+        return value
+    if isinstance(value, (int, float, bool)):
+        return str(value)
+    if isinstance(value, dict):
+        parts: list[str] = []
+        for k, v in value.items():
+            parts.append(str(k))
+            parts.append(flatten_text(v))
+        return " ".join(p for p in parts if p)
+    if isinstance(value, (list, tuple)):
+        return " ".join(p for p in (flatten_text(v) for v in value) if p)
+    return str(value)
+
+
+@dataclass
+class Question:
+    """Normalized question. ``raw`` is always the untouched original."""
+
+    id: str
+    type: QuestionType
+    instructions: Any
+    criteria: Any
+    raw: Any = field(repr=False, default=None)
+
+    @property
+    def instructions_text(self) -> str:
+        return flatten_text(self.instructions)
+
+    @property
+    def criteria_text(self) -> str:
+        return flatten_text(self.criteria)
+
+    @property
+    def text(self) -> str:
+        """Everything the model reads, as one string."""
+        return f"{self.instructions_text} {self.criteria_text}".strip()
+
+    @property
+    def options(self) -> list[str]:
+        """Choice option keys, or Score level descriptions. Empty otherwise."""
+        if self.type == "choice" and isinstance(self.criteria, dict):
+            return [str(k) for k in self.criteria.keys()]
+        if self.type == "score" and isinstance(self.criteria, (list, tuple)):
+            return [flatten_text(v) for v in self.criteria]
+        if self.type == "score" and isinstance(self.criteria, dict):
+            return [flatten_text(v) for v in self.criteria.values()]
+        return []
+
+    def option_descriptions(self) -> Iterator[tuple[str, str]]:
+        """(option key, description) pairs for a Choice."""
+        if self.type == "choice" and isinstance(self.criteria, dict):
+            for k, v in self.criteria.items():
+                yield str(k), flatten_text(v)
+
+
+def _get(obj: Any, name: str) -> Any:
+    if isinstance(obj, dict):
+        return obj.get(name)
+    return getattr(obj, name, None)
+
+
+def _infer_type(obj: Any) -> str | None:
+    declared = _get(obj, "type")
+    if isinstance(declared, str) and declared.lower() in _VALID_TYPES:
+        return declared.lower()
+    # SDK objects carry no "type" field; fall back to the class name.
+    cls = type(obj).__name__.lower()
+    if cls in _VALID_TYPES:
+        return cls
+    return None
+
+
+def normalize_question(qid: str, obj: Any) -> Question:
+    qtype = _infer_type(obj)
+    if qtype is None:
+        raise ValueError(
+            f"question {qid!r}: cannot determine type. Expected a 'type' key of "
+            f"{_VALID_TYPES}, or a Choice/Score/Noul object."
+        )
+    return Question(
+        id=qid,
+        type=qtype,
+        instructions=_get(obj, "instructions"),
+        criteria=_get(obj, "criteria"),
+        raw=obj,
+    )
+
+
+def normalize_questions(questions: dict[str, Any]) -> list[Question]:
+    return [normalize_question(qid, obj) for qid, obj in questions.items()]

jevkit_core/record.py

@@ -0,0 +1,164 @@
+"""Reading and writing `.jevl` records. See docs/specs/record-format-v1.md."""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any, IO, Iterable, Iterator
+
+from .canonical import record_id, request_id
+
+__all__ = ["Record", "FORMAT_VERSION", "RecordFormatError",
+           "read_records", "write_records", "append_record", "load_cassette"]
+
+FORMAT_VERSION = 1
+
+_REQUIRED = ("v", "id", "ts", "model", "request", "answers")
+
+
+class RecordFormatError(ValueError):
+    """A `.jevl` line is malformed, or its version is unreadable."""
+
+
+def _utcnow() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+@dataclass
+class Record:
+    model: str
+    state: Any
+    questions: dict[str, Any]
+    answers: dict[str, Any]
+    id: str = ""
+    ts: str = field(default_factory=_utcnow)
+    usage: dict[str, Any] | None = None
+    label: dict[str, Any] | None = None
+    tags: list[str] = field(default_factory=list)
+    meta: dict[str, Any] = field(default_factory=dict)
+    extra: dict[str, Any] = field(default_factory=dict, repr=False)
+
+    def __post_init__(self) -> None:
+        if not self.id:
+            self.id = record_id(self.model, self.state, self.questions)
+
+    @property
+    def request_id(self) -> str:
+        """Model-independent digest, used to pair across model versions."""
+        return request_id(self.state, self.questions)
+
+    def to_dict(self) -> dict[str, Any]:
+        out: dict[str, Any] = {
+            "v": FORMAT_VERSION,
+            "id": self.id,
+            "ts": self.ts,
+            "model": self.model,
+            "request": {"state": self.state, "questions": self.questions},
+            "answers": self.answers,
+        }
+        if self.usage is not None:
+            out["usage"] = self.usage
+        if self.label is not None:
+            out["label"] = self.label
+        if self.tags:
+            out["tags"] = list(self.tags)
+        if self.meta:
+            out["meta"] = dict(self.meta)
+        # Unknown keys survive a read/write round trip.
+        for k, v in self.extra.items():
+            out.setdefault(k, v)
+        return out
+
+    @classmethod
+    def from_dict(cls, raw: dict[str, Any], *, source: str = "<memory>",
+                  line_no: int = 0) -> "Record":
+        where = f"{source}:{line_no}" if line_no else source
+        if not isinstance(raw, dict):
+            raise RecordFormatError(f"{where}: record must be a JSON object")
+
+        version = raw.get("v")
+        if version is None:
+            raise RecordFormatError(f"{where}: missing required key 'v'")
+        if not isinstance(version, int):
+            raise RecordFormatError(f"{where}: 'v' must be an integer, got {version!r}")
+        if version > FORMAT_VERSION:
+            raise RecordFormatError(
+                f"{where}: record format v{version} is newer than this reader "
+                f"(v{FORMAT_VERSION}). Upgrade jevkit-core rather than guessing."
+            )
+
+        missing = [k for k in _REQUIRED if k not in raw]
+        if missing:
+            raise RecordFormatError(f"{where}: missing required key(s): {', '.join(missing)}")
+
+        request = raw["request"]
+        if not isinstance(request, dict) or "questions" not in request:
+            raise RecordFormatError(f"{where}: 'request' must be an object with 'questions'")
+
+        known = set(_REQUIRED) | {"usage", "label", "tags", "meta"}
+        return cls(
+            model=raw["model"],
+            state=request.get("state"),
+            questions=request["questions"],
+            answers=raw["answers"],
+            id=raw["id"],
+            ts=raw["ts"],
+            usage=raw.get("usage"),
+            label=raw.get("label"),
+            tags=list(raw.get("tags") or []),
+            meta=dict(raw.get("meta") or {}),
+            extra={k: v for k, v in raw.items() if k not in known},
+        )
+
+
+def read_records(path: str | os.PathLike[str] | IO[str]) -> Iterator[Record]:
+    """Yield records from a `.jevl` file.
+
+    A line that fails to parse raises. Skipping silently would let a truncated
+    golden set look like a passing one.
+    """
+    if hasattr(path, "read"):
+        yield from _read_stream(path, getattr(path, "name", "<stream>"))  # type: ignore[arg-type]
+        return
+    with open(path, "r", encoding="utf-8") as fh:
+        yield from _read_stream(fh, str(path))
+
+
+def _read_stream(fh: IO[str], source: str) -> Iterator[Record]:
+    for line_no, line in enumerate(fh, start=1):
+        stripped = line.strip()
+        if not stripped:
+            continue
+        try:
+            raw = json.loads(stripped)
+        except json.JSONDecodeError as exc:
+            raise RecordFormatError(f"{source}:{line_no}: invalid JSON: {exc}") from exc
+        yield Record.from_dict(raw, source=source, line_no=line_no)
+
+
+def write_records(path: str | os.PathLike[str], records: Iterable[Record]) -> int:
+    count = 0
+    with open(path, "w", encoding="utf-8") as fh:
+        for record in records:
+            fh.write(json.dumps(record.to_dict(), ensure_ascii=False) + "\n")
+            count += 1
+    return count
+
+
+def append_record(path: str | os.PathLike[str], record: Record) -> None:
+    with open(path, "a", encoding="utf-8") as fh:
+        fh.write(json.dumps(record.to_dict(), ensure_ascii=False) + "\n")
+
+
+def load_cassette(path: str | os.PathLike[str]) -> dict[str, Record]:
+    """Map record id -> Record, last occurrence winning.
+
+    Re-recording a request appends rather than rewrites, so the last line for
+    an id is the current answer.
+    """
+    table: dict[str, Record] = {}
+    for record in read_records(path):
+        table[record.id] = record
+    return table

jevkit_core/tokens.py

@@ -0,0 +1,87 @@
+"""Token budget estimation for jev requests.
+
+Jev ingests the state once and evaluates every question against it, so two
+separate budgets apply. Both are documented on the model card:
+
+    64k  state + every question combined
+    32k  state + the single longest question
+
+These are *estimates*. jevkit deliberately does not bundle a tokenizer: the
+dependency is heavy, the vendor does not publish which tokenizer Jev uses,
+and a wrong tokenizer is more misleading than an honest approximation. The
+estimator is intentionally conservative so that a request jevkit calls safe
+is very unlikely to be rejected.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .canonical import canonical_json
+
+__all__ = ["estimate_tokens", "BudgetReport", "check_budget",
+           "TOTAL_BUDGET", "STATE_BUDGET"]
+
+TOTAL_BUDGET = 64_000
+STATE_BUDGET = 32_000
+
+# Bytes per token. Real-world English on BPE-family tokenizers runs ~4.0;
+# 3.5 buys headroom for punctuation-dense JSON without being absurd.
+_BYTES_PER_TOKEN = 3.5
+
+
+def estimate_tokens(value: Any) -> int:
+    """Conservative token estimate for any JSON-serializable value."""
+    if isinstance(value, str):
+        payload = value.encode("utf-8")
+    else:
+        payload = canonical_json(value)
+    return max(1, int(len(payload) / _BYTES_PER_TOKEN) + 1)
+
+
+class BudgetReport:
+    """Where a request sits against both documented budgets."""
+
+    __slots__ = ("state_tokens", "question_tokens", "longest_question_id")
+
+    def __init__(
+        self,
+        state_tokens: int,
+        question_tokens: dict[str, int],
+        longest_question_id: str | None,
+    ) -> None:
+        self.state_tokens = state_tokens
+        self.question_tokens = question_tokens
+        self.longest_question_id = longest_question_id
+
+    @property
+    def total(self) -> int:
+        return self.state_tokens + sum(self.question_tokens.values())
+
+    @property
+    def longest_pair(self) -> int:
+        """state + the single longest question."""
+        if self.longest_question_id is None:
+            return self.state_tokens
+        return self.state_tokens + self.question_tokens[self.longest_question_id]
+
+    @property
+    def over_total(self) -> bool:
+        return self.total > TOTAL_BUDGET
+
+    @property
+    def over_state(self) -> bool:
+        return self.longest_pair > STATE_BUDGET
+
+    def __repr__(self) -> str:  # pragma: no cover - debug aid
+        return (
+            f"BudgetReport(total={self.total}, longest_pair={self.longest_pair}, "
+            f"over_total={self.over_total}, over_state={self.over_state})"
+        )
+
+
+def check_budget(state: Any, questions: dict[str, Any]) -> BudgetReport:
+    state_tokens = estimate_tokens(state)
+    per_question = {qid: estimate_tokens(q) for qid, q in questions.items()}
+    longest = max(per_question, key=lambda k: per_question[k]) if per_question else None
+    return BudgetReport(state_tokens, per_question, longest)

jevkit_core-0.2.0.dist-info/METADATA

@@ -0,0 +1,46 @@
+Metadata-Version: 2.5
+Name: jevkit-core
+Version: 0.2.0
+Summary: Shared substrate for jevkit: the .jevl record format, canonical request digests, question normalization, and token budgets for TypeSafe's Jev.
+Project-URL: Homepage, https://github.com/pjdurden/jevkit-py
+Project-URL: Issues, https://github.com/pjdurden/jevkit-py/issues
+Author: Prajjwal Chittori
+License-Expression: MIT
+Keywords: calibration,jev,llm,system-one,typesafe
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# jevkit-core
+
+Shared substrate for [jevkit](https://github.com/pjdurden/jevkit-py), a set of
+tools for building on TypeSafe's Jev. Nothing in this package calls the API.
+
+- **`.jevl` record format** — one JSON Lines format that serves as test
+  cassette, drift golden set, benchmark instance, and calibration observation.
+  See [the spec](../../docs/specs/record-format-v1.md).
+- **Canonical digests** — RFC 8785 canonicalization, so the same request always
+  hashes the same way. `record_id()` includes the model; `request_id()` does
+  not, which is what lets you pair a golden record with its replay on a new
+  model version.
+- **Question normalization** — one view over SDK objects and plain dicts alike.
+- **Token budgets** — estimates against Jev's two documented limits: 64k for
+  state plus all questions, 32k for state plus the longest single question.
+
+> Unofficial and unaffiliated with TypeSafe.
+
+## Install
+
+```bash
+pip install jevkit-core
+```
+
+## License
+
+MIT

jevkit_core-0.2.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+jevkit_core/__init__.py,sha256=DQ3rcTlVvaUUPBhmmtOEqf6qyayAKvNMF64Jaq6XkUU,1234
+jevkit_core/answers.py,sha256=chhwo6SjDi9Y0AWZXUf6nIVJyJVHRbA8sXMVuTQ0Sb4,5622
+jevkit_core/canonical.py,sha256=R27fXBIAhjF_5AsqL6ZT-hps_I2Hf7EnjEZBjjgOJMY,1794
+jevkit_core/question.py,sha256=Xv4LHE8OXdJkhb2dKLIodaEZ3f3Mhsz8YTg_Nr7JRHQ,4133
+jevkit_core/record.py,sha256=1vp7nwA-7QnlGVukPEzGtcDCBIjSyPobCBxzVX4B6k8,5759
+jevkit_core/tokens.py,sha256=KW7HHA-OmHUOq0gsHd-H3Pdz-OD3jUrGVKVA_rAd9T0,2942
+jevkit_core-0.2.0.dist-info/METADATA,sha256=8oI9PqymqfEEDt6eZ2x3iImvEokybCgXrLm8jtfOjl0,1826
+jevkit_core-0.2.0.dist-info/WHEEL,sha256=THafob7ofN-NsuMN7Mg4qZyHaQI7KkD-QlcQatYhXPo,87
+jevkit_core-0.2.0.dist-info/RECORD,,

jevkit_core-0.2.0.dist-info/WHEEL

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