djinitx 0.3.0__tar.gz → 0.3.2__tar.gz

{djinitx-0.3.0 → djinitx-0.3.2}/.github/workflows/publish.yml

@@ -11,9 +11,9 @@ jobs:
     permissions:
       id-token: write # IMPORTANT: this permission is mandatory for trusted publishing
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - name: Set up Python
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v6
       with:
         python-version: '3.12'
         cache: 'pip'

{djinitx-0.3.0 → djinitx-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: djinitx
-Version: 0.3.0
+Version: 0.3.2
 Summary: A CLI tool to setup Django project
 Project-URL: Homepage, https://github.com/S4NKALP/djinit
 Author-email: Sankalp Tharu <sankalptharu50028@gmail.com>
@@ -25,12 +25,10 @@ Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
 Classifier: Topic :: Software Development :: Code Generators
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.13
-Requires-Dist: click>=8.3.0
+Requires-Python: >=3.10
 Requires-Dist: jinja2>=3.1.0
-Requires-Dist: pre-commit>=4.5.0
+Requires-Dist: questionary>=2.0.1
 Requires-Dist: rich>=14.2.0
-Requires-Dist: ruff>=0.14.2
 Description-Content-Type: text/markdown
 
 # djinit

{djinitx-0.3.0 → djinitx-0.3.2}/TODO.md

@@ -10,5 +10,6 @@
 ## Enhancements
 
 - [ ] Add more project structure templates
-- [ ] Add interactive configuration wizard
+- [x] Add interactive configuration wizard
 - [ ] Add testing framework setup (pytest, coverage)
+- [x] Improve structure detection

{djinitx-0.3.0 → djinitx-0.3.2}/djinit/cli.py

@@ -9,7 +9,6 @@ from typing import Callable, List, Tuple
 from djinit.services.files import FileManager
 from djinit.services.project import ProjectManager
 from djinit.ui.console import UIFormatter
-from djinit.utils.security import generate_secret_command
 
 
 class Cli:
@@ -27,7 +26,8 @@ class Cli:
         self.project_manager = ProjectManager(project_dir, project_name, app_names, metadata)
         self.file_manager = FileManager(self.project_root, project_name, app_names, metadata)
 
-    def run_setup(self) -> bool:
+    def _normalize_metadata(self) -> None:
+        """Normalize metadata and app names based on structure type."""
         if self.metadata.get("predefined_structure"):
             self.metadata.setdefault("project_module_name", "config")
             self.metadata.setdefault("nested_apps", True)
@@ -36,7 +36,7 @@ class Cli:
                 self.app_names = ["users", "core"]
                 self.project_manager.app_names = self.app_names
 
-        if self.metadata.get("unified_structure"):
+        elif self.metadata.get("unified_structure"):
             self.metadata.setdefault("project_module_name", "core")
             self.metadata.setdefault("nested_apps", True)
             self.metadata.setdefault("nested_dir", "apps")
@@ -44,12 +44,15 @@ class Cli:
                 self.app_names = []
                 self.project_manager.app_names = self.app_names
 
-        if self.metadata.get("single_structure"):
+        elif self.metadata.get("single_structure"):
             self.metadata.setdefault("nested_apps", False)
             if not self.app_names:
                 self.app_names = []
                 self.project_manager.app_names = self.app_names
 
+    def run_setup(self) -> bool:
+        self._normalize_metadata()
+
         steps: List[Tuple[str, Callable[[], None]]] = []
 
         steps.append(("Creating Django project", self.project_manager.create_project))
@@ -100,6 +103,7 @@ class Cli:
             self.file_manager.create_requirements,
             self.file_manager.create_readme,
             self.file_manager.create_env_file,
+            self.file_manager.create_djinit_config,
             lambda: self.file_manager.create_pyproject_toml(self.metadata),
         ]
 
@@ -114,7 +118,3 @@ class Cli:
 
         if self.metadata.get("use_gitlab_ci", True):
             self.file_manager.create_gitlab_ci()
-
-    def generate_secret_keys(self) -> bool:
-        generate_secret_command()
-        return True

{djinitx-0.3.0 → djinitx-0.3.2}/djinit/commands/handler.py

@@ -11,7 +11,7 @@ from rich.text import Text
 
 from djinit.services.app import AppManager
 from djinit.ui.console import UIColors, UIFormatter, console
-from djinit.utils.security import display_secret_keys, generate_multiple_keys
+from djinit.utils.secretkey import display_secret_keys, generate_multiple_keys
 from djinit.utils.validators import validate_app_name
 
 
@@ -67,27 +67,17 @@ def handle_app_command(args: argparse.Namespace) -> None:
     UIFormatter.print_header("Django App Creation")
     UIFormatter.print_info("")
 
-    tokens = args.app_name if isinstance(args.app_name, list) else [args.app_name]
-    pieces = []
-    for token in tokens:
-        if token is None:
-            continue
-        for part in str(token).split(","):
-            part = part.strip()
-            if part:
-                pieces.append(part)
-    app_names = pieces
+    raw_tokens = args.app_name if isinstance(args.app_name, list) else [args.app_name]
+
+    # Flatten and clean tokens
+    app_names = [part.strip() for token in raw_tokens if token for part in str(token).split(",") if part.strip()]
 
     if not app_names:
         UIFormatter.print_error("App name cannot be empty")
         sys.exit(1)
 
-    seen = set()
-    deduped_names = []
-    for name in app_names:
-        if name not in seen:
-            deduped_names.append(name)
-            seen.add(name)
+    # Deduplicate while preserving order
+    deduped_names = list(dict.fromkeys(app_names))
 
     for name in deduped_names:
         is_valid, error_msg = validate_app_name(name)

{djinitx-0.3.0 → djinitx-0.3.2}/djinit/services/app.py

@@ -16,6 +16,7 @@ from djinit.utils.common import (
     extract_existing_apps,
     find_project_dir,
     find_settings_path,
+    get_djinit_config,
     insert_apps_into_user_defined_apps,
     is_django_project,
 )
@@ -27,6 +28,7 @@ class AppManager:
         self.app_name = app_name
         self.current_dir = os.getcwd()
         self.manage_py_path = os.path.join(self.current_dir, "manage.py")
+        self.config = get_djinit_config(self.current_dir)
         self._project_structure_cache = None
 
     def create_app(self) -> bool:
@@ -126,36 +128,58 @@ class AppManager:
     def _get_project_structure(self) -> tuple[bool, Optional[str], str]:
         """Get project structure with caching to avoid repeated detection."""
         if self._project_structure_cache is None:
-            project_dir, settings_base_path = find_project_dir(self.current_dir)
-
-            if project_dir is None:
-                self._project_structure_cache = (False, None, self.current_dir)
+            if self.config:
+                apps_config = self.config.get("apps", {})
+                nested = apps_config.get("nested", False)
+                nested_dir = apps_config.get("nested_dir")
+
+                # Determine base dir for apps
+                if nested and nested_dir:
+                    apps_base_dir = os.path.join(self.current_dir, nested_dir)
+                else:
+                    apps_base_dir = self.current_dir
+
+                self._project_structure_cache = (nested, nested_dir, apps_base_dir)
             else:
-                self._project_structure_cache = detect_nested_structure_from_settings(
-                    settings_base_path, self.current_dir
-                )
+                # Fallback to old detection method
+                project_dir, settings_base_path = find_project_dir(self.current_dir)
+
+                if project_dir is None:
+                    self._project_structure_cache = (False, None, self.current_dir)
+                else:
+                    self._project_structure_cache = detect_nested_structure_from_settings(
+                        settings_base_path, self.current_dir
+                    )
         return self._project_structure_cache
 
     def _is_predefined_structure(self) -> bool:
+        if self.config:
+            return self.config.get("structure", {}).get("predefined", False)
+
         apps_dir = os.path.join(self.current_dir, "apps")
         api_dir = os.path.join(self.current_dir, "api")
         return os.path.isdir(apps_dir) and os.path.isdir(api_dir)
 
     def _is_restricted_structure(self) -> bool:
         """Check if the project structure is Unified or Single Folder."""
-        apps_api_dir = os.path.join(self.current_dir, "apps", "api")
-        if os.path.isdir(apps_api_dir):
+        if self.config:
+            structure = self.config.get("structure", {})
+            return structure.get("unified", False) or structure.get("single", False)
+
+        # Check for Unified structure (apps/api exists)
+        if os.path.isdir(os.path.join(self.current_dir, "apps", "api")):
             return True
 
-        apps_dir = os.path.join(self.current_dir, "apps")
-        if os.path.isdir(apps_dir):
+        # Check for Predefined structure (apps/ exists but not apps/api)
+        if os.path.isdir(os.path.join(self.current_dir, "apps")):
             return False
 
+        # Check for Single Folder structure (models/ and api/ exist in project dir)
         project_dir, _ = find_project_dir(self.current_dir)
         if project_dir:
-            models_dir = os.path.join(project_dir, "models")
-            api_dir = os.path.join(project_dir, "api")
-            if os.path.isdir(models_dir) and os.path.isdir(api_dir):
+            has_models = os.path.isdir(os.path.join(project_dir, "models"))
+            has_api = os.path.isdir(os.path.join(project_dir, "api"))
+            if has_models and has_api:
                 return True
 
         return False

{djinitx-0.3.0 → djinitx-0.3.2}/djinit/services/files.py

@@ -45,10 +45,12 @@ class FileManager:
     def _create_files_from_specs(self, base_dir: str, folder_specs: dict, base_context: dict = None) -> None:
         """Helper to create multiple folders and files from a specification dict."""
         base_context = base_context or {}
-        for folder, files in folder_specs.items():
-            folder_path = os.path.join(base_dir, folder)
+
+        for folder_name, file_templates in folder_specs.items():
+            folder_path = os.path.join(base_dir, folder_name)
             create_directory_with_init(folder_path, f"Created {folder_path}/__init__.py")
-            for filename, template_path in files:
+
+            for filename, template_path in file_templates:
                 file_path = os.path.join(folder_path, filename)
                 create_file_from_template(file_path, template_path, base_context, f"Created {file_path}")
 
@@ -66,6 +68,52 @@ class FileManager:
             message = f"Created {prefix}{subdir}/__init__.py" if prefix else f"Created {subdir}/__init__.py"
             create_directory_with_init(subdir_path, message)
 
+    def _create_settings_package(self, settings_dir: str, base_context: dict, prefix: str) -> None:
+        """Helper to create settings package files (base, development, production)."""
+        from djinit.utils.secretkey import generate_secret_key
+
+        secret_key = generate_secret_key()
+        dev_context = {"secret_key": secret_key}
+
+        for filename, context in [
+            ("base.py", base_context),
+            ("development.py", dev_context),
+            ("production.py", base_context),
+        ]:
+            filepath = os.path.join(settings_dir, filename)
+            template_path = f"config/settings/{filename.replace('.py', '')}.j2"
+            self._render_and_create_file(
+                filepath,
+                template_path,
+                context,
+                f"Created {prefix}/settings/{filename}",
+                base_dir=os.path.dirname(
+                    settings_dir
+                ),  # Not strictly used by _render_and_create_file but good for context
+                should_format=True,
+            )
+
+    def _create_lifecycle_files(
+        self, target_dir: str, prefix: str, api_module: str = None, comment_out_api: bool = False
+    ) -> None:
+        """Helper to create urls.py, wsgi.py, and asgi.py."""
+
+        urls_context = {"api_module": api_module}
+        if comment_out_api:
+            urls_context["comment_out_api_url"] = True
+
+        files = [
+            ("urls.py", "config/urls/with_api.j2", urls_context),
+            ("wsgi.py", "config/wsgi.j2", {}),
+            ("asgi.py", "config/asgi.j2", {}),
+        ]
+
+        for filename, template, context in files:
+            filepath = os.path.join(target_dir, filename)
+            self._render_and_create_file(
+                filepath, template, context, f"Created {prefix}/{filename}", should_format=True
+            )
+
     def create_gitignore(self) -> None:
         self._render_and_create_file(".gitignore", "project/gitignore.j2", {}, "Created .gitignore file")
 
@@ -208,43 +256,17 @@ class FileManager:
         settings_dir = os.path.join(core_dir, "settings")
         create_directory_with_init(settings_dir, "Created core/settings/__init__.py")
 
-        from djinit.utils.security import generate_secret_key
-
-        secret_key = generate_secret_key()
-
-        # In this new structure, 'apps' is the main app.
-        # We assume the user wants 'apps' to be the app label.
-        # Or perhaps 'apps' is just a container and the components inside are what matters?
-        # Given the structure: apps/models, apps/views etc.
-        # It seems 'apps' is acting as the app.
-
+        # Create settings files
         base_context = {
-            "project_name": "core",  # Project module is 'core'
-            "app_names": ["apps"],  # 'apps' is the main app
+            "project_name": "core",
+            "app_names": ["apps"],
             "use_database_url": self.metadata.get("use_database_url", True),
             "database_type": self.metadata.get("database_type", "postgresql"),
         }
-        dev_context = {"secret_key": secret_key}
+        self._create_settings_package(settings_dir, base_context, "core")
 
-        for filename, context in [
-            ("base.py", base_context),
-            ("development.py", dev_context),
-            ("production.py", base_context),
-        ]:
-            filepath = os.path.join(settings_dir, filename)
-            template_path = f"config/settings/{filename.replace('.py', '')}.j2"
-            create_file_from_template(
-                filepath, template_path, context, f"Created core/settings/{filename}", should_format=True
-            )
-
-        core_files = [
-            ("urls.py", "config/urls/with_api.j2", {"api_module": "apps.api"}),
-            ("wsgi.py", "config/wsgi.j2", {}),
-            ("asgi.py", "config/asgi.j2", {}),
-        ]
-        for filename, template, context in core_files:
-            filepath = os.path.join(core_dir, filename)
-            create_file_from_template(filepath, template, context, f"Created core/{filename}", should_format=True)
+        # Create lifecycle files (urls, wsgi, asgi)
+        self._create_lifecycle_files(core_dir, "core", api_module="apps.api")
 
         # 2. Create 'apps' directory (The Main App)
         apps_dir = os.path.join(self.project_root, "apps")
@@ -287,43 +309,19 @@ class FileManager:
         settings_dir = os.path.join(project_dir, "settings")
         create_directory_with_init(settings_dir, f"Created {self.module_name}/settings/__init__.py")
 
-        from djinit.utils.security import generate_secret_key
-
-        secret_key = generate_secret_key()
-
+        # Create settings files
         base_context = {
             "project_name": self.module_name,
-            "app_names": [self.module_name],  # Project acts as the app
+            "app_names": [self.module_name],
             "use_database_url": self.metadata.get("use_database_url", True),
             "database_type": self.metadata.get("database_type", "postgresql"),
         }
-        dev_context = {"secret_key": secret_key}
-
-        for filename, context in [
-            ("base.py", base_context),
-            ("development.py", dev_context),
-            ("production.py", base_context),
-        ]:
-            filepath = os.path.join(settings_dir, filename)
-            template_path = f"config/settings/{filename.replace('.py', '')}.j2"
-            create_file_from_template(
-                filepath, template_path, context, f"Created {self.module_name}/settings/{filename}", should_format=True
-            )
+        self._create_settings_package(settings_dir, base_context, self.module_name)
 
-        project_files = [
-            (
-                "urls.py",
-                "config/urls/with_api.j2",
-                {"api_module": f"{self.module_name}.api", "comment_out_api_url": True},
-            ),
-            ("wsgi.py", "config/wsgi.j2", {}),
-            ("asgi.py", "config/asgi.j2", {}),
-        ]
-        for filename, template, context in project_files:
-            filepath = os.path.join(project_dir, filename)
-            create_file_from_template(
-                filepath, template, context, f"Created {self.module_name}/{filename}", should_format=True
-            )
+        # Create lifecycle files (urls, wsgi, asgi)
+        self._create_lifecycle_files(
+            project_dir, self.module_name, api_module=f"{self.module_name}.api", comment_out_api=True
+        )
 
         components = ["admin", "api", "models", "tests"]
         self._create_subdirectories_with_init(project_dir, components, f"{self.module_name}/")
@@ -395,3 +393,37 @@ class FileManager:
             context,
             "Created GitLab CI configuration (.gitlab-ci.yml)",
         )
+
+    def create_djinit_config(self) -> None:
+        """Create .djinit configuration file."""
+        import json
+
+        is_predefined = self.metadata.get("predefined_structure", False)
+        is_unified = self.metadata.get("unified_structure", False)
+        is_single = self.metadata.get("single_structure", False)
+        is_standard = not (is_predefined or is_unified or is_single)
+
+        config = {
+            "project_name": self.project_name,
+            "structure": {
+                "standard": is_standard,
+                "predefined": is_predefined,
+                "unified": is_unified,
+                "single": is_single,
+            },
+            "apps": {
+                "nested": self.metadata.get("nested_apps", False),
+                "nested_dir": self.metadata.get("nested_dir"),
+            },
+            "settings": {
+                "use_database_url": self.metadata.get("use_database_url", True),
+                "database_type": self.metadata.get("database_type", "postgresql"),
+            },
+            "cicd": {
+                "github": self.metadata.get("use_github_actions", False),
+                "gitlab": self.metadata.get("use_gitlab_ci", False),
+            },
+        }
+
+        filepath = os.path.join(self.project_root, ".djinit")
+        create_file_with_content(filepath, json.dumps(config, indent=4), "Created .djinit configuration file")

{djinitx-0.3.0 → djinitx-0.3.2}/djinit/services/project.py

@@ -89,23 +89,25 @@ class ProjectManager:
         UIFormatter.print_success(f"Added apps to USER_DEFINED_APPS: {added_apps_str}")
 
     def validate_project_structure(self) -> None:
+        join = lambda *args: os.path.join(self.project_root, *args)
+
         required_files = [
-            os.path.join(self.project_root, "manage.py"),
-            os.path.join(self.project_root, self.module_name, "__init__.py"),
-            os.path.join(self.project_root, self.module_name, "settings", "__init__.py"),
-            os.path.join(self.project_root, self.module_name, "settings", "base.py"),
-            os.path.join(self.project_root, self.module_name, "settings", "development.py"),
-            os.path.join(self.project_root, self.module_name, "settings", "production.py"),
-            os.path.join(self.project_root, self.module_name, "urls.py"),
-            os.path.join(self.project_root, self.module_name, "wsgi.py"),
-            os.path.join(self.project_root, self.module_name, "asgi.py"),
+            join("manage.py"),
+            join(self.module_name, "__init__.py"),
+            join(self.module_name, "settings", "__init__.py"),
+            join(self.module_name, "settings", "base.py"),
+            join(self.module_name, "settings", "development.py"),
+            join(self.module_name, "settings", "production.py"),
+            join(self.module_name, "urls.py"),
+            join(self.module_name, "wsgi.py"),
+            join(self.module_name, "asgi.py"),
         ]
 
         apps_base_dir = self._get_apps_base_dir()
 
         if self.metadata.get("unified_structure"):
             # Validate Unified Structure
-            apps_dir = os.path.join(self.project_root, "apps")
+            apps_dir = join("apps")
             unified_files = [
                 os.path.join(apps_dir, "__init__.py"),
                 os.path.join(apps_dir, "apps.py"),
@@ -124,16 +126,17 @@ class ProjectManager:
 
         elif not self.metadata.get("predefined_structure") and not self.metadata.get("single_structure"):
             for app_name in self.app_names:
+                app_path = lambda f, app=app_name: os.path.join(apps_base_dir, app, f)
                 app_files = [
-                    os.path.join(apps_base_dir, app_name, "__init__.py"),
-                    os.path.join(apps_base_dir, app_name, "apps.py"),
-                    os.path.join(apps_base_dir, app_name, "models.py"),
-                    os.path.join(apps_base_dir, app_name, "views.py"),
-                    os.path.join(apps_base_dir, app_name, "serializers.py"),
-                    os.path.join(apps_base_dir, app_name, "routes.py"),
-                    os.path.join(apps_base_dir, app_name, "tests.py"),
-                    os.path.join(apps_base_dir, app_name, "migrations"),
-                    os.path.join(apps_base_dir, app_name, "admin.py"),
+                    app_path("__init__.py"),
+                    app_path("apps.py"),
+                    app_path("models.py"),
+                    app_path("views.py"),
+                    app_path("serializers.py"),
+                    app_path("routes.py"),
+                    app_path("tests.py"),
+                    app_path("migrations"),
+                    app_path("admin.py"),
                 ]
                 required_files.extend(app_files)
 

{djinitx-0.3.0 → djinitx-0.3.2}/djinit/ui/console.py

@@ -6,6 +6,7 @@ Provides clean, minimal styling and user interface components.
 from contextlib import contextmanager
 from typing import Any, Dict, List, Optional
 
+import questionary
 from rich import box
 from rich.console import Console
 from rich.panel import Panel
@@ -164,20 +165,28 @@ class UIFormatter:
 
     @staticmethod
     def confirm(prompt: str, default: bool = True) -> bool:
-        """Display a confirmation prompt"""
-        default_str = "Y/n" if default else "y/N"
-        response = console.input(f"[bold cyan]?[/bold cyan] {prompt} [{default_str}]: ").strip().lower()
-        if not response:
-            return default
-        return response in ("y", "yes")
+        """Display a confirmation prompt as a selectable list"""
+        choices = [
+            questionary.Choice("Yes", value=True),
+            questionary.Choice("No", value=False),
+        ]
+        default_choice = choices[0] if default else choices[1]
+
+        result = questionary.select(
+            prompt,
+            choices=choices,
+            default=default_choice,
+        ).ask()
+
+        if result is None:
+            raise KeyboardInterrupt
+
+        return result
 
     @staticmethod
     def prompt(message: str, default: Optional[str] = None) -> str:
         """Display an input prompt"""
-        if default:
-            message = f"{message} [{default}]"
-        response = console.input(f"[bold cyan]?[/bold cyan] {message}: ").strip()
-        return response or default or ""
+        return questionary.text(message, default=default or "").ask()
 
     @staticmethod
     def handle_exception(e: Exception):