webkitpy 1.0.0__tar.gz

webkitpy-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jorge
+
+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.

webkitpy-1.0.0/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: webkitpy
+Version: 1.0.0
+Summary: Toolkit de utilidades para desarrollo web en Python.
+Author-email: Jorge <jorgeluisdcl30@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/jorge/webkitpy
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: django
+Requires-Dist: Django>=5.0; extra == "django"
+Requires-Dist: djangorestframework>=3.14; extra == "django"
+Dynamic: license-file
+
+# webkitpy
+
+Librería de utilidades para desarrollo web en Python.
+
+## Estructura
+
+- `pagination`: Utilidades para paginación.
+- `decorators`: Decoradores para métricas, errores y tiempos.
+- `request`: Normalización de peticiones.
+- `metrics`: Contadores y métricas generales.

webkitpy-1.0.0/README.md

@@ -0,0 +1,10 @@
+# webkitpy
+
+Librería de utilidades para desarrollo web en Python.
+
+## Estructura
+
+- `pagination`: Utilidades para paginación.
+- `decorators`: Decoradores para métricas, errores y tiempos.
+- `request`: Normalización de peticiones.
+- `metrics`: Contadores y métricas generales.

webkitpy-1.0.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "webkitpy"
+version = "1.0.0"
+description = "Toolkit de utilidades para desarrollo web en Python."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [
+  { name = "Jorge", email = "jorgeluisdcl30@gmail.com" }
+]
+
+dependencies = []
+
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Libraries",
+]
+
+[project.optional-dependencies]
+django = [
+    "Django>=5.0",
+    "djangorestframework>=3.14",
+]
+
+[project.urls]
+Homepage = "https://github.com/jorge/webkitpy"
+
+[tool.setuptools]
+packages = ["webkitpy", "webkitpy.decorators", "webkitpy.exceptions", "webkitpy.utils"]
+package-dir = {"" = "src"}

webkitpy-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

webkitpy-1.0.0/src/webkitpy/__init__.py

@@ -0,0 +1,32 @@
+"""
+WebKitPy – Optimized Web Utilities Toolkit
+
+Un toolkit de utilidades optimizadas para desarrollo web en Python,
+especialmente orientado a Django y Django REST Framework.
+
+Incluye:
+- Decoradores para medir y limitar consultas por endpoint
+- Decoradores para manejo de errores más expresivo y consistente
+- Conversión automática de request.data (FormData → JSON)
+- Helpers para evitar consultas innecesarias a la base de datos
+- Utilidades para análisis y optimización de queries SQL
+- Excepciones base reutilizables para APIs REST
+
+Objetivos:
+- Reducir carga en base de datos
+- Mejorar observabilidad y control de endpoints
+- Centralizar buenas prácticas
+- Mantener código limpio, reutilizable y mantenible
+"""
+from . import decorators
+from . import exceptions
+from . import utils
+
+__version__ = "1.0.0"
+__author__ = "Jorge Luis de la Cruz"
+__email__ = "jorgeluisdcl30@gmail.com"
+__all__ = [
+    "decorators",
+    "exceptions",
+    "utils"
+]

webkitpy-1.0.0/src/webkitpy/decorators/__init__.py

@@ -0,0 +1,9 @@
+from .handle_exceptions import handle_exceptions
+from .measure_performance import measure_performance
+from .proccess_formadata import proccess_formadata
+
+__all__ = [
+    "handle_exceptions",
+    "measure_performance",
+    "proccess_formadata",
+]

webkitpy-1.0.0/src/webkitpy/decorators/handle_exceptions.py

@@ -0,0 +1,234 @@
+"""
+Decoradores utilitarios para las vistas
+"""
+from webkitpy.exceptions.api import APIException
+from functools import wraps
+from rest_framework.exceptions import ValidationError as DRFValidationError
+from django.db import IntegrityError
+from django.core.exceptions import ObjectDoesNotExist
+from django.http import Http404
+from webkitpy.utils.responses import StandardResponse
+from rest_framework import status
+import traceback
+import logging
+from webkitpy.utils.error_formatter import format_validation_errors
+
+logger = logging.getLogger(__name__)
+
+
+def handle_exceptions(arg=None, *, serializer_class=None):
+    """
+    Decorador flexible que funciona de 3 formas:
+    
+    1. Sin parámetros:
+       @handle_exceptions
+       def post(self, request):
+           ...
+    
+    2. Con paréntesis vacíos:
+       @handle_exceptions()
+       def post(self, request):
+           ...
+    
+    3. Con serializer específico:
+       @handle_exceptions(serializer_class=TireInventoryWriteSerializer)
+       def post(self, request):
+           ...
+    """
+    
+    # Caso 1: @handle_exceptions (sin paréntesis)
+    # arg es la función, serializer_class es None
+    if callable(arg):
+        view_func = arg
+        return _create_wrapper(view_func, None)
+    
+    # Caso 2 y 3: @handle_exceptions() o @handle_exceptions(serializer_class=X)
+    # arg puede ser None o un serializer, pero NO es la función
+    else:
+        # Si pasaron arg (no recomendado), usarlo como serializer_class
+        if arg is not None and not callable(arg):
+            serializer_class = arg
+        
+        def decorator(view_func):
+            return _create_wrapper(view_func, serializer_class)
+        
+        return decorator
+
+
+def _create_wrapper(view_func, serializer_class):
+    """Crea el wrapper real con la lógica de manejo de excepciones"""
+    
+    @wraps(view_func)
+    def _wrapped_view(*args, **kwargs):
+        try:
+            return view_func(*args, **kwargs)
+            
+        except APIException as e:
+            # Imprimir traceback completo para debugging
+            print("\n" + "="*80)
+            print("🔴 APIException capturada:")
+            print(traceback.format_exc())
+            print("="*80 + "\n")
+            
+            logger.warning(f"API Exception: {e.code} - {e.message}")
+            if hasattr(e, 'errors') and isinstance(e.errors, list):
+                return StandardResponse.error(
+                    message=e.message,
+                    code=e.code,
+                    details=e.details,
+                    status_code=e.status_code,
+                    errors=e.errors
+                )
+            return StandardResponse.error(
+                message=e.message,
+                code=e.code,
+                details=e.details,
+                status_code=e.status_code
+            )
+        
+        except DRFValidationError as e:
+            # Imprimir traceback completo para debugging
+            print("\n" + "="*80)
+            print("🟡 DRFValidationError capturada:")
+            print(traceback.format_exc())
+            print("="*80 + "\n")
+            
+            logger.warning(f"Validation error: {e}")
+            errors = {}
+            if hasattr(e, 'detail'):
+                if isinstance(e.detail, dict):
+                    errors = e.detail
+                elif isinstance(e.detail, list):
+                    errors = {"non_field_errors": e.detail}
+            
+            # Obtener modelo para traducir errores
+            model = None
+            
+            # Prioridad 1: serializer_class pasado al decorador
+            if serializer_class and hasattr(serializer_class, 'Meta'):
+                model = getattr(serializer_class.Meta, 'model', None)
+
+            # Prioridad 2: Auto-detect desde la vista
+            if not model:
+                try:
+                    view_instance = args[0] if args else None
+                    if view_instance and hasattr(view_instance, '__class__'):
+                        view_class = view_instance.__class__
+                        view_serializer = getattr(view_class, 'serializer_class', None)
+                        if view_serializer and hasattr(view_serializer, 'Meta'):
+                            model = getattr(view_serializer.Meta, 'model', None)
+                except Exception as ex:
+                    logger.warning(f"No se pudo obtener el modelo: {ex}")
+            
+            # Formatear errores usando verbose_name del modelo
+            friendly_errors = format_validation_errors(errors, model)
+            
+            return StandardResponse.error(
+                message="Por favor revisa los siguientes campos",
+                code="VALIDATION_ERROR",
+                details="Verifica los datos enviados",
+                status_code=status.HTTP_400_BAD_REQUEST,
+                errors=errors,
+                friendly_errors=friendly_errors
+            )
+        
+        except IntegrityError as e:
+            # Imprimir traceback completo para debugging
+            print("\n" + "="*80)
+            print("🔵 IntegrityError capturada:")
+            print(traceback.format_exc())
+            print("="*80 + "\n")
+            
+            logger.error(f"Database integrity error: {e}")
+            error_message = str(e).lower()
+            
+            if 'unique' in error_message or 'duplicada' in error_message:
+                return StandardResponse.error(
+                    message="Ya existe un registro con estos datos",
+                    code="DUPLICATE_ENTRY",
+                    details=str(e),
+                    status_code=status.HTTP_409_CONFLICT
+                )
+            elif 'foreign key' in error_message:
+                return StandardResponse.error(
+                    message="No se puede completar la operación",
+                    code="FOREIGN_KEY_VIOLATION",
+                    details="Existen registros relacionados",
+                    status_code=status.HTTP_409_CONFLICT
+                )
+            elif 'not null' in error_message:
+                return StandardResponse.error(
+                    message="Campos requeridos faltantes",
+                    code="NULL_VIOLATION",
+                    details="Uno o más campos obligatorios están vacíos",
+                    status_code=status.HTTP_400_BAD_REQUEST
+                )
+            else:
+                return StandardResponse.error(
+                    message="Error de integridad de datos",
+                    code="INTEGRITY_ERROR",
+                    details=str(e),
+                    status_code=status.HTTP_400_BAD_REQUEST
+                )
+        
+        except (ObjectDoesNotExist, Http404) as e:
+            # Imprimir traceback completo para debugging
+            print("\n" + "="*80)
+            print("🟠 ObjectDoesNotExist capturada:")
+            print(traceback.format_exc())
+            print("="*80 + "\n")
+            
+            logger.warning(f"Object not found: {e}")
+            return StandardResponse.error(
+                message="Recurso no encontrado",
+                code="NOT_FOUND",
+                details=str(e),
+                status_code=status.HTTP_404_NOT_FOUND
+            )
+        
+        except ValueError as e:
+            # Imprimir traceback completo para debugging
+            print("\n" + "="*80)
+            print("🟣 ValueError capturada:")
+            print(traceback.format_exc())
+            print("="*80 + "\n")
+            
+            logger.warning(f"Value error: {e}")
+            return StandardResponse.error(
+                message="Valor inválido",
+                code="INVALID_VALUE",
+                details=str(e),
+                status_code=status.HTTP_400_BAD_REQUEST
+            )
+        
+        except TypeError as e:
+            # Imprimir traceback completo para debugging
+            print("\n" + "="*80)
+            print("🟤 TypeError capturada:")
+            print(traceback.format_exc())
+            print("="*80 + "\n")
+            
+            logger.warning(f"Type error: {e}")
+            return StandardResponse.error(
+                message="Tipo de dato incorrecto",
+                code="TYPE_ERROR",
+                details=str(e),
+                status_code=status.HTTP_400_BAD_REQUEST
+            )
+        
+        except Exception as e:
+            # Imprimir traceback completo para debugging
+            print("\n" + "="*80)
+            print("⚫ Exception NO MANEJADA capturada:")
+            print(traceback.format_exc())
+            print("="*80 + "\n")
+            
+            logger.critical(f"Unhandled exception: {traceback.format_exc()}")
+            return StandardResponse.error(
+                message="Error interno del servidor",
+                code="INTERNAL_SERVER_ERROR",
+                details=str(e),
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+    
+    return _wrapped_view

webkitpy-1.0.0/src/webkitpy/decorators/measure_performance.py

@@ -0,0 +1,56 @@
+import time
+import functools
+from django.db import connection, reset_queries
+
+
+def measure_performance(func):
+    """
+    Decorador para medir performance de views.
+    Mide: tiempo total, queries, serialización.
+    Muestra el listado completo de queries ejecutadas.
+    """
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        overall_start = time.time()
+        reset_queries()
+        
+        response = func(*args, **kwargs)
+        
+        overall_end = time.time()
+        total_time = (overall_end - overall_start) * 1000
+        queries_time = sum(float(q['time']) for q in connection.queries) * 1000
+        queries_count = len(connection.queries)
+        processing_time = total_time - queries_time
+        
+        # ===== OUTPUT PRINCIPAL =====
+        print(f"\n{'='*60}")
+        print(f"PERFORMANCE: {func.__name__}")
+        print(f"{'='*60}")
+        print(f"Total:           {total_time:>8.2f}ms")
+        print(f"Queries DB:      {queries_time:>8.2f}ms ({queries_count} queries)")
+        print(f"Procesamiento:   {processing_time:>8.2f}ms")
+        print(f"DB/Total ratio:  {(queries_time/total_time*100):>8.1f}%")
+        print(f"{'='*60}")
+        
+        # ===== LISTADO DE QUERIES =====
+        if queries_count > 0:
+            print(f"\nLISTADO DE QUERIES ({queries_count} total):")
+            print(f"{'-'*60}")
+            
+            for i, query in enumerate(connection.queries, 1):
+                query_time = float(query['time']) * 1000
+                sql = query['sql'].replace('\n', ' ').strip()
+                
+                # Indicador de query lenta
+                speed_icon = "SLOW" if query_time > 10 else "FAST"
+                
+                print(f"\n{i}. [{speed_icon}] {query_time:>6.2f}ms")
+                print(f"   {sql}")
+            
+            print(f"\n{'-'*60}")
+        
+        print()
+        
+        return response
+    
+    return wrapper

webkitpy-1.0.0/src/webkitpy/decorators/proccess_formadata.py

@@ -0,0 +1,11 @@
+from functools import wraps
+from rest_framework.request import Request
+from utils.process_querydict import process_querydict
+
+def process_formdata(func):
+    @wraps(func)
+    def wrapper(self, request: Request, *args, **kwargs):
+        if hasattr(request, 'data'):
+            request._full_data = process_querydict(request.data)
+        return func(self, request, *args, **kwargs)
+    return wrapper

webkitpy-1.0.0/src/webkitpy/exceptions/__init__.py

@@ -0,0 +1,9 @@
+from .handle_exceptions import handle_exceptions
+from .measure_performance import measure_performance
+from .proccess_formadata import proccess_formadata
+
+__all__ = [
+    "handle_exceptions",
+    "measure_performance",
+    "proccess_formadata",
+]

webkitpy-1.0.0/src/webkitpy/exceptions/api.py

@@ -0,0 +1,80 @@
+"""
+Excepciones base para toda la aplicación.
+Estas son las excepciones genéricas que pueden usar todas las apps.
+"""
+from rest_framework import status
+from typing import Optional
+
+
+class APIException(Exception):
+    """Excepción base para todas las excepciones de la API"""
+    
+    default_code = "API_ERROR"
+    default_message = "Ha ocurrido un error"
+    default_status = status.HTTP_500_INTERNAL_SERVER_ERROR
+    
+    def __init__(self, message: Optional[str] = None, code: Optional[str] = None, details: Optional[str] = None, status_code: Optional[int] = None):
+        self.message = message or self.default_message
+        self.code = code or self.default_code
+        self.details = details
+        self.status_code = status_code or self.default_status
+        super().__init__(self.message)
+    
+    def to_dict(self) -> dict:
+        return {
+            "code": self.code,
+            "message": self.message,
+            "details": self.details,
+            "status_code": self.status_code
+        }
+
+
+# Excepciones HTTP comunes
+class ValidationException(APIException):
+    """Errores de validación (400)"""
+    default_code = "VALIDATION_ERROR"
+    default_message = "Error de validación"
+    default_status = status.HTTP_400_BAD_REQUEST
+
+
+class NotFoundException(APIException):
+    """Recurso no encontrado (404)"""
+    default_code = "NOT_FOUND"
+    default_message = "Recurso no encontrado"
+    default_status = status.HTTP_404_NOT_FOUND
+
+
+class PermissionException(APIException):
+    """Sin permisos (403)"""
+    default_code = "PERMISSION_DENIED"
+    default_message = "No tienes permisos para esta acción"
+    default_status = status.HTTP_403_FORBIDDEN
+
+
+class ConflictException(APIException):
+    """Conflicto de estado (409)"""
+    default_code = "CONFLICT"
+    default_message = "Conflicto con el estado actual"
+    default_status = status.HTTP_409_CONFLICT
+
+
+class UnauthorizedException(APIException):
+    """No autenticado (401)"""
+    default_code = "UNAUTHORIZED"
+    default_message = "No estás autenticado"
+    default_status = status.HTTP_401_UNAUTHORIZED
+    
+    
+class MultipleValidationException(APIException):
+    """Excepción para múltiples errores de validación"""
+    default_code = "MULTIPLE_VALIDATION_ERRORS"
+    default_message = "Se encontraron múltiples errores de validación"
+    default_status = status.HTTP_400_BAD_REQUEST
+    
+    def __init__(self, errors: list, message: Optional[str] = None, code: Optional[str] = None):
+        self.errors = errors
+        self.message = message or self.default_message
+        self.code = code or self.default_code
+        self.details = f"Se encontraron {len(errors)} error(es) de validación"
+        self.status_code = self.default_status
+        super().__init__(self.message)

webkitpy-1.0.0/src/webkitpy/utils/__init__.py

@@ -0,0 +1,5 @@
+from .api import APIException
+
+__all__ = [
+    "APIException",
+]

webkitpy-1.0.0/src/webkitpy/utils/error_formatter.py

@@ -0,0 +1,93 @@
+# utils/error_formatter.py
+
+def get_field_verbose_name_from_model(model, field_path):
+    """
+    Lee el verbose_name directamente del modelo.
+    Maneja campos con _id y campos anidados.
+    """
+    try:
+        # Caso 1: Campo simple sin anidación
+        if '.' not in field_path:
+            # Si termina en _id, quitarlo (wheel_model_id -> wheel_model)
+            if field_path.endswith('_id'):
+                field_name = field_path[:-3]
+            else:
+                field_name = field_path
+            
+            # Buscar el campo en el modelo
+            field = model._meta.get_field(field_name)
+            
+            # Retornar verbose_name si existe
+            if hasattr(field, 'verbose_name'):
+                return field.verbose_name.capitalize()
+            
+            return field_name.replace('_', ' ').title()
+        
+        # Caso 2: Campo anidado (store_parts.store_id)
+        parts = field_path.split('.')
+        current_model = model
+        
+        for i, part in enumerate(parts):
+            # Quitar _id si es el último campo
+            if i == len(parts) - 1 and part.endswith('_id'):
+                part = part[:-3]
+            
+            # Obtener el campo
+            field = current_model._meta.get_field(part)
+            
+            # Si es el último, retornar verbose_name
+            if i == len(parts) - 1:
+                if hasattr(field, 'verbose_name'):
+                    return field.verbose_name.capitalize()
+                return part.replace('_', ' ').title()
+            
+            # Si no es el último y es una relación, seguir navegando
+            if hasattr(field, 'related_model'):
+                current_model = field.related_model
+            else:
+                # No es una relación, no podemos seguir
+                return field_path.replace('_', ' ').title()
+        
+    except Exception as e:
+        # Si algo falla, usar fallback
+        return field_path.replace('_', ' ').title()
+
+
+def format_validation_errors(errors, model=None):
+    """
+    Formatea errores de validación usando verbose_name del modelo.
+    
+    Args:
+        errors: Dict con errores de DRF
+        model: Modelo de Django para leer verbose_name
+    
+    Returns:
+        List de strings amigables
+    """
+    friendly_errors = []
+    
+    def flatten(error_dict, parent=''):
+        for key, value in error_dict.items():
+            current_path = f"{parent}.{key}" if parent else key
+            
+            if isinstance(value, dict):
+                # Recursión para objetos anidados
+                flatten(value, current_path)
+                
+            elif isinstance(value, list):
+                # Obtener label del campo
+                if model:
+                    field_label = get_field_verbose_name_from_model(model, current_path)
+                else:
+                    field_label = current_path.replace('_', ' ').title()
+                
+                # Agregar cada error
+                for error_message in value:
+                    if isinstance(error_message, str):
+                        if key == 'non_field_errors':
+                            friendly_errors.append(error_message)
+                        else:
+                            friendly_errors.append(f"{field_label}: {error_message}")
+    
+    flatten(errors)
+    return friendly_errors

webkitpy-1.0.0/src/webkitpy/utils/process_querydict.py

@@ -0,0 +1,92 @@
+import json
+import re
+import math
+from collections import defaultdict
+
+def process_querydict(querydict):
+    """
+    Procesa completamente un QueryDict multipart/form-data y devuelve
+    un dict listo para pasarse al Service.create(**kwargs)
+
+    Soporta:
+      - Campos simples:           name=John
+      - Arrays:                   drivers[]=1&drivers[]=2
+      - Objetos anidados:         address[city]=MX
+      - Arrays de objetos:        tanks[0][name]=T1&tanks[0][cap]=100
+    """
+
+    result = {}
+    nested_objects = defaultdict(dict)
+    nested_arrays = defaultdict(lambda: defaultdict(dict))
+    simple_arrays = defaultdict(list)
+
+    array_of_objects_pattern = re.compile(r'^(.+)\[(\d+)\]\[(.+)\]$')
+    nested_object_pattern = re.compile(r'^(.+)\[([^\d\]]+)\]$')
+    simple_array_pattern = re.compile(r'^(.+)\[\]$')
+
+    for key in querydict.keys():
+        values = querydict.getlist(key)
+
+        match = array_of_objects_pattern.match(key)
+        if match:
+            parent_key, index, field = match.groups()
+            nested_arrays[parent_key][int(index)][field] = _normalize_value(values[0])
+            continue
+
+        match = nested_object_pattern.match(key)
+        if match:
+            parent_key, field = match.groups()
+            nested_objects[parent_key][field] = _normalize_value(values[0])
+            continue
+
+        match = simple_array_pattern.match(key)
+        if match:
+            clean_key = match.group(1)
+            simple_arrays[clean_key].extend(_normalize_value(v) for v in values)
+            continue
+
+        result[key] = _normalize_value(values[0])
+
+    for key, index_map in nested_arrays.items():
+        result[key] = [index_map[i] for i in sorted(index_map)]
+
+    for key, obj in nested_objects.items():
+        result[key] = obj
+
+    for key, values in simple_arrays.items():
+        result[key] = values
+
+    return result
+
+
+def _normalize_value(value):
+    if value == 'null':
+        return None
+
+    if isinstance(value, str):
+        lower = value.lower()
+
+        if lower == 'true':
+            return True
+        if lower == 'false':
+            return False
+
+        try:
+            if '.' in value:
+                f = float(value)
+                if math.isfinite(f):
+                    return f
+            else:
+                return int(value)
+        except ValueError:
+            pass
+
+        try:
+            parsed = json.loads(value)
+            if isinstance(parsed, float) and not math.isfinite(parsed):
+                return value
+            return parsed
+        except (json.JSONDecodeError, TypeError):
+            return value
+
+    return value

webkitpy-1.0.0/src/webkitpy/utils/responses.py

@@ -0,0 +1,46 @@
+from rest_framework.response import Response
+from rest_framework import status
+from django.utils.timezone import now
+from typing import Any, Optional
+
+
+class StandardResponse:
+    """Clase para estandarizar todas las respuestas de la API"""
+    
+    @staticmethod
+    def success(data: Any = None, message: str = "Operación exitosa", status_code: int = status.HTTP_200_OK, meta: Optional[dict] = None) -> Response:
+        """Respuesta exitosa estandarizada"""
+        response_data = {
+            "success": True,
+            "data": data,
+            "message": message,
+            "meta": {
+                "timestamp": now().isoformat(),
+                **(meta or {})
+            }
+        }
+        return Response(response_data, status=status_code)
+    
+    @staticmethod
+    def error(message: str, code: str = "ERROR", details: Optional[str] = None, status_code: int = status.HTTP_400_BAD_REQUEST, errors: Optional[dict] = None, friendly_errors: list = None) -> Response:
+        """Respuesta de error estandarizada"""
+        error_data = {
+            "success": False,
+            "error": {
+                "code": code,
+                "message": message,
+                "details": details,
+                "timestamp": now().isoformat()
+            }
+        }
+        
+        if errors:
+            if isinstance(errors, list):
+                error_data["error"]["items"] = errors
+            elif isinstance(errors, dict):
+                error_data["error"]["fields"] = errors
+            
+        if friendly_errors:
+            error_data["error"]["friendly_errors"] = friendly_errors
+        
+        return Response(error_data, status=status_code)

webkitpy-1.0.0/src/webkitpy.egg-info/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: webkitpy
+Version: 1.0.0
+Summary: Toolkit de utilidades para desarrollo web en Python.
+Author-email: Jorge <jorgeluisdcl30@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/jorge/webkitpy
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: django
+Requires-Dist: Django>=5.0; extra == "django"
+Requires-Dist: djangorestframework>=3.14; extra == "django"
+Dynamic: license-file
+
+# webkitpy
+
+Librería de utilidades para desarrollo web en Python.
+
+## Estructura
+
+- `pagination`: Utilidades para paginación.
+- `decorators`: Decoradores para métricas, errores y tiempos.
+- `request`: Normalización de peticiones.
+- `metrics`: Contadores y métricas generales.

webkitpy-1.0.0/src/webkitpy.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+pyproject.toml
+src/webkitpy/__init__.py
+src/webkitpy.egg-info/PKG-INFO
+src/webkitpy.egg-info/SOURCES.txt
+src/webkitpy.egg-info/dependency_links.txt
+src/webkitpy.egg-info/requires.txt
+src/webkitpy.egg-info/top_level.txt
+src/webkitpy/decorators/__init__.py
+src/webkitpy/decorators/handle_exceptions.py
+src/webkitpy/decorators/measure_performance.py
+src/webkitpy/decorators/proccess_formadata.py
+src/webkitpy/exceptions/__init__.py
+src/webkitpy/exceptions/api.py
+src/webkitpy/utils/__init__.py
+src/webkitpy/utils/error_formatter.py
+src/webkitpy/utils/process_querydict.py
+src/webkitpy/utils/responses.py

webkitpy-1.0.0/src/webkitpy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

webkitpy-1.0.0/src/webkitpy.egg-info/requires.txt

@@ -0,0 +1,4 @@
+
+[django]
+Django>=5.0
+djangorestframework>=3.14

webkitpy-1.0.0/src/webkitpy.egg-info/top_level.txt

@@ -0,0 +1 @@
+webkitpy