- Fix Startup loading

- Fix import issues

Author: Firstp1ck

backend/backend.spec

@@ -95,6 +95,10 @@ a = Analysis(
         'core.serializers',
         'core.urls',
         'core.utils',
+        'core.patches',
+        'core.logging_filters',
+        'core.middleware',
+        'core.exception_handler',
         # Python standard library modules that might be needed
         'sqlite3',
         'json',

backend/config/settings.py

@@ -17,6 +17,12 @@
 DEBUG = os.getenv('DEBUG', 'True') == 'True'
 ALLOWED_HOSTS = os.getenv('ALLOWED_HOSTS', 'localhost,127.0.0.1').split(',')
 
+# Import patches early to suppress BrokenPipeError
+try:
+    import core.patches  # noqa: F401
+except ImportError:
+    pass
+
 # Application definition
 INSTALLED_APPS = [
     'django.contrib.admin',
@@ -41,6 +47,7 @@
     'django.contrib.auth.middleware.AuthenticationMiddleware',
     'django.contrib.messages.middleware.MessageMiddleware',
     'django.middleware.clickjacking.XFrameOptionsMiddleware',
+    'core.middleware.BrokenPipeHandlerMiddleware',
 ]
 
 ROOT_URLCONF = 'config.urls'
@@ -121,6 +128,7 @@
     'DEFAULT_PARSER_CLASSES': [
         'rest_framework.parsers.JSONParser',
     ],
+    'EXCEPTION_HANDLER': 'core.exception_handler.rest_framework_exception_handler',
 }
 
 # CORS settings
@@ -141,3 +149,36 @@
 CORS_ALLOW_ALL_ORIGINS = os.getenv('DEBUG', 'True') == 'True'
 
 CORS_ALLOW_CREDENTIALS = True
+
+# Logging configuration to suppress BrokenPipeError
+LOGGING = {
+    'version': 1,
+    'disable_existing_loggers': False,
+    'filters': {
+        'suppress_broken_pipe': {
+            '()': 'core.logging_filters.SuppressBrokenPipe',
+        },
+    },
+    'handlers': {
+        'console': {
+            'class': 'logging.StreamHandler',
+            'filters': ['suppress_broken_pipe'],
+        },
+    },
+    'root': {
+        'handlers': ['console'],
+        'level': 'INFO',
+    },
+    'loggers': {
+        'django': {
+            'handlers': ['console'],
+            'level': 'INFO',
+            'propagate': False,
+        },
+        'django.server': {
+            'handlers': ['console'],
+            'level': 'INFO',
+            'propagate': False,
+        },
+    },
+}

backend/config/urls.py

@@ -3,6 +3,30 @@
 """
 from django.contrib import admin
 from django.urls import path, include
+from django.http import JsonResponse
+from django.views.decorators.csrf import csrf_exempt
+
+def handler500(request):
+    """
+    Custom 500 handler that returns JSON for API requests.
+    This ensures API errors return JSON instead of HTML, even during server initialization.
+    """
+    # Check if this is an API request
+    if request.path.startswith('/api/'):
+        import traceback
+        import sys
+        exc_type, exc_value, tb = sys.exc_info()
+        return JsonResponse(
+            {
+                'error': str(exc_value) if exc_value else 'Internal server error',
+                'error_type': exc_type.__name__ if exc_type else 'UnknownError',
+                'detail': 'An error occurred processing your request'
+            },
+            status=500
+        )
+    # For non-API requests, use Django's default handler
+    from django.views.debug import technical_500_response
+    return technical_500_response(request)
 
 urlpatterns = [
     path('admin/', admin.site.urls),

backend/config/wsgi.py

@@ -3,9 +3,100 @@
 """
 
 import os
+import logging
+import sys
 
 from django.core.wsgi import get_wsgi_application
 
 os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings')
 
-application = get_wsgi_application()
+logger = logging.getLogger(__name__)
+
+# Get the base WSGI application
+_base_application = get_wsgi_application()
+
+
+class BrokenPipeHandler:
+    """
+    WSGI wrapper that handles BrokenPipeError gracefully.
+    
+    BrokenPipeError occurs when Django tries to write a response to a connection
+    that has already been closed by the client. This is not a critical error
+    and should be handled silently.
+    """
+    
+    def __init__(self, application):
+        self.application = application
+    
+    def __call__(self, environ, start_response):
+        # Wrap start_response to catch BrokenPipeError
+        response_sent = [False]
+        
+        def wrapped_start_response(status, headers, exc_info=None):
+            try:
+                start_response(status, headers, exc_info)
+                response_sent[0] = True
+            except (BrokenPipeError, OSError) as e:
+                errno = getattr(e, 'errno', None)
+                if errno == 32 or 'Broken pipe' in str(e) or 'BrokenPipeError' in str(type(e).__name__):
+                    logger.warning("Client disconnected during start_response")
+                    response_sent[0] = True
+                    raise
+                raise
+        
+        try:
+            # Get the response iterator
+            response_iter = self.application(environ, wrapped_start_response)
+            
+            # Wrap the iterator to catch BrokenPipeError during iteration
+            class SafeIterator:
+                def __init__(self, iterator):
+                    # Convert to an actual iterator - Response objects are iterable
+                    # but not iterators (they have __iter__ but not __next__)
+                    self.iterator = iter(iterator)
+                
+                def __iter__(self):
+                    return self
+                
+                def __next__(self):
+                    try:
+                        return next(self.iterator)
+                    except (BrokenPipeError, OSError) as e:
+                        errno = getattr(e, 'errno', None)
+                        if errno == 32 or 'Broken pipe' in str(e) or 'BrokenPipeError' in str(type(e).__name__):
+                            logger.warning("Client disconnected during response iteration")
+                            raise StopIteration
+                        raise
+                
+                def close(self):
+                    if hasattr(self.iterator, 'close'):
+                        try:
+                            self.iterator.close()
+                        except (BrokenPipeError, OSError) as e:
+                            errno = getattr(e, 'errno', None)
+                            if errno == 32 or 'Broken pipe' in str(e) or 'BrokenPipeError' in str(type(e).__name__):
+                                logger.warning("Client disconnected during response close")
+                                return
+                            raise
+            
+            return SafeIterator(response_iter)
+            
+        except (BrokenPipeError, OSError) as e:
+            # Check if it's a broken pipe error (client disconnected)
+            errno = getattr(e, 'errno', None)
+            if errno == 32 or 'Broken pipe' in str(e) or 'BrokenPipeError' in str(type(e).__name__):
+                # Client disconnected - log as warning but don't fail
+                logger.warning(f"Client disconnected during response (operation may have succeeded)")
+                # Return an empty response
+                if not response_sent[0]:
+                    try:
+                        wrapped_start_response('200 OK', [])
+                    except:
+                        pass
+                return []
+            # Re-raise other OSErrors
+            raise
+
+
+# Wrap the application to handle BrokenPipeError
+application = BrokenPipeHandler(_base_application)

backend/core/exception_handler.py

@@ -0,0 +1,71 @@
+"""
+Custom exception handler to suppress BrokenPipeError in Django.
+"""
+import logging
+import sys
+from rest_framework.views import exception_handler as drf_exception_handler
+from rest_framework.response import Response
+from rest_framework import status
+
+logger = logging.getLogger(__name__)
+
+
+def custom_exception_handler(exc, context):
+    """
+    Custom exception handler that suppresses BrokenPipeError.
+    
+    This prevents Django from showing error pages when clients disconnect
+    during response writing.
+    """
+    # Check if it's a BrokenPipeError
+    if isinstance(exc, (BrokenPipeError, OSError)):
+        errno = getattr(exc, 'errno', None)
+        if errno == 32 or 'Broken pipe' in str(exc) or 'BrokenPipeError' in str(type(exc).__name__):
+            # Suppress BrokenPipeError - log as warning but don't show error page
+            logger.warning(f"Client disconnected during response: {context.get('request', {}).path if context else 'unknown'}")
+            # Return None to suppress the error page
+            return None
+    
+    # For all other exceptions, use Django's default handler
+    # Import here to avoid circular imports
+    from django.views.debug import technical_500_response
+    if sys.exc_info()[1] is exc:
+        return technical_500_response(request=context.get('request'), exc=exc)
+    return None
+
+
+def rest_framework_exception_handler(exc, context):
+    """
+    Custom REST framework exception handler that ensures JSON responses.
+    
+    This ensures all exceptions return JSON, not HTML error pages.
+    """
+    # First, try REST framework's default exception handler
+    response = drf_exception_handler(exc, context)
+    
+    # If REST framework handled it, return the response (should be JSON)
+    if response is not None:
+        return response
+    
+    # If REST framework didn't handle it, it's likely a non-API exception
+    # Log it and return a JSON error response
+    import traceback
+    logger.error(f"Unhandled exception in REST framework view: {exc}", exc_info=True)
+    
+    # Check if it's a BrokenPipeError (should be suppressed)
+    if isinstance(exc, (BrokenPipeError, OSError)):
+        errno = getattr(exc, 'errno', None)
+        if errno == 32 or 'Broken pipe' in str(exc) or 'BrokenPipeError' in str(type(exc).__name__):
+            logger.warning(f"Client disconnected during response: {context.get('request', {}).path if context else 'unknown'}")
+            # Return a minimal JSON response
+            return Response({'error': 'Client disconnected'}, status=status.HTTP_200_OK)
+    
+    # For all other exceptions, return JSON error response
+    return Response(
+        {
+            'error': str(exc),
+            'error_type': type(exc).__name__,
+            'detail': 'An error occurred processing your request'
+        },
+        status=status.HTTP_500_INTERNAL_SERVER_ERROR
+    )

backend/core/logging_filters.py

@@ -0,0 +1,33 @@
+"""
+Logging filters to suppress BrokenPipeError.
+"""
+import logging
+
+
+class SuppressBrokenPipe(logging.Filter):
+    """
+    Filter to suppress BrokenPipeError from being logged.
+    
+    BrokenPipeError occurs when Django tries to write a response to a connection
+    that has already been closed by the client. This is not a critical error
+    and should be handled silently.
+    """
+    
+    def filter(self, record):
+        """Filter out BrokenPipeError log records."""
+        # Check if the log record is about BrokenPipeError
+        if hasattr(record, 'exc_info') and record.exc_info:
+            exc_type, exc_value, exc_traceback = record.exc_info
+            if exc_type is BrokenPipeError or (isinstance(exc_value, BrokenPipeError)):
+                return False  # Suppress this log record
+            # Also check for OSError with errno 32 (broken pipe)
+            if exc_type is OSError and hasattr(exc_value, 'errno') and exc_value.errno == 32:
+                return False  # Suppress this log record
+        
+        # Check the message text for BrokenPipeError
+        if record.getMessage():
+            msg = str(record.getMessage())
+            if 'BrokenPipeError' in msg or 'Broken pipe' in msg:
+                return False  # Suppress this log record
+        
+        return True  # Allow other log records

backend/core/middleware.py

@@ -0,0 +1,53 @@
+"""
+Custom middleware to handle BrokenPipeError gracefully.
+This prevents Django from showing error pages when clients disconnect during response.
+"""
+import logging
+import sys
+
+logger = logging.getLogger(__name__)
+
+
+class BrokenPipeHandlerMiddleware:
+    """
+    Middleware to catch and handle BrokenPipeError gracefully.
+    
+    BrokenPipeError occurs when Django tries to write a response to a connection
+    that has already been closed by the client. This is not a critical error
+    and should be handled silently.
+    
+    Note: This middleware may not catch all BrokenPipeError cases as they can
+    occur at the WSGI level during response writing. The WSGI wrapper in
+    config/wsgi.py also handles these errors.
+    """
+    
+    def __init__(self, get_response):
+        self.get_response = get_response
+    
+    def __call__(self, request):
+        try:
+            response = self.get_response(request)
+            return response
+        except (BrokenPipeError, OSError) as e:
+            # Check if it's a broken pipe error (client disconnected)
+            errno = getattr(e, 'errno', None)
+            if errno == 32 or 'Broken pipe' in str(e) or 'BrokenPipeError' in str(type(e).__name__):
+                # Client disconnected - log as warning but don't fail
+                logger.warning(f"Client disconnected during request: {request.path}")
+                # Suppress the error - operation likely succeeded
+                # Return a minimal response that won't be sent anyway
+                from django.http import HttpResponse
+                return HttpResponse(status=200)
+            # Re-raise other OSErrors
+            raise
+    
+    def process_exception(self, request, exception):
+        """Handle exceptions during response rendering."""
+        if isinstance(exception, (BrokenPipeError, OSError)):
+            errno = getattr(exception, 'errno', None)
+            if errno == 32 or 'Broken pipe' in str(exception) or 'BrokenPipeError' in str(type(exception).__name__):
+                logger.warning(f"Client disconnected during response: {request.path}")
+                # Suppress the error - operation likely succeeded
+                # Return None to suppress the error page
+                return None
+        return None