zikriyon-prism 0.1.0__tar.gz

zikriyon_prism-0.1.0/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: zikriyon-prism
+Version: 0.1.0
+Summary: Security, moderation and trust scoring engine — local rule engine plus optional cloud ML tier.
+Author: ZEAIPC (Zikr-e-Ameen Innovations & Programming Corporation)
+License-Expression: LicenseRef-Proprietary
+Project-URL: Homepage, https://zikriyonprism.dev
+Project-URL: Repository, https://github.com/zeaipc/zikriyon-prism
+Keywords: security,moderation,trust-score,spam-detection,anomaly-detection
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: PyYAML>=6.0
+Requires-Dist: httpx>=0.25
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4; extra == "dev"
+Requires-Dist: mypy>=1.5; extra == "dev"
+Requires-Dist: ruff>=0.1; extra == "dev"
+
+# zikriyon-prism (Python SDK)
+
+Security, moderation and trust-scoring engine — local rule engine
+(free, fully offline) plus an optional cloud ML tier (trust score,
+anomaly detection, phishing NLP).
+
+## Install
+
+```bash
+pip install zikriyon-prism
+```
+
+## Quick start
+
+```python
+from zikriyon_prism import RuleEngine
+
+engine = RuleEngine.from_file("rules/spam_abuse.yaml")
+result = engine.evaluate(
+    {"message": {"text": "click here to unlock your account"}},
+    subject_id="user_123",
+)
+print(result.action)  # "block"
+```
+
+## Paid tier
+
+```python
+from zikriyon_prism import CloudClient
+
+with CloudClient(license_key="ZP-PRO-<32 hex chars>") as client:
+    score = client.get_trust_score("user_123", signals={"login_count": 5})
+```
+
+License keys are validated for *shape* client-side only. Real
+entitlement and quota checks always happen server-side.
+
+Full project docs, the Node.js SDK, and the cloud service:
+https://github.com/zeaipc/zikriyon-prism

zikriyon_prism-0.1.0/README.md

@@ -0,0 +1,39 @@
+# zikriyon-prism (Python SDK)
+
+Security, moderation and trust-scoring engine — local rule engine
+(free, fully offline) plus an optional cloud ML tier (trust score,
+anomaly detection, phishing NLP).
+
+## Install
+
+```bash
+pip install zikriyon-prism
+```
+
+## Quick start
+
+```python
+from zikriyon_prism import RuleEngine
+
+engine = RuleEngine.from_file("rules/spam_abuse.yaml")
+result = engine.evaluate(
+    {"message": {"text": "click here to unlock your account"}},
+    subject_id="user_123",
+)
+print(result.action)  # "block"
+```
+
+## Paid tier
+
+```python
+from zikriyon_prism import CloudClient
+
+with CloudClient(license_key="ZP-PRO-<32 hex chars>") as client:
+    score = client.get_trust_score("user_123", signals={"login_count": 5})
+```
+
+License keys are validated for *shape* client-side only. Real
+entitlement and quota checks always happen server-side.
+
+Full project docs, the Node.js SDK, and the cloud service:
+https://github.com/zeaipc/zikriyon-prism

zikriyon_prism-0.1.0/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "zikriyon-prism"
+version = "0.1.0"
+description = "Security, moderation and trust scoring engine — local rule engine plus optional cloud ML tier."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "LicenseRef-Proprietary"
+authors = [{ name = "ZEAIPC (Zikr-e-Ameen Innovations & Programming Corporation)" }]
+keywords = ["security", "moderation", "trust-score", "spam-detection", "anomaly-detection"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Security",
+]
+dependencies = [
+    "PyYAML>=6.0",
+    "httpx>=0.25",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.4",
+    "mypy>=1.5",
+    "ruff>=0.1",
+]
+
+[project.urls]
+Homepage = "https://zikriyonprism.dev"
+Repository = "https://github.com/zeaipc/zikriyon-prism"
+
+[tool.setuptools.packages.find]
+include = ["zikriyon_prism*"]
+
+[tool.mypy]
+strict = true
+python_version = "3.9"
+
+[tool.ruff]
+line-length = 100
+target-version = "py39"

zikriyon_prism-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

zikriyon_prism-0.1.0/tests/test_engine.py

@@ -0,0 +1,94 @@
+import time
+
+import pytest
+
+from zikriyon_prism.engine import RuleEngine, RuleSpecError
+
+SPEC = """
+version: 1
+spec_id: test_spec
+settings:
+  case_sensitive: false
+  default_action: allow
+  max_severity_wins: true
+severity_levels:
+  low:      { weight: 1, action: flag }
+  high:     { weight: 3, action: block }
+rules:
+  - id: phishing_test
+    type: keyword_list
+    target: message.text
+    list_ref: keyword_lists.phishing
+    severity: high
+    reason: "phishing phrase"
+  - id: flood_test
+    type: rate
+    target: user.message_count
+    threshold: 3
+    window_seconds: 5
+    severity: low
+    reason: "too many messages"
+keyword_lists:
+  phishing:
+    - "verify your account"
+"""
+
+
+@pytest.fixture
+def engine() -> RuleEngine:
+    return RuleEngine.from_string(SPEC)
+
+
+def test_no_match_returns_default_action(engine: RuleEngine) -> None:
+    result = engine.evaluate({"message": {"text": "hello there"}}, subject_id="u1")
+    assert result.matched is False
+    assert result.action == "allow"
+
+
+def test_keyword_match_blocks(engine: RuleEngine) -> None:
+    result = engine.evaluate(
+        {"message": {"text": "please verify your account now"}}, subject_id="u1"
+    )
+    assert result.matched is True
+    assert result.action == "block"
+    assert result.matches[0].rule_id == "phishing_test"
+
+
+def test_case_insensitive_by_default(engine: RuleEngine) -> None:
+    result = engine.evaluate(
+        {"message": {"text": "VERIFY YOUR ACCOUNT"}}, subject_id="u1"
+    )
+    assert result.matched is True
+
+
+def test_rate_rule_triggers_after_threshold(engine: RuleEngine) -> None:
+    subject = "flood_user"
+    results = [
+        engine.evaluate({"message": {"text": "hi"}}, subject_id=subject)
+        for _ in range(3)
+    ]
+    assert results[-1].matched is True
+    assert results[-1].action == "flag"
+
+
+def test_rate_rule_resets_outside_window() -> None:
+    engine = RuleEngine.from_string(SPEC.replace("window_seconds: 5", "window_seconds: 0.2"))
+    subj = "u2"
+    engine.evaluate({}, subject_id=subj)
+    time.sleep(0.3)
+    result = engine.evaluate({}, subject_id=subj)
+    assert result.matched is False
+
+
+def test_invalid_spec_rejected() -> None:
+    with pytest.raises(RuleSpecError):
+        RuleEngine.from_string("rules: []")  # missing severity_levels
+
+
+def test_malformed_rule_does_not_crash_evaluation() -> None:
+    bad_spec = SPEC + "\n  - id: broken\n    type: pattern\n    severity: high\n"
+    engine = RuleEngine.from_string(bad_spec)
+    # 'pattern' rule missing required 'pattern'/'target' keys should be
+    # skipped, not raise, per production error-isolation requirement.
+    result = engine.evaluate({"message": {"text": "safe text"}}, subject_id="u3")
+    assert result.matched is False

zikriyon_prism-0.1.0/zikriyon_prism/__init__.py

@@ -0,0 +1,35 @@
+"""
+Zikriyon Prism — security & moderation engine for QalbConverfy and beyond.
+
+Free tier (no license needed):
+    from zikriyon_prism import RuleEngine
+    engine = RuleEngine.from_file("rules/spam_abuse.yaml")
+    result = engine.evaluate({"message": {"text": "..."}}, subject_id="user_1")
+
+Paid tier (license key required):
+    from zikriyon_prism import CloudClient
+    with CloudClient(license_key="ZP-PRO-...") as client:
+        score = client.get_trust_score("user_1", signals={...})
+"""
+
+from .cloud_client import CloudClient, CloudServiceError, LicenseRequiredError, TrustScoreResult
+from .engine import EvaluationResult, RuleEngine, RuleMatch, RuleSpecError
+from .license import InvalidLicenseKeyError, LicenseKey, load_license, parse_license
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "RuleEngine",
+    "EvaluationResult",
+    "RuleMatch",
+    "RuleSpecError",
+    "CloudClient",
+    "CloudServiceError",
+    "LicenseRequiredError",
+    "TrustScoreResult",
+    "LicenseKey",
+    "InvalidLicenseKeyError",
+    "load_license",
+    "parse_license",
+    "__version__",
+]

zikriyon_prism-0.1.0/zikriyon_prism/cloud_client.py

@@ -0,0 +1,101 @@
+"""
+Zikriyon Prism — cloud client (paid tier).
+
+Thin HTTP client for the hosted ML endpoints (trust score, anomaly
+detection, phishing NLP). Requires a valid license key. Never used
+by the free local rule engine.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+import httpx
+
+from .license import LicenseKey, load_license
+
+logger = logging.getLogger("zikriyon_prism.cloud_client")
+
+DEFAULT_BASE_URL = "https://api.zikriyonprism.dev/v1"
+
+
+class CloudServiceError(RuntimeError):
+    pass
+
+
+class LicenseRequiredError(RuntimeError):
+    pass
+
+
+@dataclass
+class TrustScoreResult:
+    user_id: str
+    score: float          # 0.0 (untrusted) - 1.0 (fully trusted)
+    factors: Dict[str, float]
+
+
+class CloudClient:
+    def __init__(
+        self,
+        license_key: Optional[str] = None,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout_seconds: float = 5.0,
+    ) -> None:
+        resolved = load_license(license_key)
+        if resolved is None:
+            raise LicenseRequiredError(
+                "CloudClient requires a license key (pass explicitly or set "
+                "ZIKRIYON_PRISM_KEY). The free local RuleEngine does not need one."
+            )
+        self._license: LicenseKey = resolved
+        self._base_url = base_url.rstrip("/")
+        self._client = httpx.Client(timeout=timeout_seconds)
+
+    def close(self) -> None:
+        self._client.close()
+
+    def __enter__(self) -> "CloudClient":
+        return self
+
+    def __exit__(self, *_exc: object) -> None:
+        self.close()
+
+    def _headers(self) -> Dict[str, str]:
+        return {
+            "Authorization": f"Bearer {self._license.raw}",
+            "Content-Type": "application/json",
+        }
+
+    def get_trust_score(self, user_id: str, signals: Dict[str, Any]) -> TrustScoreResult:
+        try:
+            resp = self._client.post(
+                f"{self._base_url}/trust-score",
+                headers=self._headers(),
+                json={"user_id": user_id, "signals": signals},
+            )
+            resp.raise_for_status()
+        except httpx.HTTPStatusError as exc:
+            raise CloudServiceError(
+                f"Trust score request failed: {exc.response.status_code} {exc.response.text}"
+            ) from exc
+        except httpx.HTTPError as exc:
+            raise CloudServiceError(f"Trust score request failed: {exc}") from exc
+
+        data = resp.json()
+        return TrustScoreResult(
+            user_id=user_id, score=data["score"], factors=data.get("factors", {})
+        )
+
+    def check_anomaly(self, subject_id: str, features: Dict[str, Any]) -> Dict[str, Any]:
+        try:
+            resp = self._client.post(
+                f"{self._base_url}/anomaly",
+                headers=self._headers(),
+                json={"subject_id": subject_id, "features": features},
+            )
+            resp.raise_for_status()
+        except httpx.HTTPError as exc:
+            raise CloudServiceError(f"Anomaly check failed: {exc}") from exc
+        return resp.json()

zikriyon_prism-0.1.0/zikriyon_prism/engine.py

@@ -0,0 +1,236 @@
+"""
+Zikriyon Prism — local rule engine (free tier).
+
+Loads the shared, language-agnostic YAML rule spec and evaluates events
+against it. Fully local, no network calls, no data leaves the process.
+
+This module intentionally mirrors node-sdk/src/engine.ts rule-for-rule.
+If you change matching semantics here, update the TypeScript port too —
+the YAML spec is the shared contract, this file is the Python side of it.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+import time
+from collections import deque
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Deque, Dict, List, Optional
+
+import yaml
+
+logger = logging.getLogger("zikriyon_prism.engine")
+
+_VALID_RULE_TYPES = {"pattern", "pattern_count", "keyword_list", "rate", "variance_check"}
+
+
+class RuleSpecError(ValueError):
+    """Raised when the YAML rule spec is malformed or internally inconsistent."""
+
+
+@dataclass
+class RuleMatch:
+    rule_id: str
+    severity: str
+    action: str
+    reason: str
+    weight: int
+
+
+@dataclass
+class EvaluationResult:
+    matched: bool
+    action: str
+    matches: List[RuleMatch] = field(default_factory=list)
+
+    @property
+    def highest_severity_match(self) -> Optional[RuleMatch]:
+        if not self.matches:
+            return None
+        return max(self.matches, key=lambda m: m.weight)
+
+
+class _SlidingWindowCounter:
+    """Tracks event timestamps per (rule_id, subject) for rate-based rules."""
+
+    def __init__(self) -> None:
+        self._windows: Dict[str, Deque[float]] = {}
+
+    def record_and_count(self, key: str, window_seconds: float, now: Optional[float] = None) -> int:
+        now = now if now is not None else time.time()
+        dq = self._windows.setdefault(key, deque())
+        dq.append(now)
+        cutoff = now - window_seconds
+        while dq and dq[0] < cutoff:
+            dq.popleft()
+        return len(dq)
+
+
+class RuleEngine:
+    """
+    Loads a Zikriyon Prism YAML rule spec and evaluates events against it.
+
+    Example:
+        engine = RuleEngine.from_file("core-engine/rules/spam_abuse.yaml")
+        result = engine.evaluate({
+            "message": {"text": "click here to unlock your account"},
+        }, subject_id="user_123")
+        if result.matched:
+            print(result.action, [m.reason for m in result.matches])
+    """
+
+    def __init__(self, spec: Dict[str, Any]) -> None:
+        self._validate_spec(spec)
+        self.spec = spec
+        self.settings = spec.get("settings", {})
+        self.severity_levels: Dict[str, Dict[str, Any]] = spec["severity_levels"]
+        self.rules: List[Dict[str, Any]] = spec["rules"]
+        self.keyword_lists: Dict[str, List[str]] = spec.get("keyword_lists", {})
+        self._case_sensitive: bool = bool(self.settings.get("case_sensitive", False))
+        self._default_action: str = self.settings.get("default_action", "allow")
+        self._counters = _SlidingWindowCounter()
+        self._compiled_patterns: Dict[str, "re.Pattern[str]"] = {}
+
+    # ---- construction -----------------------------------------------------
+
+    @classmethod
+    def from_file(cls, path: str | Path) -> "RuleEngine":
+        path = Path(path)
+        with path.open("r", encoding="utf-8") as f:
+            spec = yaml.safe_load(f)
+        logger.info("Loaded rule spec '%s' from %s", spec.get("spec_id", "?"), path)
+        return cls(spec)
+
+    @classmethod
+    def from_string(cls, yaml_text: str) -> "RuleEngine":
+        spec = yaml.safe_load(yaml_text)
+        return cls(spec)
+
+    @staticmethod
+    def _validate_spec(spec: Dict[str, Any]) -> None:
+        if not isinstance(spec, dict):
+            raise RuleSpecError("Rule spec must be a mapping at the top level")
+        for required in ("severity_levels", "rules"):
+            if required not in spec:
+                raise RuleSpecError(f"Rule spec missing required key: '{required}'")
+        for rule in spec["rules"]:
+            if rule.get("type") not in _VALID_RULE_TYPES:
+                raise RuleSpecError(
+                    f"Rule '{rule.get('id', '?')}' has invalid type "
+                    f"'{rule.get('type')}'. Must be one of {_VALID_RULE_TYPES}"
+                )
+            if rule.get("severity") not in spec["severity_levels"]:
+                raise RuleSpecError(
+                    f"Rule '{rule.get('id', '?')}' references unknown severity "
+                    f"'{rule.get('severity')}'"
+                )
+
+    # ---- evaluation ---------------------------------------------------------
+
+    def evaluate(self, event: Dict[str, Any], subject_id: str = "default") -> EvaluationResult:
+        """
+        Evaluate a single event (e.g. an incoming message or auth attempt)
+        against every rule in the spec. `subject_id` scopes rate/variance
+        counters per user/session — pass a stable ID (user id, IP, etc).
+        """
+        matches: List[RuleMatch] = []
+
+        for rule in self.rules:
+            try:
+                if self._rule_matches(rule, event, subject_id):
+                    sev = rule["severity"]
+                    level = self.severity_levels[sev]
+                    matches.append(
+                        RuleMatch(
+                            rule_id=rule["id"],
+                            severity=sev,
+                            action=level["action"],
+                            reason=rule.get("reason", ""),
+                            weight=level["weight"],
+                        )
+                    )
+            except Exception:
+                # A single malformed/failing rule must never take down
+                # the whole evaluation pass in production.
+                logger.exception("Rule '%s' raised during evaluation; skipping", rule.get("id"))
+
+        if not matches:
+            return EvaluationResult(matched=False, action=self._default_action)
+
+        if self.settings.get("max_severity_wins", True):
+            top = max(matches, key=lambda m: m.weight)
+            return EvaluationResult(matched=True, action=top.action, matches=matches)
+
+        return EvaluationResult(matched=True, action=matches[0].action, matches=matches)
+
+    # ---- rule type handlers -------------------------------------------------
+
+    def _rule_matches(self, rule: Dict[str, Any], event: Dict[str, Any], subject_id: str) -> bool:
+        rtype = rule["type"]
+        if rtype == "pattern":
+            return self._match_pattern(rule, event)
+        if rtype == "pattern_count":
+            return self._match_pattern_count(rule, event)
+        if rtype == "keyword_list":
+            return self._match_keyword_list(rule, event)
+        if rtype == "rate":
+            return self._match_rate(rule, event, subject_id)
+        if rtype == "variance_check":
+            return self._match_variance(rule, event)
+        return False
+
+    def _get_target(self, target_path: str, event: Dict[str, Any]) -> Any:
+        node: Any = event
+        for part in target_path.split("."):
+            if not isinstance(node, dict) or part not in node:
+                return None
+            node = node[part]
+        return node
+
+    def _compile(self, pattern: str) -> "re.Pattern[str]":
+        if pattern not in self._compiled_patterns:
+            flags = 0 if self._case_sensitive else re.IGNORECASE
+            self._compiled_patterns[pattern] = re.compile(pattern, flags)
+        return self._compiled_patterns[pattern]
+
+    def _match_pattern(self, rule: Dict[str, Any], event: Dict[str, Any]) -> bool:
+        text = self._get_target(rule["target"], event)
+        if not isinstance(text, str):
+            return False
+        return self._compile(rule["pattern"]).search(text) is not None
+
+    def _match_pattern_count(self, rule: Dict[str, Any], event: Dict[str, Any]) -> bool:
+        text = self._get_target(rule["target"], event)
+        if not isinstance(text, str):
+            return False
+        count = len(self._compile(rule["pattern"]).findall(text))
+        return count >= rule["threshold"]
+
+    def _match_keyword_list(self, rule: Dict[str, Any], event: Dict[str, Any]) -> bool:
+        text = self._get_target(rule["target"], event)
+        if not isinstance(text, str):
+            return False
+        haystack = text if self._case_sensitive else text.lower()
+        list_ref = rule["list_ref"].split(".", 1)[1]  # "keyword_lists.X" -> "X"
+        keywords = self.keyword_lists.get(list_ref, [])
+        for kw in keywords:
+            needle = kw if self._case_sensitive else kw.lower()
+            if needle and needle in haystack:
+                return True
+        return False
+
+    def _match_rate(self, rule: Dict[str, Any], event: Dict[str, Any], subject_id: str) -> bool:
+        # `target` here identifies the counter stream, not a literal value lookup.
+        key = f"{rule['id']}:{subject_id}"
+        count = self._counters.record_and_count(key, rule["window_seconds"])
+        return count >= rule["threshold"]
+
+    def _match_variance(self, rule: Dict[str, Any], event: Dict[str, Any]) -> bool:
+        samples = self._get_target(rule["target"], event)
+        if not isinstance(samples, list) or len(samples) < rule.get("min_samples", 5):
+            return False
+        mean = sum(samples) / len(samples)
+        variance = sum((x - mean) ** 2 for x in samples) / len(samples)
+        return variance <= rule.get("max_variance_ms", 50) ** 2

zikriyon_prism-0.1.0/zikriyon_prism/license.py

@@ -0,0 +1,57 @@
+"""
+Zikriyon Prism — license key handling.
+
+The local rule engine (engine.py) never requires a license — it is fully
+free and offline. A license key is only required when using cloud_client.py
+to call the hosted ML tier (trust score, anomaly detection, phishing NLP).
+
+Key format: ZP-<plan>-<32 hex chars>, e.g. ZP-PRO-9f1c2e4a7b3d4f5e6a7b8c9d0e1f2a3b
+This module only validates *shape* locally; real entitlement/quota checks
+always happen server-side in cloud-service — never trust a client-side
+"valid" result for authorization decisions.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+from dataclasses import dataclass
+from typing import Optional
+
+_KEY_PATTERN = re.compile(r"^ZP-(FREE|PRO|ENTERPRISE)-[0-9a-fA-F]{32}$")
+
+ENV_VAR = "ZIKRIYON_PRISM_KEY"
+
+
+class InvalidLicenseKeyError(ValueError):
+    pass
+
+
+@dataclass(frozen=True)
+class LicenseKey:
+    raw: str
+    plan: str
+
+    def __repr__(self) -> str:  # never leak the full key in logs/repr
+        return f"LicenseKey(plan={self.plan!r}, key='ZP-{self.plan}-****')"
+
+
+def load_license(explicit_key: Optional[str] = None) -> Optional[LicenseKey]:
+    """
+    Resolve a license key from an explicit argument or the
+    ZIKRIYON_PRISM_KEY environment variable. Returns None for
+    unauthenticated/free-tier usage (local engine only).
+    """
+    raw = explicit_key or os.environ.get(ENV_VAR)
+    if not raw:
+        return None
+    return parse_license(raw)
+
+
+def parse_license(raw: str) -> LicenseKey:
+    match = _KEY_PATTERN.match(raw.strip())
+    if not match:
+        raise InvalidLicenseKeyError(
+            "License key must match ZP-<FREE|PRO|ENTERPRISE>-<32 hex chars>"
+        )
+    return LicenseKey(raw=raw.strip(), plan=match.group(1))

zikriyon_prism-0.1.0/zikriyon_prism.egg-info/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: zikriyon-prism
+Version: 0.1.0
+Summary: Security, moderation and trust scoring engine — local rule engine plus optional cloud ML tier.
+Author: ZEAIPC (Zikr-e-Ameen Innovations & Programming Corporation)
+License-Expression: LicenseRef-Proprietary
+Project-URL: Homepage, https://zikriyonprism.dev
+Project-URL: Repository, https://github.com/zeaipc/zikriyon-prism
+Keywords: security,moderation,trust-score,spam-detection,anomaly-detection
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: PyYAML>=6.0
+Requires-Dist: httpx>=0.25
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4; extra == "dev"
+Requires-Dist: mypy>=1.5; extra == "dev"
+Requires-Dist: ruff>=0.1; extra == "dev"
+
+# zikriyon-prism (Python SDK)
+
+Security, moderation and trust-scoring engine — local rule engine
+(free, fully offline) plus an optional cloud ML tier (trust score,
+anomaly detection, phishing NLP).
+
+## Install
+
+```bash
+pip install zikriyon-prism
+```
+
+## Quick start
+
+```python
+from zikriyon_prism import RuleEngine
+
+engine = RuleEngine.from_file("rules/spam_abuse.yaml")
+result = engine.evaluate(
+    {"message": {"text": "click here to unlock your account"}},
+    subject_id="user_123",
+)
+print(result.action)  # "block"
+```
+
+## Paid tier
+
+```python
+from zikriyon_prism import CloudClient
+
+with CloudClient(license_key="ZP-PRO-<32 hex chars>") as client:
+    score = client.get_trust_score("user_123", signals={"login_count": 5})
+```
+
+License keys are validated for *shape* client-side only. Real
+entitlement and quota checks always happen server-side.
+
+Full project docs, the Node.js SDK, and the cloud service:
+https://github.com/zeaipc/zikriyon-prism

zikriyon_prism-0.1.0/zikriyon_prism.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+tests/test_engine.py
+zikriyon_prism/__init__.py
+zikriyon_prism/cloud_client.py
+zikriyon_prism/engine.py
+zikriyon_prism/license.py
+zikriyon_prism.egg-info/PKG-INFO
+zikriyon_prism.egg-info/SOURCES.txt
+zikriyon_prism.egg-info/dependency_links.txt
+zikriyon_prism.egg-info/requires.txt
+zikriyon_prism.egg-info/top_level.txt

zikriyon_prism-0.1.0/zikriyon_prism.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

zikriyon_prism-0.1.0/zikriyon_prism.egg-info/requires.txt

@@ -0,0 +1,7 @@
+PyYAML>=6.0
+httpx>=0.25
+
+[dev]
+pytest>=7.4
+mypy>=1.5
+ruff>=0.1

zikriyon_prism-0.1.0/zikriyon_prism.egg-info/top_level.txt

@@ -0,0 +1 @@
+zikriyon_prism