sourcecode 1.31.7__py3-none-any.whl → 1.31.8__py3-none-any.whl

sourcecode/__init__.py

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

sourcecode/architecture_analyzer.py

@@ -330,7 +330,7 @@ class ArchitectureAnalyzer:
                     tentative = True
                 if not _hard_evidence:
                     limitations.append(
-                        "Pattern not confirmed by module import graph; run with --graph-modules for structural validation"
+                        "Pattern inferred from directory structure; import graph not available — structural dependency direction unverified"
                     )
                 if not _hard_evidence:
                     matched_dirs = sorted({

sourcecode/cli.py

@@ -836,6 +836,7 @@ def main(
         code_notes = True
         no_tree = True  # agents never need the raw file tree
         architecture = True  # agents need full architectural signal (M4)
+        graph_modules = True  # IC-003: import graph needed for architecture confidence
 
     # ── GAP-9: Cache check — serve from .sourcecode-cache when git SHA unchanged ──
     import hashlib as _hashlib

sourcecode/prepare_context.py

@@ -1212,6 +1212,41 @@ class TaskContextBuilder:
                 symptom=symptom if task_name == "fix-bug" else None,
             )
 
+        # ── IC-006: fix-bug suspected_areas — recompute from ranked files + bug notes ──
+        # relevant_files is now ranked by RankingEngine (git churn, fan_in, centrality, notes).
+        # suspected_areas should reflect that ranking, not raw comment count.
+        if task_name == "fix-bug" and relevant_files:
+            _bug_kinds = {"FIXME", "BUG", "HACK", "XXX"}
+            _bug_counts: dict[str, int] = {}
+            for _note in cn_notes_for_ranking:
+                if _note.kind in _bug_kinds:
+                    _bug_counts[_note.path] = _bug_counts.get(_note.path, 0) + 1
+
+            # Primary: top-ranked RelevantFile objects (dataclass, use .path/.reason)
+            _ranked_paths = [rf.path for rf in relevant_files[:30]]
+            _primary: list[str] = []
+            for rf in relevant_files[:30]:
+                p = rf.path
+                if not p:
+                    continue
+                n = _bug_counts.get(p, 0)
+                reason_str = str(rf.reason) if rf.reason else ""
+                note_str = f" ({n} bug annotation{'s' if n > 1 else ''})" if n else ""
+                _primary.append(f"{p}{note_str}" + (f" — {reason_str}" if reason_str else ""))
+                if len(_primary) >= 5:
+                    break
+
+            # Secondary: remaining high-note files not already in primary
+            _ranked_set = set(_ranked_paths[:len(_primary)])
+            _secondary = [
+                f"{p} ({n} annotation{'s' if n > 1 else ''})"
+                for p, n in sorted(_bug_counts.items(), key=lambda x: -x[1])
+                if p not in _ranked_set
+            ][:3]
+
+            if _primary or _secondary:
+                suspected_areas = _primary + _secondary
+
         # ── 6b. review-pr: derive PR-specific impact sections from delta analysis ──
         _pr_security_impact: dict = {}
         _pr_transactional_impact: dict = {}

sourcecode/repository_ir.py

@@ -1537,6 +1537,18 @@ def _assemble(
             by_type.setdefault(e.type, []).append(e.from_symbol)
         reverse_graph_out[target] = by_type
 
+    # IC-005: aggregate event flow edges already built in _build_relations
+    _listen_edges = [e for e in sorted_rels if e.type == "listens_to_event"]
+    _publish_edges = [e for e in sorted_rels if e.type == "publishes_event"]
+    _spring_events: Optional[dict] = None
+    if _listen_edges or _publish_edges:
+        _spring_events = {
+            "listeners": sorted({e.from_symbol for e in _listen_edges}),
+            "publishers": sorted({e.from_symbol for e in _publish_edges}),
+            "event_types": sorted({e.to_symbol for e in _listen_edges + _publish_edges}),
+            "flow_count": len(_listen_edges) + len(_publish_edges),
+        }
+
     return {
         "schema_version": "final-v1",
         "graph": {
@@ -1558,7 +1570,11 @@ def _assemble(
         },
         "subsystems": subsystems,
         "change_set": change_set_out,
-        "route_surface": _build_route_surface(sorted_syms, route_diffs),
+        "route_surface": _build_route_surface(sorted_syms, route_diffs, extends_map={
+            e.from_symbol: e.to_symbol.split(".")[-1]
+            for e in sorted_rels if e.type == "extends"
+        }),
+        **({"spring_events": _spring_events} if _spring_events else {}),
         "audit": {
             "dropped_fields": dropped_fields,
         },
@@ -1569,30 +1585,119 @@ def _assemble(
 # Route surface helper (Fix 4)
 # ---------------------------------------------------------------------------
 
-def _build_route_surface(symbols: list[SymbolRecord], route_diffs: Optional[list[dict]]) -> list[dict]:
-    """Return route surface: diffs when --since provided, else static snapshot of all endpoints."""
+def _build_route_surface(
+    symbols: list[SymbolRecord],
+    route_diffs: Optional[list[dict]],
+    extends_map: Optional[dict[str, str]] = None,
+) -> list[dict]:
+    """Return route surface with inheritance projection.
+
+    extends_map: child_fqn → parent_simple_name derived from RelationEdge extends edges.
+    Projects inherited endpoints onto subclasses that have a class-level @RequestMapping
+    prefix but zero own method-level endpoints (IC-001 fix).
+    """
     if route_diffs:
         return route_diffs
+
+    # Phase 1: build per-class metadata (prefix) and own endpoint list
+    class_info: dict[str, dict] = {}  # simple_name → {fqn, prefix, own_endpoints}
+    for sym in symbols:
+        if sym.type not in ("class", "interface"):
+            continue
+        simple = sym.symbol.split(".")[-1]
+        prefix = ""
+        if "@RequestMapping" in sym.annotations:
+            args = sym.annotation_values.get("@RequestMapping", "")
+            prefix = _parse_route_path(args)
+        class_info[simple] = {"fqn": sym.symbol, "prefix": prefix, "own_endpoints": []}
+
     routes: list[dict] = []
+    seen: set[tuple] = set()
+
+    # Phase 2: emit own endpoint symbols and record them per class
     for sym in symbols:
         if sym.symbol_kind != "endpoint":
             continue
         ann_name = next((a for a in sym.annotations if a in _ENDPOINT_ANNOTATIONS), None)
         if not ann_name:
             continue
+        cls_fqn = _enclosing_class(sym.symbol)
+        cls_simple = cls_fqn.split(".")[-1]
         args = sym.annotation_values.get(ann_name, "")
-        path = _parse_route_path(args)
-        method = _parse_route_http_method(ann_name, args)
-        if not path and not method:
-            continue
-        routes.append({
-            "symbol": sym.symbol,
-            "controller": _enclosing_class(sym.symbol),
-            "path": path,
-            "method": method or "GET",
-            "stable_id": sym.stable_id,
-        })
-    return sorted(routes, key=lambda r: (r["controller"], r["path"]))
+        suffix = _parse_route_path(args)
+        method = _parse_route_http_method(ann_name, args) or "GET"
+
+        if cls_simple in class_info:
+            class_info[cls_simple]["own_endpoints"].append(
+                (method, suffix, sym.symbol, sym.stable_id)
+            )
+
+        prefix = class_info.get(cls_simple, {}).get("prefix", "")
+        full_path = (prefix + "/" + suffix).replace("//", "/").rstrip("/") or "/"
+        if not full_path.startswith("/"):
+            full_path = "/" + full_path
+
+        key = (sym.symbol, method, prefix)
+        if key not in seen:
+            seen.add(key)
+            routes.append({
+                "symbol": sym.symbol,
+                "controller": cls_fqn,
+                "declaring_class": cls_fqn,
+                "effective_class": cls_fqn,
+                "path": full_path,
+                "method": method,
+                "stable_id": sym.stable_id,
+                "inheritance_depth": 0,
+            })
+
+    # Phase 3: inheritance projection — subclasses with zero own endpoints
+    # but with a class-level @RequestMapping prefix inherit parent methods.
+    if extends_map:
+        fqn_to_simple: dict[str, str] = {d["fqn"]: s for s, d in class_info.items()}
+        simple_extends: dict[str, str] = {
+            fqn_to_simple.get(child_fqn, child_fqn.split(".")[-1]): parent_simple
+            for child_fqn, parent_simple in extends_map.items()
+        }
+
+        for cls_simple, data in class_info.items():
+            if data["own_endpoints"]:
+                continue
+            if not data["prefix"]:
+                continue
+
+            chain = simple_extends.get(cls_simple)
+            visited: set[str] = {cls_simple}
+            depth = 1
+            while chain and chain not in visited:
+                visited.add(chain)
+                parent = class_info.get(chain)
+                if not parent:
+                    break
+                if parent["own_endpoints"]:
+                    for verb, suffix, declaring_sym, stable_id in parent["own_endpoints"]:
+                        prefix = data["prefix"]
+                        full_path = (prefix + "/" + suffix).replace("//", "/").rstrip("/") or "/"
+                        if not full_path.startswith("/"):
+                            full_path = "/" + full_path
+                        key = (cls_simple, declaring_sym, verb, prefix)
+                        if key not in seen:
+                            seen.add(key)
+                            routes.append({
+                                "symbol": declaring_sym,
+                                "controller": data["fqn"],
+                                "declaring_class": parent["fqn"],
+                                "effective_class": data["fqn"],
+                                "path": full_path,
+                                "method": verb,
+                                "stable_id": stable_id,
+                                "inheritance_depth": depth,
+                            })
+                    break
+                chain = simple_extends.get(chain)
+                depth += 1
+
+    return sorted(routes, key=lambda r: (r["effective_class"], r["path"]))
 
 
 # ---------------------------------------------------------------------------
@@ -1803,7 +1908,7 @@ def apply_ir_size_limits(
 # Convenience: find Java files in a repo
 # ---------------------------------------------------------------------------
 
-def find_java_files(root: Path, *, max_files: int = 500) -> list[str]:
+def find_java_files(root: Path, *, max_files: int = 3000) -> list[str]:
     """Return relative paths to Java files under root, excluding test dirs and vendor."""
     results: list[str] = []
     for p in sorted(root.rglob("*.java")):

sourcecode/runtime_classifier.py

@@ -141,6 +141,11 @@ class RuntimeClassifier:
                 raw.append((ws_path, self._load_pkg_json(pkg_root)))
 
         fan_in = self._compute_fan_in(raw)
+        # IC-004: merge Maven pom.xml cross-module fan_in when no JS deps detected
+        maven_fan_in = self._compute_maven_fan_in(root, workspace_paths)
+        for ws_path, count in maven_fan_in.items():
+            fan_in[ws_path] = fan_in.get(ws_path, 0) + count
+
         results: list[MonorepoPackageInfo] = []
 
         for ws_path, pkg_json in raw:
@@ -280,6 +285,9 @@ class RuntimeClassifier:
                 scores["infrastructure_layer"] = scores.get("infrastructure_layer", 0) + fan_boost
 
         if not scores:
+            # IC-004: Java/Maven fallback — no JS signals but module may have a pom.xml
+            if not pkg_json:
+                return self._classify_maven_module(ws_path, name, fan_in)
             return "unknown", signals, "low"
 
         best_role = max(scores, key=lambda r: (scores[r], _ROLE_PRIORITY.get(r, 0)))
@@ -326,6 +334,76 @@ class RuntimeClassifier:
     def _criticality(self, role: str, fan_in: int) -> str:
         if role in {"runtime_core", "plugin_host"}:
             return "high"
-        if role in {"backend_runtime", "frontend_runtime", "composition_layer"} or fan_in >= 3:
+        # IC-004: infrastructure_layer with high fan_in = shared foundation = high criticality
+        if role == "infrastructure_layer" and fan_in >= 3:
+            return "high"
+        if role in {"backend_runtime", "frontend_runtime", "composition_layer",
+                    "infrastructure_layer"} or fan_in >= 3:
             return "medium"
         return "low"
+
+    def _compute_maven_fan_in(self, root: Path, workspace_paths: list[str]) -> dict[str, int]:
+        """IC-004: Compute cross-module fan_in from all pom.xml files under each workspace.
+
+        Scans all pom.xml files (top-level and sub-module) within each workspace path.
+        Counts distinct modules that declare a dependency containing another module's leaf name.
+        Uses 1 hit per source module (not per pom file) to avoid inflation.
+        """
+        fan_in: dict[str, int] = {}
+        leaf_to_path: dict[str, str] = {ws.split("/")[-1]: ws for ws in workspace_paths}
+
+        for ws_path in workspace_paths:
+            ws_dir = root / ws_path
+            if not ws_dir.is_dir():
+                continue
+            deps_found: set[str] = set()
+            for pom in ws_dir.rglob("pom.xml"):
+                if "target/" in str(pom):
+                    continue
+                try:
+                    content = pom.read_text(encoding="utf-8", errors="replace")
+                except OSError:
+                    continue
+                for dep_leaf, target_path in leaf_to_path.items():
+                    if target_path != ws_path and dep_leaf in content:
+                        deps_found.add(target_path)
+            for target_path in deps_found:
+                fan_in[target_path] = fan_in.get(target_path, 0) + 1
+
+        return fan_in
+
+    def _classify_maven_module(
+        self, ws_path: str, name: str, fan_in: int
+    ) -> tuple[str, list[str], str]:
+        """IC-004: Classify a Java/Maven module by path conventions and fan_in.
+
+        Called when no JS signals exist (no package.json). Uses path name patterns
+        and pom fan_in (cross-module dependency count) to determine role/criticality.
+        """
+        signals: list[str] = ["maven:module"]
+        leaf = ws_path.lower().rstrip("/").split("/")[-1]
+
+        if re.search(r"\b(common|shared|util|utils|lib|base|foundation)\b", leaf):
+            signals.append("maven:shared_library")
+            return "infrastructure_layer", signals, "high" if fan_in >= 3 else "medium"
+
+        if re.search(r"\b(integration|it|test|tests|e2e)\b", leaf):
+            signals.append("maven:test_module")
+            return "test_layer", signals, "low"
+
+        if re.search(r"\b(admin|web|api|rest|controller|ui)\b", leaf):
+            signals.append("maven:web_module")
+            return "backend_runtime", signals, "medium"
+
+        if re.search(r"\b(core|framework|domain|service|profile)\b", leaf):
+            signals.append("maven:core_module")
+            return "backend_runtime", signals, "high" if fan_in >= 2 else "medium"
+
+        if fan_in >= 3:
+            signals.append(f"maven:high_fan_in({fan_in})")
+            return "infrastructure_layer", signals, "high"
+        if fan_in >= 1:
+            signals.append(f"maven:fan_in({fan_in})")
+            return "infrastructure_layer", signals, "medium"
+
+        return "unknown", signals, "low"

sourcecode/serializer.py

@@ -379,6 +379,59 @@ def _spring_boot_version(sm: "SourceMap") -> "Optional[str]":
     return None
 
 
+def _spring_event_signal(sm: "SourceMap") -> "Optional[dict[str, Any]]":
+    """IC-005: Surface @EventListener and publishEvent from Java source files.
+
+    Scans sm.file_paths for Java files containing Spring event annotations.
+    Only runs on Java/Spring projects. Lightweight — path heuristics first,
+    then targeted content scan on candidate files only.
+    """
+    import re as _re
+    java_paths = [p for p in sm.file_paths if p.endswith(".java") and "target/" not in p]
+    if not java_paths:
+        return None
+    _frameworks = [f.name for s in (sm.stacks or []) for f in s.frameworks]
+    if not any("Spring" in fw for fw in _frameworks):
+        return None
+
+    analyzed_path = getattr(sm.metadata, "analyzed_path", None) if sm.metadata else None
+    root = Path(analyzed_path) if analyzed_path else None
+
+    listeners: list[str] = []
+    publishers: list[str] = []
+    event_types: set[str] = set()
+    _publish_re = _re.compile(r"\.publishEvent\s*\(\s*new\s+(\w+)")
+
+    for rel_path in java_paths:
+        if root is None:
+            break
+        try:
+            content = (root / rel_path).read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            continue
+        if "@EventListener" in content:
+            cls_m = _re.search(r"class\s+(\w+)", content)
+            cls_name = cls_m.group(1) if cls_m else Path(rel_path).stem
+            if cls_name not in listeners:
+                listeners.append(cls_name)
+        for m in _publish_re.finditer(content):
+            event_types.add(m.group(1))
+            cls_m = _re.search(r"class\s+(\w+)", content)
+            cls_name = cls_m.group(1) if cls_m else Path(rel_path).stem
+            if cls_name not in publishers:
+                publishers.append(cls_name)
+
+    if not listeners and not publishers:
+        return None
+
+    return {
+        "listeners": sorted(set(listeners))[:10],
+        "publishers": sorted(set(publishers))[:10],
+        "event_types": sorted(event_types)[:10],
+        "flow_count": len(listeners) + len(publishers),
+    }
+
+
 def _spring_profiles_context(sm: "SourceMap") -> "Optional[dict[str, Any]]":
     """Build structured spring_profiles block: detected names + per-profile file variants."""
     # Gather profile names from env_summary (populated by env_analyzer scanning
@@ -1949,6 +2002,11 @@ def agent_view(sm: SourceMap, *, full: bool = False) -> dict[str, Any]:
     if _txn:
         signals["transactional_boundaries"] = _txn
 
+    # IC-005: Spring event flows (@EventListener / publishEvent)
+    _evf = _spring_event_signal(sm)
+    if _evf:
+        signals["event_flows"] = _evf
+
     if signals:
         result["signals"] = signals
 

{sourcecode-1.31.7.dist-info → sourcecode-1.31.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 1.31.7
+Version: 1.31.8
 Summary: Deterministic codebase context for AI coding agents
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -225,7 +225,7 @@ Description-Content-Type: text/markdown
 
 **Deterministic, behavior-aware codebase context for AI agents and PR review.**
 
-![Version](https://img.shields.io/badge/version-1.31.7-blue)
+![Version](https://img.shields.io/badge/version-1.31.8-blue)
 ![Python](https://img.shields.io/badge/python-3.10%2B-green)
 
 ---
@@ -261,7 +261,7 @@ pipx install sourcecode
 
 ```bash
 sourcecode version
-# sourcecode 1.31.7
+# sourcecode 1.31.8
 ```
 
 ---

{sourcecode-1.31.7.dist-info → sourcecode-1.31.8.dist-info}/RECORD

@@ -1,10 +1,10 @@
-sourcecode/__init__.py,sha256=8R-nJsTbK4mRxB0Ix8W0xEdhYCBpK8R-2dyS_nBxiDc,103
+sourcecode/__init__.py,sha256=WLMYz2pzDdC0wqKacYMZ3CjPguJO9qdTzERPE9XQ_8c,103
 sourcecode/adaptive_scanner.py,sha256=XffluXKzJUXrMtjEiAOnSNPZnztdIcts17T9ouHeID0,10521
-sourcecode/architecture_analyzer.py,sha256=MyBa0Hf5HmkudZQDLKrjcWDKETXETXl0mQX1swtTwAA,39091
+sourcecode/architecture_analyzer.py,sha256=4R13Yb02OrPeB4IH3z6V_g7HWhmGcRHbI8CobCVnRrc,39111
 sourcecode/architecture_summary.py,sha256=z34_6v7cSwy98cof2UVciGho7SCrZ93tiqMmq5WNzRQ,20405
 sourcecode/ast_extractor.py,sha256=XgrZg2DcWcUm9r87cRG3KGO7IK2TIL_N-CvhSbUmmh4,49901
 sourcecode/classifier.py,sha256=-0t0HLc9L9UleMLfclfLM3AXhBjUb_AYyBPDbvgWtac,7755
-sourcecode/cli.py,sha256=L0KDRruMogpw9kq7trZ7dmWQuFC746GIEN1oym6LmCE,131802
+sourcecode/cli.py,sha256=paiZvANOzPPIznA7M90XSsaQd-F4B-jr0Nx9CpsQKz4,131891
 sourcecode/code_notes_analyzer.py,sha256=EJemNCNc9Dn-1RZYu-aNbK0ELzmsyC4s6FdHi3XyNEI,9392
 sourcecode/confidence_analyzer.py,sha256=ZUn-Nywi5TEQcuozqK_vfOyPT-a1dYYO42elAtVFV-k,16412
 sourcecode/context_scorer.py,sha256=QpChSpsmaAYz91rXA4Ue5xzQmNz_ZboZN09YOHScq1U,14679
@@ -23,18 +23,18 @@ sourcecode/graph_analyzer.py,sha256=iUK-7pSV-cvGqqD2hENdYmhnm0wcXFEyK-xnu5ul8OU,
 sourcecode/metrics_analyzer.py,sha256=m0ENgtqKeBL17kUIK3fmGkgo7UfXBNHxCMj0H_Y5K7c,22750
 sourcecode/path_filters.py,sha256=ROFRQ8eSLBEMiixK9f45-RO7um4VEEcjoD5AA4I427I,3739
 sourcecode/pr_comment_renderer.py,sha256=smHslxiG14lrytCkq5nFrFu-qTHgA-t-LFYfdrfjz2o,14423
-sourcecode/prepare_context.py,sha256=-9kTYuPhwr79mF6lNe9tI7glGAU_d84GyVurHceGroo,189427
+sourcecode/prepare_context.py,sha256=_bIelOcv1vdyffyv38NI_Acu7-YxWLA7o6kgaiasCbY,191161
 sourcecode/progress.py,sha256=qn30sWaHOkjTgXsSBmiPkz7Rsbwc5oSlIe6JNEMYp_k,3149
 sourcecode/ranking_engine.py,sha256=ZAucq_YX2KkWUuAZf4P0lhtQ_38vEFnUhuGtSZd1S0E,12970
 sourcecode/redactor.py,sha256=xuGcadGEHaPw4qZXlMDvzMCsr4VOkdp3oBQptHyJk8c,2884
 sourcecode/relevance_scorer.py,sha256=MYF4FFkveAQps9SmTeTlh6ODiBz2F--_hWNeHMLtUHQ,8405
 sourcecode/repo_classifier.py,sha256=FG1vaWKdWXsWdl-S8hjVMiTqcwgaRXkDyvK4rPcOGtQ,22681
-sourcecode/repository_ir.py,sha256=fLt33wadCMY77jd34YwkYbUT5TyNu2G0LX0x76Krsvo,68348
-sourcecode/runtime_classifier.py,sha256=zWX3r3HCKHc-qtIobErOa8aKMmaoPYREtJKvPcBGPjQ,14792
+sourcecode/repository_ir.py,sha256=haK4OuASLBH5zSDxxN-tdpLOGLfOIo7hRfDXMgjNiQ0,72961
+sourcecode/runtime_classifier.py,sha256=uTAD6BDCiBLUZEDRfqk718kM4RTT_vAbfkcOI2_Xx58,18432
 sourcecode/scanner.py,sha256=WdOQ78mMzjR1NjmKTlbxdgwinnCTfAhxCVLBEFQiFHU,8899
 sourcecode/schema.py,sha256=fj3BZ3IcnNV4j21BFIEvz8Qnw_vZoqIbzzRg-qQ-nd0,24530
 sourcecode/semantic_analyzer.py,sha256=12TwXYkYbDcBdu0heX_EmfPM2EkO8a_r5osf0SaeQbs,88956
-sourcecode/serializer.py,sha256=1y9DAkH2aBzlsmkHcSSc-t72_4fv9RZIuG4uhhGG5QE,111933
+sourcecode/serializer.py,sha256=upGg24ALEk9almaZeqyiGdritdd4F1bvR2-jr_dv3RM,114144
 sourcecode/summarizer.py,sha256=lPlKhMh28nueXkPo2xKeD3DUFYVGRlJMIdY-8TSM-ls,17486
 sourcecode/tree_utils.py,sha256=8GAkIfQAsvtEudIeW1l4ooH_oRtrWR8cpJQJsEa_Pfw,2093
 sourcecode/workspace.py,sha256=X_6NmNnitvT3_38V-JDChydo_sR68s249hLFlrQskU0,8271
@@ -73,8 +73,8 @@ sourcecode/telemetry/consent.py,sha256=wLMvGNJeSSyZoNkQXpoUioY6mMv4Qdvuw7S9jAEWn
 sourcecode/telemetry/events.py,sha256=oEvvulfsv5GIDWG2174gSS6tNB95w38AIYiYeifGKlE,2294
 sourcecode/telemetry/filters.py,sha256=Asa71oRl7q3Wt_FMwuufIZJFzSYdgRNKS8LHCIyFeYE,4805
 sourcecode/telemetry/transport.py,sha256=KJeIPCPWMdmbCP3ySGs2iUlia34U6vWne2dZsUezesw,1560
-sourcecode-1.31.7.dist-info/METADATA,sha256=O08_eBOxRxeDd8UkUKyIrW6haJHuQvAddgiFAEma0dQ,29083
-sourcecode-1.31.7.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-1.31.7.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
-sourcecode-1.31.7.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
-sourcecode-1.31.7.dist-info/RECORD,,
+sourcecode-1.31.8.dist-info/METADATA,sha256=s7Lh8sXmHkwJKe-pQUg9wbhf0Yrv8giYMOHYiaLp658,29083
+sourcecode-1.31.8.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-1.31.8.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
+sourcecode-1.31.8.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
+sourcecode-1.31.8.dist-info/RECORD,,