chore: update python sdk

Author: tilyupo

README.md

@@ -266,7 +266,6 @@ client.subscribe(on_change)
 ```python
 from replane import (
     ReplaneError,
-    ConfigNotFoundError,
     TimeoutError,
     AuthenticationError,
     NetworkError,
@@ -275,8 +274,8 @@ from replane import (
 
 try:
     value = client.configs["my-config"]
-except ConfigNotFoundError as e:
-    print(f"Config not found: {e.config_name}")
+except KeyError as e:
+    print(f"Config not found: {e}")
 except TimeoutError as e:
     print(f"Timed out after {e.timeout_ms}ms")
 except AuthenticationError:

docs/source/configuration.md

@@ -59,7 +59,7 @@ sdk_key="rp_test_xyz789..."  # Testing/staging
 - **Type:** `dict[str, str | int | float | bool | None]`
 - **Default:** `{}`
 
-Default context applied to all `get()` calls. This is merged with any context passed directly to `get()`.
+Default context applied to all config accesses. This is merged with any context passed via `with_context()`.
 
 ```python
 # Set default context
@@ -71,11 +71,12 @@ replane = Replane(
     },
 )
 
-# This call uses the default context
-value = replane.get("config-name")
+# This uses the default context
+value = replane.configs["config-name"]
 
-# This merges with default context
-value = replane.get("config-name", context={"user_id": "123"})
+# This merges with default context using with_context()
+user_client = replane.with_context({"user_id": "123"})
+value = user_client.configs["config-name"]
 # Effective context: {"environment": "production", "region": "us-east", "user_id": "123"}
 ```
 
@@ -100,7 +101,7 @@ replane = Replane(
 Defaults are used in two scenarios:
 
 1. During initialization if a config isn't returned by the server
-2. If `get()` is called before initialization completes
+2. If configs are accessed before initialization completes
 
 #### `required`
 
@@ -226,7 +227,7 @@ replane = Replane(base_url="...", sdk_key="...")
 replane.connect()  # Blocks until ready
 
 try:
-    value = replane.get("config")
+    value = replane.configs["config"]
 finally:
     replane.close()
 ```
@@ -250,7 +251,7 @@ replane = AsyncReplane(base_url="...", sdk_key="...")
 await replane.connect()
 
 try:
-    value = replane.get("config")
+    value = replane.configs["config"]
 finally:
     await replane.close()
 ```

docs/source/errors.md

@@ -6,7 +6,7 @@ The Replane SDK uses a hierarchy of exceptions to help you handle errors appropr
 
 ```
 ReplaneError (base class)
-├── ConfigNotFoundError
+├── ConfigNotFoundError (used for required configs at init time)
 ├── TimeoutError
 ├── AuthenticationError
 ├── NetworkError
@@ -15,13 +15,15 @@ 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.
+
 ## Error Codes
 
 Each `ReplaneError` has a `code` attribute from the `ErrorCode` enum:
 
 | Code                 | Description                             |
 | -------------------- | --------------------------------------- |
-| `not_found`          | Config doesn't exist                    |
+| `not_found`          | Config doesn't exist (required configs) |
 | `timeout`            | Operation timed out                     |
 | `network_error`      | Network request failed                  |
 | `auth_error`         | Authentication failed (invalid SDK key) |
@@ -41,7 +43,6 @@ Each `ReplaneError` has a `code` attribute from the `ErrorCode` enum:
 from replane import (
     Replane,
     ReplaneError,
-    ConfigNotFoundError,
     TimeoutError,
     AuthenticationError,
 )
@@ -51,9 +52,9 @@ try:
         base_url="https://replane.example.com",
         sdk_key="rp_...",
     ) as replane:
-        value = replane.get("my-config")
-except ConfigNotFoundError as e:
-    print(f"Config '{e.config_name}' not found")
+        value = replane.configs["my-config"]
+except KeyError as e:
+    print(f"Config not found: {e}")
 except TimeoutError as e:
     print(f"Timed out after {e.timeout_ms}ms")
 except AuthenticationError:
@@ -68,12 +69,9 @@ except ReplaneError as e:
 from replane import ReplaneError, ErrorCode
 
 try:
-    value = replane.get("config")
+    replane.connect()
 except ReplaneError as e:
     match e.code:
-        case ErrorCode.NOT_FOUND:
-            # Handle missing config
-            value = default_value
         case ErrorCode.TIMEOUT:
             # Maybe retry
             pass
@@ -87,38 +85,56 @@ except ReplaneError as e:
 
 ## Specific Exceptions
 
-### ConfigNotFoundError
+### KeyError (Missing Config)
 
-Raised when requesting a config that doesn't exist.
+Accessing a missing config via bracket notation raises a standard `KeyError`:
 
 ```python
-from replane import ConfigNotFoundError
-
 try:
-    value = replane.get("nonexistent-config")
-except ConfigNotFoundError as e:
-    print(f"Config not found: {e.config_name}")
-    # Use a default value instead
+    value = replane.configs["nonexistent-config"]
+except KeyError as e:
+    print(f"Config not found: {e}")
     value = "default"
 ```
 
-**Attributes:**
-
-- `config_name: str` - Name of the missing config
-
-**Prevention:** Use `default` parameter or `defaults` option:
+**Prevention:** Use `.get()` method or `defaults` option:
 
 ```python
-# With default
-value = replane.get("config", default="fallback")
+# With get() method
+value = replane.configs.get("config", "fallback")
 
 # With defaults during init
 replane = Replane(
     ...,
     defaults={"config": "fallback"},
 )
+
+# With with_defaults()
+safe_client = replane.with_defaults({"config": "fallback"})
+value = safe_client.configs["config"]  # Returns "fallback" if not configured
+```
+
+### ConfigNotFoundError
+
+Raised when required configs are missing during initialization.
+
+```python
+from replane import Replane, ConfigNotFoundError
+
+try:
+    with Replane(
+        ...,
+        required=["critical-config-1", "critical-config-2"],
+    ) as replane:
+        pass
+except ConfigNotFoundError as e:
+    print(f"Missing required configs: {e}")
 ```
 
+**Attributes:**
+
+- `config_name: str` - Name or description of missing config(s)
+
 ### TimeoutError
 
 Raised when an operation exceeds its timeout.
@@ -199,7 +215,7 @@ replane.connect()
 replane.close()
 
 try:
-    replane.get("config")  # Raises ClientClosedError
+    _ = replane.configs["config"]  # Raises ClientClosedError
 except ClientClosedError:
     print("Client was already closed")
 ```
@@ -215,10 +231,10 @@ replane = Replane(...)
 replane.connect(wait=False)  # Don't wait
 
 try:
-    replane.get("config")  # May raise if not ready
+    _ = replane.configs["config"]  # May raise if not ready
 except NotInitializedError:
     replane.wait_for_init()  # Wait then retry
-    value = replane.get("config")
+    value = replane.configs["config"]
 ```
 
 ### MissingDependencyError
@@ -259,22 +275,22 @@ except ReplaneError as e:
 2. **Use defaults** for resilience against missing configs
 3. **Log errors** with their codes for debugging
 4. **Don't catch and ignore** - at minimum, log the error
-5. **Use `default` parameter** instead of catching `ConfigNotFoundError` when appropriate
+5. **Use `.get()` method** instead of catching `KeyError` when appropriate
 
 ```python
 # Good: specific handling
 try:
-    value = replane.get("critical-config")
-except ConfigNotFoundError:
+    value = replane.configs["critical-config"]
+except KeyError:
     logger.error("Critical config missing!")
     raise  # Re-raise for critical configs
 
 # Good: graceful fallback
-value = replane.get("optional-config", default="safe-default")
+value = replane.configs.get("optional-config", "safe-default")
 
 # Bad: silently ignoring
 try:
-    value = replane.get("config")
-except ReplaneError:
+    value = replane.configs["config"]
+except KeyError:
     pass  # Don't do this!
 ```

docs/source/frameworks.md

@@ -37,7 +37,7 @@ def get_replane() -> AsyncReplane:
 
 @app.get("/items")
 async def get_items(replane: AsyncReplane = Depends(get_replane)):
-    max_items = replane.get("max-items-per-page")
+    max_items = replane.configs["max-items-per-page"]
     return {"max_items": max_items}
 ```
 
@@ -52,14 +52,14 @@ async def get_features(
     replane: AsyncReplane = Depends(get_replane),
 ):
     # Build context from request/user
-    context = {
+    user_client = replane.with_context({
         "user_id": request.state.user.id,
         "plan": request.state.user.plan,
-    }
+    })
 
     return {
-        "dark_mode": replane.get("dark-mode-enabled", context=context),
-        "beta_features": replane.get("beta-features", context=context),
+        "dark_mode": user_client.configs["dark-mode-enabled"],
+        "beta_features": user_client.configs["beta-features"],
     }
 ```
 
@@ -69,30 +69,22 @@ Create a dependency that automatically includes user context:
 
 ```python
 from fastapi import Request, Depends
-
-class ReplaneWithContext:
-    def __init__(self, client: AsyncReplane, context: dict):
-        self._client = client
-        self._context = context
-
-    def get(self, name: str, **kwargs):
-        ctx = {**self._context, **kwargs.get("context", {})}
-        return self._client.get(name, context=ctx, **{k: v for k, v in kwargs.items() if k != "context"})
+from replane._async import ContextualAsyncReplane
 
 def get_replane_with_context(
     request: Request,
     replane: AsyncReplane = Depends(get_replane),
-) -> ReplaneWithContext:
+) -> ContextualAsyncReplane:
     context = {}
     if hasattr(request.state, "user"):
         context["user_id"] = request.state.user.id
         context["plan"] = request.state.user.plan
-    return ReplaneWithContext(replane, context)
+    return replane.with_context(context)
 
 @app.get("/dashboard")
-async def dashboard(config: ReplaneWithContext = Depends(get_replane_with_context)):
+async def dashboard(config: ContextualAsyncReplane = Depends(get_replane_with_context)):
     # Context is automatically included
-    show_analytics = config.get("show-analytics")
+    show_analytics = config.configs["show-analytics"]
     return {"show_analytics": show_analytics}
 ```
 
@@ -124,7 +116,7 @@ def get_replane() -> Replane:
 @app.route("/items")
 def get_items():
     replane = get_replane()
-    max_items = replane.get("max-items-per-page")
+    max_items = replane.configs["max-items-per-page"]
     return {"max_items": max_items}
 ```
 
@@ -155,7 +147,7 @@ def create_app():
 @app.route("/features")
 def features():
     replane = current_app.replane
-    return {"enabled": replane.get("feature-enabled")}
+    return {"enabled": replane.configs["feature-enabled"]}
 ```
 
 ### Flask Extension Pattern
@@ -201,7 +193,7 @@ def create_app():
 
 @app.route("/")
 def index():
-    return {"feature": replane.client.get("feature")}
+    return {"feature": replane.client.configs["feature"]}
 ```
 
 ## Django
@@ -237,9 +229,13 @@ from .replane_client import get_replane
 
 def features_view(request):
     replane = get_replane()
-    context = {"user_id": str(request.user.id)} if request.user.is_authenticated else {}
+    if request.user.is_authenticated:
+        user_client = replane.with_context({"user_id": str(request.user.id)})
+        feature_enabled = user_client.configs["feature"]
+    else:
+        feature_enabled = replane.configs["feature"]
     return JsonResponse({
-        "feature_enabled": replane.get("feature", context=context),
+        "feature_enabled": feature_enabled,
     })
 ```
 
@@ -269,7 +265,7 @@ from .replane_client import get_replane
 async def features_view(request):
     replane = await get_replane()
     return JsonResponse({
-        "feature_enabled": replane.get("feature"),
+        "feature_enabled": replane.configs["feature"],
     })
 ```
 
@@ -315,7 +311,7 @@ async def shutdown():
         await _replane.close()
 
 async def homepage(request):
-    feature = _replane.get("feature")
+    feature = _replane.configs["feature"]
     return JSONResponse({"feature": feature})
 
 app = Starlette(
@@ -353,7 +349,7 @@ async def create_app():
 async def handler(request):
     replane = request.app["replane"]
     return web.json_response({
-        "feature": replane.get("feature"),
+        "feature": replane.configs["feature"],
     })
 
 if __name__ == "__main__":