code-review-validator 0.1.0__py3-none-any.whl

code_review_validator/__init__.py

@@ -0,0 +1,92 @@
+"""Public SDK surface for code-review-validator."""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as _pkg_version
+
+from .client import AsyncClient, SyncClient
+from .errors import (
+    APIError,
+    AuthenticationError,
+    BadRequestError,
+    ConnectionError,
+    CryptoNotAvailableError,
+    PaymentRequiredError,
+    RateLimitError,
+    ServiceUnavailableError,
+    TimeoutError,
+    ValidatorError,
+)
+from .gate import GateCheck, GatePolicy, GateResult, check_contract, evaluate
+from .models import (
+    AttestationStatus,
+    EvidenceLevel,
+    Finding,
+    HealthResult,
+    OnChainStatus,
+    ReputationResult,
+    ReviewResult,
+    Severity,
+    StatsResult,
+    StatusResult,
+)
+
+try:
+    __version__ = _pkg_version("code-review-validator")
+except PackageNotFoundError:
+    __version__ = "0.1.0"
+
+try:
+    from ._verify import canonical_serialize, decrypt_findings, verify_response_hash
+except Exception as exc:  # pragma: no cover - exercised via fallback wrappers
+    _CRYPTO_IMPORT_ERROR = exc
+
+    def _raise_crypto_error() -> None:
+        raise CryptoNotAvailableError(
+            "Crypto helpers require optional dependencies. Install with [crypto]."
+        ) from _CRYPTO_IMPORT_ERROR
+
+    def canonical_serialize(data: dict) -> bytes:  # type: ignore[override]
+        _raise_crypto_error()
+
+    def verify_response_hash(ipfs_payload: dict, on_chain_hash: str) -> bool:  # type: ignore[override]
+        _raise_crypto_error()
+
+    def decrypt_findings(encrypted_payload: dict, private_key_hex: str) -> dict:  # type: ignore[override]
+        _raise_crypto_error()
+
+
+__all__ = [
+    "APIError",
+    "AsyncClient",
+    "AttestationStatus",
+    "AuthenticationError",
+    "BadRequestError",
+    "ConnectionError",
+    "CryptoNotAvailableError",
+    "EvidenceLevel",
+    "Finding",
+    "GateCheck",
+    "GatePolicy",
+    "GateResult",
+    "HealthResult",
+    "OnChainStatus",
+    "PaymentRequiredError",
+    "RateLimitError",
+    "ReputationResult",
+    "ReviewResult",
+    "ServiceUnavailableError",
+    "Severity",
+    "StatsResult",
+    "StatusResult",
+    "SyncClient",
+    "TimeoutError",
+    "ValidatorError",
+    "__version__",
+    "canonical_serialize",
+    "check_contract",
+    "decrypt_findings",
+    "evaluate",
+    "verify_response_hash",
+]

code_review_validator/_verify.py

@@ -0,0 +1,48 @@
+"""Optional crypto helpers for payload verification and decryption."""
+
+from __future__ import annotations
+
+import json
+
+from .errors import CryptoNotAvailableError
+
+
+def _normalize_hex(value: str) -> str:
+    return value.removeprefix("0x")
+
+
+def canonical_serialize(data: dict) -> bytes:
+    """Deterministic JSON encoding used for hashing."""
+    return json.dumps(data, sort_keys=True, separators=(",", ":")).encode()
+
+
+def verify_response_hash(ipfs_payload: dict, on_chain_hash: str) -> bool:
+    """Verify that payload hash matches on-chain response hash."""
+    try:
+        from web3 import Web3
+    except Exception as exc:
+        raise CryptoNotAvailableError(
+            "web3 is required for verify_response_hash. Install with [crypto]."
+        ) from exc
+
+    computed = Web3.keccak(canonical_serialize(ipfs_payload)).hex()
+    return _normalize_hex(computed).lower() == _normalize_hex(on_chain_hash).lower()
+
+
+def decrypt_findings(encrypted_payload: dict, private_key_hex: str) -> dict:
+    """Decrypt findings payload using a secp256k1 private key."""
+    try:
+        import ecies
+    except Exception as exc:
+        raise CryptoNotAvailableError(
+            "eciespy is required for decrypt_findings. Install with [crypto]."
+        ) from exc
+
+    encrypted_section = encrypted_payload.get("encrypted", encrypted_payload)
+    ciphertext_hex = encrypted_section.get("ciphertext")
+    if not isinstance(ciphertext_hex, str):
+        raise ValueError("encrypted payload is missing a hex ciphertext field")
+
+    ciphertext = bytes.fromhex(_normalize_hex(ciphertext_hex))
+    plaintext = ecies.decrypt(_normalize_hex(private_key_hex), ciphertext)
+    return json.loads(plaintext)

code_review_validator/client.py

@@ -0,0 +1,242 @@
+"""HTTP clients for the Code Review Validator API."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from .errors import (
+    APIError,
+    AuthenticationError,
+    BadRequestError,
+    ConnectionError,
+    PaymentRequiredError,
+    RateLimitError,
+    ServiceUnavailableError,
+    TimeoutError,
+    parse_error_detail,
+)
+from .models import HealthResult, ReputationResult, ReviewResult, StatsResult, StatusResult
+
+_DEFAULT_BASE_URL = "https://code-review-validator.fly.dev"
+
+
+def _extract_remaining_reviews(headers: httpx.Headers) -> int | None:
+    value = headers.get("X-API-Key-Remaining") or headers.get("X-Free-Tier-Remaining")
+    if value is None:
+        return None
+    try:
+        return int(value)
+    except ValueError:
+        return None
+
+
+def _retry_after(headers: httpx.Headers) -> int | None:
+    raw = headers.get("Retry-After")
+    if raw is None:
+        return None
+    try:
+        return int(raw)
+    except ValueError:
+        return None
+
+
+def _raise_for_response(response: httpx.Response) -> None:
+    if response.status_code < 400:
+        return
+
+    try:
+        payload = response.json()
+    except ValueError:
+        payload = None
+
+    fallback = response.text.strip() or "Request failed"
+    detail = parse_error_detail(payload, fallback)
+    status_code = response.status_code
+
+    if status_code == 400:
+        raise BadRequestError(status_code, detail, response)
+    if status_code == 401:
+        raise AuthenticationError(status_code, detail, response)
+    if status_code == 402:
+        raise PaymentRequiredError(status_code, detail, response)
+    if status_code == 429:
+        raise RateLimitError(
+            status_code,
+            detail,
+            response,
+            retry_after=_retry_after(response.headers),
+        )
+    if status_code == 503:
+        raise ServiceUnavailableError(status_code, detail, response)
+    if status_code == 504:
+        raise TimeoutError(detail)
+
+    raise APIError(status_code, detail, response)
+
+
+class AsyncClient:
+    """Async SDK client."""
+
+    def __init__(
+        self,
+        base_url: str = _DEFAULT_BASE_URL,
+        api_key: str | None = None,
+        timeout: float = 120.0,
+        _client: httpx.AsyncClient | None = None,
+    ) -> None:
+        self._owns_client = _client is None
+        if _client is None:
+            headers = {"X-API-Key": api_key} if api_key else None
+            self._client = httpx.AsyncClient(
+                base_url=base_url.rstrip("/"),
+                timeout=timeout,
+                headers=headers,
+            )
+        else:
+            self._client = _client
+            if api_key:
+                self._client.headers.setdefault("X-API-Key", api_key)
+
+    async def __aenter__(self) -> AsyncClient:
+        return self
+
+    async def __aexit__(self, exc_type: object, exc: object, tb: object) -> None:
+        await self.close()
+
+    async def close(self) -> None:
+        if self._owns_client:
+            await self._client.aclose()
+
+    async def _request(self, method: str, path: str, *, json: dict[str, Any] | None = None) -> httpx.Response:
+        try:
+            response = await self._client.request(method, path, json=json)
+        except httpx.TimeoutException as exc:
+            raise TimeoutError(str(exc) or "Request timed out") from exc
+        except httpx.RequestError as exc:
+            raise ConnectionError(str(exc) or "Request failed") from exc
+
+        _raise_for_response(response)
+        return response
+
+    async def review(
+        self,
+        code: str,
+        *,
+        language: str = "solidity",
+        review_type: str = "security",
+        context: str = "",
+        encryption_key: str | None = None,
+    ) -> ReviewResult:
+        payload: dict[str, Any] = {
+            "code": code,
+            "language": language,
+            "reviewType": review_type,
+            "context": context,
+        }
+        if encryption_key is not None:
+            payload["encryptionKey"] = encryption_key
+
+        response = await self._request("POST", "/review/", json=payload)
+        result = ReviewResult.model_validate(response.json())
+        return result.model_copy(update={"remaining_reviews": _extract_remaining_reviews(response.headers)})
+
+    async def status(self, request_hash: str) -> StatusResult:
+        response = await self._request("GET", f"/status/{request_hash}")
+        return StatusResult.model_validate(response.json())
+
+    async def reputation(self, agent_id: int) -> ReputationResult:
+        response = await self._request("GET", f"/reputation/{agent_id}")
+        return ReputationResult.model_validate(response.json())
+
+    async def health(self) -> HealthResult:
+        response = await self._request("GET", "/health")
+        return HealthResult.model_validate(response.json())
+
+    async def stats(self) -> StatsResult:
+        response = await self._request("GET", "/stats/")
+        return StatsResult.model_validate(response.json())
+
+
+class SyncClient:
+    """Synchronous SDK client."""
+
+    def __init__(
+        self,
+        base_url: str = _DEFAULT_BASE_URL,
+        api_key: str | None = None,
+        timeout: float = 120.0,
+        _client: httpx.Client | None = None,
+    ) -> None:
+        self._owns_client = _client is None
+        if _client is None:
+            headers = {"X-API-Key": api_key} if api_key else None
+            self._client = httpx.Client(
+                base_url=base_url.rstrip("/"),
+                timeout=timeout,
+                headers=headers,
+            )
+        else:
+            self._client = _client
+            if api_key:
+                self._client.headers.setdefault("X-API-Key", api_key)
+
+    def __enter__(self) -> SyncClient:
+        return self
+
+    def __exit__(self, exc_type: object, exc: object, tb: object) -> None:
+        self.close()
+
+    def close(self) -> None:
+        if self._owns_client:
+            self._client.close()
+
+    def _request(self, method: str, path: str, *, json: dict[str, Any] | None = None) -> httpx.Response:
+        try:
+            response = self._client.request(method, path, json=json)
+        except httpx.TimeoutException as exc:
+            raise TimeoutError(str(exc) or "Request timed out") from exc
+        except httpx.RequestError as exc:
+            raise ConnectionError(str(exc) or "Request failed") from exc
+
+        _raise_for_response(response)
+        return response
+
+    def review(
+        self,
+        code: str,
+        *,
+        language: str = "solidity",
+        review_type: str = "security",
+        context: str = "",
+        encryption_key: str | None = None,
+    ) -> ReviewResult:
+        payload: dict[str, Any] = {
+            "code": code,
+            "language": language,
+            "reviewType": review_type,
+            "context": context,
+        }
+        if encryption_key is not None:
+            payload["encryptionKey"] = encryption_key
+
+        response = self._request("POST", "/review/", json=payload)
+        result = ReviewResult.model_validate(response.json())
+        return result.model_copy(update={"remaining_reviews": _extract_remaining_reviews(response.headers)})
+
+    def status(self, request_hash: str) -> StatusResult:
+        response = self._request("GET", f"/status/{request_hash}")
+        return StatusResult.model_validate(response.json())
+
+    def reputation(self, agent_id: int) -> ReputationResult:
+        response = self._request("GET", f"/reputation/{agent_id}")
+        return ReputationResult.model_validate(response.json())
+
+    def health(self) -> HealthResult:
+        response = self._request("GET", "/health")
+        return HealthResult.model_validate(response.json())
+
+    def stats(self) -> StatsResult:
+        response = self._request("GET", "/stats/")
+        return StatsResult.model_validate(response.json())

code_review_validator/errors.py

@@ -0,0 +1,84 @@
+"""SDK exception hierarchy."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+
+class ValidatorError(Exception):
+    """Base exception for SDK errors."""
+
+
+class APIError(ValidatorError):
+    """HTTP error returned by the validator API."""
+
+    def __init__(
+        self,
+        status_code: int,
+        detail: str,
+        response: httpx.Response | None = None,
+    ) -> None:
+        self.status_code = status_code
+        self.detail = detail
+        self.response = response
+        super().__init__(f"HTTP {status_code}: {detail}")
+
+
+class BadRequestError(APIError):
+    """400 from API."""
+
+
+class AuthenticationError(APIError):
+    """401 from API."""
+
+
+class PaymentRequiredError(APIError):
+    """402 from API."""
+
+
+class RateLimitError(APIError):
+    """429 from API."""
+
+    def __init__(
+        self,
+        status_code: int,
+        detail: str,
+        response: httpx.Response | None = None,
+        retry_after: int | None = None,
+    ) -> None:
+        self.retry_after = retry_after
+        super().__init__(status_code=status_code, detail=detail, response=response)
+
+
+class ServiceUnavailableError(APIError):
+    """503 from API."""
+
+
+class TimeoutError(ValidatorError):
+    """Timeout reaching API or 504 returned by API."""
+
+
+class ConnectionError(ValidatorError):
+    """Network/connectivity failure while calling API."""
+
+
+class CryptoNotAvailableError(ValidatorError):
+    """Raised when crypto helper dependencies are unavailable."""
+
+
+def parse_error_detail(payload: Any, fallback: str) -> str:
+    """Extract a readable error string from API payload."""
+    if isinstance(payload, dict):
+        detail = payload.get("detail")
+        error = payload.get("error")
+        if isinstance(detail, str) and isinstance(error, str):
+            if detail == error:
+                return detail
+            return f"{error}: {detail}"
+        if isinstance(detail, str):
+            return detail
+        if isinstance(error, str):
+            return error
+    return fallback

code_review_validator/gate.py

@@ -0,0 +1,119 @@
+"""Deployment gate helpers for CI/CD policies."""
+
+from __future__ import annotations
+
+from collections import Counter
+from dataclasses import dataclass
+
+from .client import SyncClient
+from .models import EvidenceLevel, ReviewResult, Severity
+
+
+@dataclass(frozen=True)
+class GatePolicy:
+    min_score: int = 70
+    min_confidence: float = 0.7
+    require_evidence: EvidenceLevel = EvidenceLevel.FULL
+    max_critical: int = 0
+    max_high: int = 2
+
+
+@dataclass(frozen=True)
+class GateCheck:
+    name: str
+    passed: bool
+    actual: str
+    threshold: str
+
+
+@dataclass(frozen=True)
+class GateResult:
+    passed: bool
+    checks: list[GateCheck]
+    severity_counts: dict[Severity, int]
+    normalized_confidence: float
+
+
+_EVIDENCE_ORDER: dict[EvidenceLevel, int] = {
+    EvidenceLevel.INSUFFICIENT: 0,
+    EvidenceLevel.PARTIAL: 1,
+    EvidenceLevel.FULL: 2,
+}
+
+_SEVERITY_ORDER: tuple[Severity, ...] = (
+    Severity.CRITICAL,
+    Severity.HIGH,
+    Severity.MEDIUM,
+    Severity.LOW,
+    Severity.INFO,
+)
+
+
+def _evidence_meets_threshold(actual: EvidenceLevel, required: EvidenceLevel) -> bool:
+    return _EVIDENCE_ORDER[actual] >= _EVIDENCE_ORDER[required]
+
+
+def _count_severity(response: ReviewResult) -> dict[Severity, int]:
+    counts = Counter(finding.severity for finding in response.findings)
+    return {severity: counts.get(severity, 0) for severity in _SEVERITY_ORDER}
+
+
+def evaluate(response: ReviewResult, policy: GatePolicy | None = None) -> GateResult:
+    """Evaluate a review response against gating policy thresholds."""
+    effective_policy = policy or GatePolicy()
+    normalized_confidence = response.confidence if response.confidence is not None else 0.0
+    severity_counts = _count_severity(response)
+
+    checks = [
+        GateCheck(
+            name="score",
+            passed=response.score >= effective_policy.min_score,
+            actual=str(response.score),
+            threshold=f">= {effective_policy.min_score}",
+        ),
+        GateCheck(
+            name="confidence",
+            passed=normalized_confidence >= effective_policy.min_confidence,
+            actual=f"{normalized_confidence:.2f}",
+            threshold=f">= {effective_policy.min_confidence:.2f}",
+        ),
+        GateCheck(
+            name="evidence_level",
+            passed=_evidence_meets_threshold(response.evidence_level, effective_policy.require_evidence),
+            actual=response.evidence_level.value,
+            threshold=f">= {effective_policy.require_evidence.value}",
+        ),
+        GateCheck(
+            name="critical_findings",
+            passed=severity_counts[Severity.CRITICAL] <= effective_policy.max_critical,
+            actual=str(severity_counts[Severity.CRITICAL]),
+            threshold=f"<= {effective_policy.max_critical}",
+        ),
+        GateCheck(
+            name="high_findings",
+            passed=severity_counts[Severity.HIGH] <= effective_policy.max_high,
+            actual=str(severity_counts[Severity.HIGH]),
+            threshold=f"<= {effective_policy.max_high}",
+        ),
+    ]
+
+    return GateResult(
+        passed=all(check.passed for check in checks),
+        checks=checks,
+        severity_counts=severity_counts,
+        normalized_confidence=normalized_confidence,
+    )
+
+
+def check_contract(
+    code: str,
+    *,
+    base_url: str = "https://code-review-validator.fly.dev",
+    api_key: str | None = None,
+    policy: GatePolicy | None = None,
+    timeout: float = 120.0,
+) -> GateResult:
+    """Submit contract code and evaluate gate policy in one call."""
+    with SyncClient(base_url=base_url, api_key=api_key, timeout=timeout) as client:
+        review = client.review(code)
+    return evaluate(review, policy)

code_review_validator/models.py

@@ -0,0 +1,106 @@
+"""Standalone SDK models mirroring API responses."""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class SDKModel(BaseModel):
+    """Base model configured for forward compatibility."""
+
+    model_config = ConfigDict(extra="ignore", populate_by_name=True)
+
+
+class Severity(str, Enum):
+    CRITICAL = "critical"
+    HIGH = "high"
+    MEDIUM = "medium"
+    LOW = "low"
+    INFO = "info"
+
+
+class EvidenceLevel(str, Enum):
+    FULL = "full"
+    PARTIAL = "partial"
+    INSUFFICIENT = "insufficient"
+
+
+class AttestationStatus(str, Enum):
+    ATTESTED = "attested"
+    ANALYSIS_ONLY = "analysis_only"
+    CHAIN_FAILED = "chain_failed"
+    IPFS_FAILED = "ipfs_failed"
+    FREE = "free"
+    METADATA_ONLY = "metadata_only"
+
+
+class OnChainStatus(str, Enum):
+    ATTESTED = "attested"
+    NOT_FOUND = "not_found"
+
+
+class Finding(SDKModel):
+    severity: Severity
+    category: str
+    line: int | None = None
+    function: str | None = None
+    description: str
+    recommendation: str
+    references: list[str] = Field(default_factory=list)
+    sources: list[str] = Field(default_factory=list)
+    confidence: float | None = Field(default=None, ge=0.0, le=1.0)
+
+
+class ReviewResult(SDKModel):
+    score: int = Field(ge=0, le=100)
+    evidence_level: EvidenceLevel
+    findings: list[Finding] = Field(default_factory=list)
+    recommendations: list[str] = Field(default_factory=list)
+    severity_counts: dict[str, int] | None = None
+    attestation: dict[str, Any] = Field(default_factory=dict)
+    attestation_status: AttestationStatus = AttestationStatus.FREE
+    ipfs_uri: str | None = None
+    confidence: float | None = Field(default=None, ge=0.0, le=1.0)
+    tx_hash: str | None = None
+    remaining_reviews: int | None = None
+
+
+class StatusResult(SDKModel):
+    request_hash: str
+    status: OnChainStatus
+    validator_address: str | None = None
+    agent_id: int | None = None
+    score: int | None = None
+    response_hash: str | None = None
+    tag: str | None = None
+    last_update: int = 0
+    response_uri: str | None = None
+
+
+class ReputationResult(SDKModel):
+    agent_id: int
+    status: str
+    feedback_count: int
+    summary_value: int
+    summary_value_decimals: int
+    summary_value_normalized: str
+    client_count: int
+
+
+class HealthResult(SDKModel):
+    status: str
+    chain_listener: str
+    stake_status: str
+    stake_eth: float
+
+
+class StatsResult(SDKModel):
+    total_reviews: int
+    avg_score: float
+    total_paid: int
+    total_free: int
+    earnings_usdc: float
+    reviews_today: int

code_review_validator-0.1.0.dist-info/METADATA

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: code-review-validator
+Version: 0.1.0
+Summary: Python SDK for the Code Review Validator API
+Author: Code Review Validator
+License: MIT
+Project-URL: Homepage, https://code-review-validator.fly.dev
+Project-URL: Repository, https://gitlab.com/danielpwhite/code-review-validator
+Project-URL: Documentation, https://gitlab.com/danielpwhite/code-review-validator/-/blob/master/sdk/python/README.md
+Keywords: solidity,smart-contract,security,attestation,erc-8004,web3
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Security
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: crypto
+Requires-Dist: eciespy>=0.4.0; extra == "crypto"
+Requires-Dist: coincurve>=20.0.0; extra == "crypto"
+Requires-Dist: web3>=7.6.0; extra == "crypto"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: anyio>=4.0.0; extra == "dev"
+Dynamic: license-file
+
+# code-review-validator (Python SDK)
+
+Python client for the Code Review Validator API.
+
+## Install
+
+```bash
+pip install code-review-validator
+# Optional crypto helpers
+pip install "code-review-validator[crypto]"
+```
+
+## Development Install
+
+```bash
+pip install -e .
+pip install -e ".[dev]"
+# Optional crypto helpers while developing
+pip install -e ".[dev,crypto]"
+```
+
+## Quickstart (async)
+
+```python
+from code_review_validator import AsyncClient
+
+async def main() -> None:
+    async with AsyncClient(api_key="your-key") as client:
+        review = await client.review("contract C {}")
+        print(review.score, review.evidence_level)
+```
+
+## Quickstart (sync)
+
+```python
+from code_review_validator import SyncClient
+
+with SyncClient(api_key="your-key") as client:
+    review = client.review("contract C {}")
+    print(review.score, review.attestation_status)
+```
+
+## CI Gate
+
+```python
+from code_review_validator import GatePolicy, check_contract
+
+policy = GatePolicy(min_score=80)
+result = check_contract("contract C {}", api_key="your-key", policy=policy)
+if not result.passed:
+    raise SystemExit(1)
+```
+
+## Optional Crypto Helpers
+
+```python
+from code_review_validator import verify_response_hash, decrypt_findings
+
+ok = verify_response_hash(ipfs_payload, on_chain_hash)
+findings = decrypt_findings(ipfs_payload, private_key_hex)
+```
+
+## Manual Publish Fallback
+
+```bash
+pip install build twine
+cd sdk/python
+python -m build
+TWINE_USERNAME=__token__ TWINE_PASSWORD="$PYPI_TOKEN" twine upload dist/*
+```

code_review_validator-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+code_review_validator/__init__.py,sha256=LwNLMwytfDh9qlz-uMgGwB7x0Jdi3G4hWQJ01PEi37g,2353
+code_review_validator/_verify.py,sha256=f96jZJgoqhPCrFMCVoXxUvZWJv6GDPVE9Lwu0Gtc3rI,1698
+code_review_validator/client.py,sha256=bPG0qi_cw6ln-7_f66HPmXKTUuyPrUNaxdiKEQgfbUU,7837
+code_review_validator/errors.py,sha256=hHXuioHRlv6Iv7JK4T6vbxYjIeOmINnhw-5cJ2OVEug,2032
+code_review_validator/gate.py,sha256=aj59l_6AFvVoeVWsXtSxS0w9SGpQjBe_ZGbek-40sh8,3696
+code_review_validator/models.py,sha256=KGnTv0JH8vIeOQ-huO6dGM-g2kvCiqk_fYE1rOWqg3U,2602
+code_review_validator/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+code_review_validator-0.1.0.dist-info/licenses/LICENSE,sha256=5VS0Hbt5xXT7bNCKJDdroyydffccq5g6s-Xov3OS5CE,1091
+code_review_validator-0.1.0.dist-info/METADATA,sha256=DpBg0c8SRf0RL2yQ8y8G2n05_4FAphA101l8fTZz7Yg,2902
+code_review_validator-0.1.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+code_review_validator-0.1.0.dist-info/top_level.txt,sha256=dm37RkTeor0Gwhts5fALC8FAscw7FmAaTHTLk0pCUMA,22
+code_review_validator-0.1.0.dist-info/RECORD,,

code_review_validator-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

code_review_validator-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Code Review Validator contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

code_review_validator-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+code_review_validator