togglemesh 0.2.0__tar.gz

togglemesh-0.2.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: togglemesh
+Version: 0.2.0
+Summary: ToggleMesh Python SDK
+Author: ToggleMesh Team
+Requires-Python: >=3.7
+Requires-Dist: requests>=2.25.0
+Requires-Dist: packaging>=21.3

togglemesh-0.2.0/README.md

@@ -0,0 +1,41 @@
+# ToggleMesh Python SDK (Local Evaluation)
+
+A lightweight, robust Python SDK for evaluating feature flags with ToggleMesh.
+
+This SDK uses **Local Evaluation**. It connects to the ToggleMesh control plane once to fetch all rules, establishes an SSE (Server-Sent Events) connection to listen for updates, and evaluates all flags locally in-memory without making network requests. This ensures ultra-fast responses (sub-millisecond) suitable for high-throughput backend services.
+
+## Installation
+
+```bash
+pip install togglemesh
+```
+
+## Usage
+
+```python
+import time
+from togglemesh import ToggleMeshClient, ToggleMeshOptions
+
+client = ToggleMeshClient(ToggleMeshOptions(
+    base_url="http://localhost:5000",
+    client_key="YOUR_API_KEY"
+))
+
+# 1. Identify the user
+client.identify("user-123", {"tenant": "acme_corp", "plan": "enterprise"})
+
+# 2. Check a flag locally (Zero network latency!)
+if client.is_enabled("new-feature", default_value=False):
+    print("Feature is ON")
+else:
+    print("Feature is OFF")
+
+# 3. Stop background threads when the app shuts down
+client.stop()
+```
+
+## Supported Features
+- Percentage Rollouts (Murmur3 / FNV-1a hashing)
+- Operator matching (Strings, Numbers, Dates, SemVer, Regex)
+- Real-time SSE updates
+- Contextual Rollouts

togglemesh-0.2.0/pyproject.toml

@@ -0,0 +1,16 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "togglemesh"
+version = "0.2.0"
+description = "ToggleMesh Python SDK"
+authors = [
+  { name="ToggleMesh Team" },
+]
+dependencies = [
+    "requests>=2.25.0",
+    "packaging>=21.3",
+]
+requires-python = ">=3.7"

togglemesh-0.2.0/setup.cfg

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

togglemesh-0.2.0/togglemesh/__init__.py

@@ -0,0 +1,4 @@
+from .models import ToggleMeshOptions, FlagState
+from .client import ToggleMeshClient
+
+__all__ = ["ToggleMeshOptions", "FlagState", "ToggleMeshClient"]

togglemesh-0.2.0/togglemesh/client.py

@@ -0,0 +1,377 @@
+import threading
+import json
+import re
+import logging
+import time
+import os
+import queue
+import hashlib
+from typing import Dict, Any, Callable, Set, Optional, List
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+from .models import ToggleMeshOptions, FeatureFlagDto, SegmentDto, RuleDto
+from .rules import RuleEngine, CachedFlag, CachedSegment, evaluate_rollout
+
+logger = logging.getLogger("togglemesh")
+
+def to_snake_case(obj):
+    if isinstance(obj, list):
+        return [to_snake_case(i) for i in obj]
+    elif isinstance(obj, dict):
+        return { re.sub(r'(?<!^)(?=[A-Z])', '_', k).lower(): to_snake_case(v) for k, v in obj.items() }
+    return obj
+
+class FlagMetrics:
+    def __init__(self):
+        self.true_count = 0
+        self.false_count = 0
+
+class ToggleMeshClient:
+    def __init__(self, options: ToggleMeshOptions):
+        self.options = options
+        self.base_url = options.base_url.rstrip("/")
+        
+        self._flags_cache: Dict[str, CachedFlag] = {}
+        self._segments_cache: Dict[str, CachedSegment] = {}
+        self.listeners: Set[Callable[[], None]] = set()
+        
+        self.rule_engine = RuleEngine(segment_provider=self)
+        
+        self._polling_thread = None
+        self._metrics_thread = None
+        self._events_thread = None
+        
+        self._stop_event = threading.Event()
+        self._lock = threading.Lock()
+        
+        self._metrics_buffer: Dict[str, FlagMetrics] = {}
+        self._metrics_lock = threading.Lock()
+        self._events_queue = queue.Queue(maxsize=10000)
+        
+        self._session = self._create_session()
+        self._fallback_path = self._resolve_fallback_path()
+        
+        if self.options.use_fallback_file:
+            self._load_fallback()
+            
+        self._sync_state()
+        self._start_threads()
+
+    def _create_session(self) -> requests.Session:
+        session = requests.Session()
+        session.verify = not self.options.disable_ssl_verification
+        retry = Retry(
+            total=3,
+            read=False,
+            backoff_factor=1,
+            status_forcelist=[500, 502, 503, 504],
+            allowed_methods=["GET", "POST"]
+        )
+        adapter = HTTPAdapter(max_retries=retry)
+        session.mount("http://", adapter)
+        session.mount("https://", adapter)
+        return session
+
+    def _resolve_fallback_path(self) -> Optional[str]:
+        if not self.options.use_fallback_file:
+            return None
+        if self.options.fallback_file_path:
+            return self.options.fallback_file_path
+            
+        safe_key = hashlib.sha256(self.options.client_key.encode('utf-8')).hexdigest()[:12]
+        base_dir = os.path.join(os.getcwd(), ".togglemesh")
+        return os.path.join(base_dir, f"{safe_key}.json")
+
+    def get_segment_rules(self, segment_id: str):
+        segment = self._segments_cache.get(segment_id)
+        return segment.groups if segment else None
+
+    def is_enabled(self, flag_key: str, default_value: bool = False, *, identity: str = None, context: Dict[str, str] = None) -> bool:
+        with self._lock:
+            flag = self._flags_cache.get(flag_key)
+            context = context or {}
+            
+        if not flag:
+            return default_value
+            
+        active_rollout_percentage = flag.rollout_percentage
+        
+        if flag.parsed_contextual_rollouts and flag.original_dto.context_partition_keys:
+            parts = []
+            for key in flag.original_dto.context_partition_keys:
+                parts.append(str(context.get(key, "null")))
+            slice_key = "|".join(parts)
+            if slice_key in flag.parsed_contextual_rollouts:
+                active_rollout_percentage = flag.parsed_contextual_rollouts[slice_key]
+                
+        if not flag.is_enabled or not self.rule_engine.evaluate(flag.groups, context):
+            result = False
+        else:
+            result = evaluate_rollout(active_rollout_percentage, flag_key, identity)
+
+        self._update_metrics(flag_key, result)
+        
+        if identity and flag.is_experiment_active:
+            self._queue_event(
+                evt_type=0,
+                identity=identity,
+                flag_key=flag_key,
+                result=result,
+                properties=context
+            )
+            
+        return result
+
+    def track(self, event_name: str, properties: Any = None, value: float = None, *, identity: str = None):
+        if not identity or not event_name:
+            return
+            
+        self._queue_event(
+            evt_type=1,
+            identity=identity,
+            event_name=event_name,
+            properties=properties,
+            value=value
+        )
+
+    def subscribe(self, listener: Callable[[], None]) -> Callable[[], None]:
+        with self._lock:
+            self.listeners.add(listener)
+        def unsubscribe():
+            with self._lock:
+                self.listeners.discard(listener)
+        return unsubscribe
+
+    def _notify_listeners(self):
+        with self._lock:
+            callbacks = list(self.listeners)
+        for cb in callbacks:
+            try:
+                cb()
+            except Exception as e:
+                logger.error(f"[ToggleMesh] Listener callback error: {e}")
+
+    def _update_metrics(self, flag_key: str, result: bool):
+        if not self.options.is_metrics_enabled: return
+        with self._metrics_lock:
+            if flag_key not in self._metrics_buffer:
+                self._metrics_buffer[flag_key] = FlagMetrics()
+            if result:
+                self._metrics_buffer[flag_key].true_count += 1
+            else:
+                self._metrics_buffer[flag_key].false_count += 1
+
+    def _queue_event(self, evt_type: int, identity: str, flag_key: str = None, 
+                     result: bool = False, event_name: str = None, 
+                     properties: Any = None, value: float = None):
+        if not self.options.is_metrics_enabled: return
+        try:
+            evt = {
+                "Type": evt_type,
+                "Timestamp": int(time.time() * 1000),
+                "Identity": identity,
+                "Properties": properties
+            }
+            if flag_key: evt["FlagKey"] = flag_key
+            if result is not None: evt["Result"] = result
+            if event_name: evt["EventName"] = event_name
+            if value is not None: evt["Value"] = value
+            
+            self._events_queue.put_nowait(evt)
+        except queue.Full:
+            pass
+
+    def _sync_state(self) -> None:
+        url = f"{self.base_url}/api/v1/sdk/flags"
+        headers = {"x-api-key": self.options.client_key}
+        try:
+            response = self._session.get(url, headers=headers, timeout=10)
+            if response.status_code != 200:
+                logger.warning(f"[ToggleMesh] Failed to sync state: {response.status_code}")
+                return
+            
+            data = to_snake_case(response.json())
+            
+            with self._lock:
+                self._flags_cache.clear()
+                self._segments_cache.clear()
+                
+                for f_data in data.get("flags", []):
+                    rules = [RuleDto.from_dict(r) for r in f_data.get("rules", [])]
+                    f_data["rules"] = rules
+                    dto = FeatureFlagDto.from_dict(f_data)
+                    self._cache_flag(dto)
+                    
+                for s_data in data.get("segments", []):
+                    rules = [RuleDto.from_dict(r) for r in s_data.get("rules", [])]
+                    s_data["rules"] = rules
+                    dto = SegmentDto.from_dict(s_data)
+                    self._cache_segment(dto)
+                    
+            self._notify_listeners()
+            self._save_fallback(data)
+        except Exception as e:
+            logger.error(f"[ToggleMesh] Error syncing state: {e}")
+
+    def _cache_flag(self, dto: FeatureFlagDto):
+        groups = self.rule_engine.compile_rules(dto.rules)
+        self._flags_cache[dto.key] = CachedFlag(dto, groups)
+        
+    def _cache_segment(self, dto: SegmentDto):
+        groups = self.rule_engine.compile_rules(dto.rules)
+        self._segments_cache[dto.id] = CachedSegment(dto, groups)
+
+    def _load_fallback(self):
+        if not self._fallback_path or not os.path.exists(self._fallback_path):
+            return
+        try:
+            with open(self._fallback_path, 'r', encoding='utf-8') as f:
+                data = to_snake_case(json.load(f))
+                with self._lock:
+                    for f_data in data.get("flags", []):
+                        rules = [RuleDto.from_dict(r) for r in f_data.get("rules", [])]
+                        f_data["rules"] = rules
+                        self._cache_flag(FeatureFlagDto.from_dict(f_data))
+                    for s_data in data.get("segments", []):
+                        rules = [RuleDto.from_dict(r) for r in s_data.get("rules", [])]
+                        s_data["rules"] = rules
+                        self._cache_segment(SegmentDto.from_dict(s_data))
+                logger.info("[ToggleMesh] Loaded fallback state.")
+        except Exception as e:
+            logger.error(f"[ToggleMesh] Failed to load fallback: {e}")
+
+    def _save_fallback(self, data: Any):
+        if not self._fallback_path: return
+        try:
+            os.makedirs(os.path.dirname(self._fallback_path), exist_ok=True)
+            with open(self._fallback_path + '.tmp', 'w', encoding='utf-8') as f:
+                json.dump(data, f)
+            os.replace(self._fallback_path + '.tmp', self._fallback_path)
+        except Exception as e:
+            logger.error(f"[ToggleMesh] Failed to save fallback: {e}")
+
+    def _start_threads(self) -> None:
+        self._stop_event.clear()
+        self._polling_thread = threading.Thread(target=self._sse_loop, daemon=True)
+        self._polling_thread.start()
+        
+        if self.options.is_metrics_enabled:
+            self._metrics_thread = threading.Thread(target=self._metrics_flusher, daemon=True)
+            self._metrics_thread.start()
+            
+            self._events_thread = threading.Thread(target=self._events_flusher, daemon=True)
+            self._events_thread.start()
+
+    def _sse_loop(self) -> None:
+        url = f"{self.base_url}/api/v1/stream"
+        headers = {"x-api-key": self.options.client_key, "Accept": "text/event-stream"}
+        backoff = 1
+        
+        while not self._stop_event.is_set():
+            try:
+                with self._session.get(url, headers=headers, stream=True, timeout=60) as response:
+                    if response.status_code == 401:
+                        logger.critical("[ToggleMesh] Invalid API Key. Background sync loop stopped permanently.")
+                        self.stop()
+                        break
+                    
+                    if response.status_code != 200:
+                        raise Exception(f"Bad status code {response.status_code}")
+                        
+                    backoff = 1
+                    for line in response.iter_lines(decode_unicode=True):
+                        if self._stop_event.is_set():
+                            break
+                        if line and line.startswith("data: "):
+                            self._handle_sse_event(line[6:])
+            except Exception as e:
+                logger.debug(f"[ToggleMesh] SSE connection error: {e}. Reconnecting in {backoff}s...")
+                self._stop_event.wait(backoff)
+                backoff = min(backoff * 2, 30)
+                self._sync_state()
+
+    def _handle_sse_event(self, data: str):
+        try:
+            doc = json.loads(data)
+            event_name = doc.get("EventName")
+            if event_name == "FlagUpdated" and "Payload" in doc:
+                payload = doc["Payload"]
+                if isinstance(payload, str): payload = json.loads(payload)
+                
+                payload = to_snake_case(payload)
+                
+                payload["rules"] = [RuleDto.from_dict(r) for r in payload.get("rules", [])]
+                dto = FeatureFlagDto.from_dict(payload)
+                with self._lock:
+                    self._cache_flag(dto)
+                self._notify_listeners()
+            elif event_name == "StateReloadRequired":
+                self._sync_state()
+        except Exception as e:
+            logger.error(f"[ToggleMesh] Failed to parse SSE event: {e}")
+
+    def _metrics_flusher(self):
+        url = f"{self.base_url}/api/v1/sdk/metrics"
+        headers = {"x-api-key": self.options.client_key, "Content-Type": "application/json"}
+        
+        while not self._stop_event.is_set():
+            if self._stop_event.wait(10):
+                break
+                
+            payload = []
+            with self._metrics_lock:
+                for key, m in list(self._metrics_buffer.items()):
+                    if m.true_count > 0 or m.false_count > 0:
+                        payload.append({"Key": key, "TrueCount": m.true_count, "FalseCount": m.false_count})
+                        m.true_count = 0
+                        m.false_count = 0
+                        
+            if not payload: continue
+                
+            try:
+                self._session.post(url, json=payload, headers=headers, timeout=5)
+            except Exception as e:
+                logger.debug(f"[ToggleMesh] Failed to flush metrics: {e}")
+                with self._metrics_lock:
+                    for item in payload:
+                        if item["Key"] not in self._metrics_buffer:
+                            self._metrics_buffer[item["Key"]] = FlagMetrics()
+                        self._metrics_buffer[item["Key"]].true_count += item["TrueCount"]
+                        self._metrics_buffer[item["Key"]].false_count += item["FalseCount"]
+
+    def _events_flusher(self):
+        url = f"{self.base_url}/api/v1/sdk/events"
+        headers = {"x-api-key": self.options.client_key, "Content-Type": "application/json"}
+        
+        while not self._stop_event.is_set():
+            if self._stop_event.wait(10):
+                break
+                
+            batch = []
+            while not self._events_queue.empty() and len(batch) < 1000:
+                try:
+                    batch.append(self._events_queue.get_nowait())
+                except queue.Empty:
+                    break
+                    
+            if not batch: continue
+                
+            try:
+                self._session.post(url, json={"Events": batch}, headers=headers, timeout=5)
+            except Exception as e:
+                logger.debug(f"[ToggleMesh] Failed to flush events: {e}")
+                for evt in batch:
+                    try:
+                        self._events_queue.put_nowait(evt)
+                    except queue.Empty:
+                        pass
+                    except queue.Full:
+                        break
+
+    def stop(self):
+        self._stop_event.set()
+        if self._polling_thread: self._polling_thread.join(timeout=2.0)
+        if self._metrics_thread: self._metrics_thread.join(timeout=2.0)
+        if self._events_thread: self._events_thread.join(timeout=2.0)

togglemesh-0.2.0/togglemesh/models.py

@@ -0,0 +1,63 @@
+from dataclasses import dataclass, field
+from typing import List, Dict, Any, Optional
+import inspect
+
+@dataclass
+class ToggleMeshOptions:
+    base_url: str
+    client_key: str
+    refresh_interval: int = 60
+    is_metrics_enabled: bool = True
+    use_fallback_file: bool = False
+    fallback_file_path: Optional[str] = None
+    disable_ssl_verification: bool = False
+
+@dataclass
+class FlagState:
+    key: str
+    is_enabled: bool
+
+def _from_dict(cls, data):
+    valid_keys = inspect.signature(cls).parameters.keys()
+    filtered = {k: v for k, v in data.items() if k in valid_keys}
+    return cls(**filtered)
+
+@dataclass
+class RuleDto:
+    group_id: int
+    attribute: str
+    operator: str
+    value: str
+
+    @classmethod
+    def from_dict(cls, data):
+        return _from_dict(cls, data)
+
+@dataclass
+class FeatureFlagDto:
+    key: str
+    is_enabled: bool
+    is_experiment_active: bool
+    rollout_percentage: Optional[int]
+    context_partition_keys: Optional[List[str]]
+    contextual_rollouts: Optional[Dict[str, int]]
+    rules: List[RuleDto]
+
+    @classmethod
+    def from_dict(cls, data):
+        return _from_dict(cls, data)
+
+@dataclass
+class SegmentDto:
+    id: str
+    name: str
+    rules: List[RuleDto]
+
+    @classmethod
+    def from_dict(cls, data):
+        return _from_dict(cls, data)
+
+@dataclass
+class SdkGetFlagsResponse:
+    flags: List[FeatureFlagDto]
+    segments: List[SegmentDto]

togglemesh-0.2.0/togglemesh/operators.py

@@ -0,0 +1,236 @@
+import re
+from datetime import datetime
+from typing import Any, Optional, Set
+from packaging.version import Version, InvalidVersion
+
+class RuleOperator:
+    @property
+    def name(self) -> str:
+        raise NotImplementedError()
+
+    def compile(self, rule_value: str) -> Any:
+        return rule_value
+
+    def evaluate(self, user_value: str, compiled_rule_value: Any) -> bool:
+        raise NotImplementedError()
+
+
+class EqualsOperator(RuleOperator):
+    @property
+    def name(self) -> str: return "Equals"
+    def evaluate(self, user_value: str, compiled_rule_value: Any) -> bool:
+        return user_value == compiled_rule_value
+
+class NotEqualsOperator(RuleOperator):
+    @property
+    def name(self) -> str: return "NotEquals"
+    def evaluate(self, user_value: str, compiled_rule_value: Any) -> bool:
+        return user_value != compiled_rule_value
+
+class ContainsOperator(RuleOperator):
+    @property
+    def name(self) -> str: return "Contains"
+    def evaluate(self, user_value: str, compiled_rule_value: Any) -> bool:
+        return str(compiled_rule_value) in user_value
+
+class StartsWithOperator(RuleOperator):
+    @property
+    def name(self) -> str: return "StartsWith"
+    def evaluate(self, user_value: str, compiled_rule_value: Any) -> bool:
+        return user_value.startswith(str(compiled_rule_value))
+
+class EndsWithOperator(RuleOperator):
+    @property
+    def name(self) -> str: return "EndsWith"
+    def evaluate(self, user_value: str, compiled_rule_value: Any) -> bool:
+        return user_value.endswith(str(compiled_rule_value))
+
+class InListOperator(RuleOperator):
+    @property
+    def name(self) -> str: return "InList"
+    def compile(self, rule_value: str) -> Set[str]:
+        return {x.strip() for x in rule_value.split(",")} if rule_value else set()
+    def evaluate(self, user_value: str, compiled_rule_value: Any) -> bool:
+        return user_value in compiled_rule_value
+
+class RegexOperator(RuleOperator):
+    @property
+    def name(self) -> str: return "Regex"
+    def compile(self, rule_value: str) -> Any:
+        try:
+            return re.compile(rule_value)
+        except Exception:
+            return None
+    def evaluate(self, user_value: str, compiled_rule_value: Any) -> bool:
+        if compiled_rule_value is None:
+            return False
+        return compiled_rule_value.match(user_value) is not None
+
+class NumberOperatorBase(RuleOperator):
+    def compile(self, rule_value: str) -> Any:
+        try:
+            return float(rule_value)
+        except ValueError:
+            return None
+
+class GreaterThanOperator(NumberOperatorBase):
+    @property
+    def name(self) -> str: return "GreaterThan"
+    def evaluate(self, user_value: str, compiled_rule_value: Any) -> bool:
+        if compiled_rule_value is None: return False
+        try:
+            return float(user_value) > compiled_rule_value
+        except ValueError:
+            return False
+
+class GreaterThanOrEqualOperator(NumberOperatorBase):
+    @property
+    def name(self) -> str: return "GreaterThanOrEqual"
+    def evaluate(self, user_value: str, compiled_rule_value: Any) -> bool:
+        if compiled_rule_value is None: return False
+        try:
+            return float(user_value) >= compiled_rule_value
+        except ValueError:
+            return False
+
+class LessThanOperator(NumberOperatorBase):
+    @property
+    def name(self) -> str: return "LessThan"
+    def evaluate(self, user_value: str, compiled_rule_value: Any) -> bool:
+        if compiled_rule_value is None: return False
+        try:
+            return float(user_value) < compiled_rule_value
+        except ValueError:
+            return False
+
+class LessThanOrEqualOperator(NumberOperatorBase):
+    @property
+    def name(self) -> str: return "LessThanOrEqual"
+    def evaluate(self, user_value: str, compiled_rule_value: Any) -> bool:
+        if compiled_rule_value is None: return False
+        try:
+            return float(user_value) <= compiled_rule_value
+        except ValueError:
+            return False
+
+class DateOperatorBase(RuleOperator):
+    def compile(self, rule_value: str) -> Any:
+        try:
+            return datetime.fromisoformat(rule_value.replace('Z', '+00:00'))
+        except ValueError:
+            return None
+
+class DateAfterOperator(DateOperatorBase):
+    @property
+    def name(self) -> str: return "DateAfter"
+    def evaluate(self, user_value: str, compiled_rule_value: Any) -> bool:
+        if compiled_rule_value is None: return False
+        try:
+            uv = datetime.fromisoformat(user_value.replace('Z', '+00:00'))
+            return uv > compiled_rule_value
+        except ValueError:
+            return False
+
+class DateBeforeOperator(DateOperatorBase):
+    @property
+    def name(self) -> str: return "DateBefore"
+    def evaluate(self, user_value: str, compiled_rule_value: Any) -> bool:
+        if compiled_rule_value is None: return False
+        try:
+            uv = datetime.fromisoformat(user_value.replace('Z', '+00:00'))
+            return uv < compiled_rule_value
+        except ValueError:
+            return False
+
+class SemVerOperatorBase(RuleOperator):
+    def compile(self, rule_value: str) -> Any:
+        try:
+            return Version(rule_value)
+        except InvalidVersion:
+            return None
+
+class SemVerEqualOperator(SemVerOperatorBase):
+    @property
+    def name(self) -> str: return "SemVerEqual"
+    def evaluate(self, user_value: str, compiled_rule_value: Any) -> bool:
+        if compiled_rule_value is None: return False
+        try:
+            return Version(user_value) == compiled_rule_value
+        except InvalidVersion:
+            return False
+
+class SemVerGreaterThanOperator(SemVerOperatorBase):
+    @property
+    def name(self) -> str: return "SemVerGreaterThan"
+    def evaluate(self, user_value: str, compiled_rule_value: Any) -> bool:
+        if compiled_rule_value is None: return False
+        try:
+            return Version(user_value) > compiled_rule_value
+        except InvalidVersion:
+            return False
+
+class SemVerGreaterThanOrEqualOperator(SemVerOperatorBase):
+    @property
+    def name(self) -> str: return "SemVerGreaterThanOrEqual"
+    def evaluate(self, user_value: str, compiled_rule_value: Any) -> bool:
+        if compiled_rule_value is None: return False
+        try:
+            return Version(user_value) >= compiled_rule_value
+        except InvalidVersion:
+            return False
+
+class SemVerLessThanOperator(SemVerOperatorBase):
+    @property
+    def name(self) -> str: return "SemVerLessThan"
+    def evaluate(self, user_value: str, compiled_rule_value: Any) -> bool:
+        if compiled_rule_value is None: return False
+        try:
+            return Version(user_value) < compiled_rule_value
+        except InvalidVersion:
+            return False
+
+class SemVerLessThanOrEqualOperator(SemVerOperatorBase):
+    @property
+    def name(self) -> str: return "SemVerLessThanOrEqual"
+    def evaluate(self, user_value: str, compiled_rule_value: Any) -> bool:
+        if compiled_rule_value is None: return False
+        try:
+            return Version(user_value) <= compiled_rule_value
+        except InvalidVersion:
+            return False
+
+
+class FalseOperator(RuleOperator):
+    @property
+    def name(self) -> str: return "False"
+    def compile(self, rule_value: str) -> Any: return None
+    def evaluate(self, user_value: str, compiled_rule_value: Any) -> bool: return False
+
+class InSegmentOperator(RuleOperator):
+    @property
+    def name(self) -> str: return "InSegment"
+    def compile(self, rule_value: str) -> Any: return rule_value
+    def evaluate(self, user_value: str, compiled_rule_value: Any) -> bool: return False
+
+ALL_OPERATORS = [
+    EqualsOperator(),
+    NotEqualsOperator(),
+    ContainsOperator(),
+    StartsWithOperator(),
+    EndsWithOperator(),
+    InListOperator(),
+    RegexOperator(),
+    GreaterThanOperator(),
+    GreaterThanOrEqualOperator(),
+    LessThanOperator(),
+    LessThanOrEqualOperator(),
+    DateAfterOperator(),
+    DateBeforeOperator(),
+    SemVerEqualOperator(),
+    SemVerGreaterThanOperator(),
+    SemVerGreaterThanOrEqualOperator(),
+    SemVerLessThanOperator(),
+    SemVerLessThanOrEqualOperator()
+]
+
+OPERATOR_MAP = {op.name.lower(): op for op in ALL_OPERATORS}

togglemesh-0.2.0/togglemesh/rules.py

@@ -0,0 +1,131 @@
+import json
+from dataclasses import dataclass
+from typing import List, Dict, Any, Optional
+
+from .models import FeatureFlagDto, RuleDto, SegmentDto
+from .operators import OPERATOR_MAP, RuleOperator, FalseOperator, InSegmentOperator
+
+def calculate_fnv1a_hash(text: str) -> int:
+    offset_basis = 2166136261
+    prime = 16777619
+    hash_val = offset_basis
+    
+    encoded = text.encode("utf-8")
+    for byte in encoded:
+        hash_val ^= byte
+        hash_val = (hash_val * prime) & 0xFFFFFFFF
+    
+    return hash_val
+
+def evaluate_rollout(rollout_percentage: Optional[int], flag_key: str, identity: str) -> bool:
+    if rollout_percentage is None:
+        return True
+    if rollout_percentage <= 0:
+        return False
+    if rollout_percentage >= 100:
+        return True
+    if not identity:
+        return False
+        
+    hash_val = calculate_fnv1a_hash(flag_key + identity)
+    bucket = hash_val % 100
+    return bucket < rollout_percentage
+
+
+@dataclass
+class CompiledRule:
+    attribute: str
+    operator: RuleOperator
+    compiled_value: Any
+
+@dataclass
+class CompiledRuleGroup:
+    rules: List[CompiledRule]
+
+class CachedFlag:
+    def __init__(self, dto: FeatureFlagDto, groups: List[CompiledRuleGroup]):
+        self.key = dto.key
+        self.is_enabled = dto.is_enabled
+        self.rollout_percentage = dto.rollout_percentage
+        self.contextual_rollouts = dto.contextual_rollouts
+        self.is_experiment_active = dto.is_experiment_active
+        self.groups = groups
+        self.original_dto = dto
+        
+        self.parsed_contextual_rollouts = {}
+        if dto.contextual_rollouts and dto.context_partition_keys:
+            for k, v in dto.contextual_rollouts.items():
+                try:
+                    d = json.loads(k)
+                    parts = []
+                    for key in dto.context_partition_keys:
+                        parts.append(str(d.get(key, "null")))
+                    slice_key = "|".join(parts)
+                    self.parsed_contextual_rollouts[slice_key] = v
+                except Exception:
+                    pass
+
+class CachedSegment:
+    def __init__(self, dto: SegmentDto, groups: List[CompiledRuleGroup]):
+        self.id = dto.id
+        self.name = dto.name
+        self.groups = groups
+
+
+class RuleEngine:
+    def __init__(self, segment_provider=None):
+        self.segment_provider = segment_provider
+
+    def compile_rules(self, rules: List[RuleDto]) -> List[CompiledRuleGroup]:
+        if not rules:
+            return []
+            
+        groups_dict = {}
+        for r in rules:
+            if r.group_id not in groups_dict:
+                groups_dict[r.group_id] = []
+            groups_dict[r.group_id].append(r)
+            
+        compiled_groups = []
+        for g_id, g_rules in groups_dict.items():
+            compiled_rules = []
+            for r in g_rules:
+                if r.operator.lower() == "insegment":
+                    op = InSegmentOperator()
+                else:
+                    op = OPERATOR_MAP.get(r.operator.lower(), FalseOperator())
+                    
+                compiled_rules.append(CompiledRule(
+                    attribute=r.attribute,
+                    operator=op,
+                    compiled_value=op.compile(r.value)
+                ))
+            compiled_groups.append(CompiledRuleGroup(rules=compiled_rules))
+            
+        return compiled_groups
+
+    def evaluate(self, groups: List[CompiledRuleGroup], context: Dict[str, str]) -> bool:
+        if not groups:
+            return True
+            
+        for group in groups:
+            group_passed = True
+            for rule in group.rules:
+                if isinstance(rule.operator, InSegmentOperator):
+                    if self.segment_provider:
+                        segment_rules = self.segment_provider.get_segment_rules(rule.compiled_value)
+                        if segment_rules is not None and self.evaluate(segment_rules, context):
+                            continue
+                else:
+                    user_value = context.get(rule.attribute)
+                    if user_value is not None:
+                        if rule.operator.evaluate(str(user_value), rule.compiled_value):
+                            continue
+                
+                group_passed = False
+                break
+                
+            if group_passed:
+                return True
+                
+        return False

togglemesh-0.2.0/togglemesh.egg-info/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: togglemesh
+Version: 0.2.0
+Summary: ToggleMesh Python SDK
+Author: ToggleMesh Team
+Requires-Python: >=3.7
+Requires-Dist: requests>=2.25.0
+Requires-Dist: packaging>=21.3

togglemesh-0.2.0/togglemesh.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+togglemesh/__init__.py
+togglemesh/client.py
+togglemesh/models.py
+togglemesh/operators.py
+togglemesh/rules.py
+togglemesh.egg-info/PKG-INFO
+togglemesh.egg-info/SOURCES.txt
+togglemesh.egg-info/dependency_links.txt
+togglemesh.egg-info/requires.txt
+togglemesh.egg-info/top_level.txt

togglemesh-0.2.0/togglemesh.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

togglemesh-0.2.0/togglemesh.egg-info/requires.txt

@@ -0,0 +1,2 @@
+requests>=2.25.0
+packaging>=21.3

togglemesh-0.2.0/togglemesh.egg-info/top_level.txt

@@ -0,0 +1 @@
+togglemesh