cyvest 0.1.0__py3-none-any.whl → 5.1.3__py3-none-any.whl

cyvest/builder.py

@@ -1,182 +0,0 @@
-from __future__ import annotations
-
-import threading
-from collections.abc import Iterable, Sequence
-from contextlib import AbstractContextManager
-from dataclasses import dataclass
-from typing import Any
-
-from .models import ContainableSLM, Container, Level, ResultCheck, Scope
-from .visitors import Report
-
-
-@dataclass
-class _ContainerNode:
-    container: Container
-
-
-class _ContainerContext(AbstractContextManager["BuilderContainerProxy"]):
-    def __init__(self, builder: ReportBuilder, node: _ContainerNode) -> None:
-        self._builder = builder
-        self._node = node
-
-    def __enter__(self) -> BuilderContainerProxy:
-        self._builder._enter_container(self._node)
-        return BuilderContainerProxy(self._builder, self._node)
-
-    def __exit__(self, exc_type, exc, exc_tb) -> None:
-        self._builder._exit_container(self._node)
-
-
-class BuilderContainerProxy:
-    def __init__(self, builder: ReportBuilder, node: _ContainerNode) -> None:
-        self._builder = builder
-        self._node = node
-
-    def add_check(
-        self,
-        path: str,
-        *,
-        identifier: str | None = None,
-        description: str | None = None,
-        level: Level = Level.INFO,
-        score: float = 0.0,
-        details: dict | None = None,
-        observable_chain: Sequence[dict[str, Any]] | None = None,
-    ) -> ResultCheck:
-        return self._builder.add_check(
-            path,
-            scope=self._node.container.scope,
-            identifier=identifier,
-            description=description,
-            level=level,
-            score=score,
-            details=details,
-            observable_chain=observable_chain,
-        )
-
-    def add_existing(self, node: ContainableSLM) -> ContainableSLM:
-        return self._builder.add_existing(node)
-
-    def container(
-        self,
-        path: str,
-        *,
-        scope: Scope | None = None,
-        description: str | None = None,
-        identifier: str | None = None,
-        level: Level = Level.INFO,
-        details: dict | None = None,
-    ) -> _ContainerContext:
-        container_scope = scope or self._node.container.scope
-        return self._builder.container(
-            path,
-            scope=container_scope,
-            description=description,
-            identifier=identifier,
-            level=level,
-            details=details,
-        )
-
-
-class ReportBuilder:
-    """Helper for constructing reports with nested containers and checks."""
-
-    def __init__(self, report: Report | None = None, *, graph: bool = False) -> None:
-        self.report: Report = report or Report(graph=graph)
-        self._stack: list[_ContainerNode] = []
-        self._roots: list[ContainableSLM] = []
-        self._lock = threading.RLock()
-
-    def container(
-        self,
-        path: str,
-        *,
-        scope: Scope,
-        description: str | None = None,
-        identifier: str | None = None,
-        level: Level = Level.INFO,
-        details: dict | None = None,
-    ) -> _ContainerContext:
-        container = Container(
-            path,
-            scope=scope,
-            identifier=identifier,
-            description=description,
-            score=0.0,
-            level=level,
-            details=details,
-        )
-        node = _ContainerNode(container)
-        return _ContainerContext(self, node)
-
-    def add_check(
-        self,
-        path: str,
-        *,
-        scope: Scope | None = None,
-        identifier: str | None = None,
-        description: str | None = None,
-        level: Level = Level.INFO,
-        score: float = 0.0,
-        details: dict | None = None,
-        observable_chain: Sequence[dict[str, Any]] | None = None,
-    ) -> ResultCheck:
-        with self._lock:
-            check_scope = scope
-            if check_scope is None:
-                if not self._stack:
-                    raise ValueError("Scope must be provided when adding a check outside a container context")
-                check_scope = self._stack[-1].container.scope
-            result_check = ResultCheck.create(
-                path,
-                scope=check_scope,
-                identifier=identifier,
-                description=description,
-                level=level,
-                score=score,
-                details=details,
-            )
-            if self._stack:
-                self._stack[-1].container.contain(result_check)
-            else:
-                self._roots.append(result_check)
-        if observable_chain:
-            result_check.add_observable_chain(observable_chain)
-        return result_check
-
-    def build(self) -> Report:
-        with self._lock:
-            roots = list(self._roots)
-            self._roots.clear()
-        for root in roots:
-            root.accept(self.report)
-        return self.report
-
-    def add_existing(self, node: ContainableSLM) -> ContainableSLM:
-        with self._lock:
-            if self._stack:
-                self._stack[-1].container.contain(node)
-            else:
-                self._roots.append(node)
-        return node
-
-    def extend_existing(self, nodes: Iterable[ContainableSLM]) -> None:
-        for node in nodes:
-            self.add_existing(node)
-
-    # Internal helpers -------------------------------------------------
-    def _enter_container(self, node: _ContainerNode) -> None:
-        with self._lock:
-            if self._stack:
-                parent = self._stack[-1].container
-                parent.contain(node.container)
-            else:
-                self._roots.append(node.container)
-            self._stack.append(node)
-
-    def _exit_container(self, node: _ContainerNode) -> None:
-        with self._lock:
-            if not self._stack or self._stack[-1] is not node:
-                raise RuntimeError("Container context stack is inconsistent")
-            self._stack.pop()

cyvest/check_tree.py

@@ -1,117 +0,0 @@
-from __future__ import annotations
-
-from collections import OrderedDict, defaultdict
-from collections.abc import Iterable
-
-from .models import ContainableSLM, Container, Level, ResultCheck
-
-
-class CheckTree:
-    """Canonical structure that stores containers/result checks and keeps their scores in sync."""
-
-    def __init__(self) -> None:
-        self._nodes: dict[str, ContainableSLM] = {}
-        self._roots: dict[str, OrderedDict[str, ContainableSLM]] = defaultdict(OrderedDict)
-
-    def integrate_container(self, container: Container) -> Container:
-        return self._integrate_container(container, seen=set())
-
-    def integrate_result_check(self, result_check: ResultCheck) -> ResultCheck:
-        return self._integrate_result_check(result_check, seen=set())
-
-    def _integrate_container(self, container: Container, seen: set[int]) -> Container:
-        if id(container) in seen:
-            existing = self._nodes.get(container.full_key)
-            if isinstance(existing, Container):
-                return existing
-        seen.add(id(container))
-        parent = container.parent
-        if parent is not None:
-            parent = self._integrate_container(parent, seen)
-            container.set_parent(parent)
-        key = container.full_key
-        existing = self._nodes.get(key)
-        if isinstance(existing, Container):
-            existing.merge_from(container)
-            target = existing
-        else:
-            target = container
-            self._nodes[key] = target
-            if target.parent is not None:
-                target.parent.attach_child(target)
-            else:
-                root_scope = target.scope.name if target.scope else "GLOBAL"
-                self._roots[root_scope][key] = target
-        # integrate children
-        for child in list(container.children):
-            if isinstance(child, Container):
-                child.set_parent(target)
-                self._integrate_container(child, seen)
-            else:
-                child.set_parent(target)
-                self._integrate_result_check(child, seen)
-        target.recompute()
-        self._recompute_upwards(target.parent)
-        return target
-
-    def _integrate_result_check(self, result_check: ResultCheck, seen: set[int]) -> ResultCheck:
-        if id(result_check) in seen:
-            existing = self._nodes.get(result_check.full_key)
-            if isinstance(existing, ResultCheck):
-                return existing
-        seen.add(id(result_check))
-        parent = result_check.parent
-        if parent is not None:
-            parent = self._integrate_container(parent, seen)
-            result_check.set_parent(parent)
-        key = result_check.full_key
-        existing = self._nodes.get(key)
-        if isinstance(existing, ResultCheck):
-            existing.merge_from(result_check)
-            target = existing
-        else:
-            target = result_check
-            self._nodes[key] = target
-            if target.parent is not None:
-                target.parent.attach_child(target)
-            else:
-                scope_name = target.scope.name if target.scope else "GLOBAL"
-                self._roots[scope_name][key] = target
-        self._recompute_upwards(target.parent)
-        return target
-
-    def _recompute_upwards(self, node: Container | None) -> None:
-        current = node
-        while current is not None:
-            current.recompute()
-            current = current.parent
-
-    def get(self, full_key: str) -> ContainableSLM | None:
-        return self._nodes.get(full_key)
-
-    def total_score(self) -> float:
-        return sum(node.score for node in self._nodes.values() if isinstance(node, ResultCheck))
-
-    def highest_level(self) -> Level:
-        highest = Level.INFO
-        for node in self._nodes.values():
-            if node.level > highest:
-                highest = node.level
-        return highest
-
-    def result_checks(self) -> Iterable[ResultCheck]:
-        for node in self._nodes.values():
-            if isinstance(node, ResultCheck):
-                yield node
-
-    def containers(self) -> Iterable[Container]:
-        for node in self._nodes.values():
-            if isinstance(node, Container):
-                yield node
-
-    def roots_for_scope(self, scope_name: str) -> list[ContainableSLM]:
-        return list(self._roots.get(scope_name, {}).values())
-
-    def iter_roots(self) -> Iterable[tuple[str, list[ContainableSLM]]]:
-        for scope_name, nodes in self._roots.items():
-            yield scope_name, list(nodes.values())