cloudsealed-jit 0.2.0__py3-none-any.whl

cloudsealed_jit/kernels.py

@@ -0,0 +1,140 @@
+"""
+Numerical kernels for baseline estimation.
+
+Cloud spend series contain the very spikes we are trying to detect. Estimating
+a baseline with a mean and flagging outliers with a standard-deviation z-score
+fails on this data: a handful of large spikes inflate the standard deviation
+enough to hide themselves and everything near them. This is the classic
+masking effect.
+
+We therefore use robust statistics throughout:
+
+    baseline  = centred rolling median
+    scale     = median absolute deviation (MAD)
+    z         = 0.6745 * (x - median) / MAD          [Iglewicz & Hoaglin, 1993]
+
+The 0.6745 constant makes the MAD a consistent estimator of the standard
+deviation for normally distributed data, so the resulting score keeps the
+familiar "number of deviations" interpretation while staying resistant to
+roughly half the sample being contaminated.
+
+A centred rolling median over a window is O(n * w log w) in the naive form.
+For the daily series produced by :mod:`cloudsealed_jit.parsing` that is
+irrelevant, but the same kernels run over per-service series and over hourly
+exports spanning years, where it is not. Numba compiles them to native code
+via LLVM; the pure NumPy path is kept as a fallback so the package installs
+and runs without a compiler toolchain.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+__all__ = ["rolling_median", "mad", "modified_zscores", "JIT_ENABLED"]
+
+_MAD_TO_SIGMA = 0.6745
+
+
+try:  # pragma: no cover - depends on the runtime environment
+    from numba import njit
+
+    JIT_ENABLED = True
+except ImportError:  # pragma: no cover
+    JIT_ENABLED = False
+
+    def njit(*args, **kwargs):  # type: ignore[misc]
+        """No-op stand-in used when numba is unavailable."""
+        def wrap(func):
+            return func
+        if args and callable(args[0]):
+            return args[0]
+        return wrap
+
+
+@njit(cache=True)
+def _rolling_median_kernel(values: np.ndarray, window: int) -> np.ndarray:
+    """Centred rolling median with shrinking windows at the edges."""
+    n = values.shape[0]
+    out = np.empty(n, dtype=np.float64)
+    half = window // 2
+    buffer = np.empty(window, dtype=np.float64)
+
+    for i in range(n):
+        lo = i - half
+        hi = i + half + 1
+        if lo < 0:
+            lo = 0
+        if hi > n:
+            hi = n
+
+        size = hi - lo
+        for k in range(size):
+            buffer[k] = values[lo + k]
+
+        # Insertion sort: window is small and the data is near-sorted.
+        for a in range(1, size):
+            key = buffer[a]
+            b = a - 1
+            while b >= 0 and buffer[b] > key:
+                buffer[b + 1] = buffer[b]
+                b -= 1
+            buffer[b + 1] = key
+
+        if size % 2 == 1:
+            out[i] = buffer[size // 2]
+        else:
+            out[i] = 0.5 * (buffer[size // 2 - 1] + buffer[size // 2])
+
+    return out
+
+
+def rolling_median(values: np.ndarray, window: int = 7) -> np.ndarray:
+    """Centred rolling median.
+
+    Args:
+        values: 1-D series.
+        window: window length in samples. Forced odd and clamped to the series
+            length so short inputs degrade to a global median rather than fail.
+    """
+    series = np.asarray(values, dtype=np.float64)
+    if series.size == 0:
+        return series.copy()
+
+    window = max(1, min(int(window), series.size))
+    if window % 2 == 0:
+        window -= 1
+    if window < 1:
+        window = 1
+    return _rolling_median_kernel(series, window)
+
+
+def mad(values: np.ndarray, centre: np.ndarray | float | None = None) -> float:
+    """Median absolute deviation about ``centre`` (default: the median)."""
+    series = np.asarray(values, dtype=np.float64)
+    if series.size == 0:
+        return 0.0
+    if centre is None:
+        centre = float(np.median(series))
+    return float(np.median(np.abs(series - centre)))
+
+
+def modified_zscores(values: np.ndarray, baseline: np.ndarray) -> np.ndarray:
+    """Robust z-scores of ``values`` against ``baseline``.
+
+    Falls back to a standard-deviation scale when the MAD is zero, which
+    happens on series that are constant apart from a few spikes. If both
+    scales are zero the series is flat and every score is zero.
+    """
+    series = np.asarray(values, dtype=np.float64)
+    base = np.asarray(baseline, dtype=np.float64)
+    residuals = series - base
+
+    scale = float(np.median(np.abs(residuals)))
+    if scale > 0.0:
+        return _MAD_TO_SIGMA * residuals / scale
+
+    fallback = float(np.std(residuals))
+    if fallback > 0.0:
+        return residuals / fallback
+
+    return np.zeros_like(series)

cloudsealed_jit/parsing.py

@@ -0,0 +1,321 @@
+"""
+Billing export parsing.
+
+Cloud providers export cost data with different schemas and different
+granularities. A single day of spend is spread across many line items -- one
+per resource, SKU or usage type. Any analysis that treats a CSV row as an
+observation is measuring line-item size, not daily spend.
+
+This module normalises the common export formats into a single daily series:
+
+    date (UTC calendar day) -> total cost, and cost per service
+
+Supported layouts, detected from the header row:
+
+    AWS Cost and Usage Report   lineItem/UsageStartDate, lineItem/UnblendedCost
+    GCP billing export          usage_start_time, cost, service.description
+    Azure cost export           Date / UsageDateTime, Cost / CostInBillingCurrency
+    Generic                     heuristic match on date / cost / service columns
+
+Rows that cannot be parsed are counted and reported rather than silently
+dropped, so callers can tell a partially-understood file from a clean one.
+"""
+
+from __future__ import annotations
+
+import csv
+import io
+from collections import defaultdict
+from dataclasses import dataclass, field
+from datetime import date, datetime
+from typing import Iterable, Sequence
+
+__all__ = ["BillingSeries", "ParseError", "parse_billing_csv"]
+
+
+class ParseError(ValueError):
+    """Raised when a billing export cannot be interpreted at all."""
+
+
+# --------------------------------------------------------------------------
+# Column detection
+# --------------------------------------------------------------------------
+
+# Explicit, provider-specific column names take priority over the heuristics.
+# Order matters: the first match wins.
+_DATE_COLUMNS: Sequence[str] = (
+    "lineitem/usagestartdate",          # AWS CUR
+    "lineitem/usagestarttime",
+    "bill/billingperiodstartdate",
+    "usage_start_time",                 # GCP
+    "usage_date",
+    "usagedatetime",                    # Azure
+    "date",
+    "billingdate",
+    "usagestart",
+)
+
+_COST_COLUMNS: Sequence[str] = (
+    "lineitem/unblendedcost",           # AWS CUR
+    "lineitem/blendedcost",
+    "lineitem/netunblendedcost",
+    "cost",                             # GCP / generic
+    "costinbillingcurrency",            # Azure
+    "pretaxcost",
+    "amortizedcost",
+    "effectivecost",
+    "amount",
+)
+
+_SERVICE_COLUMNS: Sequence[str] = (
+    "product/productname",              # AWS CUR
+    "lineitem/productcode",
+    "service.description",              # GCP
+    "service_description",
+    "service",
+    "servicename",                      # Azure
+    "metercategory",
+    "product",
+    "resourcegroup",
+)
+
+# Substrings used when no explicit column name matches. Deliberately narrow:
+# matching "cost" alone would also match "costcenter".
+_DATE_HINTS = ("date", "day", "time", "period")
+_COST_HINTS = ("cost", "amount", "charge", "spend")
+_SERVICE_HINTS = ("service", "product", "category", "resource")
+
+_COST_EXCLUDE = ("center", "code", "currency", "type", "category")
+
+
+def _normalise(name: str) -> str:
+    return name.strip().lower().replace(" ", "").replace("_", "")
+
+
+def _pick(headers: Sequence[str], explicit: Sequence[str], hints: Sequence[str],
+          exclude: Sequence[str] = ()) -> str | None:
+    lookup = {_normalise(h): h for h in headers}
+
+    for candidate in explicit:
+        key = _normalise(candidate)
+        if key in lookup:
+            return lookup[key]
+
+    for key, original in lookup.items():
+        if any(bad in key for bad in exclude):
+            continue
+        if any(hint in key for hint in hints):
+            return original
+    return None
+
+
+# --------------------------------------------------------------------------
+# Value coercion
+# --------------------------------------------------------------------------
+
+_DATE_FORMATS = (
+    "%Y-%m-%d",
+    "%Y/%m/%d",
+    "%d/%m/%Y",
+    "%m/%d/%Y",
+    "%Y-%m-%dT%H:%M:%S",
+    "%Y-%m-%dT%H:%M:%SZ",
+    "%Y-%m-%d %H:%M:%S",
+    "%Y-%m-%d %H:%M:%S %Z",
+    "%Y-%m-%dT%H:%M:%S%z",
+    "%m/%d/%Y %H:%M:%S",
+    "%d-%m-%Y",
+)
+
+
+def _parse_date(raw: str) -> date | None:
+    text = (raw or "").strip()
+    if not text:
+        return None
+
+    # ISO-8601 with timezone offsets and fractional seconds.
+    try:
+        return datetime.fromisoformat(text.replace("Z", "+00:00")).date()
+    except ValueError:
+        pass
+
+    for fmt in _DATE_FORMATS:
+        try:
+            return datetime.strptime(text, fmt).date()
+        except ValueError:
+            continue
+
+    # Trailing timezone name that strptime cannot handle, e.g. "... UTC".
+    head = text.split(" ")[0]
+    if head != text:
+        return _parse_date(head)
+    return None
+
+
+def _parse_cost(raw: str) -> float | None:
+    text = (raw or "").strip()
+    if not text:
+        return None
+    text = text.replace("$", "").replace("R$", "").replace("US$", "").strip()
+
+    # "1.234,56" (pt-BR) vs "1,234.56" (en-US): the last separator is decimal.
+    if "," in text and "." in text:
+        if text.rfind(",") > text.rfind("."):
+            text = text.replace(".", "").replace(",", ".")
+        else:
+            text = text.replace(",", "")
+    elif "," in text:
+        # Ambiguous. Treat as decimal only when it looks like one.
+        head, _, tail = text.rpartition(",")
+        text = f"{head}.{tail}" if len(tail) in (1, 2) else text.replace(",", "")
+
+    try:
+        value = float(text)
+    except ValueError:
+        return None
+    return value if value == value else None  # reject NaN
+
+
+# --------------------------------------------------------------------------
+# Result type
+# --------------------------------------------------------------------------
+
+
+@dataclass
+class BillingSeries:
+    """A billing export normalised to daily totals.
+
+    Attributes:
+        days: calendar days present in the file, ascending and gap-free.
+        costs: total cost for each day in ``days``.
+        by_service: service name -> per-day cost, aligned with ``days``.
+        currency: currency code if the export declared one.
+        rows_parsed: line items successfully interpreted.
+        rows_skipped: line items rejected (unparseable date or cost).
+    """
+
+    days: list[date]
+    costs: list[float]
+    by_service: dict[str, list[float]] = field(default_factory=dict)
+    currency: str | None = None
+    rows_parsed: int = 0
+    rows_skipped: int = 0
+
+    def __post_init__(self) -> None:
+        if len(self.days) != len(self.costs):
+            raise ValueError("days and costs must have the same length")
+
+    @property
+    def total_cost(self) -> float:
+        return float(sum(self.costs))
+
+    @property
+    def span_days(self) -> int:
+        return len(self.days)
+
+    def __len__(self) -> int:  # pragma: no cover - trivial
+        return len(self.days)
+
+
+# --------------------------------------------------------------------------
+# Entry point
+# --------------------------------------------------------------------------
+
+
+def _fill_gaps(daily: dict[date, float]) -> tuple[list[date], list[float]]:
+    """Return a contiguous daily series, inserting 0.0 for missing days.
+
+    Gaps matter: a day with no line items is a day with no spend, and leaving
+    it out would distort both the weekly seasonality model and the averages.
+    """
+    if not daily:
+        return [], []
+    start, end = min(daily), max(daily)
+    days: list[date] = []
+    costs: list[float] = []
+    current = start
+    one_day = (datetime.fromordinal(2) - datetime.fromordinal(1))
+    while current <= end:
+        days.append(current)
+        costs.append(round(daily.get(current, 0.0), 6))
+        current = (datetime.combine(current, datetime.min.time()) + one_day).date()
+    return days, costs
+
+
+def parse_billing_csv(csv_text: str, *, max_services: int = 25) -> BillingSeries:
+    """Parse a cloud billing export into a daily :class:`BillingSeries`.
+
+    Args:
+        csv_text: raw contents of the CSV export.
+        max_services: keep only the N costliest services in ``by_service``.
+
+    Raises:
+        ParseError: the file is empty, has no header, or has no usable
+            date/cost column pair.
+    """
+    if not csv_text or not csv_text.strip():
+        raise ParseError("Billing export is empty.")
+
+    reader = csv.DictReader(io.StringIO(csv_text))
+    headers = reader.fieldnames
+    if not headers:
+        raise ParseError("Billing export has no header row.")
+
+    date_col = _pick(headers, _DATE_COLUMNS, _DATE_HINTS)
+    cost_col = _pick(headers, _COST_COLUMNS, _COST_HINTS, exclude=_COST_EXCLUDE)
+    service_col = _pick(headers, _SERVICE_COLUMNS, _SERVICE_HINTS)
+    currency_col = _pick(headers, ("currency", "billingcurrency",
+                                   "lineitem/currencycode"), ("currency",))
+
+    if date_col is None or cost_col is None:
+        raise ParseError(
+            "Could not identify a date and a cost column. "
+            f"Columns found: {', '.join(headers[:20])}"
+        )
+
+    daily: dict[date, float] = defaultdict(float)
+    per_service: dict[str, dict[date, float]] = defaultdict(lambda: defaultdict(float))
+    currency: str | None = None
+    parsed = skipped = 0
+
+    for row in reader:
+        day = _parse_date(row.get(date_col, ""))
+        cost = _parse_cost(row.get(cost_col, ""))
+        if day is None or cost is None:
+            skipped += 1
+            continue
+
+        daily[day] += cost
+        if service_col:
+            name = (row.get(service_col) or "").strip() or "unattributed"
+            per_service[name][day] += cost
+        if currency is None and currency_col:
+            currency = (row.get(currency_col) or "").strip() or None
+        parsed += 1
+
+    if parsed == 0:
+        raise ParseError(
+            f"No line items could be parsed from {skipped} rows. "
+            f"Checked column '{date_col}' for dates and '{cost_col}' for costs."
+        )
+
+    days, costs = _fill_gaps(daily)
+
+    # Keep the costliest services; the long tail is noise for waste analysis.
+    by_service: dict[str, list[float]] = {}
+    ranked = sorted(per_service.items(), key=lambda kv: sum(kv[1].values()), reverse=True)
+    index = {day: i for i, day in enumerate(days)}
+    for name, series in ranked[:max_services]:
+        aligned = [0.0] * len(days)
+        for day, value in series.items():
+            aligned[index[day]] = round(value, 6)
+        by_service[name] = aligned
+
+    return BillingSeries(
+        days=days,
+        costs=costs,
+        by_service=by_service,
+        currency=currency,
+        rows_parsed=parsed,
+        rows_skipped=skipped,
+    )

cloudsealed_jit-0.2.0.dist-info/METADATA

@@ -0,0 +1,222 @@
+Metadata-Version: 2.4
+Name: cloudsealed-jit
+Version: 0.2.0
+Summary: Detect structural waste in cloud billing exports using robust day-of-week baselines
+Author: Rodrigo Martinez Pinto
+License: MIT
+Project-URL: Homepage, https://github.com/cloudsealed/JIT-Optimization-Engine
+Project-URL: Source, https://github.com/cloudsealed/JIT-Optimization-Engine
+Project-URL: Issues, https://github.com/cloudsealed/JIT-Optimization-Engine/issues
+Keywords: finops,cloud-cost,aws,gcp,azure,anomaly-detection,billing
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: System Administrators
+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 :: System :: Monitoring
+Classifier: Topic :: Office/Business :: Financial
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Provides-Extra: jit
+Requires-Dist: numba>=0.57; extra == "jit"
+Provides-Extra: api
+Requires-Dist: fastapi>=0.110; extra == "api"
+Requires-Dist: uvicorn[standard]>=0.29; extra == "api"
+Requires-Dist: pydantic>=2.6; extra == "api"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4; extra == "dev"
+Requires-Dist: httpx>=0.27; extra == "dev"
+Dynamic: license-file
+
+# cloudsealed-jit
+
+Detects structural waste in cloud billing exports.
+
+Given a billing export from AWS, GCP or Azure, it models what each day *should*
+have cost, reports the days that did not match, and turns the excess into a
+monthly figure. It is a library, a CLI and an HTTP service.
+
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![Python](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/downloads/)
+
+---
+
+## The problem
+
+Cloud cost anomaly detection is usually done by comparing each day against the
+period average and flagging anything beyond two or three standard deviations.
+On billing data that method fails in two specific ways.
+
+**Standard deviation is inflated by the very spikes you are looking for.** A
+handful of large anomalies raises σ enough to pull themselves back inside the
+threshold, and to hide every smaller anomaly with them. This is the masking
+effect, and it gets worse as the anomalies get bigger.
+
+**A flat average ignores the weekly cycle.** Most cloud bills have a pronounced
+weekday/weekend shape. Measured against a flat mean, ordinary Mondays look like
+overspend and ordinary Sundays look like savings.
+
+## The method
+
+**Baseline.** Expected spend for a day is a level term times a weekday term:
+
+```
+expected[i] = rolling_median(cost, 7)[i] × dow_factor[weekday(i)]
+```
+
+The rolling median follows growth and step changes without being dragged by
+spikes. The weekday factor is the median ratio of observed spend to the level
+term for that weekday. It is only estimated with at least two full weeks of
+data; below that every factor is 1.0.
+
+**Scoring.** Residuals are scored with a modified z-score built on the median
+absolute deviation:
+
+```
+z = 0.6745 × (x − baseline) / MAD
+```
+
+The 0.6745 constant makes MAD a consistent estimator of σ for normal data, so
+the score keeps the familiar "number of deviations" reading while tolerating
+contamination in roughly half the sample. Days at or above |z| = 3.5 are
+reported — the threshold recommended by Iglewicz & Hoaglin (1993).
+
+**Waste.** Only positive excess counts. Waste percentage is the share of total
+spend sitting above the baseline on anomalous days, which converts directly to
+currency instead of being a count of unusual days.
+
+**Recommendations.** Each carries a figure derived from the series itself,
+normalised to 30 days, and states its assumption in the description. Estimates
+that depend on facts the analyser cannot observe — whether a workload is
+production, whether a commitment is acceptable — are labelled conditional
+rather than presented as findings.
+
+## Does it actually work better?
+
+Yes, and it is measured, not asserted. `benchmarks/masking_benchmark.py` builds
+synthetic bills whose anomalies are known by construction and scores this
+method against the textbook mean+standard-deviation approach:
+
+| scenario | textbook F1 | this method F1 |
+|---|---|---|
+| masking (scale estimator) | 0.667 | **0.923** |
+| seasonality (baseline) | 0.667 | **1.000** |
+| end-to-end | 0.667 | **1.000** |
+
+Full derivation and reproduction steps in [METHODOLOGY.md](METHODOLOGY.md); the
+design of the codebase is in [architecture.md](architecture.md). The benchmark
+runs in CI (`--check`) and fails the build if the advantage ever regresses.
+
+## Install
+
+```bash
+pip install cloudsealed-jit              # library + CLI
+pip install "cloudsealed-jit[jit]"       # + numba-compiled kernels
+pip install "cloudsealed-jit[jit,api]"   # + HTTP service
+```
+
+`numba` is optional. Without it the kernels run on pure NumPy and the results
+are identical; only large inputs get slower.
+
+## Use
+
+### CLI
+
+```bash
+cloudsealed-jit billing-export.csv
+cloudsealed-jit billing-export.csv --json > findings.json
+cat export.csv | cloudsealed-jit - --type cost-forecast
+```
+
+### Library
+
+```python
+from cloudsealed_jit import parse_billing_csv, analyze
+
+series = parse_billing_csv(open("export.csv").read())
+result = analyze(series)
+
+print(result.metrics.wastePercentage)
+for r in result.recommendations:
+    print(r.title, r.potentialSavings)
+```
+
+### HTTP service
+
+```bash
+docker run -p 8091:8091 cloudsealed/jit-optimization-engine
+```
+
+```
+GET  /health
+POST /v1/analyze-billing
+```
+
+```bash
+curl -X POST localhost:8091/v1/analyze-billing \
+  -H 'Content-Type: application/json' \
+  -d '{"companyName":"Acme","csvContent":"date,cost\n2026-01-01,100\n..."}'
+```
+
+Set `JIT_OPTIMIZATION_API_KEY` to require an `X-Api-Key` header. Set
+`JIT_MAX_CSV_BYTES` to change the 64 MB upload ceiling.
+
+Response shape:
+
+```jsonc
+{
+  "anomalies": [
+    { "date": "2026-01-31", "expectedCost": 99.0, "actualCost": 500.0,
+      "deviation": 405.05, "zScore": 7.82, "severity": "CRITICAL",
+      "description": "Spend above the day-of-week baseline by USD 401.00 (405.1%)." }
+  ],
+  "metrics": {
+    "averageDailyCost": 106.32,
+    "stdDeviation": 51.69,
+    "sharpeRatio": 2.06,       // spend stability: mean / stddev of daily cost
+    "wastePercentage": 6.29    // share of total spend above the baseline
+  },
+  "recommendations": [
+    { "title": "...", "description": "...", "potentialSavings": 200.5, "effort": "MEDIUM" }
+  ],
+  "summary": "..."
+}
+```
+
+`sharpeRatio` is a **spend stability ratio** — mean daily cost divided by its
+standard deviation, the reciprocal of the coefficient of variation. Higher
+means more predictable spend. It is named for the field in the consuming API
+contract; it is not a risk-adjusted return.
+
+## Supported exports
+
+| Provider | Date column | Cost column |
+|---|---|---|
+| AWS Cost and Usage Report | `lineItem/UsageStartDate` | `lineItem/UnblendedCost` |
+| GCP billing export | `usage_start_time` | `cost` |
+| Azure cost export | `Date`, `UsageDateTime` | `Cost`, `CostInBillingCurrency` |
+| Generic | heuristic | heuristic |
+
+Line items are aggregated to calendar days. Days with no line items are
+inserted as zero-spend days rather than skipped. Rows that cannot be parsed are
+counted and reported in the summary rather than dropped silently.
+
+## Development
+
+```bash
+pip install -e ".[jit,api,dev]"
+pytest
+```
+
+The test suite builds synthetic exports whose correct answer is known in
+advance — a known spike at a known date, a known weekend-idle service, a stable
+series that must produce no findings — so the assertions test behaviour rather
+than the current output.
+
+## License
+
+MIT. See [LICENSE](LICENSE).

cloudsealed_jit-0.2.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+cloudsealed_jit/__init__.py,sha256=IOHOiFIFwFwc4XjHnr7hFaOkjqCd5RWo5eRYrWDVRmg,604
+cloudsealed_jit/analysis.py,sha256=Be3H0ksmiYxkx5prbGMZ_u-0Bb-7I7hQWYFh9K8YhCY,15355
+cloudsealed_jit/api.py,sha256=N_jhv-RNgCJM2Nc6k3x3e4D8ufR1FgV-YpMbGqyYXYk,4913
+cloudsealed_jit/cli.py,sha256=awxm-_39lPN3WB0SL86XQJukSM0So5CYcfJ0ixIotVw,1830
+cloudsealed_jit/kernels.py,sha256=ul7is6QarWhmpiQfDaJ68IBmItF6GLoNuERsggIS5dc,4568
+cloudsealed_jit/parsing.py,sha256=jSDw1E_zBELqVLioES5sexQOOcmCXVb4OlTC6rhNS0o,10483
+cloudsealed_jit-0.2.0.dist-info/licenses/LICENSE,sha256=SY8phgxBGveojrUPkmyRDhp8HhA-SsX75HK_bnixdlo,1068
+cloudsealed_jit-0.2.0.dist-info/METADATA,sha256=CnKW_5KIbYEBlphz1TWUZ9_kNxbwZWQzIwFyUjUe0TY,7803
+cloudsealed_jit-0.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+cloudsealed_jit-0.2.0.dist-info/entry_points.txt,sha256=ATQRx9QOgOyuu41BTfFxDd4HZPfMYmYyw3iDnKMmfHw,61
+cloudsealed_jit-0.2.0.dist-info/top_level.txt,sha256=r4c8dJeZHwe8UcAd8Cnok_K0Rxh7vpft7MKpogSzFNk,16
+cloudsealed_jit-0.2.0.dist-info/RECORD,,

cloudsealed_jit-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
+