django-req-generator 0.1.0__tar.gz

django_req_generator-0.1.0/.gitignore

@@ -0,0 +1,44 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtualenv
+.venv/
+venv/
+ENV/
+env/
+
+# Django
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+media/
+staticfiles/
+
+# IDEs
+.vscode/
+.idea/
+
+# Plugin specific
+temp_venv/
+requirements.txt.tmp

django_req_generator-0.1.0/LICENSE

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

django_req_generator-0.1.0/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: django-req-generator
+Version: 0.1.0
+Summary: Generador de requirements.txt avanzado para Django con análisis estático y dinámico.
+Project-URL: Homepage, https://github.com/rraczo/django-req-generator
+Author-email: Oscar Higuera <higuera86@gmail.com>
+License-File: LICENSE
+Classifier: Framework :: Django
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Requires-Dist: django>=3.2
+Description-Content-Type: text/markdown
+
+# django-req-generator 🚀
+
+**Generador inteligente de `requirements.txt` / Smart `requirements.txt` generator**
+
+---
+
+## 🇪🇸 Español
+
+### Descripción
+Este plugin para Django sirve para empaquetar tu proyecto e instalarlo de forma limpia en otros entornos (Docker, Servidores de Producción, CI/CD). Está específicamente diseñado para manejar proyectos Django complejos donde no basta con un simple `pip freeze`.
+
+### Características Principales
+- 🔍 **Análisis Estático (AST)**: Detecta imports reales en todo el árbol de tu código fuente.
+- 🧩 **Inspección Profunda de Django**: Analiza `INSTALLED_APPS`, `MIDDLEWARE`, `DATABASES` (detecta drivers como `oracledb`), y `CACHES` (detecta `django-redis` y `pymemcache`).
+- 🧹 **Limpieza Automática**: Filtra la librería estándar de Python y tus propios módulos locales (`apps`, `models`, `serializers`, etc.).
+- 🔗 **Resolución Dinámica PyPI**: No usa mapeos manuales fallidos; pregunta directamente a la API de PyPI para encontrar el paquete correcto.
+- 🤖 **Auto-curación Interactiva**: Durante la validación, si detecta un módulo faltante (`ModuleNotFoundError`), te pregunta si quieres añadirlo y reintenta la validación en caliente.
+- 🧪 **Validación en Venv**: Crea un entorno virtual temporal para asegurar que el archivo generado permite que el proyecto arranque.
+- 🌎 **Multilingüe**: Soporta comandos y mensajes en Español e Inglés.
+
+### Uso
+```bash
+# Generación estándar con backup automático
+python manage.py generate_reqs
+
+# Generación con validación y settings específicos
+python manage.py generate_reqs --validate --settings=mi_proyecto.settings_docker
+
+# Modo Desarrollo (instala el plugin desde código fuente en la validación)
+python manage.py generate_reqs --validate -d /ruta/al/plugin
+```
+
+---
+
+## 🇺🇸 English
+
+### Description
+This Django plugin is designed to package your project and install it cleanly in other environments (Docker, Production Servers, CI/CD). It is specifically built for complex Django projects where a simple `pip freeze` isn't enough.
+
+### Key Features
+- 🔍 **Static Analysis (AST)**: Deep-scans your entire source code to detect actual imports.
+- 🧩 **Deep Django Inspection**: Analyzes `INSTALLED_APPS`, `MIDDLEWARE`, `DATABASES` (detects drivers like `oracledb`), and `CACHES` (detects `django-redis` and `pymemcache`).
+- 🧹 **Automatic Cleanup**: Filters out Python's standard library and your own local modules (`apps`, `models`, `serializers`, etc.).
+- 🔗 **Dynamic PyPI Resolution**: Replaces outdated manual mappings by querying the PyPI API directly for the correct package name.
+- 🤖 **Interactive Self-Healing**: During validation, if a missing module is found (`ModuleNotFoundError`), it asks if you want to add it and retries the validation on the fly.
+- 🧪 **Venv Validation**: Creates a temporary virtual environment to ensure the generated file allows the project to start.
+- 🌎 **Multilingual**: Supports commands and console messages in both Spanish and English.
+
+### Usage
+```bash
+# Standard generation with automatic backup
+python manage.py generate_reqs
+
+# Generation with validation and specific settings
+python manage.py generate_reqs --validate --settings=my_project.settings_docker
+
+# Development Mode (installs plugin from source during validation)
+python manage.py generate_reqs --validate -d /path/to/plugin
+```
+
+---
+
+**Made with ❤️ and AI Collaboration | Creado con ❤️ y el apoyo de IA**

django_req_generator-0.1.0/README.md

@@ -0,0 +1,63 @@
+# django-req-generator 🚀
+
+**Generador inteligente de `requirements.txt` / Smart `requirements.txt` generator**
+
+---
+
+## 🇪🇸 Español
+
+### Descripción
+Este plugin para Django sirve para empaquetar tu proyecto e instalarlo de forma limpia en otros entornos (Docker, Servidores de Producción, CI/CD). Está específicamente diseñado para manejar proyectos Django complejos donde no basta con un simple `pip freeze`.
+
+### Características Principales
+- 🔍 **Análisis Estático (AST)**: Detecta imports reales en todo el árbol de tu código fuente.
+- 🧩 **Inspección Profunda de Django**: Analiza `INSTALLED_APPS`, `MIDDLEWARE`, `DATABASES` (detecta drivers como `oracledb`), y `CACHES` (detecta `django-redis` y `pymemcache`).
+- 🧹 **Limpieza Automática**: Filtra la librería estándar de Python y tus propios módulos locales (`apps`, `models`, `serializers`, etc.).
+- 🔗 **Resolución Dinámica PyPI**: No usa mapeos manuales fallidos; pregunta directamente a la API de PyPI para encontrar el paquete correcto.
+- 🤖 **Auto-curación Interactiva**: Durante la validación, si detecta un módulo faltante (`ModuleNotFoundError`), te pregunta si quieres añadirlo y reintenta la validación en caliente.
+- 🧪 **Validación en Venv**: Crea un entorno virtual temporal para asegurar que el archivo generado permite que el proyecto arranque.
+- 🌎 **Multilingüe**: Soporta comandos y mensajes en Español e Inglés.
+
+### Uso
+```bash
+# Generación estándar con backup automático
+python manage.py generate_reqs
+
+# Generación con validación y settings específicos
+python manage.py generate_reqs --validate --settings=mi_proyecto.settings_docker
+
+# Modo Desarrollo (instala el plugin desde código fuente en la validación)
+python manage.py generate_reqs --validate -d /ruta/al/plugin
+```
+
+---
+
+## 🇺🇸 English
+
+### Description
+This Django plugin is designed to package your project and install it cleanly in other environments (Docker, Production Servers, CI/CD). It is specifically built for complex Django projects where a simple `pip freeze` isn't enough.
+
+### Key Features
+- 🔍 **Static Analysis (AST)**: Deep-scans your entire source code to detect actual imports.
+- 🧩 **Deep Django Inspection**: Analyzes `INSTALLED_APPS`, `MIDDLEWARE`, `DATABASES` (detects drivers like `oracledb`), and `CACHES` (detects `django-redis` and `pymemcache`).
+- 🧹 **Automatic Cleanup**: Filters out Python's standard library and your own local modules (`apps`, `models`, `serializers`, etc.).
+- 🔗 **Dynamic PyPI Resolution**: Replaces outdated manual mappings by querying the PyPI API directly for the correct package name.
+- 🤖 **Interactive Self-Healing**: During validation, if a missing module is found (`ModuleNotFoundError`), it asks if you want to add it and retries the validation on the fly.
+- 🧪 **Venv Validation**: Creates a temporary virtual environment to ensure the generated file allows the project to start.
+- 🌎 **Multilingual**: Supports commands and console messages in both Spanish and English.
+
+### Usage
+```bash
+# Standard generation with automatic backup
+python manage.py generate_reqs
+
+# Generation with validation and specific settings
+python manage.py generate_reqs --validate --settings=my_project.settings_docker
+
+# Development Mode (installs plugin from source during validation)
+python manage.py generate_reqs --validate -d /path/to/plugin
+```
+
+---
+
+**Made with ❤️ and AI Collaboration | Creado con ❤️ y el apoyo de IA**

django_req_generator-0.1.0/django_req_generator/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

django_req_generator-0.1.0/django_req_generator/apps.py

@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+
+class DjangoReqGeneratorConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "django_req_generator"
+    verbose_name = "Django Requirements Generator"

django_req_generator-0.1.0/django_req_generator/management/commands/generate_reqs.py

@@ -0,0 +1,145 @@
+from django.core.management.base import BaseCommand
+import os
+from django_req_generator.utils.i18n import _
+
+
+class Command(BaseCommand):
+    help = _("command_help")
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "-o",
+            "--output",
+            default="requirements.txt",
+            help=_("arg_output_help"),
+        )
+        parser.add_argument(
+            "--validate",
+            action="store_true",
+            help=_("arg_validate_help"),
+        )
+        parser.add_argument(
+            "-d",
+            "--develop",
+            help=_("arg_develop_help"),
+        )
+
+    def handle(self, *args, **options):
+        output_file = options["output"]
+        validate = options["validate"]
+
+        self.stdout.write(self.style.SUCCESS(_("start_gen", file=output_file)))
+        
+        # 1. Estrategias de escaneo
+        from django_req_generator.scanner import ast_analysis, django_inspector, dynamic_tracker
+        from django_req_generator.utils import mapper, filter, validator
+
+        self.stdout.write(_("scan_ast"))
+        project_root = os.getcwd()
+        ast_modules = ast_analysis.scan_directory(project_root)
+
+        self.stdout.write(_("scan_django"))
+        django_modules = django_inspector.inspect_settings()
+        
+        self.stdout.write(_("load_dynamic"))
+        dynamic_modules = dynamic_tracker.load_tracked_modules()
+
+        all_modules = ast_modules.union(django_modules).union(dynamic_modules)
+
+        # 2. Filtrado y Mapeo
+        self.stdout.write(_("filter_map"))
+        # Filtrar librería estándar primero
+        all_cleaned = filter.filter_standard_library(all_modules)
+        # Filtrar archivos y carpetas locales (los tuyos)
+        clean_modules = filter.filter_local_modules(all_cleaned, project_root)
+        
+        # Log para depuración si verbosity >= 2
+        if options.get("verbosity", 1) >= 2:
+            self.stdout.write(f"DEBUG: Módulos detectados tras limpieza: {clean_modules}")
+
+        package_versions = mapper.map_modules_to_packages(clean_modules)
+
+        # 3. Filtrado de dependencias transitivas
+        final_packages = filter.filter_transitive_dependencies(package_versions)
+
+        # 4. Backup solo si es el nombre por defecto (requirements.txt) y ya existe
+        if output_file == "requirements.txt" and os.path.exists(output_file):
+            n = 1
+            while os.path.exists(f"{output_file}.backup_{n}"):
+                n += 1
+            backup_name = f"{output_file}.backup_{n}"
+            os.rename(output_file, backup_name)
+            self.stdout.write(self.style.WARNING(_("backup_created", backup=backup_name)))
+
+        # 5. Escritura del archivo
+        with open(output_file, "w", encoding="utf-8") as f:
+            f.write(_("header_autogen") + "\n")
+            f.write(_("header_repo") + "\n\n")
+
+            for pkg, ver in sorted(final_packages.items()):
+                if ver == "???":
+                    f.write(f"{pkg}\n")
+                else:
+                    f.write(f"{pkg}=={ver}\n")
+        
+        self.stdout.write(self.style.SUCCESS(_("write_success", file=output_file, count=len(final_packages))))
+
+        if validate:
+            self.stdout.write(self.style.WARNING(_("warn_production")))
+            confirm = input(_("prompt_continue")).lower()
+            
+            if confirm not in ["y", "s", "yes", "si"]:
+                self.stdout.write(self.style.NOTICE(_("validate_skipped")))
+            else:
+                self.stdout.write(_("validate_start"))
+                # Capturar el módulo de configuración y la ruta del plugin
+                settings_module = os.environ.get("DJANGO_SETTINGS_MODULE")
+                
+                # Priorizar flag --develop para la ruta del plugin
+                plugin_root = options.get("develop")
+                if not plugin_root:
+                    # Fallback si no se pasa el flag (intentar subir niveles)
+                    plugin_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+                
+                # Gestión de entorno temporal fuera del bucle para reutilización óptima
+                import tempfile
+                with tempfile.TemporaryDirectory() as venv_dir:
+                    # Bucle de auto-curación interactivo
+                    while True:
+                        report = validator.validate_requirements(
+                            output_file, 
+                            project_root, 
+                            settings_module=settings_module,
+                            plugin_root=plugin_root,
+                            log_callback=self.stdout.write,
+                            venv_dir=venv_dir
+                        )
+                        
+                        if report["success"]:
+                            self.stdout.write(self.style.SUCCESS(_("validate_success")))
+                            break
+                    
+                    # Si falló, mirar si es por un módulo faltante (lazy import)
+                    missing_mod = report.get("missing_module")
+                    if missing_mod:
+                        confirm_add = input(_("prompt_missing_module", module=missing_mod)).lower()
+                        if confirm_add in ["y", "s", "yes", "si"]:
+                            # Mapear y añadir a la lista actual
+                            new_pkgs = mapper.map_modules_to_packages({missing_mod})
+                            final_packages.update(new_pkgs)
+                            
+                            # Sobrescribir el archivo con la nueva librería
+                            with open(output_file, "w", encoding="utf-8") as f:
+                                f.write(_("header_autogen") + "\n")
+                                f.write(_("header_repo") + "\n\n")
+                                for pkg, ver in sorted(final_packages.items()):
+                                    if ver == "???":
+                                        f.write(f"{pkg}\n")
+                                    else:
+                                        f.write(f"{pkg}=={ver}\n")
+                            
+                            # Reintentar validación
+                            continue
+                    
+                    self.stdout.write(self.style.ERROR(_("validate_error", output=report['output'])))
+                    break

django_req_generator-0.1.0/django_req_generator/management/commands/track_reqs.py

@@ -0,0 +1,42 @@
+from django.core.management import ManagementUtility
+from django.core.management.base import BaseCommand
+import sys
+
+
+class Command(BaseCommand):
+    help = "Registra dependencias dinámicas durante la ejecución de un comando de Django (ej. runserver)."
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "subcommand",
+            nargs="*",
+            help="El comando de Django a ejecutar (ej. runserver, test)",
+        )
+
+    def handle(self, *args, **options):
+        subcommand = options["subcommand"]
+        if not subcommand:
+            self.stdout.write(self.style.ERROR("Faltan argumentos para ejecutar el comando subyacente (ej. runserver)."))
+            return
+
+        from django_req_generator.scanner import dynamic_tracker
+        
+        self.stdout.write(self.style.SUCCESS(f"Activando rastreador dinámico..."))
+        dynamic_tracker.start_tracking()
+
+        try:
+            # Ejecutamos el comando de Django dentro del mismo proceso
+            # para que el Hook de importación capture todo.
+            utility = ManagementUtility([sys.argv[0]] + subcommand)
+            utility.execute()
+        except KeyboardInterrupt:
+            self.stdout.write("\nRastreo interrumpido por el usuario.")
+        finally:
+            dynamic_tracker.stop_tracking()
+            used_modules = dynamic_tracker.get_tracked_modules()
+            dynamic_tracker.save_tracked_modules()
+            
+            self.stdout.write(self.style.SUCCESS(f"\nSe detectaron {len(used_modules)} módulos raíces usados dinámicamente."))
+            self.stdout.write(self.style.SUCCESS(f"Los hallazgos se guardaron en '.tracked_modules.json'."))
+            
+            self.stdout.write(self.style.WARNING("\nUsa 'generate_reqs' para consolidar estos hallazgos."))

django_req_generator-0.1.0/django_req_generator/scanner/ast_analysis.py

@@ -0,0 +1,38 @@
+import ast
+import os
+
+
+def scan_directory(path):
+    """Escanea un directorio buscando archivos .py y extrayendo sus imports."""
+    imports = set()
+    ignore_dirs = {".git", "venv", ".venv", "__pycache__", "node_modules", "dist", "build", ".pytest_cache", ".tox"}
+
+    for root, dirs, files in os.walk(path):
+        dirs[:] = [d for d in dirs if d not in ignore_dirs]
+
+        for file in files:
+            if file.endswith(".py"):
+                file_path = os.path.join(root, file)
+                # Llamada al extractor por cada archivo
+                imports.update(get_imports_from_file(file_path))
+    return imports
+
+
+def get_imports_from_file(file_path):
+    """Extrae los nombres de los módulos importados en un archivo usando AST."""
+    file_imports = set()
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            tree = ast.parse(f.read())
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                for n in node.names:
+                    file_imports.add(n.name.split(".")[0])
+            elif isinstance(node, ast.ImportFrom):
+                if node.module:
+                    file_imports.add(node.module.split(".")[0])
+    except Exception:
+        # Ignorar archivos que no se pueden parsear (ej. errores de sintaxis)
+        pass
+    return file_imports

django_req_generator-0.1.0/django_req_generator/scanner/django_inspector.py

@@ -0,0 +1,58 @@
+from django.conf import settings
+
+
+def inspect_settings():
+    """Extrae nombres de módulos de las configuraciones de Django."""
+    found_modules = set()
+
+    # Si estamos inspeccionando esto, Django DEBE estar
+    found_modules.add("django")
+
+    # 1. INSTALLED_APPS
+    apps = getattr(settings, "INSTALLED_APPS", [])
+    for app in apps:
+        if isinstance(app, str):
+            app = app.strip()
+            if app:
+                found_modules.add(app.split(".")[0])
+
+    # 2. MIDDLEWARE
+    middlewares = getattr(settings, "MIDDLEWARE", [])
+    for middleware in middlewares:
+        found_modules.add(middleware.split(".")[0])
+
+    # 3. CACHES (Detectar django-redis, etc.)
+    caches = getattr(settings, "CACHES", {})
+    for cache_config in caches.values():
+        backend = cache_config.get("BACKEND", "")
+        if backend:
+            found_modules.add(backend.split(".")[0])
+
+    # 4. AUTHENTICATION_BACKENDS
+    auth_backends = getattr(settings, "AUTHENTICATION_BACKENDS", [])
+    for auth in auth_backends:
+        found_modules.add(auth.split(".")[0])
+
+    # 5. DATABASES (Motores internos de Django y sus drivers)
+    databases = getattr(settings, "DATABASES", {})
+    db_drivers = {
+        "django.db.backends.postgresql": "psycopg2", # o psycopg
+        "django.db.backends.mysql": "mysqlclient",
+        "django.db.backends.oracle": "oracledb",
+        "django.db.backends.sqlite3": None, # stdlib
+    }
+
+    for db_config in databases.values():
+        engine = db_config.get("ENGINE", "")
+        if engine:
+            if engine in db_drivers:
+                driver = db_drivers[engine]
+                if driver:
+                    found_modules.add(driver)
+            else:
+                # Si es un motor de terceros
+                parts = engine.split(".")
+                if len(parts) > 1 and parts[0] != "django":
+                    found_modules.add(parts[0])
+
+    return found_modules

django_req_generator-0.1.0/django_req_generator/scanner/dynamic_tracker.py

@@ -0,0 +1,45 @@
+import builtins
+
+
+_used_modules = set()
+_original_import = builtins.__import__
+
+
+def tracking_import(name, *args, **kwargs):
+    """Hook que registra el nombre del módulo raíz importado."""
+    if name:
+        root_module = name.split(".")[0]
+        _used_modules.add(root_module)
+    return _original_import(name, *args, **kwargs)
+
+
+def start_tracking():
+    """Activa el Hook de importación."""
+    builtins.__import__ = tracking_import
+
+
+def stop_tracking():
+    """Detiene el Hook de importación y restaura el original."""
+    builtins.__import__ = _original_import
+
+
+def get_tracked_modules():
+    """Devuelve la lista de módulos registrados."""
+    return _used_modules
+
+
+def save_tracked_modules(file_path=".tracked_modules.json"):
+    """Guarda los módulos rastreados en un archivo JSON."""
+    import json
+    with open(file_path, "w") as f:
+        json.dump(list(_used_modules), f)
+
+
+def load_tracked_modules(file_path=".tracked_modules.json"):
+    """Carga módulos rastreados desde un archivo JSON."""
+    import json
+    import os
+    if os.path.exists(file_path):
+        with open(file_path, "r") as f:
+            return set(json.load(f))
+    return set()

django_req_generator-0.1.0/django_req_generator/utils/filter.py

@@ -0,0 +1,60 @@
+import sys
+import os
+import importlib.metadata as md
+
+def filter_standard_library(module_names):
+    """Filtra módulos que pertenecen a la librería estándar de Python."""
+    if sys.version_info >= (3, 10):
+        stdlib_names = sys.stdlib_module_names
+    else:
+        from distutils.sysconfig import get_python_lib
+        stdlib_names = set(os.listdir(get_python_lib(standard_lib=True)))
+
+    return {name for name in module_names if name not in stdlib_names}
+
+
+def filter_local_modules(module_names, project_root):
+    """
+    Filtra módulos locales pero prioriza los de Pip si hay coincidencia de nombre.
+    """
+    # 1. Identificar módulos instalados en Pip (para evitar falsos positivos locales)
+    pkg_dist = md.packages_distributions()
+    
+    # 2. Identificar todos los nombres locales del proyecto (carpetas y archivos .py)
+    local_names_found = set()
+    root_name = os.path.basename(project_root.rstrip(os.path.sep))
+    local_names_found.add(root_name)
+
+    ignore_dirs = {".git", "venv", ".venv", "__pycache__", "node_modules"}
+    for root, dirs, files in os.walk(project_root):
+        dirs[:] = [d for d in dirs if d not in ignore_dirs]
+        for d in dirs:
+            local_names_found.add(d)
+        for f in files:
+            if f.endswith(".py"):
+                local_names_found.add(f[:-3])
+
+    non_local = set()
+    for name in module_names:
+        # WHITELIST: Apps críticas que NUNCA deben filtrarse
+        if name.lower() in ["django", "ckeditor", "ckeditor_uploader"]:
+            non_local.add(name)
+            continue
+            
+        # Si el nombre es un paquete de pip real, se mantiene
+        if name in pkg_dist:
+            non_local.add(name)
+            continue
+            
+        # Si NO es de pip y SÍ está en nuestra lista de carpetas/archivos locales, se filtra
+        if name in local_names_found:
+            continue
+            
+        non_local.add(name)
+            
+    return non_local
+
+
+def filter_transitive_dependencies(package_versions):
+    """Inactivo para asegurar visibilidad de lxml/Django."""
+    return package_versions

django_req_generator-0.1.0/django_req_generator/utils/i18n.py

@@ -0,0 +1,88 @@
+import locale
+import os
+
+# Diccionario de traducciones
+MESSAGES = {
+    "es": {
+        "command_help": "Genera un archivo requirements.txt basado en análisis estático y de configuración.",
+        "arg_output_help": "Nombre del archivo de salida (por defecto: requirements.txt)",
+        "arg_validate_help": "Valida el archivo generado en un entorno temporal.",
+        "arg_develop_help": "Ruta local del código del plugin para instalarlo durante la validación (modo desarrollo).",
+        "start_gen": "Iniciando generación de {file}...",
+        "scan_ast": "Escaneando código fuente (AST)...",
+        "scan_django": "Inspeccionando configuraciones de Django...",
+        "load_dynamic": "Cargando hallazgos dinámicos previos...",
+        "filter_map": "Filtrando librería estándar y mapeando a paquetes...",
+        "backup_created": "Archivo existente respaldado en: {backup}",
+        "write_success": "Archivo {file} generado con {count} dependencias.",
+        "header_autogen": "# Archivo autogenerado por django-req-generator",
+        "header_repo": "# Repositorio: https://github.com/oscar/django-req-generator",
+        "validate_start": "Validando requisitos en entorno temporal...",
+        "validate_success": "¡Validación exitosa! El proyecto arranca correctamente.",
+        "validate_error": "Error de validación:\n{output}",
+        "error_no_manage": "No se encontró manage.py para validar.",
+        "log_create_venv": "Creando entorno virtual temporal en: {path}",
+        "log_install_plugin": "Instalando el plugin local desde: {path}",
+        "log_install_reqs": "Instalando dependencias desde: {file}",
+        "log_running_check": "Ejecutando 'python manage.py check' con settings: {settings}",
+        "warn_production": "¡ADVERTENCIA!: El flag --validate crea un entorno virtual temporal y realiza instalaciones. NO se recomienda su uso en servidores de producción reales.",
+        "prompt_continue": "¿Desea continuar con la validación? (S/n): ",
+        "validate_skipped": "Validación saltada por el usuario.",
+        "prompt_missing_module": "Se detectó que falta el módulo '{module}'. ¿Desea agregarlo a los requisitos y reintentar? (S/n): ",
+    },
+    "en": {
+        "command_help": "Generates a requirements.txt file based on static and configuration analysis.",
+        "arg_output_help": "Output filename (default: requirements.txt)",
+        "arg_validate_help": "Validates the generated file in a temporary environment.",
+        "arg_develop_help": "Local path of the plugin source code for installation during validation (development mode).",
+        "start_gen": "Starting generation for {file}...",
+        "scan_ast": "Scanning source code (AST)...",
+        "scan_django": "Inspecting Django configurations...",
+        "load_dynamic": "Loading previous dynamic findings...",
+        "filter_map": "Filtering standard library and mapping to packages...",
+        "backup_created": "Existing file backed up to: {backup}",
+        "write_success": "File {file} generated with {count} dependencies.",
+        "header_autogen": "# File auto-generated by django-req-generator",
+        "header_repo": "# Repository: https://github.com/oscar/django-req-generator",
+        "validate_start": "Validating requirements in temporary environment...",
+        "validate_success": "Validation successful! The project starts correctly.",
+        "validate_error": "Validation error:\n{output}",
+        "error_no_manage": "manage.py was not found for validation.",
+        "log_create_venv": "Creating temporary virtual environment in: {path}",
+        "log_install_plugin": "Installing local plugin from: {path}",
+        "log_install_reqs": "Installing dependencies from: {file}",
+        "log_running_check": "Running 'python manage.py check' with settings: {settings}",
+        "warn_production": "WARNING!: The --validate flag creates a temporary virtual environment and performs installations. It is NOT recommended for use on real production servers.",
+        "prompt_continue": "Do you want to continue with validation? (Y/n): ",
+        "validate_skipped": "Validation skipped by user.",
+        "prompt_missing_module": "Module '{module}' was detected as missing. Would you like to add it to requirements and retry? (Y/n): ",
+    }
+}
+
+def get_language():
+    """Detecta el idioma del sistema."""
+    # Primero intentar con la variable de entorno
+    lang_env = os.environ.get("LANG", "").split(".")[0].split("_")[0].lower()
+    if lang_env in MESSAGES:
+        return lang_env
+    
+    # Después intentar con locale
+    try:
+        lang_loc, _ = locale.getdefaultlocale()
+        if lang_loc:
+            lang_loc = lang_loc.split("_")[0].lower()
+            if lang_loc in MESSAGES:
+                return lang_loc
+    except Exception:
+        pass
+        
+    return "es"  # Por defecto español
+
+CURRENT_LANG = get_language()
+
+def _(key, **kwargs):
+    """Traduce la clave según el idioma detectado."""
+    text = MESSAGES.get(CURRENT_LANG, MESSAGES["es"]).get(key, key)
+    if kwargs:
+        return text.format(**kwargs)
+    return text

django_req_generator-0.1.0/django_req_generator/utils/mapper.py

@@ -0,0 +1,67 @@
+import importlib.metadata as md
+import urllib.request
+import json
+import logging
+
+def check_pypi_existence(package_name):
+    """
+    Verifica si un paquete existe en PyPI usando su API JSON.
+    Devuelve el nombre oficial si existe, None si no.
+    """
+    url = f"https://pypi.org/pypi/{package_name}/json"
+    try:
+        with urllib.request.urlopen(url, timeout=3) as response:
+            if response.status == 200:
+                data = json.loads(response.read().decode())
+                return data.get("info", {}).get("name", package_name)
+    except Exception:
+        pass
+    return None
+
+def map_modules_to_packages(module_names):
+    """
+    Mapea módulos a paquetes de forma dinámica. 
+    Prioriza lo instalado y usa PyPI como fallback inteligente.
+    """
+    pkg_dist = md.packages_distributions()
+    canonical_names = {dist.metadata.get("Name").lower(): dist.metadata.get("Name") 
+                       for dist in md.distributions() if dist.metadata.get("Name")}
+
+    mapped_packages = {}
+
+    for module in module_names:
+        # Django es innegociable
+        if module == "django":
+            try:
+                import django as dj
+                mapped_packages["Django"] = dj.get_version()
+                continue
+            except Exception: pass
+
+        # 1. ¿Está instalado localmente? (La vía rápida)
+        if module in pkg_dist:
+            dist_name = pkg_dist[module][0]
+            official_name = canonical_names.get(dist_name.lower(), dist_name)
+            try:
+                mapped_packages[official_name] = md.version(dist_name)
+                continue
+            except Exception: pass
+
+        # 2. ¿No está instalado? Vamos a preguntarle a PyPI (Detección Dinámica)
+        # Probamos el nombre original (con guiones si tiene guiones bajos)
+        search_name = module.replace("_", "-")
+        pypi_name = check_pypi_existence(search_name)
+        
+        if pypi_name:
+            mapped_packages[pypi_name] = "???"
+        else:
+            # 3. No existe tal cual... ¿será una app de Django? Probemos con prefijo
+            django_guess = f"django-{search_name}"
+            pypi_name = check_pypi_existence(django_guess)
+            if pypi_name:
+                mapped_packages[pypi_name] = "???"
+            else:
+                # 4. Fallback final: lo incluimos como el módulo mismo
+                mapped_packages[search_name] = "???"
+
+    return mapped_packages

django_req_generator-0.1.0/django_req_generator/utils/validator.py

@@ -0,0 +1,88 @@
+import subprocess
+import venv
+import tempfile
+import os
+import shutil
+
+from django_req_generator.utils.i18n import _
+
+def validate_requirements(requirements_file_path, project_root, settings_module=None, plugin_root=None, log_callback=None, venv_dir=None):
+    """
+    Ejecuta django check en un entorno virtual. 
+    Si venv_dir es proporcionado, reutiliza ese entorno (mucho más rápido).
+    """
+    report = {"success": True, "output": ""}
+
+    def log(msg):
+        if log_callback:
+            log_callback(msg)
+
+    # Si no nos pasan un venv_dir, creamos uno efímero (comportamiento antiguo)
+    is_temporary = venv_dir is None
+    if is_temporary:
+        venv_dir = tempfile.mkdtemp()
+
+    try:
+        # Determinar el binario de python y pip
+        if os.name == "nt":
+            python_exe = os.path.join(venv_dir, "Scripts", "python.exe")
+            pip_exe = os.path.join(venv_dir, "Scripts", "pip.exe")
+        else:
+            python_exe = os.path.join(venv_dir, "bin", "python")
+            pip_exe = os.path.join(venv_dir, "bin", "pip")
+
+        # 1. Crear el entorno si no existe todavía
+        if not os.path.exists(python_exe):
+            log(_("log_create_venv", path=venv_dir))
+            venv.create(venv_dir, with_pip=True)
+            
+            # 2. Instalar el propio plugin solo la primera vez
+            if plugin_root:
+                log(_("log_install_plugin", path=plugin_root))
+                subprocess.run(
+                    [pip_exe, "install", plugin_root],
+                    check=True, capture_output=True, text=True
+                )
+
+        # 3. Instalar los requisitos (Pip es inteligente y solo instalará lo nuevo)
+        log(_("log_install_reqs", file=requirements_file_path))
+        subprocess.run(
+            [pip_exe, "install", "-r", requirements_file_path],
+            check=True, capture_output=True, text=True
+        )
+
+        # 4. Ejecutar django check
+        manage_py = os.path.join(project_root, "manage.py")
+        if not os.path.exists(manage_py):
+            return {"success": False, "output": _("error_no_manage")}
+
+        log(_("log_running_check", settings=settings_module or "Default"))
+        check_cmd = [python_exe, manage_py, "check"]
+        if settings_module:
+            check_cmd.append(f"--settings={settings_module}")
+
+        result = subprocess.run(
+            check_cmd, check=True, capture_output=True, text=True
+        )
+        report["output"] = result.stdout
+
+    except subprocess.CalledProcessError as e:
+        report["success"] = False
+        output = (e.stdout or "") + (e.stderr or "")
+        report["output"] = output
+        
+        # Intentar extraer el módulo faltante del traceback
+        import re
+        match = re.search(r"ModuleNotFoundError: No module named '([^']+)'", output)
+        if match:
+            report["missing_module"] = match.group(1)
+    except Exception as e:
+        report["success"] = False
+        report["output"] = str(e)
+    finally:
+        # Solo lo borramos si es de la sesión efímera. 
+        # Si lo gestiona generate_reqs.py, allí se debe borrar.
+        if is_temporary and os.path.exists(venv_dir):
+            shutil.rmtree(venv_dir)
+
+    return report

django_req_generator-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "django-req-generator"
+version = "0.1.0"
+authors = [
+  { name = "Oscar Higuera", email = "higuera86@gmail.com" },
+]
+description = "Generador de requirements.txt avanzado para Django con análisis estático y dinámico."
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Framework :: Django",
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+]
+dependencies = [
+    "django>=3.2",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/rraczo/django-req-generator"
+
+[tool.hatch.build.targets.wheel]
+packages = ["django_req_generator"]