chore: update docs

Author: tilyupo

README.md

@@ -41,14 +41,14 @@ with Replane(
     sdk_key="rp_...",
 ) as replane:
     # Get a simple config value
-    rate_limit = replane.configs["rate-limit"]
+    rate_limit = replane.configs["rate_limit"]
 
     # Get with context for override evaluation
     user_client = replane.with_context({"user_id": user.id, "plan": user.plan})
-    feature_enabled = user_client.configs["new-feature"]
+    feature_enabled = user_client.configs["new_feature"]
 
     # Get with fallback default
-    timeout = replane.configs.get("request-timeout", 30)
+    timeout = replane.configs.get("request_timeout", 30)
 ```
 
 ### Asynchronous Client
@@ -63,7 +63,7 @@ async with AsyncReplane(
     sdk_key="rp_...",
 ) as replane:
     # Access configs from local cache
-    rate_limit = replane.configs["rate-limit"]
+    rate_limit = replane.configs["rate_limit"]
 
     # With context
     enabled = replane.with_context({"plan": "premium"}).configs["feature"]
@@ -89,9 +89,9 @@ replane.connect(
 )
 
 # Use configs
-rate_limit = replane.configs["rate-limit"]
+rate_limit = replane.configs["rate_limit"]
 user_client = replane.with_context({"user_id": "123"})
-feature = user_client.configs["feature-flag"]
+feature = user_client.configs["feature_flag"]
 
 # Don't forget to close when done
 replane.close()
@@ -111,23 +111,23 @@ with Replane[Configs](
     sdk_key="rp_...",
 ) as replane:
     # Access configs with dictionary-style notation
-    settings = replane.configs["app-settings"]
+    settings = replane.configs["app_settings"]
 
     # Full type safety - IDE knows the structure of settings
     print(settings["max_upload_size_mb"])
     print(settings["allowed_file_types"])
 
     # Check if config exists
-    if "feature-flag" in replane.configs:
-        flag = replane.configs["feature-flag"]
+    if "feature_flag" in replane.configs:
+        flag = replane.configs["feature_flag"]
 
     # Safe access with default
     timeout = replane.configs.get("timeout", 30)
 ```
 
 The `.configs` property provides:
 
-- **Dictionary-style access** with `replane.configs["config-name"]`
+- **Dictionary-style access** with `replane.configs["config_name"]`
 - **Type inference** when using generated TypedDict types
 - **Override evaluation** using the default context
 - **Familiar dict methods**: `.get()`, `.keys()`, `in` operator
@@ -146,12 +146,12 @@ replane = Replane(
 
     # Default values used if server is unavailable during init
     defaults={
-        "rate-limit": 100,
-        "feature-enabled": False,
+        "rate_limit": 100,
+        "feature_enabled": False,
     },
 
     # Configs that must exist (raises error if missing)
-    required=["rate-limit", "feature-enabled"],
+    required=["rate_limit", "feature_enabled"],
 
     # Timeouts in milliseconds
     request_timeout_ms=2000,
@@ -181,7 +181,7 @@ context = {
 }
 
 # Overrides are evaluated locally using with_context()
-value = replane.with_context(context).configs["feature-flag"]
+value = replane.with_context(context).configs["feature_flag"]
 ```
 
 ### Scoped Clients with `with_context()`
@@ -200,8 +200,8 @@ with Replane(
     })
 
     # All operations use the merged context
-    rate_limit = user_client.configs["rate-limit"]
-    settings = user_client.configs["app-settings"]
+    rate_limit = user_client.configs["rate_limit"]
+    settings = user_client.configs["app_settings"]
 
     # Can be chained for additional context
     request_client = user_client.with_context({"region": request.region})
@@ -221,15 +221,15 @@ with Replane(
     # Create a client with fallback defaults
     safe_client = replane.with_defaults({
         "timeout": 30,
-        "max-retries": 3,
+        "max_retries": 3,
     })
 
     # Returns the default if config doesn't exist
     timeout = safe_client.configs["timeout"]  # 30 if not configured
 
     # Chain with with_context() for both features
     user_client = replane.with_context({"plan": "premium"}).with_defaults({
-        "rate-limit": 1000,
+        "rate_limit": 1000,
     })
 ```
 
@@ -242,20 +242,20 @@ Explicit defaults in `.configs.get()` take precedence over scoped defaults.
 ```python
 # Server config has 10% rollout based on user_id
 # Same user always gets same result (deterministic hashing)
-enabled = replane.with_context({"user_id": user.id}).configs["new-checkout"]
+enabled = replane.with_context({"user_id": user.id}).configs["new_checkout"]
 ```
 
 **Plan-based features**:
 
 ```python
-max_items = replane.with_context({"plan": user.plan}).configs["max-items"]
+max_items = replane.with_context({"plan": user.plan}).configs["max_items"]
 # Returns different values for free/pro/enterprise plans
 ```
 
 **Geographic targeting**:
 
 ```python
-content = replane.with_context({"country": request.country}).configs["homepage-banner"]
+content = replane.with_context({"country": request.country}).configs["homepage_banner"]
 ```
 
 ## Subscribing to Changes
@@ -273,7 +273,7 @@ unsubscribe = replane.subscribe(on_any_change)
 def on_feature_change(config):
     update_feature_state(config.value)
 
-unsubscribe_feature = replane.subscribe_config("my-feature", on_feature_change)
+unsubscribe_feature = replane.subscribe_config("my_feature", on_feature_change)
 
 # Later: stop receiving updates
 unsubscribe()
@@ -301,7 +301,7 @@ from replane import (
 )
 
 try:
-    value = replane.configs["my-config"]
+    value = replane.configs["my_config"]
 except KeyError as e:
     print(f"Config not found: {e}")
 except TimeoutError as e:
@@ -321,11 +321,11 @@ from replane.testing import create_test_client, InMemoryReplaneClient
 
 # Simple usage
 replane = create_test_client({
-    "feature-enabled": True,
-    "rate-limit": 100,
+    "feature_enabled": True,
+    "rate_limit": 100,
 })
 
-assert replane.configs["feature-enabled"] is True
+assert replane.configs["feature_enabled"] is True
 
 # With overrides
 replane = InMemoryReplaneClient()
@@ -354,13 +354,13 @@ from replane.testing import create_test_client
 @pytest.fixture
 def replane_client():
     return create_test_client({
-        "feature-flags": {"dark-mode": True, "new-ui": False},
-        "rate-limits": {"default": 100, "premium": 1000},
+        "feature_flags": {"dark_mode": True, "new-ui": False},
+        "rate_limits": {"default": 100, "premium": 1000},
     })
 
 def test_feature_flag(replane_client):
-    flags = replane_client.configs["feature-flags"]
-    assert flags["dark-mode"] is True
+    flags = replane_client.configs["feature_flags"]
+    assert flags["dark_mode"] is True
 ```
 
 ## Manual Lifecycle Management
@@ -420,7 +420,7 @@ Replane = Annotated[AsyncReplane, Depends(get_replane)]
 
 @app.get("/items")
 async def get_items(replane: Replane):
-    max_items = replane.with_context({"plan": "free"}).configs["max-items"]
+    max_items = replane.with_context({"plan": "free"}).configs["max_items"]
     return {"max_items": max_items}
 ```
 
@@ -444,7 +444,7 @@ def init_replane():
 
 @app.route("/items")
 def get_items():
-    max_items = _replane.configs["max-items"]
+    max_items = _replane.configs["max_items"]
     return {"max_items": max_items}
 ```
 

docs/source/configuration.md

@@ -16,8 +16,8 @@ replane = Replane(
 
     # Optional
     context={"environment": "production"},
-    defaults={"rate-limit": 100, "feature-enabled": False},
-    required=["rate-limit", "feature-enabled"],
+    defaults={"rate_limit": 100, "feature_enabled": False},
+    required=["rate_limit", "feature_enabled"],
     request_timeout_ms=2000,
     initialization_timeout_ms=5000,
     retry_delay_ms=200,
@@ -80,11 +80,11 @@ replane = Replane(
 )
 
 # This uses the default context
-value = replane.configs["config-name"]
+value = replane.configs["config_name"]
 
 # This merges with default context using with_context()
 user_client = replane.with_context({"user_id": "123"})
-value = user_client.configs["config-name"]
+value = user_client.configs["config_name"]
 # Effective context: {"environment": "production", "region": "us-east", "user_id": "123"}
 ```
 
@@ -99,8 +99,8 @@ Default values used when configs can't be loaded from the server. This is useful
 replane = Replane(
     ...,
     defaults={
-        "rate-limit": 100,
-        "feature-enabled": False,
+        "rate_limit": 100,
+        "feature_enabled": False,
         "max-connections": 10,
     },
 )
@@ -121,7 +121,7 @@ List of config names that must be present after initialization. If any required
 ```python
 replane = Replane(
     ...,
-    required=["rate-limit", "feature-enabled"],
+    required=["rate_limit", "feature_enabled"],
 )
 # Raises ConfigNotFoundError if either config is missing
 ```
@@ -218,7 +218,7 @@ Example output:
 2024-01-15 10:30:00 [DEBUG] replane: Connecting to SSE: host=cloud.replane.dev, port=443, https=True
 2024-01-15 10:30:00 [DEBUG] replane: Response status: 200 OK
 2024-01-15 10:30:00 [DEBUG] replane: SSE event received: type=init
-2024-01-15 10:30:00 [DEBUG] replane: Loaded config: rate-limit (value=100, overrides=2)
+2024-01-15 10:30:00 [DEBUG] replane: Loaded config: rate_limit (value=100, overrides=2)
 2024-01-15 10:30:00 [DEBUG] replane: Initialization complete: 5 configs loaded
 ```
 

docs/source/errors.md

@@ -52,7 +52,7 @@ try:
         base_url="https://cloud.replane.dev",
         sdk_key="rp_...",
     ) as replane:
-        value = replane.configs["my-config"]
+        value = replane.configs["my_config"]
 except KeyError as e:
     print(f"Config not found: {e}")
 except TimeoutError as e:
@@ -91,7 +91,7 @@ Accessing a missing config via bracket notation raises a standard `KeyError`:
 
 ```python
 try:
-    value = replane.configs["nonexistent-config"]
+    value = replane.configs["nonexistent_config"]
 except KeyError as e:
     print(f"Config not found: {e}")
     value = "default"
@@ -124,7 +124,7 @@ from replane import Replane, ConfigNotFoundError
 try:
     with Replane(
         ...,
-        required=["critical-config-1", "critical-config-2"],
+        required=["critical_config-1", "critical_config-2"],
     ) as replane:
         pass
 except ConfigNotFoundError as e:
@@ -280,7 +280,7 @@ except ReplaneError as e:
 ```python
 # Good: specific handling
 try:
-    value = replane.configs["critical-config"]
+    value = replane.configs["critical_config"]
 except KeyError:
     logger.error("Critical config missing!")
     raise  # Re-raise for critical configs

docs/source/frameworks.md

@@ -42,7 +42,7 @@ Replane = Annotated[AsyncReplane, Depends(get_replane)]
 
 @app.get("/items")
 async def get_items(replane: Replane):
-    max_items = replane.configs["max-items-per-page"]
+    max_items = replane.configs["max_items_per_page"]
     return {"max_items": max_items}
 ```
 
@@ -60,8 +60,8 @@ async def get_features(request: Request, replane: Replane):
     })
 
     return {
-        "dark_mode": user_client.configs["dark-mode-enabled"],
-        "beta_features": user_client.configs["beta-features"],
+        "dark_mode": user_client.configs["dark_mode_enabled"],
+        "beta_features": user_client.configs["beta_features"],
     }
 ```
 
@@ -88,7 +88,7 @@ ReplaneWithContext = Annotated[ContextualAsyncReplane, Depends(get_replane_with_
 @app.get("/dashboard")
 async def dashboard(replane: ReplaneWithContext):
     # Context is automatically included
-    show_analytics = replane.configs["show-analytics"]
+    show_analytics = replane.configs["show_analytics"]
     return {"show_analytics": show_analytics}
 ```
 
@@ -120,7 +120,7 @@ def get_replane() -> Replane:
 @app.route("/items")
 def get_items():
     replane = get_replane()
-    max_items = replane.configs["max-items-per-page"]
+    max_items = replane.configs["max_items_per_page"]
     return {"max_items": max_items}
 ```
 
@@ -151,7 +151,7 @@ def create_app():
 @app.route("/features")
 def features():
     replane = current_app.replane
-    return {"enabled": replane.configs["feature-enabled"]}
+    return {"enabled": replane.configs["feature_enabled"]}
 ```
 
 ### Flask Extension Pattern