chore: update examples

Author: tilyupo

docs/source/errors.md

@@ -15,7 +15,7 @@ ReplaneError (base class)
 └── MissingDependencyError
 ```
 
-Note: Accessing a missing config via `client.configs["name"]` raises a standard `KeyError`, not `ConfigNotFoundError`. Use `client.configs.get("name", default)` to avoid exceptions.
+Note: Accessing a missing config via `replane.configs["name"]` raises a standard `KeyError`, not `ConfigNotFoundError`. Use `replane.configs.get("name", default)` to avoid exceptions.
 
 ## Error Codes
 

examples/basic-async/main.py

@@ -27,24 +27,22 @@ async def main():
         },
         # Optional: enable debug logging
         debug=True,
-    ) as client:
+    ) as replane:
         # Read a boolean feature flag (sync - reads from local cache)
-        is_feature_enabled = client.get("feature-enabled")
+        is_feature_enabled = replane.configs["feature-enabled"]
         print(f"Feature enabled: {is_feature_enabled}")
 
         # Read a numeric config
-        max_items = client.get("max-items")
+        max_items = replane.configs["max-items"]
         print(f"Max items: {max_items}")
 
         # Read with context for override evaluation
-        rate_limit = client.get(
-            "rate-limit",
-            context={"plan": "premium", "user_id": "user-123"},
-        )
+        user_client = replane.with_context({"plan": "premium", "user_id": "user-123"})
+        rate_limit = user_client.configs["rate-limit"]
         print(f"Rate limit: {rate_limit}")
 
         # Read with default value if config doesn't exist
-        timeout = client.get("request-timeout", default=30)
+        timeout = replane.configs.get("request-timeout", 30)
         print(f"Timeout: {timeout}")
 
         # Keep running to receive real-time updates
@@ -53,49 +51,49 @@ async def main():
             while True:
                 await asyncio.sleep(5)
                 # Re-read to see any updates
-                current_value = client.get("feature-enabled")
+                current_value = replane.configs["feature-enabled"]
                 print(f"Current feature-enabled value: {current_value}")
         except KeyboardInterrupt:
             print("\nStopping...")
 
 
 async def example_manual_lifecycle():
     """Example showing manual connect/close lifecycle."""
-    client = AsyncReplane(
+    replane = AsyncReplane(
         base_url=BASE_URL,
         sdk_key=SDK_KEY,
     )
 
     try:
         # Connect and wait for initial configs
-        await client.connect(wait=True)
+        await replane.connect(wait=True)
 
         # Now you can read configs
-        value = client.get("my-config")
+        value = replane.configs["my-config"]
         print(f"Config value: {value}")
 
     finally:
         # Always close the client when done
-        await client.close()
+        await replane.close()
 
 
 async def example_with_subscriptions():
     """Example showing how to subscribe to config changes."""
     async with AsyncReplane(
         base_url=BASE_URL,
         sdk_key=SDK_KEY,
-    ) as client:
+    ) as replane:
         # Subscribe to all config changes
         def on_any_change(name, config):
             print(f"Config '{name}' changed to: {config.value}")
 
-        unsubscribe_all = client.subscribe(on_any_change)
+        unsubscribe_all = replane.subscribe(on_any_change)
 
         # Subscribe to a specific config
         def on_feature_change(config):
             print(f"Feature flag updated: {config.value}")
 
-        unsubscribe_feature = client.subscribe_config("feature-enabled", on_feature_change)
+        unsubscribe_feature = replane.subscribe_config("feature-enabled", on_feature_change)
 
         # Keep running to receive updates
         print("Listening for changes...")
@@ -111,15 +109,15 @@ async def example_async_callback():
     async with AsyncReplane(
         base_url=BASE_URL,
         sdk_key=SDK_KEY,
-    ) as client:
+    ) as replane:
         # Async callbacks are supported
         async def on_change(name, config):
             print(f"Config '{name}' changed")
             # Can do async operations here
             await asyncio.sleep(0.1)
             print(f"Processed change for '{name}'")
 
-        client.subscribe(on_change)
+        replane.subscribe(on_change)
 
         await asyncio.sleep(60)
 

examples/basic-sync/main.py

@@ -25,70 +25,68 @@ def main():
         },
         # Optional: enable debug logging
         debug=True,
-    ) as client:
+    ) as replane:
         # Read a boolean feature flag
-        is_feature_enabled = client.get("feature-enabled")
+        is_feature_enabled = replane.configs["feature-enabled"]
         print(f"Feature enabled: {is_feature_enabled}")
 
         # Read a numeric config
-        max_items = client.get("max-items")
+        max_items = replane.configs["max-items"]
         print(f"Max items: {max_items}")
 
         # Read with context for override evaluation
-        rate_limit = client.get(
-            "rate-limit",
-            context={"plan": "premium", "user_id": "user-123"},
-        )
+        user_client = replane.with_context({"plan": "premium", "user_id": "user-123"})
+        rate_limit = user_client.configs["rate-limit"]
         print(f"Rate limit: {rate_limit}")
 
         # Read with default value if config doesn't exist
-        timeout = client.get("request-timeout", default=30)
+        timeout = replane.configs.get("request-timeout", 30)
         print(f"Timeout: {timeout}")
 
 
 def example_manual_lifecycle():
     """Example showing manual connect/close lifecycle."""
-    client = Replane(
+    replane = Replane(
         base_url=BASE_URL,
         sdk_key=SDK_KEY,
     )
 
     try:
         # Connect and wait for initial configs
-        client.connect(wait=True)
+        replane.connect(wait=True)
 
         # Now you can read configs
-        value = client.get("my-config")
+        value = replane.configs["my-config"]
         print(f"Config value: {value}")
 
     finally:
         # Always close the client when done
-        client.close()
+        replane.close()
 
 
 def example_non_blocking_connect():
     """Example showing non-blocking connection."""
-    client = Replane(
+    replane = Replane(
         base_url=BASE_URL,
         sdk_key=SDK_KEY,
         defaults={"my-config": "default-value"},
     )
 
     # Start connection without waiting
-    client.connect(wait=False)
+    replane.connect(wait=False)
 
     # Can use default values immediately
-    value = client.get("my-config")
+    value = replane.configs.get("my-config", "default-value")
     print(f"Initial value (may be default): {value}")
 
     # Later, wait for initialization if needed
-    client.wait_for_init()
+    replane.wait_for_init()
 
     # Now we have fresh values from server
-    value = client.get("my-config")
+    value = replane.configs["my-config"]
     print(f"Server value: {value}")
 
-    client.close()
+    replane.close()
 
 
 if __name__ == "__main__":

examples/django-integration/README.md

@@ -140,8 +140,9 @@ class DemoConfig(AppConfig):
 ```python
 from demo.replane_client import get_replane
 
-client = get_replane()
-value = client.get("feature-flag", context={"user_id": "123"})
+replane = get_replane()
+user_client = replane.with_context({"user_id": "123"})
+value = user_client.configs["feature-flag"]
 ```
 
 ### 4. Middleware (`demo/middleware.py`)

examples/django-integration/demo/views.py

@@ -9,11 +9,12 @@ class IndexView(View):
     """Homepage with feature flag check."""
 
     def get(self, request):
-        client = get_replane()
+        replane = get_replane()
         ctx = getattr(request, "replane_context", {})
 
         # Check if new dashboard is enabled for this user
-        new_dashboard = client.get("new-dashboard-enabled", context=ctx)
+        user_client = replane.with_context(ctx)
+        new_dashboard = user_client.configs["new-dashboard-enabled"]
 
         if new_dashboard:
             return JsonResponse(
@@ -35,11 +36,12 @@ class ItemsView(View):
     """List items with configurable rate limiting."""
 
     def get(self, request):
-        client = get_replane()
+        replane = get_replane()
         ctx = getattr(request, "replane_context", {})
 
         # Get rate limit for this user
-        rate_limit = client.get("rate-limit", context=ctx)
+        user_client = replane.with_context(ctx)
+        rate_limit = user_client.configs["rate-limit"]
 
         items = [
             {"id": 1, "name": "Item 1"},
@@ -60,11 +62,12 @@ class UploadView(View):
     """Upload endpoint with configurable size limit."""
 
     def post(self, request):
-        client = get_replane()
+        replane = get_replane()
         ctx = getattr(request, "replane_context", {})
 
         # Get the max upload size based on user's plan
-        max_size_mb = client.get("max-upload-size-mb", context=ctx)
+        user_client = replane.with_context(ctx)
+        max_size_mb = user_client.configs["max-upload-size-mb"]
 
         content_length = int(request.headers.get("Content-Length", 0))
         max_bytes = max_size_mb * 1024 * 1024
@@ -90,17 +93,18 @@ class ConfigView(View):
     """Debug endpoint to view current config values."""
 
     def get(self, request):
-        client = get_replane()
+        replane = get_replane()
         ctx = getattr(request, "replane_context", {})
 
+        user_client = replane.with_context(ctx)
         return JsonResponse(
             {
                 "context": ctx,
                 "configs": {
-                    "new-dashboard-enabled": client.get("new-dashboard-enabled", context=ctx),
-                    "rate-limit": client.get("rate-limit", context=ctx),
-                    "max-upload-size-mb": client.get("max-upload-size-mb", context=ctx),
-                    "maintenance-mode": client.get("maintenance-mode", context=ctx),
+                    "new-dashboard-enabled": user_client.configs["new-dashboard-enabled"],
+                    "rate-limit": user_client.configs["rate-limit"],
+                    "max-upload-size-mb": user_client.configs["max-upload-size-mb"],
+                    "maintenance-mode": user_client.configs["maintenance-mode"],
                 },
             }
         )
@@ -111,8 +115,8 @@ class HealthView(View):
 
     def get(self, request):
         try:
-            client = get_replane()
-            replane_connected = client.is_initialized()
+            replane = get_replane()
+            replane_connected = replane.is_initialized()
         except RuntimeError:
             replane_connected = False
 

examples/fastapi-integration/app.py

@@ -98,7 +98,7 @@ class UploadResponse(BaseModel):
 @app.middleware("http")
 async def check_maintenance_mode(request: Request, call_next):
     if replane_client and request.url.path != "/health":
-        maintenance = replane_client.get("maintenance-mode", default=False)
+        maintenance = replane_client.configs.get("maintenance-mode", False)
         if maintenance:
             return HTTPException(
                 status_code=503,
@@ -113,7 +113,8 @@ async def index(
     ctx: Annotated[dict, Depends(get_user_context)],
 ):
     """Homepage with feature flag check."""
-    new_dashboard = replane.get("new-dashboard-enabled", context=ctx)
+    user_client = replane.with_context(ctx)
+    new_dashboard = user_client.configs["new-dashboard-enabled"]
 
     if new_dashboard:
         return WelcomeResponse(message="Welcome to the new dashboard!", version="v2")
@@ -127,7 +128,8 @@ async def get_items(
     ctx: Annotated[dict, Depends(get_user_context)],
 ):
     """List items with configurable rate limiting."""
-    rate_limit = replane.get("rate-limit", context=ctx)
+    user_client = replane.with_context(ctx)
+    rate_limit = user_client.configs["rate-limit"]
 
     items = [
         {"id": 1, "name": "Item 1"},
@@ -149,7 +151,8 @@ async def upload(
     ctx: Annotated[dict, Depends(get_user_context)],
 ):
     """Upload endpoint with configurable size limit."""
-    max_size_mb = replane.get("max-upload-size-mb", context=ctx)
+    user_client = replane.with_context(ctx)
+    max_size_mb = user_client.configs["max-upload-size-mb"]
 
     content_length = request.headers.get("content-length", 0)
     max_bytes = max_size_mb * 1024 * 1024
@@ -172,13 +175,14 @@ async def get_config(
     ctx: Annotated[dict, Depends(get_user_context)],
 ):
     """Debug endpoint to view current config values."""
+    user_client = replane.with_context(ctx)
     return ConfigResponse(
         context=ctx,
         configs={
-            "new-dashboard-enabled": replane.get("new-dashboard-enabled", context=ctx),
-            "rate-limit": replane.get("rate-limit", context=ctx),
-            "max-upload-size-mb": replane.get("max-upload-size-mb", context=ctx),
-            "maintenance-mode": replane.get("maintenance-mode", context=ctx),
+            "new-dashboard-enabled": user_client.configs["new-dashboard-enabled"],
+            "rate-limit": user_client.configs["rate-limit"],
+            "max-upload-size-mb": user_client.configs["max-upload-size-mb"],
+            "maintenance-mode": user_client.configs["maintenance-mode"],
         },
     )