pylitmus 1.0.0__tar.gz → 1.1.0__tar.gz

{pylitmus-1.0.0 → pylitmus-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pylitmus
-Version: 1.0.0
+Version: 1.1.0
 Summary: A high-performance rules engine for Python - evaluate data against configurable rules and get clear verdicts
 Project-URL: Homepage, https://github.com/yourorg/pylitmus
 Project-URL: Documentation, https://pylitmus.readthedocs.io/

{pylitmus-1.0.0 → pylitmus-1.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pylitmus"
-version = "1.0.0"
+version = "1.1.0"
 description = "A high-performance rules engine for Python - evaluate data against configurable rules and get clear verdicts"
 readme = "README.md"
 license = {text = "MIT"}

{pylitmus-1.0.0 → pylitmus-1.1.0}/src/pylitmus/__init__.py

@@ -26,9 +26,9 @@ from .storage import (
     RuleRepository,
 )
 from .strategies import MaxStrategy, ScoringStrategy, SumStrategy, WeightedStrategy
-from .types import AssessmentResult, Operator, Rule, RuleResult, Severity
+from .types import AssessmentResult, DecisionTier, Operator, Rule, RuleResult, Severity
 
-__version__ = "1.0.0"
+__version__ = "1.1.0"
 
 __all__ = [
     # Main
@@ -40,6 +40,7 @@ __all__ = [
     "Rule",
     "RuleResult",
     "AssessmentResult",
+    "DecisionTier",
     "Operator",
     "Severity",
     # Conditions

{pylitmus-1.0.0 → pylitmus-1.1.0}/src/pylitmus/engine.py

@@ -7,7 +7,7 @@ import time
 from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
 from .exceptions import EvaluationError
-from .types import AssessmentResult, Rule, RuleResult
+from .types import AssessmentResult, DecisionTier, Rule, RuleResult
 
 if TYPE_CHECKING:
     from .storage.base import RuleRepository
@@ -21,24 +21,34 @@ class RuleEngine:
     Main rules engine for evaluating data against configured rules.
 
     Usage:
+        # Without decision tiers (returns None for decision)
         engine = RuleEngine(
             repository=DatabaseRuleRepository(db_url),
             scoring_strategy=WeightedStrategy()
         )
 
+        # With user-defined decision tiers
+        engine = RuleEngine(
+            repository=DatabaseRuleRepository(db_url),
+            scoring_strategy=WeightedStrategy(),
+            decision_tiers=[
+                DecisionTier("AUTO_APPROVE", 0, 20, "Very low risk"),
+                DecisionTier("APPROVE", 20, 40, "Low risk"),
+                DecisionTier("SOFT_REVIEW", 40, 60, "Medium risk"),
+                DecisionTier("HARD_REVIEW", 60, 80, "Higher risk"),
+                DecisionTier("FLAG", 80, 95, "High risk"),
+                DecisionTier("AUTO_REJECT", 95, 101, "Very high risk"),
+            ]
+        )
+
         result = engine.evaluate(claim, context)
     """
 
-    DEFAULT_THRESHOLDS = {
-        "approve": 30,
-        "review": 70,
-    }
-
     def __init__(
         self,
         repository: "RuleRepository",
         scoring_strategy: Optional["ScoringStrategy"] = None,
-        decision_thresholds: Optional[Dict[str, int]] = None,
+        decision_tiers: Optional[List[DecisionTier]] = None,
         condition_builder: Optional[Any] = None,
     ):
         """
@@ -47,12 +57,13 @@ class RuleEngine:
         Args:
             repository: Rule storage backend
             scoring_strategy: Strategy for calculating scores
-            decision_thresholds: Custom thresholds for decisions
+            decision_tiers: User-defined decision tiers with score ranges.
+                           If not provided, decision will be None.
             condition_builder: Builder for creating conditions from dicts
         """
         self.repository = repository
         self._scoring_strategy = scoring_strategy
-        self._thresholds = decision_thresholds or self.DEFAULT_THRESHOLDS.copy()
+        self._decision_tiers = decision_tiers
         self._condition_builder = condition_builder
         self._rules_cache: Optional[List[Rule]] = None
 
@@ -189,25 +200,25 @@ class RuleEngine:
             explanation=rule.description if triggered else "Condition not met",
         )
 
-    def _make_decision(self, score: int) -> str:
+    def _make_decision(self, score: int) -> Optional[str]:
         """
-        Make a decision based on the total score.
+        Make a decision based on the total score and configured decision tiers.
 
         Args:
             score: Total calculated score
 
         Returns:
-            Decision string: 'APPROVE', 'REVIEW', or 'FLAG'
+            Decision string if a matching tier is found, None otherwise.
+            If no decision tiers are configured, returns None.
         """
-        approve_threshold = self._thresholds.get("approve", 30)
-        review_threshold = self._thresholds.get("review", 70)
-
-        if score < approve_threshold:
-            return "APPROVE"
-        elif score < review_threshold:
-            return "REVIEW"
-        else:
-            return "FLAG"
+        if not self._decision_tiers:
+            return None
+
+        for tier in self._decision_tiers:
+            if tier.matches(score):
+                return tier.name
+
+        return None
 
     def reload_rules(self) -> None:
         """Force reload rules from repository."""

{pylitmus-1.0.0 → pylitmus-1.1.0}/src/pylitmus/factory.py

@@ -4,7 +4,7 @@ Factory functions for creating RuleEngine instances with sensible defaults.
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, List, Optional, Union
 
 from .engine import RuleEngine
 from .storage import (
@@ -15,6 +15,7 @@ from .storage import (
     RuleRepository,
 )
 from .strategies import MaxStrategy, ScoringStrategy, SumStrategy, WeightedStrategy
+from .types import DecisionTier
 
 if TYPE_CHECKING:
     from .types import Rule
@@ -34,7 +35,7 @@ def create_engine(
     # Scoring
     scoring_strategy: Union[str, ScoringStrategy] = "sum",
     # Decision
-    decision_thresholds: Optional[Dict[str, int]] = None,
+    decision_tiers: Optional[List[DecisionTier]] = None,
 ) -> RuleEngine:
     """
     Create a configured RuleEngine instance.
@@ -52,13 +53,14 @@ def create_engine(
         cache_url: Redis URL (for 'redis' cache)
         cache_ttl: Cache TTL in seconds
         scoring_strategy: 'sum', 'weighted', 'max', or ScoringStrategy instance
-        decision_thresholds: Custom thresholds {'approve': 30, 'review': 70}
+        decision_tiers: User-defined decision tiers with score ranges.
+                       If not provided, decision will be None in results.
 
     Returns:
         Configured RuleEngine instance
 
     Examples:
-        # Simple in-memory engine
+        # Simple in-memory engine (no decision tiers - decision will be None)
         engine = create_engine()
 
         # In-memory with predefined rules
@@ -78,10 +80,17 @@ def create_engine(
             rules_file='./rules/fraud_rules.yaml'
         )
 
-        # With weighted scoring
+        # With user-defined decision tiers
         engine = create_engine(
             scoring_strategy='weighted',
-            decision_thresholds={'approve': 25, 'review': 60}
+            decision_tiers=[
+                DecisionTier("AUTO_APPROVE", 0, 20, "Very low risk"),
+                DecisionTier("APPROVE", 20, 40, "Low risk"),
+                DecisionTier("SOFT_REVIEW", 40, 60, "Medium risk"),
+                DecisionTier("HARD_REVIEW", 60, 80, "Higher risk"),
+                DecisionTier("FLAG", 80, 95, "High risk"),
+                DecisionTier("AUTO_REJECT", 95, 101, "Very high risk"),
+            ]
         )
     """
 
@@ -112,7 +121,7 @@ def create_engine(
     return RuleEngine(
         repository=repo,
         scoring_strategy=strategy,
-        decision_thresholds=decision_thresholds,
+        decision_tiers=decision_tiers,
     )
 
 

{pylitmus-1.0.0 → pylitmus-1.1.0}/src/pylitmus/types.py

@@ -3,13 +3,14 @@ Core type definitions for the CMAP Rules Engine.
 """
 
 from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional
-from enum import Enum
 from datetime import datetime
+from enum import Enum
+from typing import Any, Dict, List, Optional
 
 
 class Operator(str, Enum):
     """Supported condition operators."""
+
     EQUALS = "equals"
     NOT_EQUALS = "not_equals"
     GREATER_THAN = "greater_than"
@@ -32,6 +33,7 @@ class Operator(str, Enum):
 
 class Severity(str, Enum):
     """Rule severity levels."""
+
     LOW = "LOW"
     MEDIUM = "MEDIUM"
     HIGH = "HIGH"
@@ -41,6 +43,7 @@ class Severity(str, Enum):
 @dataclass
 class Rule:
     """A rule definition."""
+
     code: str
     name: str
     description: str
@@ -73,6 +76,7 @@ class Rule:
 @dataclass
 class RuleResult:
     """Result of evaluating a single rule."""
+
     rule_code: str
     rule_name: str
     triggered: bool
@@ -82,11 +86,33 @@ class RuleResult:
     explanation: str
 
 
+@dataclass
+class DecisionTier:
+    """
+    A decision tier definition with score range.
+
+    Example:
+        DecisionTier(name="APPROVE", min_score=0, max_score=30)
+        DecisionTier(name="REVIEW", min_score=30, max_score=70)
+        DecisionTier(name="FLAG", min_score=70, max_score=100)
+    """
+
+    name: str
+    min_score: int
+    max_score: int
+    description: Optional[str] = None
+
+    def matches(self, score: int) -> bool:
+        """Check if score falls within this tier's range (min inclusive, max exclusive)."""
+        return self.min_score <= score < self.max_score
+
+
 @dataclass
 class AssessmentResult:
     """Complete assessment result."""
+
     total_score: int
-    decision: str
+    decision: Optional[str]
     triggered_rules: List[RuleResult] = field(default_factory=list)
     all_rules_evaluated: int = 0
     processing_time_ms: float = 0.0

{pylitmus-1.0.0 → pylitmus-1.1.0}/tests/test_phase1_core.py

@@ -5,10 +5,10 @@ Phase 1 Tests: Core Engine - Types, RuleEngine, Exceptions
 from datetime import datetime, timedelta
 
 import pytest
-
-from cmap_rules_engine import (
+from pylitmus import (
     AssessmentResult,
     ConditionError,
+    DecisionTier,
     EvaluationError,
     Operator,
     Rule,
@@ -19,8 +19,8 @@ from cmap_rules_engine import (
     StorageError,
     UnknownOperatorError,
 )
-from cmap_rules_engine.storage import InMemoryRuleRepository
-from cmap_rules_engine.strategies import SumStrategy
+from pylitmus.storage import InMemoryRuleRepository
+from pylitmus.strategies import SumStrategy
 
 
 class TestOperatorEnum:
@@ -207,13 +207,20 @@ class TestAssessmentResult:
 
     def test_assessment_result_defaults(self):
         """Test AssessmentResult default values."""
-        result = AssessmentResult(total_score=0, decision="APPROVE")
+        result = AssessmentResult(total_score=0, decision=None)
 
         assert result.triggered_rules == []
         assert result.all_rules_evaluated == 0
         assert result.processing_time_ms == 0.0
         assert result.metadata == {}
 
+    def test_assessment_result_with_none_decision(self):
+        """Test AssessmentResult with None decision (no tiers configured)."""
+        result = AssessmentResult(total_score=50, decision=None)
+
+        assert result.total_score == 50
+        assert result.decision is None
+
 
 class TestExceptions:
     """Tests for custom exceptions."""
@@ -288,10 +295,19 @@ class TestRuleEngine:
         ]
 
     @pytest.fixture
-    def engine(self, sample_rules):
-        """Create engine with sample rules."""
+    def standard_tiers(self):
+        """Create standard decision tiers."""
+        return [
+            DecisionTier("APPROVE", 0, 30),
+            DecisionTier("REVIEW", 30, 70),
+            DecisionTier("FLAG", 70, 101),
+        ]
+
+    @pytest.fixture
+    def engine(self, sample_rules, standard_tiers):
+        """Create engine with sample rules and standard tiers."""
         repo = InMemoryRuleRepository(sample_rules)
-        return RuleEngine(repository=repo)
+        return RuleEngine(repository=repo, decision_tiers=standard_tiers)
 
     def test_engine_creation(self, sample_rules):
         """Test engine creation."""
@@ -299,16 +315,19 @@ class TestRuleEngine:
         engine = RuleEngine(repository=repo)
 
         assert engine.repository is repo
-        assert engine._thresholds == {"approve": 30, "review": 70}
+        assert engine._decision_tiers is None
 
-    def test_engine_with_custom_thresholds(self, sample_rules):
-        """Test engine with custom thresholds."""
+    def test_engine_with_custom_tiers(self, sample_rules):
+        """Test engine with custom decision tiers."""
         repo = InMemoryRuleRepository(sample_rules)
-        engine = RuleEngine(
-            repository=repo, decision_thresholds={"approve": 20, "review": 50}
-        )
+        custom_tiers = [
+            DecisionTier("LOW", 0, 20),
+            DecisionTier("MEDIUM", 20, 50),
+            DecisionTier("HIGH", 50, 101),
+        ]
+        engine = RuleEngine(repository=repo, decision_tiers=custom_tiers)
 
-        assert engine._thresholds == {"approve": 20, "review": 50}
+        assert engine._decision_tiers == custom_tiers
 
     def test_engine_evaluate_no_triggers(self, engine):
         """Test evaluation with no rules triggered."""
@@ -347,7 +366,7 @@ class TestRuleEngine:
         result = engine.evaluate({"amount": 6000})  # triggers 60 point rule
         assert result.decision == "REVIEW"
 
-    def test_engine_decision_flag(self, sample_rules):
+    def test_engine_decision_flag(self, sample_rules, standard_tiers):
         """Test FLAG decision (score >= 70)."""
         # Add a high score rule
         sample_rules.append(
@@ -364,11 +383,21 @@ class TestRuleEngine:
         )
 
         repo = InMemoryRuleRepository(sample_rules)
-        engine = RuleEngine(repository=repo)
+        engine = RuleEngine(repository=repo, decision_tiers=standard_tiers)
 
         result = engine.evaluate({"critical": True, "amount": 1000})
         assert result.decision == "FLAG"
 
+    def test_engine_no_decision_tiers(self, sample_rules):
+        """Test engine without decision tiers returns None decision."""
+        repo = InMemoryRuleRepository(sample_rules)
+        engine = RuleEngine(repository=repo)  # No decision_tiers
+
+        result = engine.evaluate({"amount": 6000})
+
+        assert result.total_score == 60
+        assert result.decision is None
+
     def test_engine_evaluate_rule_directly(self, engine, sample_rules):
         """Test evaluating a single rule."""
         rule = sample_rules[0]  # HIGH_AMOUNT
@@ -448,7 +477,7 @@ class TestRuleEngineWithStrategies:
 
     def test_sum_strategy(self, rules):
         """Test SumStrategy adds scores."""
-        from cmap_rules_engine.strategies import SumStrategy
+        from pylitmus.strategies import SumStrategy
 
         repo = InMemoryRuleRepository(rules)
         engine = RuleEngine(repository=repo, scoring_strategy=SumStrategy())
@@ -459,7 +488,7 @@ class TestRuleEngineWithStrategies:
 
     def test_sum_strategy_with_cap(self, rules):
         """Test SumStrategy respects max cap."""
-        from cmap_rules_engine.strategies import SumStrategy
+        from pylitmus.strategies import SumStrategy
 
         repo = InMemoryRuleRepository(rules)
         engine = RuleEngine(repository=repo, scoring_strategy=SumStrategy(max_score=50))
@@ -470,7 +499,7 @@ class TestRuleEngineWithStrategies:
 
     def test_max_strategy(self, rules):
         """Test MaxStrategy takes highest score."""
-        from cmap_rules_engine.strategies import MaxStrategy
+        from pylitmus.strategies import MaxStrategy
 
         repo = InMemoryRuleRepository(rules)
         engine = RuleEngine(repository=repo, scoring_strategy=MaxStrategy())
@@ -481,7 +510,7 @@ class TestRuleEngineWithStrategies:
 
     def test_weighted_strategy(self, rules):
         """Test WeightedStrategy weights by severity."""
-        from cmap_rules_engine.strategies import WeightedStrategy
+        from pylitmus.strategies import WeightedStrategy
 
         repo = InMemoryRuleRepository(rules)
         engine = RuleEngine(repository=repo, scoring_strategy=WeightedStrategy())

{pylitmus-1.0.0 → pylitmus-1.1.0}/tests/test_phase2_conditions.py

@@ -4,13 +4,13 @@ Phase 2 Tests: Conditions System - Simple and Composite Conditions
 
 import pytest
 
-from cmap_rules_engine.conditions import (
+from pylitmus.conditions import (
     CompositeCondition,
     Condition,
     ConditionBuilder,
     SimpleCondition,
 )
-from cmap_rules_engine.exceptions import UnknownOperatorError
+from pylitmus.exceptions import UnknownOperatorError
 
 
 class TestConditionBase:
@@ -523,8 +523,8 @@ class TestConditionIntegration:
 
     def test_condition_with_rule_engine(self):
         """Test conditions work correctly with RuleEngine."""
-        from cmap_rules_engine import RuleEngine, Rule, Severity
-        from cmap_rules_engine.storage import InMemoryRuleRepository
+        from pylitmus import RuleEngine, Rule, Severity
+        from pylitmus.storage import InMemoryRuleRepository
 
         rules = [
             Rule(

{pylitmus-1.0.0 → pylitmus-1.1.0}/tests/test_phase3_evaluators.py

@@ -6,8 +6,8 @@ from datetime import datetime, timedelta
 
 import pytest
 
-from cmap_rules_engine.evaluators import Evaluator, EvaluatorFactory
-from cmap_rules_engine.exceptions import UnknownOperatorError
+from pylitmus.evaluators import Evaluator, EvaluatorFactory
+from pylitmus.exceptions import UnknownOperatorError
 
 
 class TestEvaluatorBase:
@@ -411,7 +411,7 @@ class TestEvaluatorIntegration:
 
     def test_all_operators_with_simple_condition(self):
         """Test all operators work correctly through SimpleCondition."""
-        from cmap_rules_engine.conditions import SimpleCondition
+        from pylitmus.conditions import SimpleCondition
 
         # Test a selection of operators
         test_cases = [
@@ -435,8 +435,8 @@ class TestEvaluatorIntegration:
 
     def test_temporal_operators_with_rule_engine(self):
         """Test temporal operators work with RuleEngine."""
-        from cmap_rules_engine import Rule, RuleEngine, Severity
-        from cmap_rules_engine.storage import InMemoryRuleRepository
+        from pylitmus import Rule, RuleEngine, Severity
+        from pylitmus.storage import InMemoryRuleRepository
 
         yesterday = (datetime.utcnow() - timedelta(days=1)).strftime("%Y-%m-%d")
         old_date = (datetime.utcnow() - timedelta(days=30)).strftime("%Y-%m-%d")

{pylitmus-1.0.0 → pylitmus-1.1.0}/tests/test_phase4_strategies.py

@@ -4,13 +4,13 @@ Phase 4 Tests: Scoring Strategies - Sum, Weighted, Max strategies
 
 import pytest
 
-from cmap_rules_engine.strategies import (
+from pylitmus.strategies import (
     MaxStrategy,
     ScoringStrategy,
     SumStrategy,
     WeightedStrategy,
 )
-from cmap_rules_engine.types import RuleResult, Severity
+from pylitmus.types import RuleResult, Severity
 
 
 def make_result(score: int, severity: Severity = Severity.MEDIUM) -> RuleResult:
@@ -326,8 +326,8 @@ class TestStrategyIntegration:
 
     def test_engine_with_sum_strategy(self):
         """Test RuleEngine uses SumStrategy correctly."""
-        from cmap_rules_engine import Rule, RuleEngine, Severity
-        from cmap_rules_engine.storage import InMemoryRuleRepository
+        from pylitmus import Rule, RuleEngine, Severity
+        from pylitmus.storage import InMemoryRuleRepository
 
         rules = [
             Rule(
@@ -360,8 +360,8 @@ class TestStrategyIntegration:
 
     def test_engine_with_weighted_strategy(self):
         """Test RuleEngine uses WeightedStrategy correctly."""
-        from cmap_rules_engine import Rule, RuleEngine, Severity
-        from cmap_rules_engine.storage import InMemoryRuleRepository
+        from pylitmus import Rule, RuleEngine, Severity
+        from pylitmus.storage import InMemoryRuleRepository
 
         rules = [
             Rule(
@@ -395,8 +395,8 @@ class TestStrategyIntegration:
 
     def test_engine_with_max_strategy(self):
         """Test RuleEngine uses MaxStrategy correctly."""
-        from cmap_rules_engine import Rule, RuleEngine, Severity
-        from cmap_rules_engine.storage import InMemoryRuleRepository
+        from pylitmus import Rule, RuleEngine, Severity
+        from pylitmus.storage import InMemoryRuleRepository
 
         rules = [
             Rule(
@@ -429,8 +429,8 @@ class TestStrategyIntegration:
 
     def test_default_strategy_is_sum(self):
         """Test that default strategy is SumStrategy."""
-        from cmap_rules_engine import RuleEngine
-        from cmap_rules_engine.storage import InMemoryRuleRepository
+        from pylitmus import RuleEngine
+        from pylitmus.storage import InMemoryRuleRepository
 
         repo = InMemoryRuleRepository([])
         engine = RuleEngine(repository=repo)

{pylitmus-1.0.0 → pylitmus-1.1.0}/tests/test_phase5_storage.py

@@ -8,13 +8,13 @@ import tempfile
 
 import pytest
 
-from cmap_rules_engine.storage import (
+from pylitmus.storage import (
     CachedRuleRepository,
     FileRuleRepository,
     InMemoryRuleRepository,
     RuleRepository,
 )
-from cmap_rules_engine.types import Rule, Severity
+from pylitmus.types import Rule, Severity
 
 
 def make_rule(code: str, score: int = 50, enabled: bool = True) -> Rule:
@@ -516,7 +516,7 @@ class TestStorageIntegration:
 
     def test_engine_with_file_repository(self):
         """Test RuleEngine with FileRuleRepository."""
-        from cmap_rules_engine import RuleEngine
+        from pylitmus import RuleEngine
 
         content = {
             "rules": [
@@ -552,7 +552,7 @@ class TestStorageIntegration:
 
     def test_engine_with_cached_repository(self):
         """Test RuleEngine with CachedRuleRepository."""
-        from cmap_rules_engine import RuleEngine
+        from pylitmus import RuleEngine
 
         inner = InMemoryRuleRepository(
             [

{pylitmus-1.0.0 → pylitmus-1.1.0}/tests/test_phase6_patterns.py

@@ -4,7 +4,7 @@ Phase 6 Tests: Pattern Matching - Regex, Fuzzy, Range matchers
 
 import pytest
 
-from cmap_rules_engine.patterns import (
+from pylitmus.patterns import (
     EnhancedPatternEngine,
     ExactMatcher,
     FuzzyMatcher,
@@ -374,8 +374,8 @@ class TestPatternIntegration:
 
     def test_register_fuzzy_evaluator(self):
         """Test registering fuzzy matcher as an evaluator."""
-        from cmap_rules_engine.evaluators import Evaluator, EvaluatorFactory
-        from cmap_rules_engine.patterns import FuzzyMatcher
+        from pylitmus.evaluators import Evaluator, EvaluatorFactory
+        from pylitmus.patterns import FuzzyMatcher
 
         class FuzzyMatchEvaluator(Evaluator):
             def __init__(self):
@@ -400,10 +400,10 @@ class TestPatternIntegration:
 
     def test_patterns_with_rule_engine(self):
         """Test pattern matching integration with RuleEngine."""
-        from cmap_rules_engine import Rule, RuleEngine, Severity
-        from cmap_rules_engine.evaluators import Evaluator, EvaluatorFactory
-        from cmap_rules_engine.patterns import GlobMatcher
-        from cmap_rules_engine.storage import InMemoryRuleRepository
+        from pylitmus import Rule, RuleEngine, Severity
+        from pylitmus.evaluators import Evaluator, EvaluatorFactory
+        from pylitmus.patterns import GlobMatcher
+        from pylitmus.storage import InMemoryRuleRepository
 
         # Register glob evaluator
         class GlobMatchEvaluator(Evaluator):