sourcecode 2.5.6__py3-none-any.whl → 2.5.8__py3-none-any.whl

sourcecode/__init__.py

@@ -4,4 +4,4 @@ ASK Engine is the product. ``ask`` is the canonical CLI command; ``sourcecode``
 the legacy compatibility alias and the Python/PyPI package name. See
 docs/PRODUCT_IDENTITY.md (normative)."""
 
-__version__ = "2.5.6"
+__version__ = "2.5.8"

sourcecode/architecture_summary.py

@@ -205,6 +205,22 @@ class ArchitectureSummarizer:
                 for f in s.frameworks[:2]
             ))[:3]
 
+        # F-1 reconciliation: the headline describes ONE program, but fw_names is
+        # gathered from every stack in the repo. On a polyglot repository that
+        # welds a foreign runtime's framework onto the primary's label. Drop what
+        # the claimed stack does not attest, and never let the TYPE label — which
+        # those same frameworks drove — survive its own evidence (P2-F).
+        from sourcecode.reconciliation import type_claim_unattested, unattested_frameworks
+
+        foreign = unattested_frameworks(primary.stack, sm.project_type, sm.stacks)
+        attested = [name for name in fw_names if name not in foreign]
+        dropped = [name for name in fw_names if name in foreign]
+        if dropped and not attested and type_claim_unattested(
+            claimed_stack=primary.stack, project_type=sm.project_type, stacks=sm.stacks
+        ):
+            return self._describe_foreign_evidence(sm, stack_label, runtime, dropped)
+        fw_names = attested
+
         fw_str = f" using {', '.join(fw_names)}" if fw_names else ""
         if runtime:
             # BUG #4: never assert "rest api" in the headline unless the endpoints
@@ -237,6 +253,29 @@ class ArchitectureSummarizer:
             return f"{stack_label} {runtime.lower()}{fw_str}."
         return f"{stack_label} project{fw_str}."
 
+    def _describe_foreign_evidence(
+        self, sm: SourceMap, stack_label: str, runtime: str, dropped: list[str]
+    ) -> str:
+        """Headline for a claim whose defining evidence belongs to another stack.
+
+        Says what IS known instead of asserting a program that does not exist:
+        the primary stack, the foreign frameworks, and the stacks that actually
+        declare them. The reader gets the same facts, correctly attributed.
+        """
+        from sourcecode.context_summarizer import _STACK_LABELS
+        from sourcecode.reconciliation import framework_owner_stacks
+
+        owners = framework_owner_stacks(sm.stacks)
+        owner_ids = sorted({sid for name in dropped for sid in owners.get(name, ())})
+        owner_labels = [_STACK_LABELS.get(sid, sid) for sid in owner_ids] or ["another"]
+        plural = "s" if len(owner_labels) > 1 else ""
+        return (
+            f"{stack_label} project. Polyglot repository: the {runtime.lower()} "
+            f"evidence ({', '.join(dropped)}) is declared by the "
+            f"{', '.join(owner_labels)} stack{plural}, not by {stack_label} — no "
+            "single stack owns this repository's architecture. See `stacks`."
+        )
+
     def _endpoint_support(self) -> tuple[int, int]:
         """Return (total, high_confidence) endpoint counts from the canonical
         Java endpoint extractor — the same source the `endpoints` command uses,
@@ -412,41 +451,51 @@ class ArchitectureSummarizer:
         return None
 
     def _summarize_dotnet_entry(self, stacks: list[StackDetection]) -> list[str]:
+        # P2-F-RESIDUE(c): every line here counts .csproj files — facts about the
+        # .NET stack ALONE. Unscoped, they read as claims about the repository:
+        # the confluent examples monorepo (20+ subprojects, mostly Java/Python/Go)
+        # reported a bare "1 project detected." beside a headline that had just
+        # called it polyglot. Naming the stack costs one word and makes each line
+        # true on any repo, so no polyglot test is needed to decide the wording.
+        from sourcecode.context_summarizer import _STACK_LABELS
+
         dotnet_stacks = [s for s in stacks if s.stack == "dotnet"]
         if not dotnet_stacks:
             return []
+        label = _STACK_LABELS.get("dotnet", "dotnet")  # same table as the headline
         lines: list[str] = []
         signals = [sig for s in dotnet_stacks for sig in s.signals]
 
         for sig in signals:
             if "project" in sig and "detected" in sig:
-                lines.append(sig[0].upper() + sig[1:] + ".")
+                count = sig.split(" ", 1)[0]
+                lines.append(f"{label} projects: {count}.")
                 break
 
         for sig in signals:
             if sig.startswith("project types:"):
                 types = sig.removeprefix("project types:").strip()
-                lines.append(f"Stack: {types}.")
+                lines.append(f"{label} project types: {types}.")
                 break
 
         for sig in signals:
             if sig.startswith("target frameworks:"):
                 fws = sig.removeprefix("target frameworks:").strip()
-                lines.append(f"Target: {fws}.")
+                lines.append(f"{label} target frameworks: {fws}.")
                 break
 
         for sig in signals:
             if sig.startswith("architecture:"):
                 pattern = sig.removeprefix("architecture:").strip()
-                lines.append(f"Patrón detectado: {pattern}.")
+                lines.append(f"{label} solution pattern: {pattern}.")
                 break
 
         framework_names = [f.name for s in dotnet_stacks for f in s.frameworks]
         if framework_names:
-            lines.append(f"Frameworks: {', '.join(framework_names)}.")
+            lines.append(f"{label} frameworks: {', '.join(framework_names)}.")
 
         if not lines:
-            lines.append("Solución .NET detectada.")
+            lines.append(f"{label} solution detected.")
         return lines
 
     def _summarize_go_entry(self, path: str, content: str) -> list[str]:

sourcecode/confidence_analyzer.py

@@ -102,6 +102,45 @@ class ConfidenceAnalyzer:
         if heuristic_only and not any(s.detection_method != "heuristic" for s in sm.stacks):
             anomalies.append("All stacks detected via heuristic only — no manifest found")
 
+        # ── Anomaly: a claim attributed to a stack that does not attest it ────
+        # F-1 reconciliation, second sink. The headline degrades itself
+        # (architecture_summary), but `project_type` and `primary_stack` are
+        # separate structured fields an agent can read on their own — and they
+        # keep asserting the claim this rule refutes. Same rule, same judgement,
+        # different surface: here it becomes an anomaly + gap instead of prose.
+        if primary_stacks:
+            from sourcecode.reconciliation import (
+                reconcile_headline_evidence,
+                type_claim_unattested,
+            )
+
+            _primary = primary_stacks[0]
+            for _rf in reconcile_headline_evidence(
+                claimed_stack=_primary.stack,
+                project_type=sm.project_type,
+                stacks=sm.stacks,
+            ):
+                anomalies.append(
+                    f"{', '.join(_rf.symbols)} declared by another runtime, not by the "
+                    f"{_primary.stack} primary stack"
+                )
+                _reason = _rf.detail
+                if type_claim_unattested(
+                    claimed_stack=_primary.stack,
+                    project_type=sm.project_type,
+                    stacks=sm.stacks,
+                ):
+                    _reason += (
+                        f' project_type="{sm.project_type}" rests on that same evidence — '
+                        f"it is not attested for the {_primary.stack} primary stack, and "
+                        "the repository is polyglot rather than one program."
+                    )
+                gaps.append(AnalysisGap(
+                    area=_rf.rule,
+                    reason=_reason,
+                    impact="medium",
+                ))
+
         # ── Anomaly: entry points all low-confidence ──────────────────────────
         if normalized_entry_points and all(ep.confidence == "low" for ep in normalized_entry_points):
             anomalies.append("All entry points are low-confidence (heuristic/code_signal only)")

sourcecode/reconciliation.py

@@ -42,6 +42,15 @@ Rule registry (architecture):
         subsystems (SIM-3: keycloak's "MVC … view layer" was a React SPA, zero
         Java files, sitting beside a 1088-file Java model).
 
+Rule registry (narrative):
+    framework_stack_attestation — the headline welds a stack label to a
+        framework that no stack of that runtime declares. The stack table and
+        the framework-ownership view are contradicting each other: the sentence
+        describes one program while the evidence names two (P2-F: the confluent
+        examples repo read "C#/.NET rest api using JAX-RS" — a JVM framework,
+        declared by a Java stack in one sub-workspace, attributed to a .NET
+        primary that declares no framework at all).
+
 Never raises. Empty evidence → no findings.
 """
 from __future__ import annotations
@@ -438,6 +447,188 @@ def incoherent_layers(
     return frozenset(out)
 
 
+# ---------------------------------------------------------------------------
+# Narrative reconciliation (headline claim × stack ownership)
+# ---------------------------------------------------------------------------
+
+# Stack identifier → RUNTIME FAMILY. Same reasoning as `_RUNTIME_FAMILY` above,
+# applied to the stack ontology instead of file extensions: a Kotlin framework
+# named in a Java headline is ONE program (same runtime, direct interop), while a
+# Java framework named in a .NET headline is a different one. Stacks absent here
+# are deliberately unjudgeable: an unknown stack can never prove a contradiction.
+_STACK_FAMILY: dict[str, str] = {
+    "java": "jvm", "kotlin": "jvm", "scala": "jvm", "groovy": "jvm",
+    "nodejs": "js", "deno": "js", "bun": "js",
+    "python": "python",
+    "go": "go",
+    "rust": "rust",
+    "ruby": "ruby",
+    "dotnet": "dotnet",
+    "php": "php",
+    "swift": "swift",
+    "dart": "dart",
+    "elixir": "beam", "erlang": "beam",
+}
+
+# Project types that are SUPPOSED to span runtimes — their headline names a tier
+# split, so a framework from another runtime is the point, not a contradiction.
+# Same carve-out (and same names) as `_CROSS_RUNTIME_PATTERNS` for layer claims.
+_CROSS_RUNTIME_TYPES = _CROSS_RUNTIME_PATTERNS
+
+# Project types DRIVEN by framework presence: `_classify_project_type` pools
+# frameworks across every stack to pick them, while a separate vote picks the
+# primary stack — so on a polyglot repo the type can be decided by one stack's
+# evidence and reported as another's. When the frameworks that drove the type are
+# all foreign to the primary, the type inherits their lie: the sentence
+# "C#/.NET rest api" is the same claim as "using JAX-RS", one clause shorter.
+# Lives here, not in a consumer: BOTH the headline and the confidence/gap surface
+# must judge this identically or the duplicated table lies again.
+_FRAMEWORK_DRIVEN_TYPES: frozenset[str] = frozenset({
+    "api", "webapp", "web_mvc", "angular-spa",
+})
+
+
+def framework_owner_stacks(stacks) -> dict[str, frozenset[str]]:
+    """{framework name -> stack ids that declare it} — the ownership view.
+
+    Ownership is already structural: a FrameworkDetection is discovered inside a
+    StackDetection's manifests, so which runtime a framework belongs to is
+    evidence the detector recorded, never a name lookup (VAI-safe — no rule here
+    branches on what the framework is called).
+    """
+    out: dict[str, set[str]] = {}
+    for stack in stacks or []:
+        sid = getattr(stack, "stack", "") or ""
+        if not sid:
+            continue
+        for fw in getattr(stack, "frameworks", None) or []:
+            name = getattr(fw, "name", "") or ""
+            if name:
+                out.setdefault(name, set()).add(sid)
+    return {name: frozenset(ids) for name, ids in out.items()}
+
+
+def framework_owner_families(stacks) -> dict[str, frozenset[str]]:
+    """{framework name -> runtime families that declare it} — the ownership view."""
+    return {
+        name: frozenset(
+            fam for sid in ids if (fam := _STACK_FAMILY.get(sid)) is not None
+        )
+        for name, ids in framework_owner_stacks(stacks).items()
+    }
+
+
+def _rule_framework_stack_attestation(
+    claimed_family: str | None,
+    owner_families: dict[str, frozenset[str]],
+) -> list[ReconciliationFinding]:
+    """A framework named in a headline is declared by no stack of the claimed runtime.
+
+    The headline describes ONE program: it welds a stack label ("C#/.NET") to the
+    frameworks found anywhere in the repo. On a polyglot repository those can be
+    different programs, and the sentence asserts a relationship the evidence
+    denies — the confluent examples repo read "C#/.NET rest api using JAX-RS",
+    attributing a JVM-only framework, declared by a Java stack in one
+    sub-workspace, to a .NET primary that declares no framework at all.
+
+    Fires only when ownership is PROVEN and disjoint: the framework has at least
+    one known owning family and the claimed family is not among them. An unknown
+    stack, or a framework no stack claims, yields nothing.
+    """
+    if not claimed_family:
+        return []
+    foreign = sorted(
+        name for name, fams in owner_families.items()
+        if fams and claimed_family not in fams
+    )
+    if not foreign:
+        return []
+    others = sorted({fam for name in foreign for fam in owner_families[name]})
+    return [
+        ReconciliationFinding(
+            rule="framework_stack_attestation",
+            symbols=tuple(foreign),
+            # Sink-neutral: this detail is read by a prose surface AND by a
+            # structured gap, so it states the contradiction, never "the
+            # headline says…" — the headline may already have dropped the claim.
+            detail=(
+                f"{len(foreign)} framework(s) are declared only by "
+                f"{', '.join(others)} stack(s), not by the {claimed_family} "
+                "primary stack — attributing them to it describes two separate "
+                "programs as one."
+            ),
+        )
+    ]
+
+
+def reconcile_headline_evidence(
+    *,
+    claimed_stack: str,
+    project_type: str | None,
+    stacks,
+) -> list[ReconciliationFinding]:
+    """Run headline reconciliation rules. Never raises.
+
+    Args:
+        claimed_stack: stack id the headline's label is built from (the primary).
+        project_type:  claimed type — cross-runtime types are exempt, their
+                       headline is MEANT to name another tier's framework.
+        stacks:        every StackDetection, each owning its own frameworks.
+    """
+    if project_type in _CROSS_RUNTIME_TYPES:
+        return []
+    findings: list[ReconciliationFinding] = []
+    try:
+        findings.extend(
+            _rule_framework_stack_attestation(
+                _STACK_FAMILY.get(claimed_stack or ""),
+                framework_owner_families(stacks),
+            )
+        )
+    except Exception:
+        pass
+    return findings
+
+
+def type_claim_unattested(
+    *, claimed_stack: str, project_type: str | None, stacks
+) -> bool:
+    """True when a framework-driven type label rests ONLY on foreign evidence.
+
+    The sibling of `_rule_framework_stack_attestation` for the type clause: the
+    frameworks that decided `project_type` are declared, every one of them, by
+    stacks of another runtime. The narrative consumer degrades the sentence; the
+    confidence consumer records the gap — same judgement, two sinks, one table.
+
+    Provable only: silent when the type is not framework-driven, when the claimed
+    stack's runtime is unknown, or when no framework is owned at all.
+    """
+    try:
+        if project_type not in _FRAMEWORK_DRIVEN_TYPES:
+            return False
+        family = _STACK_FAMILY.get(claimed_stack or "")
+        if not family:
+            return False
+        owners = framework_owner_families(stacks)
+        if not owners:
+            return False
+        return not any(family in fams for fams in owners.values())
+    except Exception:
+        return False
+
+
+def unattested_frameworks(
+    claimed_stack: str, project_type: str | None, stacks
+) -> frozenset[str]:
+    """Framework names the claimed stack does not attest (convenience view)."""
+    out: set[str] = set()
+    for f in reconcile_headline_evidence(
+        claimed_stack=claimed_stack, project_type=project_type, stacks=stacks
+    ):
+        out.update(f.symbols)
+    return frozenset(out)
+
+
 def reconcile_extraction_evidence(
     *,
     type_decl_files: frozenset[str],

sourcecode/ris.py

@@ -29,7 +29,7 @@ import subprocess
 from dataclasses import asdict, dataclass
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Optional
+from typing import Any, Optional
 
 RIS_SCHEMA_VERSION: str = "1.0"
 _RIS_FILENAME: str = "ris.json.gz"
@@ -107,9 +107,46 @@ def save_ris(repo_root: Path, ris: RepositoryIntelligenceSnapshot) -> None:
 # Data extraction from L1 core_dict
 # ---------------------------------------------------------------------------
 
+def _entrypoint_paths(raw: Any) -> list[str]:
+    """Normalize agent_view's `entry_points` to the file paths RIS promises.
+
+    `structural_map["entrypoints"]` is consumed as a list of path STRINGS (it is
+    sliced, and every reader guards with `isinstance(fp, str)`), but agent_view
+    emits that key in two different shapes under one schema_version:
+
+        {"bootstrap": [path, …], "security": […], "controllers": {counts}}
+            when a bootstrap/security entry point was detected (Spring, …)
+        [{"path": …, "kind": …}, …]
+            otherwise
+
+    Storing either verbatim broke BOTH readers: the dict raised `KeyError` on
+    `entrypoints[:10]` — swallowed by a bare `except Exception`, silently
+    disabling the RIS fast path on exactly the Java/Spring repos it exists for —
+    and the list of dicts recovered zero paths, because a dict is not a `str`.
+
+    The shape drift itself is a separate schema question; normalizing here keeps
+    RIS's own contract true whichever shape it is handed, including plain paths.
+    """
+    if isinstance(raw, dict):
+        # Only bootstrap/security carry paths; `controllers` is a count summary.
+        out: list[str] = []
+        for key in ("bootstrap", "security"):
+            out.extend(p for p in (raw.get(key) or []) if isinstance(p, str))
+        return out
+    if isinstance(raw, list):
+        out = []
+        for item in raw:
+            if isinstance(item, str):
+                out.append(item)
+            elif isinstance(item, dict) and isinstance(item.get("path"), str):
+                out.append(item["path"])
+        return out
+    return []
+
+
 def _extract_structural_map(agent_data: dict) -> dict:
     """Extract structural map from agent_view output."""
-    entry_points = agent_data.get("entry_points", [])
+    entry_points = _entrypoint_paths(agent_data.get("entry_points", []))
 
     layers = []
     domains = []

{sourcecode-2.5.6.dist-info → sourcecode-2.5.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 2.5.6
+Version: 2.5.8
 Summary: Persistent structural context and ultra-fast repeated analysis for AI coding agents
 License-File: LICENSE
 Keywords: agents,ai,codebase,context,developer-tools,llm

{sourcecode-2.5.6.dist-info → sourcecode-2.5.8.dist-info}/RECORD

@@ -1,8 +1,8 @@
-sourcecode/__init__.py,sha256=vjtgJnZwnfESbFdca_Oeq9DtPkuQkSn7b-N3LsiDp78,308
+sourcecode/__init__.py,sha256=_NfSfXuUp-msE-TND4uH-8TBeVxxl6h_wE6eoRCY_E8,308
 sourcecode/adaptive_scanner.py,sha256=XffluXKzJUXrMtjEiAOnSNPZnztdIcts17T9ouHeID0,10521
 sourcecode/archetype.py,sha256=d7yoN6Tj4OBj-VgSMPEKg4WF9H8FypnZ5A6AkUh5oIE,34484
 sourcecode/architecture_analyzer.py,sha256=1CEIeFtuxdzeFaeUtA5QuDmFkb5eilUK8zRmk9tcDxc,55644
-sourcecode/architecture_summary.py,sha256=pkl6lIOnSy-poa9EzW43U0MkXhx2FDfAFh8pDXLpcTo,26630
+sourcecode/architecture_summary.py,sha256=oBkjx7hZxmpdKLt4EracjRKHJFOGuPTd6SadTyPxY7Q,29568
 sourcecode/ast_extractor.py,sha256=FEsYTsMCXbJfSYQZRk1k-I-PjUNGnKqO1IxMftsgA5U,51351
 sourcecode/cache.py,sha256=1V3vsaODAa2UBJAC0xpvxpmRdriCezQx5Q8JCcfgziE,31892
 sourcecode/call_surface.py,sha256=fiqYfHooxN1fX9oQoysq1LS3LoZcobhyUNjAGEZKpwk,4148
@@ -12,7 +12,7 @@ sourcecode/cir_graphs.py,sha256=9G0HHj1kw2325IDyzo2OpX73BNswEckecf4MZUXB4JM,1207
 sourcecode/classifier.py,sha256=9olDN5joeKHcwG9vf73X-t_son16hLVNib0rBbqk1vc,18865
 sourcecode/cli.py,sha256=46Chp0JsEWD_j0HUWOx4tOhrsXSWgWV8JhL5G8SyW4I,322078
 sourcecode/code_notes_analyzer.py,sha256=EJemNCNc9Dn-1RZYu-aNbK0ELzmsyC4s6FdHi3XyNEI,9392
-sourcecode/confidence_analyzer.py,sha256=_jckZSxksV-OU38vbkxfVNBnWCtlCq8Vwfg23x1uspA,19054
+sourcecode/confidence_analyzer.py,sha256=KCRg8B4WH15LpOB7oYhE4dD5nou9Xi48RT3vpaO6Ar4,20868
 sourcecode/context_cache.py,sha256=maws79rLKDwyZ7c9Q2LwlIxqZHRFlaKzErtO3mglWoA,25036
 sourcecode/context_graph.py,sha256=WFtUvfxoE8XtQxtRJLvaF4SJuS00ICjNoTk0sH2_V5U,44454
 sourcecode/context_scorer.py,sha256=QpChSpsmaAYz91rXA4Ue5xzQmNz_ZboZN09YOHScq1U,14679
@@ -51,13 +51,13 @@ sourcecode/pr_impact.py,sha256=dCDVw83EDbyVf6F9ZmEQmsFz8ruVH7d4mpeKQCIZHM0,16805
 sourcecode/prepare_context.py,sha256=PYygAKL_jwz8gGElgM9mroUSih18UKSSjv08ndfl4aA,222877
 sourcecode/progress.py,sha256=qn30sWaHOkjTgXsSBmiPkz7Rsbwc5oSlIe6JNEMYp_k,3149
 sourcecode/ranking_engine.py,sha256=ZAucq_YX2KkWUuAZf4P0lhtQ_38vEFnUhuGtSZd1S0E,12970
-sourcecode/reconciliation.py,sha256=j3PctM_9FlaAV_OQ5_LjNhuZCehJ-XIwLo_iQbRQKTo,18335
+sourcecode/reconciliation.py,sha256=Ulmo4cNgeBnS1KxWv7kKFkXkwgJaQ70P0x6zC4F0I_I,26342
 sourcecode/redactor.py,sha256=SB4hwIvg8h-hvcqKcDWaZvA-aSyn-at-BIRwa0tUv5E,3227
 sourcecode/relevance_scorer.py,sha256=0AgEt4KrV73nioMqBgjhGjtY7L2C7L7cSyKtj3IKcrw,9408
 sourcecode/rename_refactor.py,sha256=h6dNFlB9aZ_3q6heeHBkgXQeXaT03nvPSsYH6P8qxFg,12965
 sourcecode/repo_classifier.py,sha256=FG1vaWKdWXsWdl-S8hjVMiTqcwgaRXkDyvK4rPcOGtQ,22681
 sourcecode/repository_ir.py,sha256=F6lRgPoP8oTtnGpRgjoLw-dlxZRXH7XOcehtcNwufEY,309550
-sourcecode/ris.py,sha256=aG2D4159gtpg968yD3PylYbIXhGFOwIlFBI0DSr84yY,20412
+sourcecode/ris.py,sha256=Hw8TakTQ6hku-Abf2k8954NwkrH_sP73_8wVH8x5khc,22079
 sourcecode/runtime_classifier.py,sha256=uTAD6BDCiBLUZEDRfqk718kM4RTT_vAbfkcOI2_Xx58,18432
 sourcecode/scanner.py,sha256=WdOQ78mMzjR1NjmKTlbxdgwinnCTfAhxCVLBEFQiFHU,8899
 sourcecode/schema.py,sha256=aHNXDf8LGyUC8ZDE_VS9kiskC2-Oswhi_WnpdGy6HDw,24897
@@ -137,8 +137,8 @@ sourcecode/telemetry/consent.py,sha256=LIAO9ohJZF8OuZwM4u1VWtALlYfTCCKq4wV3Vwc7i
 sourcecode/telemetry/events.py,sha256=LtzYfaX9Ilckj5PTvAcTpDa9mLqDsYPDUiDkRa58piY,2580
 sourcecode/telemetry/filters.py,sha256=NHa5T-6DaZduQPFuC34jOqHWQgSizM-Ygq8aZ4j19ng,5834
 sourcecode/telemetry/transport.py,sha256=4gGHsq0WeY9VywEZXA3vUxykfiYnw9uuqfjAAec7F8o,1681
-sourcecode-2.5.6.dist-info/METADATA,sha256=MW8dYaMUIriCSIBFCDunGYxcxAK0p_0WF1fQHY4jidE,10851
-sourcecode-2.5.6.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-2.5.6.dist-info/entry_points.txt,sha256=-JEAdChrK5We51kZcb7OaDcyil-dHBjBPL-NhuO-QY8,89
-sourcecode-2.5.6.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
-sourcecode-2.5.6.dist-info/RECORD,,
+sourcecode-2.5.8.dist-info/METADATA,sha256=woc6vFFAaDW8k2ZxGcFwNar-lnPjeWZA15ZhMjSZBz8,10851
+sourcecode-2.5.8.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-2.5.8.dist-info/entry_points.txt,sha256=-JEAdChrK5We51kZcb7OaDcyil-dHBjBPL-NhuO-QY8,89
+sourcecode-2.5.8.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
+sourcecode-2.5.8.dist-info/RECORD,,