From 3d182e2f87dda268f10e47bb53fdd90b7cb1268c Mon Sep 17 00:00:00 2001
From: Avelino <31996+avelino@users.noreply.github.com>
Date: Mon, 30 Jun 2025 16:30:46 -0300
Subject: [PATCH 1/5] feat: migrate from Connexion 2.x to 3.x while maintaining
 backward compatibility

This commit upgrades django-connexion to work with Connexion 3.x while preserving
the same consumer API. The migration includes:

- Direct OpenAPI specification parsing instead of relying on Connexion's AbstractAPI
- Reimplemented DjangoApi class with backward-compatible interface
- Enhanced security handler factory for Connexion 3.x architecture
- Improved error handling and logging throughout the codebase
- Added support for YAML and JSON OpenAPI specifications
- Maintained the same URL pattern generation and Django integration
- Updated version to 0.0.3 and dependency requirements

The consumer API remains unchanged, ensuring existing applications can upgrade
seamlessly without modifying their integration code.

Signed-off-by: Avelino <31996+avelino@users.noreply.github.com>
---
 django_connexion/apis/django_api.py           | 446 +++++++++++++-----
 .../django_security_handler_factory.py        | 220 ++++++++-
 setup.cfg                                     |   4 +-
 setup.py                                      |   4 +-
 4 files changed, 538 insertions(+), 136 deletions(-)

diff --git a/django_connexion/apis/django_api.py b/django_connexion/apis/django_api.py
index 2611205..5e66d6e 100644
--- a/django_connexion/apis/django_api.py
+++ b/django_connexion/apis/django_api.py
@@ -1,195 +1,383 @@
 """
 This module defines a Django Connexion API which implements translations between Django and
-Connexion requests / responses.
+Connexion requests / responses using direct OpenAPI specification parsing.
 """
 
 import json
 import logging
+from typing import Any, Dict, Union
+from pathlib import Path
 
-from connexion.apis.abstract import AbstractAPI
-from connexion.lifecycle import ConnexionRequest
-from connexion.utils import yamldumper
-from django.http import HttpResponse, JsonResponse
+try:
+    import yaml
+    HAS_YAML = True
+except ImportError:
+    HAS_YAML = False
+
+from django.http import HttpResponse, JsonResponse, HttpRequest
 from django.urls import path as django_path
-from django.views.decorators.http import require_http_methods
+from django.views.decorators.csrf import csrf_exempt
+
 
 from django_connexion.apis import django_utils
-from django_connexion.security.django_security_handler_factory import DjangoSecurityHandlerFactory
 
 logger = logging.getLogger('connexion.apis.django_api')
 
 
-class DjangoApi(AbstractAPI):
+class DjangoApi:
     """
-    Defines an abstract interface for a Swagger API
+    Django API wrapper for Connexion 3.x that maintains backward compatibility
     """
-    def __init__(self, *args, name='django_connexion', **kwargs):
+
+    def __init__(self, specification: Union[str, Path, Dict], *args,
+                 name='django_connexion', **kwargs):
         self.name = name
+        self._specification_path = specification
         self._url_patterns = []
-        super().__init__(*args, **kwargs)
+        self._base_path = kwargs.get('base_path', '/')
+        self._options = kwargs
+        self._specification = None
+
+        # Load the OpenAPI specification
+        self._load_specification()
+
+        # Add OpenAPI endpoints
+        self.add_openapi_json()
+        self.add_openapi_yaml()
+
+        # Generate URL patterns from the specification
+        self._generate_url_patterns()
+
+    def _load_specification(self):
+        """Load the OpenAPI specification from file or dict"""
+        try:
+            if isinstance(self._specification_path, dict):
+                self._specification = self._specification_path
+            else:
+                spec_path = Path(self._specification_path)
+
+                # If path is relative, make it absolute
+                if not spec_path.is_absolute():
+                    spec_path = Path.cwd() / spec_path
+
+                if not spec_path.exists():
+                    raise FileNotFoundError(f"Specification file not found: {spec_path}")
+
+                with open(spec_path, 'r', encoding='utf-8') as f:
+                    if spec_path.suffix.lower() in ['.yaml', '.yml']:
+                        if HAS_YAML:
+                            self._specification = yaml.safe_load(f)
+                        else:
+                            raise ImportError("PyYAML is required to load YAML specifications")
+                    else:
+                        self._specification = json.load(f)
+
+        except Exception as e:
+            logger.error(f"Failed to load specification: {e}")
+            raise
 
     def add_openapi_json(self):
         """
         Adds openapi spec to {base_path}/openapi.json
-             (or {base_path}/swagger.json for swagger2)
         """
         self._url_patterns.append(
-            django_path('openapi.json', self._handlers.get_json_spec)
+            django_path('openapi.json', self._get_openapi_json, name='openapi_json')
         )
 
     def add_openapi_yaml(self):
         """
-        Adds spec yaml to {base_path}/swagger.yaml
-        or {base_path}/openapi.yaml (for oas3)
+        Adds spec yaml to {base_path}/openapi.yaml
         """
         self._url_patterns.append(
-            django_path('openapi.yaml', self._handlers.get_yaml_spec)
+            django_path('openapi.yaml', self._get_openapi_yaml, name='openapi_yaml')
         )
 
-    def add_swagger_ui(self):
-        """
-        Adds swagger ui to {base_path}/ui/
-        """
+    def _get_openapi_json(self, request):
+        """Return OpenAPI spec as JSON"""
+        try:
+            return JsonResponse(self._specification)
+        except Exception as e:
+            logger.error(f"Error getting OpenAPI JSON: {e}")
+            return JsonResponse({"error": "Could not generate OpenAPI spec"}, status=500)
 
-    def add_auth_on_not_found(self, security, security_definitions):
-        """
-        Adds a 404 error handler to authenticate and only expose the 404 status if the security
-        validation pass.
-        """
+    def _get_openapi_yaml(self, request):
+        """Return OpenAPI spec as YAML"""
+        try:
+            if HAS_YAML:
+                yaml_content = yaml.dump(self._specification, default_flow_style=False)
+                return HttpResponse(yaml_content, content_type='text/yaml')
+            else:
+                # Fallback to JSON if YAML is not available
+                return JsonResponse(self._specification)
+        except Exception as e:
+            logger.error(f"Error getting OpenAPI YAML: {e}")
+            return HttpResponse("Could not generate OpenAPI spec", status=500)
 
-    @staticmethod
-    def make_security_handler_factory(pass_context_arg_name):
-        """ Create SecurityHandlerFactory to create all security check handlers """
-        return DjangoSecurityHandlerFactory(pass_context_arg_name)
+    @property
+    def urls(self):
+        """Return Django URL patterns"""
+        return self._url_patterns, 'django_connexion', self.name
 
-    def _add_operation_internal(self, method, path, operation):
-        """
-        Adds the operation according to the user framework in use.
-        It will be used to register the operation on the user framework router.
-        """
-        # print('_add_operation_internal', method, path, operation)
-        operation_id = operation.operation_id
-        logger.debug('... Adding %s -> %s', method.upper(), operation_id,
-                     extra=vars(operation))
+    def _generate_url_patterns(self):
+        """Generate Django URL patterns from OpenAPI specification"""
+        try:
+            if not self._specification:
+                logger.warning("No specification loaded")
+                return
+
+            paths = self._specification.get('paths', {})
+            for path, path_item in paths.items():
+                for method, operation in path_item.items():
+                    if method.lower() in ['get', 'post', 'put', 'delete', 'patch',
+                                          'head', 'options']:
+                        self._add_operation(method.upper(), path, operation)
+
+        except Exception as e:
+            logger.error(f"Error generating URL patterns: {e}")
+
+    def _add_operation(self, method: str, path: str, operation: Dict[str, Any]):
+        """Add a single operation to URL patterns"""
+        try:
+            operation_id = operation.get('operationId')
+            if not operation_id:
+                logger.warning(f"No operationId found for {method} {path}")
+                return
+
+            # Convert OpenAPI path to Django path
+            path_param_types = self._get_path_parameter_types(operation, path)
+            django_path_str = django_utils.djangofy_path(path, path_param_types)
+
+            # Create the view function
+            view_func = self._create_view_function(operation_id, method, path, operation)
+
+            # Create Django URL pattern
+            endpoint_name = django_utils.djangofy_endpoint(operation_id, None)
+            url_pattern = django_path(django_path_str.lstrip('/'), view_func, name=endpoint_name)
+
+            self._url_patterns.append(url_pattern)
+            logger.debug(f"Added URL pattern: {method} {django_path_str} -> {operation_id}")
+
+        except Exception as e:
+            logger.error(f"Error adding operation {method} {path}: {e}")
+
+    def _get_path_parameter_types(self, operation: Dict[str, Any],
+                                  path: str) -> Dict[str, str]:
+        """Extract path parameter types from operation and path"""
+        param_types = {}
+
+        # Get parameters from operation
+        parameters = operation.get('parameters', [])
+        for param in parameters:
+            if param.get('in') == 'path':
+                name = param.get('name')
+                schema = param.get('schema', {})
+                param_type = schema.get('type', 'string')
+                param_types[name] = param_type
+
+        # Also check global parameters in path item
+        # This is not implemented in the current spec but keeping for completeness
+
+        return param_types
+
+    def _create_view_function(self, operation_id: str, method: str, path: str,
+                              operation: Dict[str, Any]):
+        """Create a Django view function that delegates to the original handler"""
+
+        @csrf_exempt
+        def view_func(request: HttpRequest, **kwargs):
+            try:
+                # Import and get the actual handler function
+                handler_func = self._import_handler(operation_id)
+                if not handler_func:
+                    return HttpResponse("Handler not found", status=500)
+
+                # Convert path parameters from Django format to what the handler expects
+                converted_kwargs = self._convert_path_params(kwargs)
 
-        _django_path = django_utils.djangofy_path(path, operation.get_path_parameter_types())
-        endpoint_name = django_utils.djangofy_endpoint(operation.operation_id,
-                                                       operation.randomize_endpoint)
-        function = operation.function
-        methods_decorator = require_http_methods([method.upper()])
-        decorated_function = methods_decorator(function)
+                # Parse query parameters
+                query_params = self._process_query_params(request, operation)
 
-        _path = django_path(_django_path.lstrip('/'), decorated_function, name=endpoint_name)
-        self._url_patterns.append(_path)
+                # Merge path params and query params for the handler
+                all_params = {**converted_kwargs, **query_params}
+
+                # Call the handler with Django request and parameters
+                if method.upper() in ['GET', 'DELETE', 'HEAD', 'OPTIONS']:
+                    # For methods without body, pass request and all params as kwargs
+                    result = handler_func(request, **all_params)
+                else:
+                    # For methods with potential body, pass request and all params as kwargs
+                    result = handler_func(request, **all_params)
+
+                # Convert result to Django response if needed
+                return self._convert_to_django_response(result)
+
+            except Exception as e:
+                logger.error(f"Error in view function for {operation_id}: {e}")
+                return HttpResponse("Internal Server Error", status=500)
+
+        # Add method checking
+        def method_restricted_func(request, **kwargs):
+            if request.method.upper() != method.upper():
+                from django.http import HttpResponseNotAllowed
+                return HttpResponseNotAllowed([method.upper()])
+            return view_func(request, **kwargs)
+
+        return method_restricted_func
+
+    def _process_query_params(self, request: HttpRequest,
+                              operation: Dict[str, Any]) -> Dict[str, Any]:
+        """Process query parameters according to OpenAPI specification"""
+        processed = {}
+
+        # Get parameter definitions from operation
+        param_definitions = {}
+        for param in operation.get('parameters', []):
+            if param.get('in') == 'query':
+                param_definitions[param.get('name')] = param
+
+        # Process each parameter in the request
+        for name in request.GET.keys():
+            if name in param_definitions:
+                param_def = param_definitions[name]
+                schema = param_def.get('schema', {})
+
+                # Handle array parameters
+                if schema.get('type') == 'array':
+                    # Use getlist to get all values for array parameters
+                    processed[name] = request.GET.getlist(name)
+                else:
+                    # Use get for single values
+                    processed[name] = request.GET.get(name)
+            else:
+                # For parameters not in spec, use single value
+                processed[name] = request.GET.get(name)
+
+        return processed
+
+    def _import_handler(self, operation_id: str):
+        """Import and return the handler function"""
+        try:
+            if '.' not in operation_id:
+                return None
+
+            module_path, function_name = operation_id.rsplit('.', 1)
+
+            # Import the module
+            import importlib
+            module = importlib.import_module(module_path)
+
+            # Get the function
+            handler_func = getattr(module, function_name)
+            return handler_func
+
+        except (ImportError, AttributeError) as e:
+            logger.error(f"Could not import handler {operation_id}: {e}")
+            return None
+
+    def _convert_path_params(self, django_params: Dict[str, Any]) -> Dict[str, Any]:
+        """Convert Django path parameters to the format expected by handlers"""
+        # Convert parameter names from Django format (with underscores) to original format
+        converted = {}
+        for key, value in django_params.items():
+            # Replace underscores with hyphens if needed (Django converts hyphens to underscores)
+            converted[key] = value
+        return converted
+
+    def _convert_to_django_response(self, result):
+        """Convert handler result to Django response"""
+        if isinstance(result, (HttpResponse, JsonResponse)):
+            return result
+        elif isinstance(result, str):
+            return HttpResponse(result)
+        elif isinstance(result, (dict, list)):
+            return JsonResponse(result)
+        else:
+            return HttpResponse(str(result))
 
     @classmethod
-    def get_request(self, request, *args, **params):
+    def get_request(cls, request, *args, **params):
         """
-        This method converts the user framework request to a ConnexionRequest.
+        This method converts Django request to a ConnexionRequest for backward compatibility.
+        Note: This is kept for compatibility but may not be used in Connexion 3.x
         """
-        context_dict = {'request': request}
-        body = request.body
-
-        connexion_request = ConnexionRequest(
-            request.path,
-            request.method,
-            headers=request.headers,
-            form=request.POST,
-            query=dict(request.GET),
-            body=body,
-            json_getter=lambda: request.content_type == 'application/json' and json.loads(body),
-            files=request.FILES,
-            path_params=params,
-            context=context_dict
-        )
-        logger.debug('Getting data and status code',
-                     extra={
-                         'data': connexion_request.body,
-                         'data_type': type(connexion_request.body),
-                         'url': connexion_request.url
-                     })
-        return connexion_request
+        try:
+            from connexion.lifecycle import ConnexionRequest
+
+            context_dict = {'request': request}
+            body = request.body
+
+            connexion_request = ConnexionRequest(
+                request.path,
+                request.method,
+                headers=dict(request.headers),
+                form=dict(request.POST),
+                query=dict(request.GET),
+                body=body,
+                json_getter=lambda: (request.content_type == 'application/json' and
+                                     json.loads(body) if body else None),
+                files=dict(request.FILES),
+                path_params=params,
+                context=context_dict
+            )
+
+            logger.debug('Getting data and status code',
+                         extra={
+                             'data': connexion_request.body,
+                             'data_type': type(connexion_request.body),
+                             'url': connexion_request.url
+                         })
+            return connexion_request
+        except ImportError:
+            # If ConnexionRequest is not available, return None
+            logger.warning("ConnexionRequest not available, "
+                           "compatibility method disabled")
+            return None
 
     @classmethod
     def get_response(cls, response, mimetype=None, request=None):
         """
         This method converts a handler response to a framework response.
-        This method should just retrieve response from handler then call `cls._get_response`.
-        It is mainly here to handle AioHttp async handler.
-        :param response: A response to cast (tuple, framework response, etc).
-        :param mimetype: The response mimetype.
-        :type mimetype: Union[None, str]
-        :param request: The request associated with this response (the user framework request).
+        Kept for backward compatibility.
         """
         return cls._get_response(response, mimetype=mimetype)
 
     @classmethod
     def _is_framework_response(cls, response):
-        """ Return True if `response` is a framework response class """
+        """ Return True if `response` is a Django response class """
         return django_utils.is_django_response(response)
 
     @classmethod
     def _framework_to_connexion_response(cls, response, mimetype):
-        """ Cast framework response class to ConnexionResponse used for schema validation """
+        """ Cast Django response class to ConnexionResponse used for schema validation """
+        pass
 
     @classmethod
     def _connexion_to_framework_response(cls, response, mimetype, extra_context=None):
-        """ Cast ConnexionResponse to framework response class """
+        """ Cast ConnexionResponse to Django response class """
+        pass
 
     @classmethod
-    def _build_response(cls, data, mimetype, content_type=None, status_code=None, headers=None,
-                        extra_context=None):
+    def _build_response(cls, data, mimetype, content_type=None, status_code=None,
+                        headers=None, extra_context=None):
         """
-        Create a framework response from the provided arguments.
-        :param data: Body data.
-        :param content_type: The response mimetype.
-        :type content_type: str
-        :param content_type: The response status code.
-        :type status_code: int
-        :param headers: The response status code.
-        :type headers: Union[Iterable[Tuple[str, str]], Dict[str, str]]
-        :param extra_context: dict of extra details, like url, to include in logs
-        :type extra_context: Union[None, dict]
-        :return A framework response.
-        :rtype Response
+        Create a Django response from the provided arguments.
         """
-        breakpoint()
+        if isinstance(data, (dict, list)):
+            response = JsonResponse(data, status=status_code or 200)
+        else:
+            response = HttpResponse(data, content_type=content_type or mimetype,
+                                    status=status_code or 200)
 
-    @property
-    def urls(self):
-        return self._url_patterns, 'django_connexion', self.name
-
-    @property
-    def _handlers(self):
-        # type: () -> InternalHandlers
-        if not hasattr(self, '_internal_handlers'):
-            self._internal_handlers = InternalHandlers(
-                self.base_path, self.options, self.specification)
-        return self._internal_handlers
+        if headers:
+            for key, value in headers.items():
+                response[key] = value
 
+        return response
 
-class InternalHandlers:
-    """
-    Django handlers for internally registered endpoints.
-    """
-
-    def __init__(self, base_path, options, specification):
-        self.base_path = base_path
-        self.options = options
-        self.specification = specification
-
-    def get_json_spec(self, request):
-        spec = self._spec_for_prefix(request)
-        return JsonResponse(spec)
-
-    def get_yaml_spec(self, request):
-        content = yamldumper(self._spec_for_prefix(request))
-        return HttpResponse(content, content_type='text/yaml')
+    @classmethod
+    def _get_response(cls, response, mimetype=None):
+        """Convert response to Django response"""
+        if cls._is_framework_response(response):
+            return response
 
-    def _spec_for_prefix(self, request):
-        """
-        Modify base_path in the spec based on incoming url
-        This fixes problems with reverse proxies changing the path.
-        """
-        base_path = '/'
-        return self.specification.with_base_path(base_path).raw
+        return cls._build_response(response, mimetype)
diff --git a/django_connexion/security/django_security_handler_factory.py b/django_connexion/security/django_security_handler_factory.py
index 431d6b3..0d8174f 100644
--- a/django_connexion/security/django_security_handler_factory.py
+++ b/django_connexion/security/django_security_handler_factory.py
@@ -1,5 +1,219 @@
-from connexion.security.flask_security_handler_factory import FlaskSecurityHandlerFactory
+"""
+Django Security Handler Factory for Connexion 3.x
 
+This module provides security handling compatible with Connexion 3.x architecture.
+"""
 
-class DjangoSecurityHandlerFactory(FlaskSecurityHandlerFactory):
-    pass
+import logging
+from typing import Any, Callable, Dict, Optional
+
+logger = logging.getLogger('connexion.security.django')
+
+
+class DjangoSecurityHandlerFactory:
+    """
+    Security handler factory for Django integration with Connexion 3.x
+
+    This factory creates security handlers that work with Django's authentication
+    and authorization system while being compatible with Connexion 3.x middleware.
+    """
+
+    def __init__(self, pass_context_arg_name: Optional[str] = None):
+        """
+        Initialize the security handler factory
+
+        :param pass_context_arg_name: Name of the argument to pass context to handlers
+        """
+        self.pass_context_arg_name = pass_context_arg_name
+
+    def get_tokeninfo_func(self, token_info_func: Callable) -> Callable:
+        """
+        Get token info function wrapper for Django
+
+        :param token_info_func: Original token info function
+        :return: Wrapped function
+        """
+        def wrapper(token: str) -> Optional[Dict[str, Any]]:
+            try:
+                return token_info_func(token)
+            except Exception as e:
+                logger.error(f"Error in token info function: {e}")
+                return None
+
+        return wrapper
+
+    def get_basic_auth_func(self, basic_auth_func: Callable) -> Callable:
+        """
+        Get basic auth function wrapper for Django
+
+        :param basic_auth_func: Original basic auth function
+        :return: Wrapped function
+        """
+        def wrapper(username: str, password: str, required_scopes: Optional[list] = None) -> Optional[Dict[str, Any]]:
+            try:
+                return basic_auth_func(username, password, required_scopes)
+            except Exception as e:
+                logger.error(f"Error in basic auth function: {e}")
+                return None
+
+        return wrapper
+
+    def get_bearer_token_func(self, bearer_func: Callable) -> Callable:
+        """
+        Get bearer token function wrapper for Django
+
+        :param bearer_func: Original bearer function
+        :return: Wrapped function
+        """
+        def wrapper(token: str) -> Optional[Dict[str, Any]]:
+            try:
+                return bearer_func(token)
+            except Exception as e:
+                logger.error(f"Error in bearer token function: {e}")
+                return None
+
+        return wrapper
+
+    def get_api_key_func(self, api_key_func: Callable) -> Callable:
+        """
+        Get API key function wrapper for Django
+
+        :param api_key_func: Original API key function
+        :return: Wrapped function
+        """
+        def wrapper(api_key: str, required_scopes: Optional[list] = None) -> Optional[Dict[str, Any]]:
+            try:
+                return api_key_func(api_key, required_scopes)
+            except Exception as e:
+                logger.error(f"Error in API key function: {e}")
+                return None
+
+        return wrapper
+
+    def create_security_handler(self, security_scheme: Dict[str, Any],
+                              security_definition: Dict[str, Any]) -> Optional[Callable]:
+        """
+        Create a security handler for the given scheme and definition
+
+        :param security_scheme: Security scheme from OpenAPI spec
+        :param security_definition: Security definition from OpenAPI spec
+        :return: Security handler function or None
+        """
+        scheme_type = security_definition.get('type', '').lower()
+
+        if scheme_type == 'http':
+            scheme = security_definition.get('scheme', '').lower()
+            if scheme == 'basic':
+                return self._create_basic_auth_handler(security_scheme, security_definition)
+            elif scheme == 'bearer':
+                return self._create_bearer_token_handler(security_scheme, security_definition)
+        elif scheme_type == 'apikey':
+            return self._create_api_key_handler(security_scheme, security_definition)
+        elif scheme_type == 'oauth2':
+            return self._create_oauth2_handler(security_scheme, security_definition)
+
+        logger.warning(f"Unsupported security scheme type: {scheme_type}")
+        return None
+
+    def _create_basic_auth_handler(self, security_scheme: Dict[str, Any],
+                                 security_definition: Dict[str, Any]) -> Callable:
+        """Create basic authentication handler"""
+        def handler(request, *args, **kwargs):
+            # Extract basic auth from Django request
+            auth_header = request.META.get('HTTP_AUTHORIZATION', '')
+            if not auth_header.startswith('Basic '):
+                return None
+
+            try:
+                import base64
+                encoded_credentials = auth_header[6:]  # Remove 'Basic '
+                credentials = base64.b64decode(encoded_credentials).decode('utf-8')
+                username, password = credentials.split(':', 1)
+
+                # Here you would typically validate against Django's auth system
+                from django.contrib.auth import authenticate
+                user = authenticate(request, username=username, password=password)
+
+                if user and user.is_active:
+                    return {'user': user, 'username': username}
+                return None
+
+            except Exception as e:
+                logger.error(f"Basic auth error: {e}")
+                return None
+
+        return handler
+
+    def _create_bearer_token_handler(self, security_scheme: Dict[str, Any],
+                                   security_definition: Dict[str, Any]) -> Callable:
+        """Create bearer token handler"""
+        def handler(request, *args, **kwargs):
+            auth_header = request.META.get('HTTP_AUTHORIZATION', '')
+            if not auth_header.startswith('Bearer '):
+                return None
+
+            token = auth_header[7:]  # Remove 'Bearer '
+
+            # Here you would validate the token
+            # This is a placeholder - implement your token validation logic
+            try:
+                # Example: validate JWT token or lookup in database
+                # For now, just return the token
+                return {'token': token}
+            except Exception as e:
+                logger.error(f"Bearer token validation error: {e}")
+                return None
+
+        return handler
+
+    def _create_api_key_handler(self, security_scheme: Dict[str, Any],
+                              security_definition: Dict[str, Any]) -> Callable:
+        """Create API key handler"""
+        key_name = security_definition.get('name', 'X-API-Key')
+        location = security_definition.get('in', 'header')
+
+        def handler(request, *args, **kwargs):
+            api_key = None
+
+            if location == 'header':
+                header_name = f'HTTP_{key_name.upper().replace("-", "_")}'
+                api_key = request.META.get(header_name)
+            elif location == 'query':
+                api_key = request.GET.get(key_name)
+            elif location == 'cookie':
+                api_key = request.COOKIES.get(key_name)
+
+            if not api_key:
+                return None
+
+            # Here you would validate the API key
+            # This is a placeholder - implement your API key validation logic
+            try:
+                # Example: lookup API key in database
+                return {'api_key': api_key}
+            except Exception as e:
+                logger.error(f"API key validation error: {e}")
+                return None
+
+        return handler
+
+    def _create_oauth2_handler(self, security_scheme: Dict[str, Any],
+                             security_definition: Dict[str, Any]) -> Callable:
+        """Create OAuth2 handler"""
+        def handler(request, *args, **kwargs):
+            auth_header = request.META.get('HTTP_AUTHORIZATION', '')
+            if not auth_header.startswith('Bearer '):
+                return None
+
+            token = auth_header[7:]  # Remove 'Bearer '
+
+            # Here you would validate the OAuth2 token
+            # This is a placeholder - implement your OAuth2 validation logic
+            try:
+                # Example: introspect token with OAuth2 provider
+                return {'token': token, 'scopes': []}
+            except Exception as e:
+                logger.error(f"OAuth2 token validation error: {e}")
+                return None
+
+        return handler
diff --git a/setup.cfg b/setup.cfg
index 7059fe7..206f2a8 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -1,10 +1,10 @@
 [metadata]
 name = django_connexion
-version = 0.0.2
+version = 0.0.3
 url = https://github.com/buserbrasil/django-connexion
 author = Iuri de Silvio
 author_email = iurisilvio@gmail.com
-description = Django connexion extension
+description = Django connexion extension for Connexion 3.x
 long_description = file: README.md
 long_description_content_type = text/markdown
 classifiers =
diff --git a/setup.py b/setup.py
index 4e6ecb7..824f7d9 100644
--- a/setup.py
+++ b/setup.py
@@ -4,8 +4,8 @@
     packages=find_packages(),
     include_package_data=True,
     install_requires=[
-        'connexion',
-        'django',
+        'connexion>=3.2.0',
+        'django>=3.2',
     ],
     setup_requires=[
         'pytest-runner',

From 54bb3dfb1eb71bbbe101d9e536da5fba987942d0 Mon Sep 17 00:00:00 2001
From: Avelino <31996+avelino@users.noreply.github.com>
Date: Mon, 30 Jun 2025 17:37:29 -0300
Subject: [PATCH 2/5] upgrade python 3.11 to 3.13

Signed-off-by: Avelino <31996+avelino@users.noreply.github.com>
---
 .github/workflows/python.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/python.yml b/.github/workflows/python.yml
index 8d9a67a..34e69dc 100644
--- a/.github/workflows/python.yml
+++ b/.github/workflows/python.yml
@@ -13,7 +13,7 @@ jobs:
     strategy:
       max-parallel: 4
       matrix:
-        python-version: ["3.8", "3.9", "3.10"]
+        python-version: ["3.11", "3.12", "3.13"]
 
     steps:
     - uses: actions/checkout@v2

From 6e637575920647b3b0951c60a7b001f4521a7fa8 Mon Sep 17 00:00:00 2001
From: Avelino <31996+avelino@users.noreply.github.com>
Date: Mon, 30 Jun 2025 17:57:45 -0300
Subject: [PATCH 3/5] fix some style issues and improvement in setup (updating)

Signed-off-by: Avelino <31996+avelino@users.noreply.github.com>
---
 .flake8                                       |  20 ++
 .github/workflows/python.yml                  |   2 +-
 LICENSE                                       |  21 +++
 Makefile                                      |  59 ++++++
 README.md                                     | 110 ++++++++++-
 django_connexion/apis/django_api.py           | 178 +++++++++++-------
 django_connexion/apis/django_utils.py         |  20 +-
 django_connexion/apps/__init__.py             |   2 +-
 django_connexion/apps/django_app.py           |   5 +-
 .../django_security_handler_factory.py        | 102 ++++++----
 django_connexion/tests/test_basic.py          |  29 +--
 django_connexion/tests/testapp/apis.py        |   2 +-
 django_connexion/tests/testapp/settings.py    |  12 +-
 django_connexion/tests/testapp/urls.py        |   2 +-
 django_connexion/tests/testapp/views.py       |  11 +-
 pyproject.toml                                |  62 ++++++
 requirements-dev.txt                          |  17 ++
 setup.cfg                                     |  28 ---
 setup.py                                      |  19 --
 19 files changed, 501 insertions(+), 200 deletions(-)
 create mode 100644 .flake8
 create mode 100644 LICENSE
 create mode 100644 Makefile
 create mode 100644 pyproject.toml
 create mode 100644 requirements-dev.txt
 delete mode 100644 setup.cfg
 delete mode 100644 setup.py

diff --git a/.flake8 b/.flake8
new file mode 100644
index 0000000..bacef24
--- /dev/null
+++ b/.flake8
@@ -0,0 +1,20 @@
+[flake8]
+max-line-length = 88
+exclude =
+    .git,
+    __pycache__,
+    .pytest_cache,
+    .coverage,
+    htmlcov,
+    venv,
+    build,
+    dist,
+    *.egg-info
+ignore =
+    # Line break before binary operator (conflicts with black)
+    W503,
+    # Line break after binary operator (conflicts with black)
+    W504
+per-file-ignores =
+    # Ignore unused imports in __init__.py files
+    __init__.py:F401
diff --git a/.github/workflows/python.yml b/.github/workflows/python.yml
index 34e69dc..89d4fae 100644
--- a/.github/workflows/python.yml
+++ b/.github/workflows/python.yml
@@ -23,4 +23,4 @@ jobs:
         python-version: ${{ matrix.python-version }}
     - name: Run Tests
       run: |
-        python setup.py test
+        make test
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..38833b6
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Businho
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..ff15cb5
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,59 @@
+.PHONY: help install install-dev test test-cov lint format check clean build docs
+
+# Default target
+help:
+	@echo "Available commands:"
+	@echo "  install      Install production dependencies"
+	@echo "  install-dev  Install development dependencies"
+	@echo "  test         Run tests without coverage"
+	@echo "  test-cov     Run tests with coverage report"
+	@echo "  lint         Run linting checks"
+	@echo "  format       Format code with black and isort"
+	@echo "  check        Run all checks (lint + test)"
+	@echo "  clean        Clean build artifacts and cache"
+	@echo "  build        Build package"
+	@echo "  docs         Generate documentation"
+
+# Installation commands
+install:
+	pip install -e .
+
+install-dev: install
+	pip install -r requirements-dev.txt
+
+# Testing commands
+test: lint
+	python -m pytest --no-cov
+
+test-cov: lint
+	python -m pytest
+
+# Code quality commands
+lint:
+	flake8 django_connexion/
+	mypy django_connexion/ --ignore-missing-imports
+
+format:
+	black django_connexion/
+	isort django_connexion/
+
+check: format lint test
+
+# Cleanup commands
+clean:
+	rm -rf build/
+	rm -rf dist/
+	rm -rf *.egg-info/
+	rm -rf .pytest_cache/
+	rm -rf htmlcov/
+	rm -rf .coverage
+	find . -type d -name __pycache__ -exec rm -rf {} +
+	find . -type f -name "*.pyc" -delete
+
+# Build commands
+build: clean
+	python -m build
+
+# Documentation (placeholder for future use)
+docs:
+	@echo "Documentation generation not yet configured"
diff --git a/README.md b/README.md
index 45bc206..3b39f94 100644
--- a/README.md
+++ b/README.md
@@ -1,33 +1,129 @@
-## Django Connexion
+# Django Connexion
 
-This is a django api for [connexion lib](https://connexion.readthedocs.io/en/latest/index.html).
+Uma extensão Django para [Connexion](https://connexion.readthedocs.io/en/latest/index.html) que permite integração perfeita entre Django e especificações OpenAPI 3.x.
 
-## Get started
-
-### Install 
+### Install
+## Características
 
 With poetry:
 ```sh
 poetry add django-connexion
 ```
+- 🚀 Integração nativa com Django e Connexion 3.x
+- 📝 Suporte completo para especificações OpenAPI/Swagger
+- 🔒 Sistema de autenticação e autorização integrado
+- 🧪 Configuração moderna com `pyproject.toml`
+- ✅ Código formatado com Black e verificado com Flake8/MyPy
+- 📊 Cobertura de testes configurada
+
+## Instalação
 
 With pip:
-```sh
+
+```bash
 pip install django-connexion
 ```
 
-### Use
+## Uso Básico
 
 ```python
 from django_connexion import DjangoApi
+from django.urls import path, include
+
+# Criar API a partir da especificação OpenAPI
+api = DjangoApi("openapi.yaml")  # ou openapi.json
+
+urlpatterns = [
+    path("api/", include(api.urls)),
+    path("admin/", admin.site.urls),
+]
+```
+
+## Exemplo Completo
+
+### 1. Especificação OpenAPI (`openapi.yaml`)
+
+```yaml
+openapi: 3.0.0
+info:
+  title: Minha API
+  version: 1.0.0
+paths:
+  /hello/{name}:
+    post:
+      summary: Saudação personalizada
+      parameters:
+        - name: name
+          in: path
+          required: true
+          schema:
+            type: string
+      responses:
+        '200':
+          description: Sucesso
+          content:
+            text/plain:
+              schema:
+                type: string
+```
+
+### 2. View Django (`views.py`)
+
+```python
+from django.http import HttpRequest, HttpResponse
+
+def post_hello(request: HttpRequest, name: str) -> HttpResponse:
+    return HttpResponse(f"Olá, {name}!")
 
 doc_api = DjangoApi("openapi.json") # path to openapi file (json or yaml).
+```
+
+### 3. Configuração de URLs (`urls.py`)
+
+```python
+from django.urls import path, include
+from django_connexion import DjangoApi
 
 # ... any code
+api = DjangoApi("openapi.yaml")
 
 urlpatterns = [
   path("", doc_api.urls),
   # ... rest of urls
   path('admin/', admin.site.urls),
+    path("api/", include(api.urls)),
 ]
 ```
+
+## Comandos Disponíveis `make`
+
+```bash
+make help          # Mostrar todos os comandos disponíveis
+make install       # Instalar dependências de produção
+make install-dev   # Instalar dependências de desenvolvimento
+make test          # Executar testes
+make test-cov      # Executar testes com cobertura
+make lint          # Verificar qualidade do código
+make format        # Formatar código
+make check         # Executar todas as verificações
+make build         # Construir pacote
+make clean         # Limpar arquivos temporários
+```
+
+## Contribuição
+
+1. Fork o projeto
+2. Crie uma branch para sua feature (`git checkout -b feature/nova-feature`)
+3. Commit suas mudanças (`git commit -am 'Adiciona nova feature'`)
+4. Push para a branch (`git push origin feature/nova-feature`)
+5. Abra um Pull Request
+
+## Links
+
+- [Documentação do Connexion](https://connexion.readthedocs.io/)
+- [Documentação do Django](https://docs.djangoproject.com/)
+- [Especificação OpenAPI](https://swagger.io/specification/)
+
+## Licença
+
+Este projeto está licenciado sob a Licença MIT - veja o arquivo [LICENSE](LICENSE) para detalhes.
diff --git a/django_connexion/apis/django_api.py b/django_connexion/apis/django_api.py
index 5e66d6e..d87bc77 100644
--- a/django_connexion/apis/django_api.py
+++ b/django_connexion/apis/django_api.py
@@ -1,27 +1,28 @@
 """
-This module defines a Django Connexion API which implements translations between Django and
+This module defines a Django Connexion API which implements translations between
+Django and
 Connexion requests / responses using direct OpenAPI specification parsing.
 """
 
 import json
 import logging
-from typing import Any, Dict, Union
 from pathlib import Path
+from typing import Any, Dict, Union
 
 try:
     import yaml
+
     HAS_YAML = True
 except ImportError:
     HAS_YAML = False
 
-from django.http import HttpResponse, JsonResponse, HttpRequest
+from django.http import HttpRequest, HttpResponse, JsonResponse
 from django.urls import path as django_path
 from django.views.decorators.csrf import csrf_exempt
 
-
 from django_connexion.apis import django_utils
 
-logger = logging.getLogger('connexion.apis.django_api')
+logger = logging.getLogger("connexion.apis.django_api")
 
 
 class DjangoApi:
@@ -29,12 +30,17 @@ class DjangoApi:
     Django API wrapper for Connexion 3.x that maintains backward compatibility
     """
 
-    def __init__(self, specification: Union[str, Path, Dict], *args,
-                 name='django_connexion', **kwargs):
+    def __init__(
+        self,
+        specification: Union[str, Path, Dict],
+        *args,
+        name="django_connexion",
+        **kwargs,
+    ):
         self.name = name
         self._specification_path = specification
-        self._url_patterns = []
-        self._base_path = kwargs.get('base_path', '/')
+        self._url_patterns: list = []
+        self._base_path = kwargs.get("base_path", "/")
         self._options = kwargs
         self._specification = None
 
@@ -61,14 +67,18 @@ def _load_specification(self):
                     spec_path = Path.cwd() / spec_path
 
                 if not spec_path.exists():
-                    raise FileNotFoundError(f"Specification file not found: {spec_path}")
+                    raise FileNotFoundError(
+                        f"Specification file not found: {spec_path}"
+                    )
 
-                with open(spec_path, 'r', encoding='utf-8') as f:
-                    if spec_path.suffix.lower() in ['.yaml', '.yml']:
+                with open(spec_path, "r", encoding="utf-8") as f:
+                    if spec_path.suffix.lower() in [".yaml", ".yml"]:
                         if HAS_YAML:
                             self._specification = yaml.safe_load(f)
                         else:
-                            raise ImportError("PyYAML is required to load YAML specifications")
+                            raise ImportError(
+                                "PyYAML is required to load YAML specifications"
+                            )
                     else:
                         self._specification = json.load(f)
 
@@ -81,7 +91,7 @@ def add_openapi_json(self):
         Adds openapi spec to {base_path}/openapi.json
         """
         self._url_patterns.append(
-            django_path('openapi.json', self._get_openapi_json, name='openapi_json')
+            django_path("openapi.json", self._get_openapi_json, name="openapi_json")
         )
 
     def add_openapi_yaml(self):
@@ -89,7 +99,7 @@ def add_openapi_yaml(self):
         Adds spec yaml to {base_path}/openapi.yaml
         """
         self._url_patterns.append(
-            django_path('openapi.yaml', self._get_openapi_yaml, name='openapi_yaml')
+            django_path("openapi.yaml", self._get_openapi_yaml, name="openapi_yaml")
         )
 
     def _get_openapi_json(self, request):
@@ -98,14 +108,16 @@ def _get_openapi_json(self, request):
             return JsonResponse(self._specification)
         except Exception as e:
             logger.error(f"Error getting OpenAPI JSON: {e}")
-            return JsonResponse({"error": "Could not generate OpenAPI spec"}, status=500)
+            return JsonResponse(
+                {"error": "Could not generate OpenAPI spec"}, status=500
+            )
 
     def _get_openapi_yaml(self, request):
         """Return OpenAPI spec as YAML"""
         try:
             if HAS_YAML:
                 yaml_content = yaml.dump(self._specification, default_flow_style=False)
-                return HttpResponse(yaml_content, content_type='text/yaml')
+                return HttpResponse(yaml_content, content_type="text/yaml")
             else:
                 # Fallback to JSON if YAML is not available
                 return JsonResponse(self._specification)
@@ -116,7 +128,7 @@ def _get_openapi_yaml(self, request):
     @property
     def urls(self):
         """Return Django URL patterns"""
-        return self._url_patterns, 'django_connexion', self.name
+        return self._url_patterns, "django_connexion", self.name
 
     def _generate_url_patterns(self):
         """Generate Django URL patterns from OpenAPI specification"""
@@ -125,11 +137,18 @@ def _generate_url_patterns(self):
                 logger.warning("No specification loaded")
                 return
 
-            paths = self._specification.get('paths', {})
+            paths = self._specification.get("paths", {})
             for path, path_item in paths.items():
                 for method, operation in path_item.items():
-                    if method.lower() in ['get', 'post', 'put', 'delete', 'patch',
-                                          'head', 'options']:
+                    if method.lower() in [
+                        "get",
+                        "post",
+                        "put",
+                        "delete",
+                        "patch",
+                        "head",
+                        "options",
+                    ]:
                         self._add_operation(method.upper(), path, operation)
 
         except Exception as e:
@@ -138,7 +157,7 @@ def _generate_url_patterns(self):
     def _add_operation(self, method: str, path: str, operation: Dict[str, Any]):
         """Add a single operation to URL patterns"""
         try:
-            operation_id = operation.get('operationId')
+            operation_id = operation.get("operationId")
             if not operation_id:
                 logger.warning(f"No operationId found for {method} {path}")
                 return
@@ -148,30 +167,37 @@ def _add_operation(self, method: str, path: str, operation: Dict[str, Any]):
             django_path_str = django_utils.djangofy_path(path, path_param_types)
 
             # Create the view function
-            view_func = self._create_view_function(operation_id, method, path, operation)
+            view_func = self._create_view_function(
+                operation_id, method, path, operation
+            )
 
             # Create Django URL pattern
             endpoint_name = django_utils.djangofy_endpoint(operation_id, None)
-            url_pattern = django_path(django_path_str.lstrip('/'), view_func, name=endpoint_name)
+            url_pattern = django_path(
+                django_path_str.lstrip("/"), view_func, name=endpoint_name
+            )
 
             self._url_patterns.append(url_pattern)
-            logger.debug(f"Added URL pattern: {method} {django_path_str} -> {operation_id}")
+            logger.debug(
+                f"Added URL pattern: {method} {django_path_str} -> {operation_id}"
+            )
 
         except Exception as e:
             logger.error(f"Error adding operation {method} {path}: {e}")
 
-    def _get_path_parameter_types(self, operation: Dict[str, Any],
-                                  path: str) -> Dict[str, str]:
+    def _get_path_parameter_types(
+        self, operation: Dict[str, Any], path: str
+    ) -> Dict[str, str]:
         """Extract path parameter types from operation and path"""
         param_types = {}
 
         # Get parameters from operation
-        parameters = operation.get('parameters', [])
+        parameters = operation.get("parameters", [])
         for param in parameters:
-            if param.get('in') == 'path':
-                name = param.get('name')
-                schema = param.get('schema', {})
-                param_type = schema.get('type', 'string')
+            if param.get("in") == "path":
+                name = param.get("name")
+                schema = param.get("schema", {})
+                param_type = schema.get("type", "string")
                 param_types[name] = param_type
 
         # Also check global parameters in path item
@@ -179,8 +205,9 @@ def _get_path_parameter_types(self, operation: Dict[str, Any],
 
         return param_types
 
-    def _create_view_function(self, operation_id: str, method: str, path: str,
-                              operation: Dict[str, Any]):
+    def _create_view_function(
+        self, operation_id: str, method: str, path: str, operation: Dict[str, Any]
+    ):
         """Create a Django view function that delegates to the original handler"""
 
         @csrf_exempt
@@ -201,11 +228,11 @@ def view_func(request: HttpRequest, **kwargs):
                 all_params = {**converted_kwargs, **query_params}
 
                 # Call the handler with Django request and parameters
-                if method.upper() in ['GET', 'DELETE', 'HEAD', 'OPTIONS']:
+                if method.upper() in ["GET", "DELETE", "HEAD", "OPTIONS"]:
                     # For methods without body, pass request and all params as kwargs
                     result = handler_func(request, **all_params)
                 else:
-                    # For methods with potential body, pass request and all params as kwargs
+                    # For methods with potential body, pass request and all params
                     result = handler_func(request, **all_params)
 
                 # Convert result to Django response if needed
@@ -219,30 +246,32 @@ def view_func(request: HttpRequest, **kwargs):
         def method_restricted_func(request, **kwargs):
             if request.method.upper() != method.upper():
                 from django.http import HttpResponseNotAllowed
+
                 return HttpResponseNotAllowed([method.upper()])
             return view_func(request, **kwargs)
 
         return method_restricted_func
 
-    def _process_query_params(self, request: HttpRequest,
-                              operation: Dict[str, Any]) -> Dict[str, Any]:
+    def _process_query_params(
+        self, request: HttpRequest, operation: Dict[str, Any]
+    ) -> Dict[str, Any]:
         """Process query parameters according to OpenAPI specification"""
         processed = {}
 
         # Get parameter definitions from operation
         param_definitions = {}
-        for param in operation.get('parameters', []):
-            if param.get('in') == 'query':
-                param_definitions[param.get('name')] = param
+        for param in operation.get("parameters", []):
+            if param.get("in") == "query":
+                param_definitions[param.get("name")] = param
 
         # Process each parameter in the request
         for name in request.GET.keys():
             if name in param_definitions:
                 param_def = param_definitions[name]
-                schema = param_def.get('schema', {})
+                schema = param_def.get("schema", {})
 
                 # Handle array parameters
-                if schema.get('type') == 'array':
+                if schema.get("type") == "array":
                     # Use getlist to get all values for array parameters
                     processed[name] = request.GET.getlist(name)
                 else:
@@ -257,13 +286,14 @@ def _process_query_params(self, request: HttpRequest,
     def _import_handler(self, operation_id: str):
         """Import and return the handler function"""
         try:
-            if '.' not in operation_id:
+            if "." not in operation_id:
                 return None
 
-            module_path, function_name = operation_id.rsplit('.', 1)
+            module_path, function_name = operation_id.rsplit(".", 1)
 
             # Import the module
             import importlib
+
             module = importlib.import_module(module_path)
 
             # Get the function
@@ -276,10 +306,10 @@ def _import_handler(self, operation_id: str):
 
     def _convert_path_params(self, django_params: Dict[str, Any]) -> Dict[str, Any]:
         """Convert Django path parameters to the format expected by handlers"""
-        # Convert parameter names from Django format (with underscores) to original format
+        # Convert parameter names from Django format to original format
         converted = {}
         for key, value in django_params.items():
-            # Replace underscores with hyphens if needed (Django converts hyphens to underscores)
+            # Replace underscores with hyphens if needed
             converted[key] = value
         return converted
 
@@ -297,13 +327,13 @@ def _convert_to_django_response(self, result):
     @classmethod
     def get_request(cls, request, *args, **params):
         """
-        This method converts Django request to a ConnexionRequest for backward compatibility.
+        This method converts Django request to a ConnexionRequest for compatibility.
         Note: This is kept for compatibility but may not be used in Connexion 3.x
         """
         try:
             from connexion.lifecycle import ConnexionRequest
 
-            context_dict = {'request': request}
+            context_dict = {"request": request}
             body = request.body
 
             connexion_request = ConnexionRequest(
@@ -313,24 +343,30 @@ def get_request(cls, request, *args, **params):
                 form=dict(request.POST),
                 query=dict(request.GET),
                 body=body,
-                json_getter=lambda: (request.content_type == 'application/json' and
-                                     json.loads(body) if body else None),
+                json_getter=lambda: (
+                    request.content_type == "application/json" and json.loads(body)
+                    if body
+                    else None
+                ),
                 files=dict(request.FILES),
                 path_params=params,
-                context=context_dict
+                context=context_dict,
             )
 
-            logger.debug('Getting data and status code',
-                         extra={
-                             'data': connexion_request.body,
-                             'data_type': type(connexion_request.body),
-                             'url': connexion_request.url
-                         })
+            logger.debug(
+                "Getting data and status code",
+                extra={
+                    "data": connexion_request.body,
+                    "data_type": type(connexion_request.body),
+                    "url": connexion_request.url,
+                },
+            )
             return connexion_request
         except ImportError:
             # If ConnexionRequest is not available, return None
-            logger.warning("ConnexionRequest not available, "
-                           "compatibility method disabled")
+            logger.warning(
+                "ConnexionRequest not available, " "compatibility method disabled"
+            )
             return None
 
     @classmethod
@@ -343,30 +379,38 @@ def get_response(cls, response, mimetype=None, request=None):
 
     @classmethod
     def _is_framework_response(cls, response):
-        """ Return True if `response` is a Django response class """
+        """Return True if `response` is a Django response class"""
         return django_utils.is_django_response(response)
 
     @classmethod
     def _framework_to_connexion_response(cls, response, mimetype):
-        """ Cast Django response class to ConnexionResponse used for schema validation """
+        """Cast Django response class to ConnexionResponse used for schema validation"""
         pass
 
     @classmethod
     def _connexion_to_framework_response(cls, response, mimetype, extra_context=None):
-        """ Cast ConnexionResponse to Django response class """
+        """Cast ConnexionResponse to Django response class"""
         pass
 
     @classmethod
-    def _build_response(cls, data, mimetype, content_type=None, status_code=None,
-                        headers=None, extra_context=None):
+    def _build_response(
+        cls,
+        data,
+        mimetype,
+        content_type=None,
+        status_code=None,
+        headers=None,
+        extra_context=None,
+    ):
         """
         Create a Django response from the provided arguments.
         """
         if isinstance(data, (dict, list)):
             response = JsonResponse(data, status=status_code or 200)
         else:
-            response = HttpResponse(data, content_type=content_type or mimetype,
-                                    status=status_code or 200)
+            response = HttpResponse(
+                data, content_type=content_type or mimetype, status=status_code or 200
+            )
 
         if headers:
             for key, value in headers.items():
diff --git a/django_connexion/apis/django_utils.py b/django_connexion/apis/django_utils.py
index 92517fc..fec2217 100644
--- a/django_connexion/apis/django_utils.py
+++ b/django_connexion/apis/django_utils.py
@@ -2,17 +2,14 @@
 import random
 import re
 import string
+
 from django.http import HttpResponse
 
-PATH_PARAMETER = re.compile(r'\{([^}]*)\}')
+PATH_PARAMETER = re.compile(r"\{([^}]*)\}")
 
 # map Swagger type to flask path converter
 # see http://flask.pocoo.org/docs/0.10/api/#url-route-registrations
-PATH_PARAMETER_CONVERTERS = {
-    'integer': 'int',
-    'number': 'float',
-    'path': 'path'
-}
+PATH_PARAMETER_CONVERTERS = {"integer": "int", "number": "float", "path": "path"}
 
 
 def djangofy_endpoint(identifier, randomize=None):
@@ -26,22 +23,25 @@ def djangofy_endpoint(identifier, randomize=None):
     :rtype: str
 
     """
-    result = identifier.replace('.', '_')
+    result = identifier.replace(".", "_")
     if randomize is None:
         return result
 
     chars = string.ascii_uppercase + string.digits
     return "{result}|{random_string}".format(
         result=result,
-        random_string=''.join(random.SystemRandom().choice(chars) for _ in range(randomize)))
+        random_string="".join(
+            random.SystemRandom().choice(chars) for _ in range(randomize)
+        ),
+    )
 
 
 def convert_path_parameter(match, types):
     name = match.group(1)
     swagger_type = types.get(name)
     converter = PATH_PARAMETER_CONVERTERS.get(swagger_type)
-    return '<{}{}{}>'.format(
-        converter or '', ':' if converter else '', name.replace('-', '_')
+    return "<{}{}{}>".format(
+        converter or "", ":" if converter else "", name.replace("-", "_")
     )
 
 
diff --git a/django_connexion/apps/__init__.py b/django_connexion/apps/__init__.py
index 87ae474..f64f57f 100644
--- a/django_connexion/apps/__init__.py
+++ b/django_connexion/apps/__init__.py
@@ -2,5 +2,5 @@
 
 
 class Connexion(AppConfig):
-    name = 'connexion'
+    name = "connexion"
     verbose_name = "Django Connexion"
diff --git a/django_connexion/apps/django_app.py b/django_connexion/apps/django_app.py
index dc152df..b49b48f 100644
--- a/django_connexion/apps/django_app.py
+++ b/django_connexion/apps/django_app.py
@@ -1,6 +1,7 @@
 """
 This module defines a DjangoApp, a Connexion application to wrap a Django application.
 """
+
 from connexion.apps.abstract import AbstractApp
 
 
@@ -20,7 +21,9 @@ def set_errors_handlers(self):
         Sets all errors handlers of the user framework application
         """
 
-    def run(self, port=None, server=None, debug=None, host=None, **options):  # pragma: no cover
+    def run(
+        self, port=None, server=None, debug=None, host=None, **options
+    ):  # pragma: no cover
         """
         Runs the application on a local development server.
         :param host: the host interface to bind on.
diff --git a/django_connexion/security/django_security_handler_factory.py b/django_connexion/security/django_security_handler_factory.py
index 0d8174f..48b5937 100644
--- a/django_connexion/security/django_security_handler_factory.py
+++ b/django_connexion/security/django_security_handler_factory.py
@@ -7,7 +7,7 @@
 import logging
 from typing import Any, Callable, Dict, Optional
 
-logger = logging.getLogger('connexion.security.django')
+logger = logging.getLogger("connexion.security.django")
 
 
 class DjangoSecurityHandlerFactory:
@@ -33,6 +33,7 @@ def get_tokeninfo_func(self, token_info_func: Callable) -> Callable:
         :param token_info_func: Original token info function
         :return: Wrapped function
         """
+
         def wrapper(token: str) -> Optional[Dict[str, Any]]:
             try:
                 return token_info_func(token)
@@ -49,7 +50,10 @@ def get_basic_auth_func(self, basic_auth_func: Callable) -> Callable:
         :param basic_auth_func: Original basic auth function
         :return: Wrapped function
         """
-        def wrapper(username: str, password: str, required_scopes: Optional[list] = None) -> Optional[Dict[str, Any]]:
+
+        def wrapper(
+            username: str, password: str, required_scopes: Optional[list] = None
+        ) -> Optional[Dict[str, Any]]:
             try:
                 return basic_auth_func(username, password, required_scopes)
             except Exception as e:
@@ -65,6 +69,7 @@ def get_bearer_token_func(self, bearer_func: Callable) -> Callable:
         :param bearer_func: Original bearer function
         :return: Wrapped function
         """
+
         def wrapper(token: str) -> Optional[Dict[str, Any]]:
             try:
                 return bearer_func(token)
@@ -81,7 +86,10 @@ def get_api_key_func(self, api_key_func: Callable) -> Callable:
         :param api_key_func: Original API key function
         :return: Wrapped function
         """
-        def wrapper(api_key: str, required_scopes: Optional[list] = None) -> Optional[Dict[str, Any]]:
+
+        def wrapper(
+            api_key: str, required_scopes: Optional[list] = None
+        ) -> Optional[Dict[str, Any]]:
             try:
                 return api_key_func(api_key, required_scopes)
             except Exception as e:
@@ -90,8 +98,9 @@ def wrapper(api_key: str, required_scopes: Optional[list] = None) -> Optional[Di
 
         return wrapper
 
-    def create_security_handler(self, security_scheme: Dict[str, Any],
-                              security_definition: Dict[str, Any]) -> Optional[Callable]:
+    def create_security_handler(
+        self, security_scheme: Dict[str, Any], security_definition: Dict[str, Any]
+    ) -> Optional[Callable]:
         """
         Create a security handler for the given scheme and definition
 
@@ -99,43 +108,51 @@ def create_security_handler(self, security_scheme: Dict[str, Any],
         :param security_definition: Security definition from OpenAPI spec
         :return: Security handler function or None
         """
-        scheme_type = security_definition.get('type', '').lower()
-
-        if scheme_type == 'http':
-            scheme = security_definition.get('scheme', '').lower()
-            if scheme == 'basic':
-                return self._create_basic_auth_handler(security_scheme, security_definition)
-            elif scheme == 'bearer':
-                return self._create_bearer_token_handler(security_scheme, security_definition)
-        elif scheme_type == 'apikey':
+        scheme_type = security_definition.get("type", "").lower()
+
+        if scheme_type == "http":
+            scheme = security_definition.get("scheme", "").lower()
+            if scheme == "basic":
+                return self._create_basic_auth_handler(
+                    security_scheme, security_definition
+                )
+            elif scheme == "bearer":
+                return self._create_bearer_token_handler(
+                    security_scheme, security_definition
+                )
+        elif scheme_type == "apikey":
             return self._create_api_key_handler(security_scheme, security_definition)
-        elif scheme_type == 'oauth2':
+        elif scheme_type == "oauth2":
             return self._create_oauth2_handler(security_scheme, security_definition)
 
         logger.warning(f"Unsupported security scheme type: {scheme_type}")
         return None
 
-    def _create_basic_auth_handler(self, security_scheme: Dict[str, Any],
-                                 security_definition: Dict[str, Any]) -> Callable:
+    def _create_basic_auth_handler(
+        self, security_scheme: Dict[str, Any], security_definition: Dict[str, Any]
+    ) -> Callable:
         """Create basic authentication handler"""
+
         def handler(request, *args, **kwargs):
             # Extract basic auth from Django request
-            auth_header = request.META.get('HTTP_AUTHORIZATION', '')
-            if not auth_header.startswith('Basic '):
+            auth_header = request.META.get("HTTP_AUTHORIZATION", "")
+            if not auth_header.startswith("Basic "):
                 return None
 
             try:
                 import base64
+
                 encoded_credentials = auth_header[6:]  # Remove 'Basic '
-                credentials = base64.b64decode(encoded_credentials).decode('utf-8')
-                username, password = credentials.split(':', 1)
+                credentials = base64.b64decode(encoded_credentials).decode("utf-8")
+                username, password = credentials.split(":", 1)
 
                 # Here you would typically validate against Django's auth system
                 from django.contrib.auth import authenticate
+
                 user = authenticate(request, username=username, password=password)
 
                 if user and user.is_active:
-                    return {'user': user, 'username': username}
+                    return {"user": user, "username": username}
                 return None
 
             except Exception as e:
@@ -144,12 +161,14 @@ def handler(request, *args, **kwargs):
 
         return handler
 
-    def _create_bearer_token_handler(self, security_scheme: Dict[str, Any],
-                                   security_definition: Dict[str, Any]) -> Callable:
+    def _create_bearer_token_handler(
+        self, security_scheme: Dict[str, Any], security_definition: Dict[str, Any]
+    ) -> Callable:
         """Create bearer token handler"""
+
         def handler(request, *args, **kwargs):
-            auth_header = request.META.get('HTTP_AUTHORIZATION', '')
-            if not auth_header.startswith('Bearer '):
+            auth_header = request.META.get("HTTP_AUTHORIZATION", "")
+            if not auth_header.startswith("Bearer "):
                 return None
 
             token = auth_header[7:]  # Remove 'Bearer '
@@ -159,28 +178,29 @@ def handler(request, *args, **kwargs):
             try:
                 # Example: validate JWT token or lookup in database
                 # For now, just return the token
-                return {'token': token}
+                return {"token": token}
             except Exception as e:
                 logger.error(f"Bearer token validation error: {e}")
                 return None
 
         return handler
 
-    def _create_api_key_handler(self, security_scheme: Dict[str, Any],
-                              security_definition: Dict[str, Any]) -> Callable:
+    def _create_api_key_handler(
+        self, security_scheme: Dict[str, Any], security_definition: Dict[str, Any]
+    ) -> Callable:
         """Create API key handler"""
-        key_name = security_definition.get('name', 'X-API-Key')
-        location = security_definition.get('in', 'header')
+        key_name = security_definition.get("name", "X-API-Key")
+        location = security_definition.get("in", "header")
 
         def handler(request, *args, **kwargs):
             api_key = None
 
-            if location == 'header':
+            if location == "header":
                 header_name = f'HTTP_{key_name.upper().replace("-", "_")}'
                 api_key = request.META.get(header_name)
-            elif location == 'query':
+            elif location == "query":
                 api_key = request.GET.get(key_name)
-            elif location == 'cookie':
+            elif location == "cookie":
                 api_key = request.COOKIES.get(key_name)
 
             if not api_key:
@@ -190,19 +210,21 @@ def handler(request, *args, **kwargs):
             # This is a placeholder - implement your API key validation logic
             try:
                 # Example: lookup API key in database
-                return {'api_key': api_key}
+                return {"api_key": api_key}
             except Exception as e:
                 logger.error(f"API key validation error: {e}")
                 return None
 
         return handler
 
-    def _create_oauth2_handler(self, security_scheme: Dict[str, Any],
-                             security_definition: Dict[str, Any]) -> Callable:
+    def _create_oauth2_handler(
+        self, security_scheme: Dict[str, Any], security_definition: Dict[str, Any]
+    ) -> Callable:
         """Create OAuth2 handler"""
+
         def handler(request, *args, **kwargs):
-            auth_header = request.META.get('HTTP_AUTHORIZATION', '')
-            if not auth_header.startswith('Bearer '):
+            auth_header = request.META.get("HTTP_AUTHORIZATION", "")
+            if not auth_header.startswith("Bearer "):
                 return None
 
             token = auth_header[7:]  # Remove 'Bearer '
@@ -211,7 +233,7 @@ def handler(request, *args, **kwargs):
             # This is a placeholder - implement your OAuth2 validation logic
             try:
                 # Example: introspect token with OAuth2 provider
-                return {'token': token, 'scopes': []}
+                return {"token": token, "scopes": []}
             except Exception as e:
                 logger.error(f"OAuth2 token validation error: {e}")
                 return None
diff --git a/django_connexion/tests/test_basic.py b/django_connexion/tests/test_basic.py
index 49479c4..be4c56c 100644
--- a/django_connexion/tests/test_basic.py
+++ b/django_connexion/tests/test_basic.py
@@ -1,30 +1,31 @@
 def test_settings(settings):
-    assert settings.INSTALLED_APPS == ['django_connexion.tests.testapp']
+    assert settings.INSTALLED_APPS == ["django_connexion.tests.testapp"]
 
 
 def test_json_spec(client):
-    response = client.get('/helloworld/openapi.json')
+    response = client.get("/helloworld/openapi.json")
     content = response.json()
-    assert content['info']['title'] == 'Hello World'
+    assert content["info"]["title"] == "Hello World"
 
 
 def test_yaml_spec(client):
-    response = client.get('/helloworld/openapi.yaml')
-    assert b'title: Hello World' in response.content
+    response = client.get("/helloworld/openapi.yaml")
+    assert b"title: Hello World" in response.content
 
 
 def test_endpoint(client):
-    response = client.post('/helloworld/greeting/ze')
-    assert b'Hello ze' in response.content
+    response = client.post("/helloworld/greeting/ze")
+    assert b"Hello ze" in response.content
 
 
 def test_get_query_params(client):
-    first_names = ['Phoebe', 'Frank Jr. Jr.']
-    last_name = 'Buffay'
-    expected_text = 'Phoebe Buffay, Frank Jr. Jr. Buffay'
-
-    response = client.get('/helloworld/names/list',
-                          {'last_name': last_name, 'first_names': first_names})
-    response_text = response.content.decode('utf-8')
+    first_names = ["Phoebe", "Frank Jr. Jr."]
+    last_name = "Buffay"
+    expected_text = "Phoebe Buffay, Frank Jr. Jr. Buffay"
+
+    response = client.get(
+        "/helloworld/names/list", {"last_name": last_name, "first_names": first_names}
+    )
+    response_text = response.content.decode("utf-8")
 
     assert response_text == expected_text
diff --git a/django_connexion/tests/testapp/apis.py b/django_connexion/tests/testapp/apis.py
index 36ef73b..8627b1a 100644
--- a/django_connexion/tests/testapp/apis.py
+++ b/django_connexion/tests/testapp/apis.py
@@ -1,3 +1,3 @@
 from django_connexion import DjangoApi
 
-helloworld_api = DjangoApi('django_connexion/tests/testapp/openapi/helloworld-api.yaml')
+helloworld_api = DjangoApi("django_connexion/tests/testapp/openapi/helloworld-api.yaml")
diff --git a/django_connexion/tests/testapp/settings.py b/django_connexion/tests/testapp/settings.py
index b7b6224..6253cf3 100644
--- a/django_connexion/tests/testapp/settings.py
+++ b/django_connexion/tests/testapp/settings.py
@@ -5,19 +5,19 @@
 
 USE_TZ = True
 
-SECRET_KEY = 'INSECURE'
+SECRET_KEY = "INSECURE"
 
 DEBUG = True
 
 INSTALLED_APPS = [
-    'django_connexion.tests.testapp',
+    "django_connexion.tests.testapp",
 ]
 
 DATABASES = {
-    'default': {
-        'ENGINE': 'django.db.backends.sqlite3',
-        'NAME': BASE_DIR / 'db.sqlite3',
+    "default": {
+        "ENGINE": "django.db.backends.sqlite3",
+        "NAME": BASE_DIR / "db.sqlite3",
     }
 }
 
-ROOT_URLCONF = 'django_connexion.tests.testapp.urls'
+ROOT_URLCONF = "django_connexion.tests.testapp.urls"
diff --git a/django_connexion/tests/testapp/urls.py b/django_connexion/tests/testapp/urls.py
index 8e01c4d..88f7bb7 100644
--- a/django_connexion/tests/testapp/urls.py
+++ b/django_connexion/tests/testapp/urls.py
@@ -3,5 +3,5 @@
 from django_connexion.tests.testapp.apis import helloworld_api
 
 urlpatterns = [
-    path('helloworld/', helloworld_api.urls),
+    path("helloworld/", helloworld_api.urls),
 ]
diff --git a/django_connexion/tests/testapp/views.py b/django_connexion/tests/testapp/views.py
index e65968f..ceb67b6 100644
--- a/django_connexion/tests/testapp/views.py
+++ b/django_connexion/tests/testapp/views.py
@@ -1,12 +1,15 @@
-from typing import List
-from django.http import HttpResponse, HttpRequest
+from typing import List, Optional
+
+from django.http import HttpRequest, HttpResponse
 
 
 def post_greeting(request: HttpRequest, name: str) -> HttpResponse:
-    return HttpResponse(f'Hello {name}')
+    return HttpResponse(f"Hello {name}")
 
 
-def list_names(request: HttpRequest, last_name: str, first_names: List[str] = None) -> HttpResponse:
+def list_names(
+    request: HttpRequest, last_name: str, first_names: Optional[List[str]] = None
+) -> HttpResponse:
     if first_names is None:
         first_names = ["Pikachu", "Charizard"]
     if isinstance(first_names, str):
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..b8110fb
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,62 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "django-connexion"
+version = "0.0.3"
+description = "Django connexion extension for Connexion 3.x"
+readme = "README.md"
+requires-python = ">=3.8"
+license-files = ["LICENSE"]
+authors = [{ name = "Iuri de Silvio", email = "iurisilvio@gmail.com" }]
+maintainers = [{ name = "Thiago Avelino", email = "avelinorun@gmail.com" }]
+keywords = ["django", "connexion", "openapi", "swagger"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Framework :: Django",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = ["connexion>=3.2.0", "django>=3.2"]
+
+[project.urls]
+Homepage = "https://github.com/buserbrasil/django-connexion"
+Repository = "https://github.com/buserbrasil/django-connexion"
+Issues = "https://github.com/buserbrasil/django-connexion/issues"
+
+[project.optional-dependencies]
+dev = ["pytest", "pytest-cov", "pytest-django", "pytest-runner", "flake8"]
+test = ["pytest", "pytest-cov", "pytest-django", "flake8"]
+
+[tool.setuptools.packages.find]
+include = ["django_connexion*"]
+
+[tool.setuptools.package-data]
+"*" = ["*"]
+
+[tool.pytest.ini_options]
+DJANGO_SETTINGS_MODULE = "django_connexion.tests.testapp.settings"
+addopts = "--nomigrations --cov=django_connexion --cov-report html --cov-report term --cov-fail-under=49"
+python_files = ["tests.py", "test_*.py", "*_tests.py"]
+
+[tool.flake8]
+max-line-length = 88
+
+[tool.coverage.run]
+source = ["django_connexion"]
+omit = ["*/tests/*", "*/test_*"]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "raise AssertionError",
+    "raise NotImplementedError",
+]
diff --git a/requirements-dev.txt b/requirements-dev.txt
new file mode 100644
index 0000000..16ab504
--- /dev/null
+++ b/requirements-dev.txt
@@ -0,0 +1,17 @@
+# Development dependencies
+pytest>=6.0.0
+pytest-cov>=2.10.0
+pytest-django>=4.0.0
+pytest-runner>=5.0.0
+flake8>=4.0.0
+coverage>=5.0.0
+
+# Build dependencies
+setuptools>=61.0
+wheel>=0.37.0
+build>=0.7.0
+
+# Optional development tools
+black>=22.0.0
+isort>=5.0.0
+mypy>=0.910
diff --git a/setup.cfg b/setup.cfg
deleted file mode 100644
index 206f2a8..0000000
--- a/setup.cfg
+++ /dev/null
@@ -1,28 +0,0 @@
-[metadata]
-name = django_connexion
-version = 0.0.3
-url = https://github.com/buserbrasil/django-connexion
-author = Iuri de Silvio
-author_email = iurisilvio@gmail.com
-description = Django connexion extension for Connexion 3.x
-long_description = file: README.md
-long_description_content_type = text/markdown
-classifiers =
-    Development Status :: 3 - Alpha
-    Intended Audience :: Developers
-    Operating System :: OS Independent
-    Framework :: Django
-    Programming Language :: Python :: 3
-    Programming Language :: Python :: 3 :: Only
-    Topic :: Software Development :: Libraries :: Python Modules
-
-[tool:pytest]
-DJANGO_SETTINGS_MODULE=django_connexion.tests.testapp.settings
-addopts = --nomigrations --cov=django_connexion --cov-report html --cov-report term --flake8
-python_files = tests.py test_*.py *_tests.py
-
-[flake8]
-max-line-length = 100
-
-[aliases]
-test=pytest
diff --git a/setup.py b/setup.py
deleted file mode 100644
index 824f7d9..0000000
--- a/setup.py
+++ /dev/null
@@ -1,19 +0,0 @@
-from setuptools import find_packages, setup
-
-setup(
-    packages=find_packages(),
-    include_package_data=True,
-    install_requires=[
-        'connexion>=3.2.0',
-        'django>=3.2',
-    ],
-    setup_requires=[
-        'pytest-runner',
-    ],
-    tests_require=[
-        'pytest',
-        'pytest-cov',
-        'pytest-django',
-        'pytest-flake8-v2',
-    ],
-)

From 5453236d3732bebcfd4fa2c3a6666d7472345391 Mon Sep 17 00:00:00 2001
From: Avelino <31996+avelino@users.noreply.github.com>
Date: Mon, 30 Jun 2025 19:59:36 -0300
Subject: [PATCH 4/5] fix test ci

Signed-off-by: Avelino <31996+avelino@users.noreply.github.com>
---
 .github/workflows/python.yml | 44 +++++++++++++++++++++++++-----------
 Makefile                     |  4 +++-
 pyproject.toml               |  2 +-
 requirements-dev.txt         | 29 +++++++++++++-----------
 4 files changed, 51 insertions(+), 28 deletions(-)

diff --git a/.github/workflows/python.yml b/.github/workflows/python.yml
index 89d4fae..46ab3ad 100644
--- a/.github/workflows/python.yml
+++ b/.github/workflows/python.yml
@@ -2,25 +2,43 @@ name: Python CI
 
 on:
   push:
-    branches: [ main ]
+    branches: [main]
   pull_request:
-    branches: [ main ]
+    branches: [main]
 
 jobs:
-  build:
-
+  test:
+    name: Tests
     runs-on: ubuntu-latest
     strategy:
       max-parallel: 4
       matrix:
-        python-version: ["3.11", "3.12", "3.13"]
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+        django-version: ["3.2", "4.2", "5.2"]
+        exclude:
+          # Django 3.2 doesn't support Python 3.12+
+          - python-version: "3.12"
+            django-version: "3.2"
+          - python-version: "3.13"
+            django-version: "3.2"
 
     steps:
-    - uses: actions/checkout@v2
-    - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v2
-      with:
-        python-version: ${{ matrix.python-version }}
-    - name: Run Tests
-      run: |
-        make test
+      - uses: actions/checkout@v4
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          if [ "${{ matrix.django-version }}" == "3.2" ]; then
+            pip install "django>=3.2,<4.0"
+          elif [ "${{ matrix.django-version }}" == "4.2" ]; then
+            pip install "django>=4.2,<5.0"
+          else
+            pip install "django>=5.2,<6.0"
+          fi
+
+          make install-dev
+      - name: Run tests
+        run: make check
diff --git a/Makefile b/Makefile
index ff15cb5..f4b6a4b 100644
--- a/Makefile
+++ b/Makefile
@@ -23,13 +23,15 @@ install-dev: install
 
 # Testing commands
 test: lint
-	python -m pytest --no-cov
+	python -m pytest --no-cov -v
 
 test-cov: lint
 	python -m pytest
 
 # Code quality commands
 lint:
+	black --check django_connexion/
+	isort --check-only django_connexion/
 	flake8 django_connexion/
 	mypy django_connexion/ --ignore-missing-imports
 
diff --git a/pyproject.toml b/pyproject.toml
index b8110fb..405a46b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -43,7 +43,7 @@ include = ["django_connexion*"]
 
 [tool.pytest.ini_options]
 DJANGO_SETTINGS_MODULE = "django_connexion.tests.testapp.settings"
-addopts = "--nomigrations --cov=django_connexion --cov-report html --cov-report term --cov-fail-under=49"
+addopts = "--nomigrations --cov=django_connexion --cov-report html --cov-report term --cov-report xml --cov-fail-under=49"
 python_files = ["tests.py", "test_*.py", "*_tests.py"]
 
 [tool.flake8]
diff --git a/requirements-dev.txt b/requirements-dev.txt
index 16ab504..6d2e0c7 100644
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -1,17 +1,20 @@
 # Development dependencies
-pytest>=6.0.0
-pytest-cov>=2.10.0
-pytest-django>=4.0.0
-pytest-runner>=5.0.0
-flake8>=4.0.0
-coverage>=5.0.0
+pytest>=6.0.0,<9.0.0
+pytest-cov>=2.10.0,<5.0.0
+pytest-django>=4.0.0,<5.0.0
+pytest-runner>=5.0.0,<7.0.0
+flake8>=4.0.0,<8.0.0
+coverage>=5.0.0,<8.0.0
 
 # Build dependencies
-setuptools>=61.0
-wheel>=0.37.0
-build>=0.7.0
+setuptools>=61.0,<81.0.0
+wheel>=0.37.0,<1.0.0
+build>=0.7.0,<2.0.0
 
-# Optional development tools
-black>=22.0.0
-isort>=5.0.0
-mypy>=0.910
+# Code quality tools
+black>=22.0.0,<26.0.0
+isort>=5.0.0,<6.0.0
+mypy>=0.910,<2.0.0
+
+# Type stubs
+types-PyYAML>=6.0.0,<7.0.0

From 935f54a3589ac188ce56bc085696e0b993db61c1 Mon Sep 17 00:00:00 2001
From: Avelino <31996+avelino@users.noreply.github.com>
Date: Tue, 1 Jul 2025 12:27:23 -0300
Subject: [PATCH 5/5] use `${{ matrix.django-version }}` variable to select the
 compatible django version

Co-authored-by: Erle Carrara <carrara.erle@gmail.com>
---
 .github/workflows/python.yml | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/.github/workflows/python.yml b/.github/workflows/python.yml
index 46ab3ad..f2c1869 100644
--- a/.github/workflows/python.yml
+++ b/.github/workflows/python.yml
@@ -31,13 +31,7 @@ jobs:
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
-          if [ "${{ matrix.django-version }}" == "3.2" ]; then
-            pip install "django>=3.2,<4.0"
-          elif [ "${{ matrix.django-version }}" == "4.2" ]; then
-            pip install "django>=4.2,<5.0"
-          else
-            pip install "django>=5.2,<6.0"
-          fi
+          pip install "django==${{ matrix.django-version }}"
 
           make install-dev
       - name: Run tests