pylitmus 1.0.0__py3-none-any.whl

pylitmus/storage/base.py

@@ -0,0 +1,78 @@
+"""
+Base repository class for rule storage.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+
+from ..types import Rule
+
+
+class RuleRepository(ABC):
+    """Abstract base for rule storage backends."""
+
+    @abstractmethod
+    def get_all(self, filters: Optional[Dict[str, Any]] = None) -> List[Rule]:
+        """
+        Get all rules, optionally filtered.
+
+        Args:
+            filters: Optional filters to apply
+
+        Returns:
+            List of rules
+        """
+        pass
+
+    @abstractmethod
+    def get_by_code(self, code: str) -> Optional[Rule]:
+        """
+        Get a specific rule by code.
+
+        Args:
+            code: Rule code
+
+        Returns:
+            Rule if found, None otherwise
+        """
+        pass
+
+    @abstractmethod
+    def save(self, rule: Rule) -> Rule:
+        """
+        Save a rule (create or update).
+
+        Args:
+            rule: Rule to save
+
+        Returns:
+            Saved rule
+        """
+        pass
+
+    @abstractmethod
+    def delete(self, code: str) -> bool:
+        """
+        Delete a rule by code.
+
+        Args:
+            code: Rule code
+
+        Returns:
+            True if deleted, False otherwise
+        """
+        pass
+
+    def get_enabled(self, filters: Optional[Dict[str, Any]] = None) -> List[Rule]:
+        """
+        Get only enabled rules.
+
+        Args:
+            filters: Additional filters
+
+        Returns:
+            List of enabled rules
+        """
+        all_filters = filters.copy() if filters else {}
+        all_filters["enabled"] = True
+        return self.get_all(all_filters)

pylitmus/storage/cached.py

@@ -0,0 +1,167 @@
+"""
+Cached rule repository decorator implementation.
+"""
+
+import json
+import time
+from typing import Any, Dict, List, Optional
+
+from ..types import Rule
+from .base import RuleRepository
+
+
+class CachedRuleRepository(RuleRepository):
+    """Decorator that adds caching to any repository."""
+
+    def __init__(
+        self,
+        repository: RuleRepository,
+        cache_backend: str = "memory",
+        cache_url: Optional[str] = None,
+        ttl_seconds: int = 300,
+    ):
+        """
+        Initialize cached repository.
+
+        Args:
+            repository: The underlying repository to cache
+            cache_backend: 'memory' or 'redis'
+            cache_url: Redis URL (for redis backend)
+            ttl_seconds: Cache TTL in seconds
+        """
+        self._repository = repository
+        self._ttl = ttl_seconds
+        self._cache_backend = cache_backend
+
+        if cache_backend == "redis":
+            try:
+                import redis
+
+                self._cache = redis.from_url(cache_url or "redis://localhost:6379/0")
+                self._is_redis = True
+            except ImportError:
+                raise ImportError("redis package required for redis cache backend")
+        else:
+            self._cache: Dict[str, Any] = {}
+            self._cache_expiry: Dict[str, float] = {}
+            self._is_redis = False
+
+    def _make_key(
+        self, operation: str, filters: Optional[Dict[str, Any]] = None
+    ) -> str:
+        """Create cache key."""
+        key = f"rules:{operation}"
+        if filters:
+            key += f":{json.dumps(filters, sort_keys=True)}"
+        return key
+
+    def _get_cached(self, key: str) -> Optional[List[Rule]]:
+        """Get value from cache."""
+        if self._is_redis:
+            data = self._cache.get(key)
+            if data:
+                return self._deserialize_rules(json.loads(data))
+            return None
+        else:
+            # Check expiry for memory cache
+            if key in self._cache:
+                if time.time() < self._cache_expiry.get(key, 0):
+                    return self._cache[key]
+                else:
+                    # Expired
+                    del self._cache[key]
+                    if key in self._cache_expiry:
+                        del self._cache_expiry[key]
+            return None
+
+    def _set_cached(self, key: str, rules: List[Rule]) -> None:
+        """Set value in cache."""
+        if self._is_redis:
+            data = json.dumps(self._serialize_rules(rules))
+            self._cache.setex(key, self._ttl, data)
+        else:
+            self._cache[key] = rules
+            self._cache_expiry[key] = time.time() + self._ttl
+
+    def _serialize_rules(self, rules: List[Rule]) -> List[Dict[str, Any]]:
+        """Serialize rules for caching."""
+        return [
+            {
+                "code": r.code,
+                "name": r.name,
+                "description": r.description,
+                "category": r.category,
+                "severity": r.severity.value,
+                "score": r.score,
+                "enabled": r.enabled,
+                "conditions": r.conditions,
+                "version": r.version,
+                "metadata": r.metadata,
+            }
+            for r in rules
+        ]
+
+    def _deserialize_rules(self, data: List[Dict[str, Any]]) -> List[Rule]:
+        """Deserialize rules from cache."""
+        from ..types import Severity
+
+        return [
+            Rule(
+                code=r["code"],
+                name=r["name"],
+                description=r["description"],
+                category=r["category"],
+                severity=Severity(r["severity"]),
+                score=r["score"],
+                enabled=r["enabled"],
+                conditions=r["conditions"],
+                version=r["version"],
+                metadata=r["metadata"],
+            )
+            for r in data
+        ]
+
+    def get_all(self, filters: Optional[Dict[str, Any]] = None) -> List[Rule]:
+        """Get all rules, with caching."""
+        cache_key = self._make_key("all", filters)
+
+        cached = self._get_cached(cache_key)
+        if cached is not None:
+            return cached
+
+        rules = self._repository.get_all(filters)
+        self._set_cached(cache_key, rules)
+        return rules
+
+    def get_by_code(self, code: str) -> Optional[Rule]:
+        """Get a specific rule by code (not cached, delegates to repository)."""
+        return self._repository.get_by_code(code)
+
+    def save(self, rule: Rule) -> Rule:
+        """Save a rule and invalidate cache."""
+        result = self._repository.save(rule)
+        self.invalidate()
+        return result
+
+    def delete(self, code: str) -> bool:
+        """Delete a rule and invalidate cache."""
+        result = self._repository.delete(code)
+        if result:
+            self.invalidate()
+        return result
+
+    def invalidate(self) -> None:
+        """Clear the cache."""
+        if self._is_redis:
+            # Scan and delete all rules:* keys
+            for key in self._cache.scan_iter(match="rules:*"):
+                self._cache.delete(key)
+        else:
+            self._cache.clear()
+            self._cache_expiry.clear()
+
+    def get_enabled(self, filters: Optional[Dict[str, Any]] = None) -> List[Rule]:
+        """Get only enabled rules, with caching."""
+        all_filters = filters.copy() if filters else {}
+        all_filters["enabled"] = True
+        return self.get_all(all_filters)

pylitmus/storage/database.py

@@ -0,0 +1,181 @@
+"""
+Database rule repository implementation using SQLAlchemy.
+"""
+
+from typing import Any, Callable, Dict, List, Optional, Type
+
+from ..exceptions import StorageError
+from ..types import Rule, Severity
+from .base import RuleRepository
+
+
+class DatabaseRuleRepository(RuleRepository):
+    """SQLAlchemy-based rule storage."""
+
+    def __init__(
+        self,
+        session_factory: Callable,
+        model_class: Optional[Type] = None,
+        table_name: str = "rules",
+    ):
+        """
+        Initialize database repository.
+
+        Args:
+            session_factory: Callable that returns a database session
+            model_class: SQLAlchemy model class for rules (optional)
+            table_name: Name of rules table (if not using model_class)
+        """
+        self.session_factory = session_factory
+        self.model_class = model_class
+        self.table_name = table_name
+
+    def get_all(self, filters: Optional[Dict[str, Any]] = None) -> List[Rule]:
+        """Get all rules, optionally filtered."""
+        try:
+            with self.session_factory() as session:
+                if self.model_class:
+                    query = session.query(self.model_class)
+                    if filters:
+                        query = self._apply_model_filters(query, filters)
+                    return [self._model_to_rule(m) for m in query.all()]
+                else:
+                    # Raw SQL fallback
+                    return self._get_all_raw(session, filters)
+        except Exception as e:
+            raise StorageError(f"Failed to get rules from database: {e}") from e
+
+    def get_by_code(self, code: str) -> Optional[Rule]:
+        """Get a specific rule by code."""
+        try:
+            with self.session_factory() as session:
+                if self.model_class:
+                    model = session.query(self.model_class).filter_by(code=code).first()
+                    return self._model_to_rule(model) if model else None
+                else:
+                    return self._get_by_code_raw(session, code)
+        except Exception as e:
+            raise StorageError(f"Failed to get rule {code} from database: {e}") from e
+
+    def save(self, rule: Rule) -> Rule:
+        """Save a rule (create or update)."""
+        try:
+            with self.session_factory() as session:
+                if self.model_class:
+                    existing = (
+                        session.query(self.model_class)
+                        .filter_by(code=rule.code)
+                        .first()
+                    )
+                    if existing:
+                        self._update_model(existing, rule)
+                    else:
+                        model = self._rule_to_model(rule)
+                        session.add(model)
+                    session.commit()
+                else:
+                    self._save_raw(session, rule)
+                return rule
+        except Exception as e:
+            raise StorageError(
+                f"Failed to save rule {rule.code} to database: {e}"
+            ) from e
+
+    def delete(self, code: str) -> bool:
+        """Delete a rule by code."""
+        try:
+            with self.session_factory() as session:
+                if self.model_class:
+                    model = session.query(self.model_class).filter_by(code=code).first()
+                    if model:
+                        session.delete(model)
+                        session.commit()
+                        return True
+                    return False
+                else:
+                    return self._delete_raw(session, code)
+        except Exception as e:
+            raise StorageError(
+                f"Failed to delete rule {code} from database: {e}"
+            ) from e
+
+    def _model_to_rule(self, model: Any) -> Rule:
+        """Convert SQLAlchemy model to Rule object."""
+        severity_value = model.severity
+        if isinstance(severity_value, str):
+            severity = Severity(severity_value.upper())
+        else:
+            severity = severity_value
+
+        return Rule(
+            code=model.code,
+            name=model.name,
+            description=getattr(model, "description", ""),
+            category=getattr(model, "category", "DEFAULT"),
+            severity=severity,
+            score=getattr(model, "score", 0),
+            enabled=getattr(model, "enabled", True),
+            conditions=getattr(model, "conditions", {}),
+            version=getattr(model, "version", 1),
+            metadata=getattr(model, "metadata", {}),
+        )
+
+    def _rule_to_model(self, rule: Rule) -> Any:
+        """Convert Rule to SQLAlchemy model."""
+        if not self.model_class:
+            raise StorageError("No model class configured")
+
+        return self.model_class(
+            code=rule.code,
+            name=rule.name,
+            description=rule.description,
+            category=rule.category,
+            severity=rule.severity.value,
+            score=rule.score,
+            enabled=rule.enabled,
+            conditions=rule.conditions,
+            version=rule.version,
+            metadata=rule.metadata,
+        )
+
+    def _update_model(self, model: Any, rule: Rule) -> None:
+        """Update model from Rule."""
+        model.name = rule.name
+        model.description = rule.description
+        model.category = rule.category
+        model.severity = rule.severity.value
+        model.score = rule.score
+        model.enabled = rule.enabled
+        model.conditions = rule.conditions
+        model.version = rule.version
+        model.metadata = rule.metadata
+
+    def _apply_model_filters(self, query: Any, filters: Dict[str, Any]) -> Any:
+        """Apply filters to SQLAlchemy query."""
+        if "enabled" in filters:
+            query = query.filter(self.model_class.enabled == filters["enabled"])
+        if "category" in filters:
+            query = query.filter(self.model_class.category == filters["category"])
+        if "severity" in filters:
+            query = query.filter(self.model_class.severity == filters["severity"].value)
+        return query
+
+    # Raw SQL fallback methods (for when no model class is provided)
+    def _get_all_raw(
+        self, session: Any, filters: Optional[Dict[str, Any]]
+    ) -> List[Rule]:
+        """Get all rules using raw SQL."""
+        # This is a placeholder - actual implementation depends on DB setup
+        raise NotImplementedError("Raw SQL queries require model_class to be specified")
+
+    def _get_by_code_raw(self, session: Any, code: str) -> Optional[Rule]:
+        """Get rule by code using raw SQL."""
+        raise NotImplementedError("Raw SQL queries require model_class to be specified")
+
+    def _save_raw(self, session: Any, rule: Rule) -> None:
+        """Save rule using raw SQL."""
+        raise NotImplementedError("Raw SQL queries require model_class to be specified")
+
+    def _delete_raw(self, session: Any, code: str) -> bool:
+        """Delete rule using raw SQL."""
+        raise NotImplementedError("Raw SQL queries require model_class to be specified")

pylitmus/storage/file.py

@@ -0,0 +1,143 @@
+"""
+File-based rule repository implementation.
+"""
+
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import yaml
+
+from ..exceptions import StorageError
+from ..types import Rule, Severity
+from .base import RuleRepository
+
+
+class FileRuleRepository(RuleRepository):
+    """YAML/JSON file-based rule storage."""
+
+    def __init__(self, file_path: str):
+        """
+        Initialize file repository.
+
+        Args:
+            file_path: Path to rules file (YAML or JSON)
+        """
+        self.file_path = Path(file_path)
+        self._rules: Dict[str, Rule] = {}
+        self._load_rules()
+
+    def _load_rules(self) -> None:
+        """Load rules from file."""
+        if not self.file_path.exists():
+            return
+
+        try:
+            with open(self.file_path) as f:
+                if self.file_path.suffix in [".yaml", ".yml"]:
+                    data = yaml.safe_load(f)
+                else:
+                    data = json.load(f)
+
+            if data and "rules" in data:
+                for rule_data in data["rules"]:
+                    rule = self._dict_to_rule(rule_data)
+                    self._rules[rule.code] = rule
+        except Exception as e:
+            raise StorageError(
+                f"Failed to load rules from {self.file_path}: {e}"
+            ) from e
+
+    def _dict_to_rule(self, data: Dict[str, Any]) -> Rule:
+        """Convert dictionary to Rule object."""
+        severity_str = data.get("severity", "MEDIUM")
+        if isinstance(severity_str, str):
+            severity = Severity(severity_str.upper())
+        else:
+            severity = severity_str
+
+        return Rule(
+            code=data["code"],
+            name=data["name"],
+            description=data.get("description", ""),
+            category=data.get("category", "DEFAULT"),
+            severity=severity,
+            score=data.get("score", 0),
+            enabled=data.get("enabled", True),
+            conditions=data.get("conditions", {}),
+            version=data.get("version", 1),
+            metadata=data.get("metadata", {}),
+        )
+
+    def _rule_to_dict(self, rule: Rule) -> Dict[str, Any]:
+        """Convert Rule object to dictionary."""
+        return {
+            "code": rule.code,
+            "name": rule.name,
+            "description": rule.description,
+            "category": rule.category,
+            "severity": rule.severity.value,
+            "score": rule.score,
+            "enabled": rule.enabled,
+            "conditions": rule.conditions,
+            "version": rule.version,
+            "metadata": rule.metadata,
+        }
+
+    def get_all(self, filters: Optional[Dict[str, Any]] = None) -> List[Rule]:
+        """Get all rules, optionally filtered."""
+        rules = list(self._rules.values())
+        if filters:
+            rules = self._apply_filters(rules, filters)
+        return rules
+
+    def get_by_code(self, code: str) -> Optional[Rule]:
+        """Get a specific rule by code."""
+        return self._rules.get(code)
+
+    def save(self, rule: Rule) -> Rule:
+        """Save a rule (updates in-memory, writes to file)."""
+        self._rules[rule.code] = rule
+        self._save_to_file()
+        return rule
+
+    def delete(self, code: str) -> bool:
+        """Delete a rule by code."""
+        if code in self._rules:
+            del self._rules[code]
+            self._save_to_file()
+            return True
+        return False
+
+    def _save_to_file(self) -> None:
+        """Save rules to file."""
+        data = {"rules": [self._rule_to_dict(r) for r in self._rules.values()]}
+
+        try:
+            with open(self.file_path, "w") as f:
+                if self.file_path.suffix in [".yaml", ".yml"]:
+                    yaml.safe_dump(data, f, default_flow_style=False)
+                else:
+                    json.dump(data, f, indent=2)
+        except Exception as e:
+            raise StorageError(f"Failed to save rules to {self.file_path}: {e}") from e
+
+    def _apply_filters(self, rules: List[Rule], filters: Dict[str, Any]) -> List[Rule]:
+        """Apply filters to rule list."""
+        result = rules
+
+        if "enabled" in filters:
+            result = [r for r in result if r.enabled == filters["enabled"]]
+
+        if "category" in filters:
+            result = [r for r in result if r.category == filters["category"]]
+
+        if "severity" in filters:
+            result = [r for r in result if r.severity == filters["severity"]]
+
+        return result
+
+    def reload(self) -> None:
+        """Reload rules from file."""
+        self._rules.clear()
+        self._load_rules()

pylitmus/storage/memory.py

@@ -0,0 +1,107 @@
+"""
+In-memory rule repository implementation.
+"""
+
+from typing import Any, Dict, List, Optional
+
+from ..types import Rule
+from .base import RuleRepository
+
+
+class InMemoryRuleRepository(RuleRepository):
+    """In-memory rule storage for testing and simple use cases."""
+
+    def __init__(self, rules: Optional[List[Rule]] = None):
+        """
+        Initialize in-memory repository.
+
+        Args:
+            rules: Optional list of rules to initialize with
+        """
+        self._rules: Dict[str, Rule] = {}
+        if rules:
+            for rule in rules:
+                self._rules[rule.code] = rule
+
+    def get_all(self, filters: Optional[Dict[str, Any]] = None) -> List[Rule]:
+        """
+        Get all rules, optionally filtered.
+
+        Args:
+            filters: Optional filters to apply
+
+        Returns:
+            List of rules
+        """
+        rules = list(self._rules.values())
+        if filters:
+            rules = self._apply_filters(rules, filters)
+        return rules
+
+    def get_by_code(self, code: str) -> Optional[Rule]:
+        """
+        Get a specific rule by code.
+
+        Args:
+            code: Rule code
+
+        Returns:
+            Rule if found, None otherwise
+        """
+        return self._rules.get(code)
+
+    def save(self, rule: Rule) -> Rule:
+        """
+        Save a rule (create or update).
+
+        Args:
+            rule: Rule to save
+
+        Returns:
+            Saved rule
+        """
+        self._rules[rule.code] = rule
+        return rule
+
+    def delete(self, code: str) -> bool:
+        """
+        Delete a rule by code.
+
+        Args:
+            code: Rule code
+
+        Returns:
+            True if deleted, False otherwise
+        """
+        if code in self._rules:
+            del self._rules[code]
+            return True
+        return False
+
+    def _apply_filters(self, rules: List[Rule], filters: Dict[str, Any]) -> List[Rule]:
+        """
+        Apply filters to rule list.
+
+        Args:
+            rules: List of rules to filter
+            filters: Filters to apply
+
+        Returns:
+            Filtered list of rules
+        """
+        result = rules
+
+        if "enabled" in filters:
+            result = [r for r in result if r.enabled == filters["enabled"]]
+
+        if "category" in filters:
+            result = [r for r in result if r.category == filters["category"]]
+
+        if "severity" in filters:
+            result = [r for r in result if r.severity == filters["severity"]]
+
+        return result
+
+    def clear(self) -> None:
+        """Clear all rules from the repository."""
+        self._rules.clear()

pylitmus/strategies/__init__.py

@@ -0,0 +1,15 @@
+"""
+Scoring strategies module for the CMAP Rules Engine.
+"""
+
+from .base import ScoringStrategy
+from .max import MaxStrategy
+from .sum import SumStrategy
+from .weighted import WeightedStrategy
+
+__all__ = [
+    "ScoringStrategy",
+    "SumStrategy",
+    "WeightedStrategy",
+    "MaxStrategy",
+]