WIP

Author: huynguyengl99

chanx/core/websocket.py

@@ -268,9 +268,9 @@ async def websocket_connect(self, message: WebSocketConnectEvent) -> None:
         if self.authenticator:
             auth_result = await self.authenticator.authenticate(self.scope)
 
-        if not auth_result:
-            await self.close()
-            return
+            if not auth_result:
+                await self.close()
+                return
 
         await self.post_authentication()
 

chanx/ext/fast_channels/__init__.py

@@ -9,27 +9,15 @@
 - AsyncAPI documentation generation
 - Interactive WebSocket playground
 - FastAPI integration utilities
-
-Usage:
-    from chanx.ext.fast_channels import add_asyncapi_routes
-    from fastapi import FastAPI
-
-    app = FastAPI()
-    add_asyncapi_routes(app)
 """
 
-from .discovery import auto_discover_and_register, discover_consumers_in_module
 from .views import (
-    add_asyncapi_routes,
     asyncapi_docs,
     asyncapi_spec_json,
     asyncapi_spec_yaml,
 )
 
 __all__ = [
-    "auto_discover_and_register",
-    "discover_consumers_in_module",
-    "add_asyncapi_routes",
     "asyncapi_spec_json",
     "asyncapi_spec_yaml",
     "asyncapi_docs",

chanx/ext/fast_channels/discovery.py

@@ -5,190 +5,11 @@
 in FastAPI applications, similar to Django's app discovery.
 """
 
-import importlib
-import inspect
 from typing import Any
 
-from chanx.asyncapi.generator import AsyncAPIGenerator
-from chanx.core.registry import message_registry
-from chanx.core.websocket import AsyncJsonWebsocketConsumer
-from chanx.routing.discovery import RouteDiscovery, RouteInfo
-
+from starlette.routing import Mount, WebSocketRoute
 
-def discover_consumers_in_module(
-    module_name: str,
-) -> list[type[AsyncJsonWebsocketConsumer]]:
-    """
-    Discover chanx consumers in a given module.
-
-    Args:
-        module_name: The module name to scan for consumers (e.g., 'app.consumers')
-
-    Returns:
-        List of discovered consumer classes
-    """
-    try:
-        module = importlib.import_module(module_name)
-        consumers = []
-
-        for name in dir(module):
-            obj = getattr(module, name)
-            if (
-                inspect.isclass(obj)
-                and issubclass(obj, AsyncJsonWebsocketConsumer)
-                and obj != AsyncJsonWebsocketConsumer
-            ):
-                consumers.append(obj)
-
-        return consumers
-    except ImportError:
-        return []
-
-
-def discover_consumers_in_packages(
-    package_names: list[str],
-) -> list[type[AsyncJsonWebsocketConsumer]]:
-    """
-    Discover chanx consumers in multiple packages.
-
-    Args:
-        package_names: List of package names to scan
-
-    Returns:
-        List of all discovered consumer classes
-    """
-    all_consumers = []
-
-    for package in package_names:
-        # Try common consumer module names
-        for module_suffix in ["consumers", "consumer", "websockets", "ws"]:
-            module_name = f"{package}.{module_suffix}"
-            consumers = discover_consumers_in_module(module_name)
-            all_consumers.extend(consumers)
-
-    return all_consumers
-
-
-def register_consumers_with_message_registry(
-    consumers: list[type[AsyncJsonWebsocketConsumer]],
-) -> None:
-    """
-    Register discovered consumers with the message registry.
-
-    Args:
-        consumers: List of consumer classes to register
-    """
-    for consumer_class in consumers:
-        # Process message handlers
-        for attr_name in dir(consumer_class):
-            if attr_name.startswith("_"):
-                continue
-
-            try:
-                attr = getattr(consumer_class, attr_name)
-                if hasattr(attr, "_ws_handler_info"):
-                    handler_info = attr._ws_handler_info
-                    input_type = handler_info.get("input_type")
-                    output_type = handler_info.get("output_type")
-
-                    if input_type:
-                        message_registry.add(input_type, consumer_class.__name__)
-                    if output_type:
-                        message_registry.add(output_type, consumer_class.__name__)
-
-                elif hasattr(attr, "_event_handler_info"):
-                    handler_info = attr._event_handler_info
-                    input_type = handler_info.get("input_type")
-                    output_type = handler_info.get("output_type")
-
-                    if input_type:
-                        message_registry.add(input_type, consumer_class.__name__)
-                    if output_type:
-                        message_registry.add(output_type, consumer_class.__name__)
-
-            except (AttributeError, TypeError):
-                continue
-
-
-def auto_discover_and_register(package_names: list[str] = None) -> dict[str, Any]:
-    """
-    Auto-discover consumers and register them with the message registry.
-
-    Args:
-        package_names: List of package names to scan. If None, uses common patterns.
-
-    Returns:
-        Dictionary with discovery results and statistics
-    """
-    if package_names is None:
-        # Try to auto-detect common package structures
-        import sys
-
-        package_names = []
-
-        # Look for common app structures
-        for module_name in sys.modules:
-            if (
-                "." not in module_name
-                and module_name not in ["chanx", "fast_channels", "channels"]
-                and not module_name.startswith("_")
-            ):
-                package_names.append(module_name)
-
-    consumers = discover_consumers_in_packages(package_names)
-    register_consumers_with_message_registry(consumers)
-
-    return {
-        "discovered_consumers": len(consumers),
-        "consumer_classes": [c.__name__ for c in consumers],
-        "scanned_packages": package_names,
-    }
-
-
-def get_consumer_info(
-    consumer_class: type[AsyncJsonWebsocketConsumer],
-) -> dict[str, Any]:
-    """
-    Get detailed information about a consumer class.
-
-    Args:
-        consumer_class: The consumer class to analyze
-
-    Returns:
-        Dictionary with consumer information
-    """
-    info = {
-        "name": consumer_class.__name__,
-        "module": consumer_class.__module__,
-        "doc": consumer_class.__doc__,
-        "handlers": [],
-        "channel_info": getattr(consumer_class, "_channel_info", None),
-    }
-
-    # Analyze handlers
-    for attr_name in dir(consumer_class):
-        if attr_name.startswith("_"):
-            continue
-
-        try:
-            attr = getattr(consumer_class, attr_name)
-
-            if hasattr(attr, "_ws_handler_info"):
-                handler_info = attr._ws_handler_info.copy()
-                handler_info["type"] = "websocket"
-                handler_info["method"] = attr_name
-                info["handlers"].append(handler_info)
-
-            elif hasattr(attr, "_event_handler_info"):
-                handler_info = attr._event_handler_info.copy()
-                handler_info["type"] = "event"
-                handler_info["method"] = attr_name
-                info["handlers"].append(handler_info)
-
-        except (AttributeError, TypeError):
-            continue
-
-    return info
+from chanx.routing.discovery import RouteDiscovery, RouteInfo
 
 
 class FastAPIRouteDiscovery(RouteDiscovery):
@@ -229,7 +50,6 @@ def _walk_routes(
             base_url: Base WebSocket URL
             prefix: Current path prefix
         """
-        from starlette.routing import Mount, WebSocketRoute
 
         # Skip if application doesn't have routes (e.g., StaticFiles)
         if not hasattr(application, "routes"):
@@ -305,21 +125,6 @@ def _extract_path_params(self, path: str) -> dict[str, str] | None:
 
         return params if params else None
 
-    def _discover_from_consumers(self, routes: list[RouteInfo], base_url: str) -> None:
-        """Create routes from discovered consumers (fallback method)."""
-        discovery_result = auto_discover_and_register()
-
-        # Create basic routes for each consumer (simplified)
-        for consumer_name in discovery_result["consumer_classes"]:
-            # Create a basic route - in practice you'd want more sophisticated discovery
-            route = RouteInfo(
-                path=f"/ws/{consumer_name.lower().replace('consumer', '')}",
-                handler=None,  # Would be the actual consumer instance
-                base_url=base_url,
-                consumer=None,  # Would be the consumer class
-            )
-            routes.append(route)
-
     def get_websocket_application(self) -> Any:
         """Get the FastAPI WebSocket application."""
         return self.app
@@ -329,44 +134,3 @@ def extract_routes_from_router(
     ) -> None:
         """Extract routes from FastAPI router (using the walk method instead)."""
         self._walk_routes(router, routes, base_url, prefix)
-
-
-def generate_fastapi_asyncapi_spec(
-    consumers: list[type[AsyncJsonWebsocketConsumer]] = None,
-    app=None,
-    title: str = "FastAPI WebSocket API",
-    version: str = "1.0.0",
-    description: str = "AsyncAPI specification for FastAPI application using chanx framework",
-) -> dict[str, Any]:
-    """
-    Generate AsyncAPI specification for FastAPI application.
-
-    Args:
-        consumers: List of consumer classes. If None, auto-discovers.
-        app: FastAPI application instance
-        title: API title
-        version: API version
-        description: API description
-
-    Returns:
-        AsyncAPI specification dictionary
-    """
-    # Auto-discover consumers if not provided
-    if consumers is None:
-        auto_discover_and_register()
-
-    # Create route discovery
-    discovery = FastAPIRouteDiscovery(app)
-    routes = discovery.discover_routes()
-
-    # Generate AsyncAPI spec using the existing generator
-    generator = AsyncAPIGenerator(
-        routes=routes,
-        title=title,
-        version=version,
-        description=description,
-        server_url="localhost:8000",
-        server_protocol="ws",
-    )
-
-    return generator.generate()