sourcecode 1.65.0__py3-none-any.whl → 1.66.0__py3-none-any.whl

sourcecode/__init__.py

@@ -1,3 +1,3 @@
 """sourcecode — Deterministic codebase context maps for AI coding agents."""
 
-__version__ = "1.65.0"
+__version__ = "1.66.0"

sourcecode/migrate_check.py

@@ -648,6 +648,19 @@ _BOOT3_MIGRATION_TARGETS: frozenset[str] = frozenset(
 # upgrade. It is advisory only and must never sink a readiness dimension to 0 —
 # reported as a separate hygiene metric, excluded from JDK-modernization scoring.
 _BEST_PRACTICE_TARGETS: frozenset[str] = frozenset({"java_8_best_practice"})
+
+# BUG #3: the migration dimensions that feed the readiness_score aggregate, in
+# order. jdk_modernization is deliberately NOT here — it is orthogonal upkeep debt
+# reported on its own axis, never folded into the migration headline.
+_MIGRATION_DIMENSIONS: tuple[str, ...] = ("jakarta", "boot3", "hibernate")
+
+
+def _parse_major(version: "Optional[str]") -> "Optional[int]":
+    """Leading integer of a version string ('4.0.3' → 4); None when not parseable."""
+    if not version:
+        return None
+    m = re.match(r"\s*(\d+)", version)
+    return int(m.group(1)) if m else None
 # Cap on total readiness deduction from JDK-modernization findings (medium/low),
 # so reflection/date cleanups cannot collapse a jakarta-ready repo's headline.
 _JDK_ADVISORY_DEDUCTION_CAP: int = 15
@@ -1170,6 +1183,9 @@ class MigrationReport:
     # is excluded from the aggregate — it is never counted as 0. Maps dimension →
     # {"applicable": bool, "score": int|None, "reason": str}.
     applicable_dimensions: dict = field(default_factory=dict)
+    # BUG #3: how readiness_score was derived (method + the exact applicable
+    # dimension scores it aggregates) so the headline number is fully traceable.
+    readiness_aggregate: dict = field(default_factory=dict)
     blocking_count: int = 0
     estimated_effort_days: float = 0.0
     # Tri-state: True = Boot 2 confirmed, False = Boot 3+ confirmed,
@@ -1238,71 +1254,67 @@ class MigrationReport:
             1 for f in main_findings if f.severity in ("critical", "high")
         )
 
-        # BUG #4 / #6: readiness deduction. FRAMEWORK blockers (jakarta / Boot3 /
-        # Security — critical+high) are UNCAPPED so a genuinely blocked repo floors
-        # at 0. Orthogonal JDK-modernization debt (SecurityManager, sun.*, reflection)
-        # is advisory-CAPPED so it can never sink the framework headline. Best-practice
-        # hygiene (java.util.Date) is EXCLUDED entirely — it blocks no version upgrade.
-        fw = _BOOT3_MIGRATION_TARGETS
-        fw_crit = _files_by_sev(main_findings, "critical", targets=fw)
-        fw_high = _files_by_sev(main_findings, "high", targets=fw)
-        fw_med = _files_by_sev(main_findings, "medium", targets=fw)
-        fw_low = _files_by_sev(main_findings, "low", targets=fw)
-        _jdk_exclude = fw | _BEST_PRACTICE_TARGETS
-        jdk_crit = {f.source_file for f in main_findings
-                    if f.severity == "critical" and f.migration_target not in _jdk_exclude}
-        jdk_high = {f.source_file for f in main_findings
-                    if f.severity == "high" and f.migration_target not in _jdk_exclude}
-        jdk_med = {f.source_file for f in main_findings
-                   if f.severity == "medium" and f.migration_target not in _jdk_exclude}
-        jdk_low = {f.source_file for f in main_findings
-                   if f.severity == "low" and f.migration_target not in _jdk_exclude}
-        jdk_raw = len(jdk_crit) * 15 + len(jdk_high) * 8 + len(jdk_med) * 3 + len(jdk_low) * 1
-
-        deduction = (
-            len(fw_crit) * 15
-            + len(fw_high) * 8
-            + len(fw_med) * 3
-            + min(len(fw_low) * 1, _LOW_SEVERITY_DEDUCTION_CAP)
-            + min(jdk_raw, _JDK_ADVISORY_DEDUCTION_CAP)
-        )
-        self.readiness_score = max(0, 100 - deduction)
-
         # Per-dimension readiness — independent severity-weighted scores (MAIN only).
         self.jakarta_readiness = _dimension_score(main_findings, _JAKARTA_TARGETS)
         self.boot3_readiness = _dimension_score(main_findings, _BOOT3_MIGRATION_TARGETS)
         self.jdk_modernization = _dimension_score(main_findings, None)
+        if not self.spring_present:
+            self.boot3_readiness = 100
 
-        # BUG #1: Hibernate 5→6 is its own rewrite axis and applies ONLY when the
-        # repo is actually on Hibernate < 6. A resolved Hibernate 6+ (Keycloak:
-        # 6.2.13) means the migration is already done → N/A, never a blocker. An
-        # unresolved version degrades to a low-confidence hypothesis (no headline).
+        # ── BUG #2: Hibernate applicability — version-driven, never heuristic ────
+        # The 5→6 axis is applicable ONLY when the repo is actually on Hibernate < 6.
+        #   resolved < 6        → applicable (rewrite score is a measurement)
+        #   resolved ≥ 6        → N/A (already migrated)
+        #   unresolved, Boot≥3  → N/A (Boot 3/4 BOM manages Hibernate ORM ≥6)
+        #   unresolved, Boot==2 → applicable (Boot 2 BOM manages Hibernate 5.x)
+        #   unresolved, no BOM  → N/A, status "unresolved" (NEVER a heuristic number
+        #                          that looks like a measurement on absent data)
         hib = self.hibernate
-        _hibernate_applies = (
-            hib is not None and hib.detected and hib.migration_applicable
-        )
-        if hib is not None and hib.detected:
-            # Already on H6+ → nothing to migrate → 100; else the rewrite score.
-            self.hibernate_readiness = hib.readiness if hib.migration_applicable else 100
-        if _hibernate_applies and hib.classification == "rewrite_zone" \
+        hib_detected = hib is not None and hib.detected
+        boot_major = _parse_major(self.spring_boot_version_detected)
+        _hibernate_applies = False
+        _hib_score: Optional[int] = None
+        hib_status = "not_detected"
+        _hib_reason = "N/A — no Hibernate dependency or import detected"
+        if hib_detected:
+            if hib.version_confidence == "high":
+                if hib.migration_applicable:              # resolved major < 6
+                    _hibernate_applies, _hib_score = True, hib.readiness
+                    hib_status = "resolved_h5"
+                    _hib_reason = f"Hibernate 5→6 rewrite axis (resolved {hib.effective_version})"
+                else:                                     # resolved major ≥ 6
+                    hib_status = "managed_ge6"
+                    _hib_reason = (f"N/A — resolved Hibernate {hib.effective_version} (≥6); "
+                                   f"no 5→6 migration pending")
+            elif boot_major is not None and boot_major >= 3:
+                hib_status = "managed_ge6"
+                _hib_reason = (f"N/A — Hibernate version managed by Spring Boot "
+                               f"{self.spring_boot_version_detected} BOM (Hibernate ORM ≥6); "
+                               f"5→6 axis inapplicable")
+            elif boot_major == 2:
+                _hibernate_applies, _hib_score = True, hib.readiness
+                hib_status = "managed_h5"
+                _hib_reason = (f"Hibernate 5→6 rewrite axis (Hibernate 5.x managed by Spring "
+                               f"Boot {self.spring_boot_version_detected} BOM)")
+            else:
+                hib_status = "unresolved"
+                _hib_reason = ("N/A — Hibernate version unresolved (not declared and no Spring "
+                               "Boot BOM to infer from); not penalized on absent data")
+        # Top-level scalar: the rewrite score only when applicable; else 100 (nothing
+        # pending) — never a heuristic penalty on an inapplicable/unresolved axis.
+        self.hibernate_readiness = _hib_score if _hibernate_applies else 100
+        # Headline blocker only on a DIRECTLY-resolved Hibernate-5 rewrite zone.
+        if _hibernate_applies and hib is not None and hib.classification == "rewrite_zone" \
                 and hib.version_confidence == "high":
-            # Only a CONFIRMED Hibernate-5 rewrite zone earns the headline blocker.
             self.headline_blocker = "hibernate_rewrite"
 
-        # BUG #2 / #3: declare which dimensions apply. jakarta + JDK are always
-        # applicable to a Java repo; boot3 applies only when Spring is actually used
-        # (Quarkus/Micronaut/Jakarta-pure repos have no Boot 2→3 axis); hibernate
-        # applies only for a real Hibernate < 6. N/A dimensions carry score=None and
-        # are excluded from the aggregate — never scored as 0.
-        if not self.spring_present:
-            self.boot3_readiness = 100
-        if _hibernate_applies:
-            _hib_reason = f"Hibernate 5→6 rewrite axis (detected {hib.effective_version or 'version unknown'})"
-        elif hib is not None and hib.detected and not hib.migration_applicable:
-            _hib_reason = (f"N/A — already on Hibernate {hib.version_major} "
-                           f"({hib.effective_version}); no 5→6 migration pending")
-        else:
-            _hib_reason = "N/A — no Hibernate dependency or import detected"
+        # BUG #3: declare which dimensions apply, then derive readiness_score as a
+        # DOCUMENTED aggregate over the applicable MIGRATION dimensions only. jakarta
+        # is always applicable; boot3 only with Spring; hibernate only for a real
+        # Hibernate < 6. jdk_modernization is an orthogonal upkeep axis (SecurityManager,
+        # reflection, java.time) — reported but EXCLUDED from the headline so JDK debt
+        # cannot sink a framework-complete repo. N/A dimensions carry score=None and
+        # never enter the aggregate.
         self.applicable_dimensions = {
             "jakarta": {"applicable": True, "score": self.jakarta_readiness,
                         "reason": "javax→jakarta namespace migration"},
@@ -1314,14 +1326,44 @@ class MigrationReport:
                            else "N/A — no Spring usage detected (non-Spring stack)"),
             },
             "jdk_modernization": {"applicable": True, "score": self.jdk_modernization,
-                                  "reason": "orthogonal JDK modernization debt"},
+                                  "reason": "orthogonal JDK modernization debt (excluded from "
+                                            "the readiness_score aggregate)",
+                                  "in_aggregate": False},
             "hibernate": {
                 "applicable": _hibernate_applies,
                 "score": self.hibernate_readiness if _hibernate_applies else None,
                 "reason": _hib_reason,
+                "status": hib_status,
             },
         }
 
+        # ── BUG #3: aggregate invariant ─────────────────────────────────────────
+        # readiness_score == min(score of every applicable migration dimension).
+        # MIN (not mean): a migration is only as ready as its weakest applicable
+        # axis. _MIGRATION_DIMENSIONS lists exactly which dimensions feed it; the
+        # consistency invariant is asserted in finalize and covered by a unit test.
+        agg_inputs = {
+            name: self.applicable_dimensions[name]["score"]
+            for name in _MIGRATION_DIMENSIONS
+            if self.applicable_dimensions[name]["applicable"]
+        }
+        self.readiness_score = min(agg_inputs.values()) if agg_inputs else 100
+        self.readiness_aggregate = {
+            "method": "min",
+            "inputs": agg_inputs,
+            "excluded": ["jdk_modernization"],
+            "note": ("readiness_score = min over applicable migration dimensions "
+                     "(jakarta / boot3 / hibernate). jdk_modernization is an orthogonal "
+                     "upkeep axis and is intentionally excluded."),
+        }
+        # Internal consistency guard — the headline cannot diverge from the dimensions
+        # it claims to summarize (catches a future scorer change that breaks the model).
+        if agg_inputs:
+            assert self.readiness_score == min(agg_inputs.values()), (
+                "readiness_score must equal min(applicable migration dimensions); "
+                f"got {self.readiness_score} vs inputs {agg_inputs}"
+            )
+
         # BUG #5: effort over MAIN findings only — N/A axes (Hibernate-6 phantom,
         # test fixtures) no longer pad the estimate.
         self.estimated_effort_days = round(
@@ -1375,10 +1417,13 @@ class MigrationReport:
             "jdk_modernization": self.jdk_modernization,
             "hibernate_readiness": self.hibernate_readiness,
             "applicable_dimensions": self.applicable_dimensions,
+            "readiness_aggregate": self.readiness_aggregate,
             "readiness_note": (
-                "readiness_score is a DERIVED aggregate over applicable dimensions only "
-                "(N/A dimensions excluded, never counted as 0). For migration decisions read "
-                "the per-dimension breakdown + blocking_count, not the single number."
+                "readiness_score = min over applicable MIGRATION dimensions "
+                "(jakarta / boot3 / hibernate); see readiness_aggregate for the exact "
+                "inputs. N/A dimensions are excluded (never counted as 0); "
+                "jdk_modernization is orthogonal upkeep and is NOT in the aggregate. "
+                "For decisions read the per-dimension breakdown + blocking_count."
             ),
             "headline_blocker": self.headline_blocker,
             "blocking_count": self.blocking_count,

sourcecode/serializer.py

@@ -291,17 +291,65 @@ _JAKARTA_RENAMED_NAMESPACES: tuple[str, ...] = (
 )
 
 
+# Permanent JDK / JSR javax.* namespaces. These are part of the Java SE platform
+# (or standalone JCP specs) and were NEVER renamed to jakarta.* — Spring Boot 3/4
+# still uses them under javax.*. They must be excluded from EVERY javax→jakarta
+# detection rule (dependency coordinates AND import scanning). This is the single
+# source of truth for the allowlist — do NOT re-implement prefix checks elsewhere.
+# Counterpart in migrate_check._JAKARTA_NO_MIGRATE_PREFIXES (import side); keep both
+# in sync. NOTE: `javax.annotation.processing` is permanent (JSR-269, compiler API)
+# but bare `javax.annotation` (JSR-250 EE subset) DID move — handled below.
+_JAVAX_PERMANENT_NAMESPACES: tuple[str, ...] = (
+    "javax.cache",              # JSR-107 (JCache) — never renamed
+    "javax.sql",                # JDBC standard extension (Java SE)
+    "javax.xml",                # JAXP (parsers/transform/xpath/stream/namespace…)
+    "javax.naming",             # JNDI (Java SE)
+    "javax.management",         # JMX (Java SE)
+    "javax.crypto",             # JCE (Java SE)
+    "javax.net",                # incl. javax.net.ssl (Java SE)
+    "javax.security.auth",      # JAAS (Java SE)
+    "javax.security.cert",      # Java SE
+    "javax.security.sasl",      # Java SE
+    "javax.annotation.processing",  # JSR-269 compiler API (NOT the JSR-250 subset)
+    "javax.tools",              # Java SE compiler API
+    "javax.lang.model",         # Java SE annotation-processing model
+    "javax.sound",              # Java SE
+    "javax.imageio",            # Java SE
+    "javax.print",              # Java SE
+    "javax.accessibility",      # Java SE
+    "javax.swing",              # Java SE
+    "javax.smartcardio",        # Java SE
+)
+
+
+def _longest_namespace_match(nl: str, namespaces: "tuple[str, ...]") -> int:
+    """Length of the longest namespace in *namespaces* that is a prefix of *nl*.
+
+    Matches an exact namespace or a dotted sub-package (javax.xml → javax.xml.bind);
+    returns 0 when none match.
+    """
+    best = 0
+    for ns in namespaces:
+        if (nl == ns or nl.startswith(ns + ".")) and len(ns) > best:
+            best = len(ns)
+    return best
+
+
 def _is_jakarta_renamed_namespace(nl: str) -> bool:
     """True only for javax.* namespaces actually renamed to jakarta.* in Jakarta EE 9.
 
-    Matches exact namespace or a sub-package (e.g. javax.servlet → javax.servlet.http).
+    Decided by LONGEST-prefix match across the renamed list and the permanent
+    JDK/JSR allowlist — the more specific namespace wins. This keeps both nuanced
+    cases correct simultaneously:
+      - javax.xml.bind (renamed, len 14) beats javax.xml (permanent, len 9) → flag.
+      - javax.annotation.processing (permanent, len 27) beats javax.annotation
+        (renamed, len 16) → no flag.
     JDK/JSR namespaces that keep javax.* forever (javax.cache, javax.sql, javax.xml
-    JAXP, javax.naming, …) return False.
+    JAXP, javax.naming, …) never flag. A bare javax.* with no match also never flags.
     """
-    for ns in _JAKARTA_RENAMED_NAMESPACES:
-        if nl == ns or nl.startswith(ns + "."):
-            return True
-    return False
+    renamed = _longest_namespace_match(nl, _JAKARTA_RENAMED_NAMESPACES)
+    permanent = _longest_namespace_match(nl, _JAVAX_PERMANENT_NAMESPACES)
+    return renamed > 0 and renamed >= permanent
 
 
 def _dep_risk_flags(name: str, version: "Optional[str]") -> list[str]:

{sourcecode-1.65.0.dist-info → sourcecode-1.66.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 1.65.0
+Version: 1.66.0
 Summary: Persistent structural context and ultra-fast repeated analysis for AI coding agents
 License-File: LICENSE
 Keywords: agents,ai,codebase,context,developer-tools,llm
@@ -738,9 +738,21 @@ evidence. `migrate-check` enforces:
   usage; Quarkus / Micronaut / Helidon / Jakarta-pure repos report `boot3` as N/A
   (`spring_present: false`), not a contradictory `applicable: true`.
 - **Permanent `javax.*` are never jakarta debt.** JDK/JSR namespaces
-  (`javax.xml.*`, `javax.crypto.*`, `javax.naming.*`, `javax.sql.*`,
-  `javax.management.*`, `javax.security.auth.*`, …) are allowlisted across every
-  jakarta scorer.
+  (`javax.cache`, `javax.sql`, `javax.xml` JAXP, `javax.crypto`, `javax.naming`,
+  `javax.management`, `javax.security.auth`, `javax.annotation.processing`, …) are
+  allowlisted across every jakarta scorer (single source of truth:
+  `serializer._JAVAX_PERMANENT_NAMESPACES` + `migrate_check._JAKARTA_NO_MIGRATE_PREFIXES`).
+  The `javax→jakarta` dependency flag decides via **longest-prefix match**, so
+  `javax.xml.bind` (JAXB — moved) flags while `javax.xml` (JAXP) does not, and
+  `javax.annotation` (JSR-250 — moved) flags while `javax.annotation.processing`
+  (JSR-269) does not. The allowlist never silences a real migration.
+- **`readiness_score` is a traceable aggregate.** It is `min` over the applicable
+  **migration** dimensions (`jakarta` / `boot3` / `hibernate`); `jdk_modernization`
+  is orthogonal upkeep and is excluded. The exact inputs are in `readiness_aggregate{}`
+  and an invariant (`readiness_score == min(applicable migration dims)`) is asserted in
+  code. When the Hibernate version is undeclared it is inferred from the Spring Boot
+  BOM (Boot ≥3 → Hibernate ≥6 → N/A; Boot 2 → Hibernate 5 → applicable; no BOM →
+  `status: unresolved`, never a heuristic score).
 - **Three buckets: blocker ≠ hygiene ≠ test.** Only product (`main`) code counts
   toward `blocking_count`, readiness, and effort. Test harnesses
   (`testsuite/`, `test-framework/`, `integration-arquillian/`, `*-test*`,

{sourcecode-1.65.0.dist-info → sourcecode-1.66.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-sourcecode/__init__.py,sha256=p8-GKiFQV7kVIfsCmKNXmTPDXKUpvscoIAbYoLSteFs,103
+sourcecode/__init__.py,sha256=_rKEwisXr1IeFjMbYXGSfdRcelQmOHaAB0XR84P9tsk,103
 sourcecode/adaptive_scanner.py,sha256=XffluXKzJUXrMtjEiAOnSNPZnztdIcts17T9ouHeID0,10521
 sourcecode/architecture_analyzer.py,sha256=liCwQmLgb5vplohy8arjYxs_HOIv5C9MjLh_gY6bc5Q,44115
 sourcecode/architecture_summary.py,sha256=z34_6v7cSwy98cof2UVciGho7SCrZ93tiqMmq5WNzRQ,20405
@@ -33,7 +33,7 @@ sourcecode/integration_detector.py,sha256=mQulsXN1P-4V_3ueh3xy_N9x3Aqlvm7GQ-3YGq
 sourcecode/license.py,sha256=wckiLuiwaE35KMCStUf1gYzleJuFe6qsSyxUQJvit3s,23500
 sourcecode/mcp_nudge.py,sha256=5ELU_ixzh6uA83NXLOZT8h00OhL53okfQdji3jyKOjg,2917
 sourcecode/metrics_analyzer.py,sha256=m0ENgtqKeBL17kUIK3fmGkgo7UfXBNHxCMj0H_Y5K7c,22750
-sourcecode/migrate_check.py,sha256=pv7jZGhHRaw160sWYk0NWR-jWZERl_2S_gFAJ72maFI,80133
+sourcecode/migrate_check.py,sha256=daZLA7KaeoWoUPSMN8cYqHYD6HBflzc-z_N4bCGVPak,82993
 sourcecode/openapi_surface.py,sha256=BTt0K-woZbkbWTN77IkqeBm_Okag9owR0848fmot8sk,16207
 sourcecode/output_budget.py,sha256=Js9yUlfQtPhqBl9R6wn_9UHVjjJc3GtLcqyfjf5t50Q,9869
 sourcecode/path_filters.py,sha256=DMea0KIlmj2pzTkuy-3YYFF4ktP0q5zP9mH4v4uXh84,5237
@@ -53,7 +53,7 @@ sourcecode/scanner.py,sha256=WdOQ78mMzjR1NjmKTlbxdgwinnCTfAhxCVLBEFQiFHU,8899
 sourcecode/schema.py,sha256=aHNXDf8LGyUC8ZDE_VS9kiskC2-Oswhi_WnpdGy6HDw,24897
 sourcecode/security_config.py,sha256=_m8oQAy2gP7Ho2I-IIMTFFjFVWbJIGlLEOiAWK2TDjs,3503
 sourcecode/semantic_analyzer.py,sha256=4OdG6tTSnTvq3_dSWMbQu8Ad1ndSCKeG-b9qM4hIxkw,89176
-sourcecode/serializer.py,sha256=6YoGyRqkjtp34ELwgRGCZ1r1b6zu6SqiAWT8ySjs-M8,126516
+sourcecode/serializer.py,sha256=MSxYZ-_UYDPKMvg-hVk-MnKN-TfrmxXL202siCssa9U,129110
 sourcecode/spring_event_topology.py,sha256=5_ON_21Le5zbG-1GRc5GLIi5HJfy_QjcXLVPC5WeUGQ,18055
 sourcecode/spring_findings.py,sha256=G7Or2lKBUQbcTDqudLvSs9XvNg_YoAa-_lBOG_ULs8E,5457
 sourcecode/spring_impact.py,sha256=qLwLfItX_o9LU-k_qjhD2hFpTX3PpEQ85TsYTAArzvg,56016
@@ -103,8 +103,8 @@ sourcecode/telemetry/consent.py,sha256=H5z2Wu63pZqbaKucRPoJQJ0zCo4cke9ZlBrJC-MaW
 sourcecode/telemetry/events.py,sha256=LtzYfaX9Ilckj5PTvAcTpDa9mLqDsYPDUiDkRa58piY,2580
 sourcecode/telemetry/filters.py,sha256=NHa5T-6DaZduQPFuC34jOqHWQgSizM-Ygq8aZ4j19ng,5834
 sourcecode/telemetry/transport.py,sha256=4gGHsq0WeY9VywEZXA3vUxykfiYnw9uuqfjAAec7F8o,1681
-sourcecode-1.65.0.dist-info/METADATA,sha256=tuUMAq5_nLV0J0Zrsl8TAS1NdxLSgunoAtnhlFoYv2U,46300
-sourcecode-1.65.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-1.65.0.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
-sourcecode-1.65.0.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
-sourcecode-1.65.0.dist-info/RECORD,,
+sourcecode-1.66.0.dist-info/METADATA,sha256=PVY4maYclqHt2AKj_bcGmDzF7xmKhD0i7k2MrQepPKo,47341
+sourcecode-1.66.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-1.66.0.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
+sourcecode-1.66.0.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
+sourcecode-1.66.0.dist-info/RECORD,,