flagura-sdk 1.0.0__tar.gz

flagura_sdk-1.0.0/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: flagura-sdk
+Version: 1.0.0
+Summary: Official Python SDK and OpenFeature Provider for Flagura
+Author-email: Dhawal Dyavanpalli <dhawalhost@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/dhawalhost/flagura
+Project-URL: Repository, https://github.com/dhawalhost/flagura
+Keywords: feature-flags,feature-toggles,openfeature,flagura,a-b-testing
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0
+Requires-Dist: openfeature-sdk>=0.7.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: build>=1.0.0; extra == "dev"
+Requires-Dist: twine>=4.0.0; extra == "dev"
+
+# ⚡ Flagura Python SDK
+
+Official Python client for the **Flagura Feature Flag Platform**, supporting:
+- High-performance evaluations
+- **Real-Time SSE Flag Streaming (`<5ms` sync)**
+- **CNCF OpenFeature Provider**
+- FastAPI, Django, Flask, Celery, and AI Agent compatibility
+
+---
+
+## 📦 Installation
+
+```bash
+pip install flagura
+```
+
+---
+
+## 🚀 Quickstart
+
+### 1. Direct Client with Real-Time SSE Streaming
+
+```python
+from flagura import FlaguraClient, EvaluationContext
+
+# Initialize client with real-time SSE streaming
+client = FlaguraClient(
+    endpoint="https://flagura.dhawalhost.com",
+    api_key="your-api-key",
+    project_id="proj_default", # optional: project scoping
+    default_environment="production",
+    enable_streaming=True, # <5ms live flag updates
+)
+
+# Register real-time change listener
+client.on_update(lambda flags: print(f"Flags updated in real-time! Count: {len(flags)}"))
+
+# Evaluate flag
+context = EvaluationContext(
+    user_id="usr_dhawal_01",
+    email="dhawal@flagura.dev",
+    tier="enterprise",
+)
+
+if client.is_enabled("ai-smart-search", context):
+    variant = client.get_variant("ai-smart-search", context)
+    print(f"AI Smart Search is ON! Variant: {variant}")
+
+# Cleanup on shutdown
+client.close()
+```
+
+---
+
+### 2. OpenFeature Universal Provider
+
+```python
+from openfeature import api
+from openfeature.evaluation_context import EvaluationContext
+from flagura.openfeature_provider import FlaguraOpenFeatureProvider
+
+# Register Flagura as OpenFeature provider
+api.set_provider(FlaguraOpenFeatureProvider(
+    endpoint="https://flagura.dhawalhost.com",
+    api_key="your-api-key",
+    enable_streaming=True,
+))
+of_client = api.get_client()
+
+# Evaluate with OpenFeature standard APIs
+ctx = EvaluationContext(targeting_key="usr_dhawal_01", attributes={"email": "dhawal@flagura.dev"})
+is_enabled = of_client.get_boolean_value("ai-smart-search", False, ctx)
+```
+
+---
+
+## 📄 License
+MIT

flagura_sdk-1.0.0/README.md

@@ -0,0 +1,78 @@
+# ⚡ Flagura Python SDK
+
+Official Python client for the **Flagura Feature Flag Platform**, supporting:
+- High-performance evaluations
+- **Real-Time SSE Flag Streaming (`<5ms` sync)**
+- **CNCF OpenFeature Provider**
+- FastAPI, Django, Flask, Celery, and AI Agent compatibility
+
+---
+
+## 📦 Installation
+
+```bash
+pip install flagura
+```
+
+---
+
+## 🚀 Quickstart
+
+### 1. Direct Client with Real-Time SSE Streaming
+
+```python
+from flagura import FlaguraClient, EvaluationContext
+
+# Initialize client with real-time SSE streaming
+client = FlaguraClient(
+    endpoint="https://flagura.dhawalhost.com",
+    api_key="your-api-key",
+    project_id="proj_default", # optional: project scoping
+    default_environment="production",
+    enable_streaming=True, # <5ms live flag updates
+)
+
+# Register real-time change listener
+client.on_update(lambda flags: print(f"Flags updated in real-time! Count: {len(flags)}"))
+
+# Evaluate flag
+context = EvaluationContext(
+    user_id="usr_dhawal_01",
+    email="dhawal@flagura.dev",
+    tier="enterprise",
+)
+
+if client.is_enabled("ai-smart-search", context):
+    variant = client.get_variant("ai-smart-search", context)
+    print(f"AI Smart Search is ON! Variant: {variant}")
+
+# Cleanup on shutdown
+client.close()
+```
+
+---
+
+### 2. OpenFeature Universal Provider
+
+```python
+from openfeature import api
+from openfeature.evaluation_context import EvaluationContext
+from flagura.openfeature_provider import FlaguraOpenFeatureProvider
+
+# Register Flagura as OpenFeature provider
+api.set_provider(FlaguraOpenFeatureProvider(
+    endpoint="https://flagura.dhawalhost.com",
+    api_key="your-api-key",
+    enable_streaming=True,
+))
+of_client = api.get_client()
+
+# Evaluate with OpenFeature standard APIs
+ctx = EvaluationContext(targeting_key="usr_dhawal_01", attributes={"email": "dhawal@flagura.dev"})
+is_enabled = of_client.get_boolean_value("ai-smart-search", False, ctx)
+```
+
+---
+
+## 📄 License
+MIT

flagura_sdk-1.0.0/flagura/__init__.py

@@ -0,0 +1,5 @@
+from .client import FlaguraClient, EvaluationContext, EvaluationResult
+from .openfeature_provider import FlaguraOpenFeatureProvider
+
+__all__ = ["FlaguraClient", "EvaluationContext", "EvaluationResult", "FlaguraOpenFeatureProvider"]
+__version__ = "1.1.0"

flagura_sdk-1.0.0/flagura/client.py

@@ -0,0 +1,234 @@
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, List, Optional
+import urllib.request
+import urllib.error
+import json
+import threading
+import time
+import datetime
+
+
+@dataclass
+class EvaluationContext:
+    user_id: str
+    email: Optional[str] = None
+    country: Optional[str] = None
+    role: Optional[str] = None
+    tier: Optional[str] = None
+    environment: str = "production"
+    custom: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        d: Dict[str, Any] = {
+            "user_id": self.user_id,
+            "environment": self.environment,
+        }
+        if self.email:
+            d["email"] = self.email
+        if self.country:
+            d["country"] = self.country
+        if self.role:
+            d["role"] = self.role
+        if self.tier:
+            d["tier"] = self.tier
+        if self.custom:
+            d["custom"] = self.custom
+        return d
+
+
+@dataclass
+class EvaluationResult:
+    flag_key: str
+    enabled: bool
+    variant: str = "off"
+    value: Any = False
+    reason: str = ""
+    bucket: Optional[float] = None
+    latency_ns: int = 0
+    latency_us: float = 0.0
+
+
+class FlaguraClient:
+    """Official Python Client for Flagura Feature Flag Platform."""
+
+    def __init__(
+        self,
+        endpoint: str = "http://localhost:3000",
+        api_key: Optional[str] = None,
+        project_id: Optional[str] = None,
+        default_environment: str = "production",
+        timeout: float = 5.0,
+        enable_streaming: bool = False,
+    ):
+        self.endpoint = endpoint.rstrip("/")
+        self.api_key = api_key
+        self.project_id = project_id
+        self.default_environment = default_environment
+        self.timeout = timeout
+        self._local_flags: Dict[str, Any] = {}
+        self._listeners: List[Callable[[Dict[str, Any]], None]] = []
+        self._stop_event = threading.Event()
+        self._stream_thread: Optional[threading.Thread] = None
+
+        if enable_streaming:
+            self._start_streaming()
+
+    def on_update(self, callback: Callable[[Dict[str, Any]], None]) -> None:
+        """Register a callback invoked when feature flags are updated in real time."""
+        self._listeners.append(callback)
+
+    def _start_streaming(self) -> None:
+        self._stream_thread = threading.Thread(target=self._stream_worker, daemon=True)
+        self._stream_thread.start()
+
+    def _stream_worker(self) -> None:
+        url = f"{self.endpoint}/api/v1/flags/stream"
+        headers = {"Accept": "text/event-stream"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        if self.project_id:
+            headers["X-Project-ID"] = self.project_id
+
+        while not self._stop_event.is_set():
+            try:
+                req = urllib.request.Request(url, headers=headers)
+                with urllib.request.urlopen(req, timeout=30) as resp:
+                    for line_bytes in resp:
+                        if self._stop_event.is_set():
+                            break
+                        line = line_bytes.decode("utf-8").strip()
+                        if line.startswith("data:"):
+                            try:
+                                data_str = line[5:].strip()
+                                if data_str == "ping" or not data_str:
+                                    continue
+                                payload = json.loads(data_str)
+                                if isinstance(payload, list):
+                                    self._local_flags = {f["key"]: f for f in payload if "key" in f}
+                                elif isinstance(payload, dict) and "flags" in payload:
+                                    raw_flags = payload["flags"]
+                                    if isinstance(raw_flags, list):
+                                        self._local_flags = {f["key"]: f for f in raw_flags if "key" in f}
+                                    elif isinstance(raw_flags, dict):
+                                        self._local_flags = raw_flags
+                                for listener in self._listeners:
+                                    listener(dict(self._local_flags))
+                            except Exception:
+                                pass
+            except Exception:
+                if not self._stop_event.is_set():
+                    time.sleep(3.0)
+
+    def is_enabled(self, flag_key: str, context: EvaluationContext) -> bool:
+        """Check if a boolean flag is enabled for the given context."""
+        try:
+            res = self.evaluate(flag_key, context)
+            return bool(res.enabled)
+        except Exception:
+            return False
+
+    def get_variant(self, flag_key: str, context: EvaluationContext, fallback: str = "off") -> str:
+        """Retrieve the assigned variant string for a multivariate flag."""
+        try:
+            res = self.evaluate(flag_key, context)
+            return res.variant if res.variant and res.variant != "off" else fallback
+        except Exception:
+            return fallback
+
+    def evaluate(self, flag_key: str, context: EvaluationContext) -> EvaluationResult:
+        """Evaluate a single feature flag."""
+        results = self.evaluate_batch([flag_key], context)
+        if flag_key in results:
+            return results[flag_key]
+        return EvaluationResult(
+            flag_key=flag_key,
+            enabled=False,
+            variant="off",
+            value=False,
+            reason="FLAG_NOT_FOUND",
+        )
+
+    def evaluate_batch(self, flag_keys: List[str], context: EvaluationContext) -> Dict[str, EvaluationResult]:
+        """Evaluate multiple feature flags concurrently in a single HTTP payload."""
+        ctx_dict = context.to_dict()
+        if "environment" not in ctx_dict or not ctx_dict["environment"]:
+            ctx_dict["environment"] = self.default_environment
+
+        payload = {
+            "flags": flag_keys,
+            "context": ctx_dict,
+        }
+
+        req_data = json.dumps(payload).encode("utf-8")
+        headers = {"Content-Type": "application/json"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        if self.project_id:
+            headers["X-Project-ID"] = self.project_id
+
+        req = urllib.request.Request(
+            f"{self.endpoint}/api/v1/evaluate",
+            data=req_data,
+            headers=headers,
+            method="POST",
+        )
+
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                data = json.loads(resp.read().decode("utf-8"))
+                results: Dict[str, EvaluationResult] = {}
+                raw_results = data.get("results", {})
+
+                for k, v in raw_results.items():
+                    results[k] = EvaluationResult(
+                        flag_key=v.get("flag_key", k),
+                        enabled=v.get("enabled", False),
+                        variant=v.get("variant", "off"),
+                        value=v.get("value", False),
+                        reason=v.get("reason", ""),
+                        bucket=v.get("bucket"),
+                        latency_ns=v.get("latency_ns", 0),
+                        latency_us=v.get("latency_us", 0.0),
+                    )
+                return results
+        except Exception as e:
+            raise RuntimeError(f"Flagura evaluation request failed: {e}") from e
+
+    def track(self, flag_key: str, variant: str, metric_name: str, value: float = 1.0, user_id: str = "") -> None:
+        """Track an experiment conversion or numeric metric event."""
+        payload = {
+            "events": [
+                {
+                    "flag_key": flag_key,
+                    "project_id": self.project_id,
+                    "variant": variant,
+                    "metric_name": metric_name,
+                    "value": value,
+                    "user_id": user_id,
+                    "environment": self.default_environment,
+                    "timestamp": datetime.datetime.now(datetime.timezone.utc).isoformat(),
+                }
+            ]
+        }
+        req_data = json.dumps(payload).encode("utf-8")
+        headers = {"Content-Type": "application/json"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        if self.project_id:
+            headers["X-Project-ID"] = self.project_id
+
+        req = urllib.request.Request(
+            f"{self.endpoint}/api/v1/telemetry/events",
+            data=req_data,
+            headers=headers,
+            method="POST",
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout):
+                pass
+        except Exception:
+            pass
+
+    def close(self) -> None:
+        """Close active background stream threads."""
+        self._stop_event.set()

flagura_sdk-1.0.0/flagura/openfeature_provider.py

@@ -0,0 +1,266 @@
+from typing import Any, Dict, Optional
+from .client import FlaguraClient, EvaluationContext as FlaguraContext
+
+
+class ResolutionDetails:
+    """Represents flag resolution details conforming to OpenFeature spec."""
+
+    def __init__(
+        self,
+        value: Any,
+        variant: Optional[str] = None,
+        reason: Optional[str] = None,
+        error_code: Optional[str] = None,
+        error_message: Optional[str] = None,
+    ):
+        self.value = value
+        self.variant = variant
+        self.reason = reason
+        self.error_code = error_code
+        self.error_message = error_message
+
+    def __repr__(self) -> str:
+        return f"ResolutionDetails(value={self.value!r}, variant={self.variant!r}, reason={self.reason!r})"
+
+
+class FlaguraOpenFeatureProvider:
+    """Official Flagura OpenFeature Provider for Python applications."""
+
+    def __init__(self, client: Optional[FlaguraClient] = None, **kwargs: Any):
+        if client is not None:
+            self.client = client
+        else:
+            self.client = FlaguraClient(**kwargs)
+        self.name = "flagura-python-provider"
+
+    def get_metadata(self) -> Dict[str, str]:
+        return {"name": self.name}
+
+    def _map_context(self, context: Any) -> FlaguraContext:
+        if context is None:
+            return FlaguraContext(user_id="anonymous")
+
+        # OpenFeature evaluation context in Python can be an object with targeting_key and attributes dict
+        user_id = getattr(context, "targeting_key", None)
+        attributes = getattr(context, "attributes", {})
+
+        if isinstance(context, dict):
+            user_id = context.get("targeting_key") or context.get("user_id") or context.get("userId")
+            attributes = context
+
+        if not user_id:
+            user_id = attributes.get("user_id") or attributes.get("userId") or "anonymous"
+
+        return FlaguraContext(
+            user_id=str(user_id),
+            email=attributes.get("email"),
+            country=attributes.get("country"),
+            role=attributes.get("role"),
+            tier=attributes.get("tier"),
+            environment=attributes.get("environment", self.client.default_environment),
+            custom={
+                k: v
+                for k, v in attributes.items()
+                if k not in {"targeting_key", "user_id", "userId", "email", "country", "role", "tier", "environment"}
+            },
+        )
+
+    def _map_reason(self, reason: str) -> str:
+        r = (reason or "").upper()
+        if "TARGETING" in r or "RULE" in r:
+            return "TARGETING_MATCH"
+        if "PERCENTAGE" in r or "MULTIVARIATE" in r or "BUCKET" in r:
+            return "SPLIT"
+        if "KILL_SWITCH" in r or "ENV_DISABLED" in r or "DISABLED" in r:
+            return "DISABLED"
+        if "DEFAULT" in r:
+            return "DEFAULT"
+        return "STATIC"
+
+    def resolve_boolean_details(
+        self, flag_key: str, default_value: bool, evaluation_context: Any = None
+    ) -> ResolutionDetails:
+        try:
+            ctx = self._map_context(evaluation_context)
+            res = self.client.evaluate(flag_key, ctx)
+
+            if res.reason == "FLAG_NOT_FOUND":
+                return ResolutionDetails(
+                    value=default_value,
+                    reason="ERROR",
+                    error_code="FLAG_NOT_FOUND",
+                    error_message=f"Flag '{flag_key}' not found",
+                )
+
+            if not res.enabled:
+                return ResolutionDetails(
+                    value=default_value,
+                    variant=res.variant or "off",
+                    reason=self._map_reason(res.reason),
+                )
+
+            val = res.value if isinstance(res.value, bool) else bool(res.value) if res.value is not None else True
+            return ResolutionDetails(
+                value=val,
+                variant=res.variant or "treatment",
+                reason=self._map_reason(res.reason),
+            )
+        except Exception as e:
+            return ResolutionDetails(
+                value=default_value,
+                reason="ERROR",
+                error_code="GENERAL",
+                error_message=str(e),
+            )
+
+    def resolve_string_details(
+        self, flag_key: str, default_value: str, evaluation_context: Any = None
+    ) -> ResolutionDetails:
+        try:
+            ctx = self._map_context(evaluation_context)
+            res = self.client.evaluate(flag_key, ctx)
+
+            if res.reason == "FLAG_NOT_FOUND":
+                return ResolutionDetails(
+                    value=default_value,
+                    reason="ERROR",
+                    error_code="FLAG_NOT_FOUND",
+                    error_message=f"Flag '{flag_key}' not found",
+                )
+
+            if not res.enabled:
+                return ResolutionDetails(
+                    value=default_value,
+                    variant=res.variant or "off",
+                    reason=self._map_reason(res.reason),
+                )
+
+            val = str(res.value) if res.value else res.variant or default_value
+            return ResolutionDetails(
+                value=val,
+                variant=res.variant or "treatment",
+                reason=self._map_reason(res.reason),
+            )
+        except Exception as e:
+            return ResolutionDetails(
+                value=default_value,
+                reason="ERROR",
+                error_code="GENERAL",
+                error_message=str(e),
+            )
+
+    def resolve_integer_details(
+        self, flag_key: str, default_value: int, evaluation_context: Any = None
+    ) -> ResolutionDetails:
+        try:
+            ctx = self._map_context(evaluation_context)
+            res = self.client.evaluate(flag_key, ctx)
+
+            if res.reason == "FLAG_NOT_FOUND":
+                return ResolutionDetails(
+                    value=default_value,
+                    reason="ERROR",
+                    error_code="FLAG_NOT_FOUND",
+                    error_message=f"Flag '{flag_key}' not found",
+                )
+
+            if not res.enabled:
+                return ResolutionDetails(
+                    value=default_value,
+                    variant=res.variant or "off",
+                    reason=self._map_reason(res.reason),
+                )
+
+            try:
+                val = int(res.value)
+            except (ValueError, TypeError):
+                val = default_value
+
+            return ResolutionDetails(
+                value=val,
+                variant=res.variant or "treatment",
+                reason=self._map_reason(res.reason),
+            )
+        except Exception as e:
+            return ResolutionDetails(
+                value=default_value,
+                reason="ERROR",
+                error_code="GENERAL",
+                error_message=str(e),
+            )
+
+    def resolve_float_details(
+        self, flag_key: str, default_value: float, evaluation_context: Any = None
+    ) -> ResolutionDetails:
+        try:
+            ctx = self._map_context(evaluation_context)
+            res = self.client.evaluate(flag_key, ctx)
+
+            if res.reason == "FLAG_NOT_FOUND":
+                return ResolutionDetails(
+                    value=default_value,
+                    reason="ERROR",
+                    error_code="FLAG_NOT_FOUND",
+                    error_message=f"Flag '{flag_key}' not found",
+                )
+
+            if not res.enabled:
+                return ResolutionDetails(
+                    value=default_value,
+                    variant=res.variant or "off",
+                    reason=self._map_reason(res.reason),
+                )
+
+            try:
+                val = float(res.value)
+            except (ValueError, TypeError):
+                val = default_value
+
+            return ResolutionDetails(
+                value=val,
+                variant=res.variant or "treatment",
+                reason=self._map_reason(res.reason),
+            )
+        except Exception as e:
+            return ResolutionDetails(
+                value=default_value,
+                reason="ERROR",
+                error_code="GENERAL",
+                error_message=str(e),
+            )
+
+    def resolve_object_details(
+        self, flag_key: str, default_value: Any, evaluation_context: Any = None
+    ) -> ResolutionDetails:
+        try:
+            ctx = self._map_context(evaluation_context)
+            res = self.client.evaluate(flag_key, ctx)
+
+            if res.reason == "FLAG_NOT_FOUND":
+                return ResolutionDetails(
+                    value=default_value,
+                    reason="ERROR",
+                    error_code="FLAG_NOT_FOUND",
+                    error_message=f"Flag '{flag_key}' not found",
+                )
+
+            if not res.enabled:
+                return ResolutionDetails(
+                    value=default_value,
+                    variant=res.variant or "off",
+                    reason=self._map_reason(res.reason),
+                )
+
+            val = res.value if res.value is not None else default_value
+            return ResolutionDetails(
+                value=val,
+                variant=res.variant or "treatment",
+                reason=self._map_reason(res.reason),
+            )
+        except Exception as e:
+            return ResolutionDetails(
+                value=default_value,
+                reason="ERROR",
+                error_code="GENERAL",
+                error_message=str(e),
+            )

flagura_sdk-1.0.0/flagura_sdk.egg-info/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: flagura-sdk
+Version: 1.0.0
+Summary: Official Python SDK and OpenFeature Provider for Flagura
+Author-email: Dhawal Dyavanpalli <dhawalhost@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/dhawalhost/flagura
+Project-URL: Repository, https://github.com/dhawalhost/flagura
+Keywords: feature-flags,feature-toggles,openfeature,flagura,a-b-testing
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28.0
+Requires-Dist: openfeature-sdk>=0.7.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: build>=1.0.0; extra == "dev"
+Requires-Dist: twine>=4.0.0; extra == "dev"
+
+# ⚡ Flagura Python SDK
+
+Official Python client for the **Flagura Feature Flag Platform**, supporting:
+- High-performance evaluations
+- **Real-Time SSE Flag Streaming (`<5ms` sync)**
+- **CNCF OpenFeature Provider**
+- FastAPI, Django, Flask, Celery, and AI Agent compatibility
+
+---
+
+## 📦 Installation
+
+```bash
+pip install flagura
+```
+
+---
+
+## 🚀 Quickstart
+
+### 1. Direct Client with Real-Time SSE Streaming
+
+```python
+from flagura import FlaguraClient, EvaluationContext
+
+# Initialize client with real-time SSE streaming
+client = FlaguraClient(
+    endpoint="https://flagura.dhawalhost.com",
+    api_key="your-api-key",
+    project_id="proj_default", # optional: project scoping
+    default_environment="production",
+    enable_streaming=True, # <5ms live flag updates
+)
+
+# Register real-time change listener
+client.on_update(lambda flags: print(f"Flags updated in real-time! Count: {len(flags)}"))
+
+# Evaluate flag
+context = EvaluationContext(
+    user_id="usr_dhawal_01",
+    email="dhawal@flagura.dev",
+    tier="enterprise",
+)
+
+if client.is_enabled("ai-smart-search", context):
+    variant = client.get_variant("ai-smart-search", context)
+    print(f"AI Smart Search is ON! Variant: {variant}")
+
+# Cleanup on shutdown
+client.close()
+```
+
+---
+
+### 2. OpenFeature Universal Provider
+
+```python
+from openfeature import api
+from openfeature.evaluation_context import EvaluationContext
+from flagura.openfeature_provider import FlaguraOpenFeatureProvider
+
+# Register Flagura as OpenFeature provider
+api.set_provider(FlaguraOpenFeatureProvider(
+    endpoint="https://flagura.dhawalhost.com",
+    api_key="your-api-key",
+    enable_streaming=True,
+))
+of_client = api.get_client()
+
+# Evaluate with OpenFeature standard APIs
+ctx = EvaluationContext(targeting_key="usr_dhawal_01", attributes={"email": "dhawal@flagura.dev"})
+is_enabled = of_client.get_boolean_value("ai-smart-search", False, ctx)
+```
+
+---
+
+## 📄 License
+MIT

flagura_sdk-1.0.0/flagura_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+flagura/__init__.py
+flagura/client.py
+flagura/openfeature_provider.py
+flagura_sdk.egg-info/PKG-INFO
+flagura_sdk.egg-info/SOURCES.txt
+flagura_sdk.egg-info/dependency_links.txt
+flagura_sdk.egg-info/requires.txt
+flagura_sdk.egg-info/top_level.txt

flagura_sdk-1.0.0/flagura_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

flagura_sdk-1.0.0/flagura_sdk.egg-info/requires.txt

@@ -0,0 +1,7 @@
+requests>=2.28.0
+openfeature-sdk>=0.7.0
+
+[dev]
+pytest>=7.0.0
+build>=1.0.0
+twine>=4.0.0

flagura_sdk-1.0.0/flagura_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+flagura

flagura_sdk-1.0.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "flagura-sdk"
+version = "1.0.0"
+description = "Official Python SDK and OpenFeature Provider for Flagura"
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [
+    { name = "Dhawal Dyavanpalli", email = "dhawalhost@gmail.com" }
+]
+keywords = ["feature-flags", "feature-toggles", "openfeature", "flagura", "a-b-testing"]
+dependencies = [
+    "requests>=2.28.0",
+    "openfeature-sdk>=0.7.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "build>=1.0.0",
+    "twine>=4.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/dhawalhost/flagura"
+Repository = "https://github.com/dhawalhost/flagura"

flagura_sdk-1.0.0/setup.cfg

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