djinitx 0.1.0__py3-none-any.whl

djinit/cli.py

@@ -0,0 +1,109 @@
+"""
+Main CLI orchestrator for djinit.
+Coordinates between different managers to create a complete Django project.
+"""
+
+import os
+from typing import Callable, List, Tuple
+
+from djinit.scripts.cicd_config_generator import CICDConfigGenerator
+from djinit.scripts.console_ui import UIFormatter
+from djinit.scripts.deployment_files_generator import DeploymentConfigGenerator
+from djinit.scripts.files import FileManager
+from djinit.scripts.project import ProjectManager
+from djinit.scripts.secretkey_generator import generate_secret_command
+from djinit.scripts.settings import SettingsManager
+
+
+class Cli:
+    def __init__(self, project_dir: str, project_name: str, primary_app: str, app_names: list, metadata: dict):
+        self.project_dir = project_dir
+        self.project_name = project_name
+        self.primary_app = primary_app
+        self.app_names = app_names
+        self.metadata = metadata
+        self.project_root = os.path.join(os.getcwd(), project_dir)
+
+        # Initialize managers
+        self.project_manager = ProjectManager(project_dir, project_name, app_names, metadata)
+        self.settings_manager = SettingsManager(self.project_root, project_name, app_names, metadata)
+        self.file_manager = FileManager(self.project_root, project_name, app_names, metadata)
+        self.deployment_manager = DeploymentConfigGenerator(self.project_root, project_name)
+        self.cicd_manager = CICDConfigGenerator(self.project_root, project_name)
+
+    def run_setup(self) -> bool:
+        steps: List[Tuple[str, Callable[[], bool]]] = [
+            ("Creating Django project", self.project_manager.create_project),
+            ("Creating Django apps", self.project_manager.create_apps),
+            ("Validating project structure", self.project_manager.validate_project_structure),
+            ("Setting up project structure", self.settings_manager.create_settings_structure),
+            ("Configuring base settings", self.settings_manager.update_base_settings),
+            ("Configuring development settings", self.settings_manager.update_development_settings),
+            ("Configuring production settings", self.settings_manager.update_production_settings),
+            ("Creating utility files", self._create_utility_files),
+            ("Setting up app URLs", self.file_manager.create_app_urls),
+            ("Creating app serializers", self.file_manager.create_app_serializers),
+            ("Creating app routes", self.file_manager.create_app_routes),
+            ("Configuring comprehensive URLs", self.file_manager.update_project_urls),
+            ("Updating WSGI configuration", self.file_manager.update_wsgi_file),
+            ("Updating ASGI configuration", self.file_manager.update_asgi_file),
+            ("Updating manage.py", self.file_manager.update_manage_py),
+            ("Creating Justfile", self.deployment_manager.create_justfile),
+            ("Creating Procfile", self.deployment_manager.create_procfile),
+            ("Creating runtime.txt", lambda: self.deployment_manager.create_runtime_txt("3.13")),
+            ("Creating CI/CD pipelines", self._create_cicd_pipelines),
+        ]
+
+        total_steps = len(steps)
+        success = True
+
+        # Create live progress display
+        progress, task = UIFormatter.create_live_progress(description="Setup Progress", total_steps=total_steps)
+
+        with progress:
+            # Execute each step with progress tracking
+            for step_number, (description, step_func) in enumerate(steps, 1):
+                result = step_func()
+                if not result:
+                    success = False
+                    UIFormatter.print_error(f"Step {step_number} failed: {description}")
+                    break
+
+                # Update the same progress bar
+                progress.update(task, advance=1, description=f"Step {step_number}/{total_steps}")
+
+        return success
+
+    def _create_utility_files(self) -> bool:
+        utility_steps = [
+            self.file_manager.create_gitignore,
+            self.file_manager.create_requirements,
+            self.file_manager.create_readme,
+            self.file_manager.create_env_file,
+            lambda: self.file_manager.create_pyproject_toml(self.metadata),
+        ]
+
+        for step_func in utility_steps:
+            result = step_func()
+            if not result:
+                return False
+
+        UIFormatter.print_success("Created all utility files successfully!")
+        return True
+
+    def _create_cicd_pipelines(self) -> bool:
+        if self.metadata.get("use_github_actions", True):
+            result = self.cicd_manager.create_github_actions()
+            if not result:
+                return False
+
+        if self.metadata.get("use_gitlab_ci", True):
+            result = self.cicd_manager.create_gitlab_ci()
+            if not result:
+                return False
+
+        return True
+
+    def generate_secret_keys(self) -> bool:
+        generate_secret_command()
+        return True

djinit/generator.py

@@ -0,0 +1,74 @@
+"""
+Main script entry point for djinit.
+Handles user input validation and orchestrates the setup process.
+"""
+
+import os
+import subprocess
+import sys
+
+from djinit.cli import Cli
+from djinit.scripts.command_handler import handle_app_command, handle_secret_command, parse_arguments
+from djinit.scripts.console_ui import UIFormatter, console
+from djinit.scripts.input_handler import confirm_setup, get_user_input
+
+
+def clear_screen() -> None:
+    try:
+        if os.name == "nt":
+            subprocess.run("cls", shell=True, check=True)  # Windows
+        else:
+            subprocess.run("clear", shell=True, check=True)  # Linux/MacOS
+    except subprocess.CalledProcessError:
+        # If clearing fails, just print some newlines
+        console.print("\n" * 50)
+
+
+def main() -> None:
+    # Parse command line arguments
+    args = parse_arguments()
+
+    # Handle secret command
+    if args.command == "secret":
+        handle_secret_command(args)
+        return
+
+    # Handle app command
+    if args.command == "app":
+        handle_app_command(args)
+        return
+
+    # Default to setup command
+    # Clear screen
+    clear_screen()
+
+    # Display welcome screen
+    console.print()
+    console.print(UIFormatter.create_welcome_panel())
+    console.print()
+
+    # Get user input
+    project_dir, project_name, primary_app, app_names, metadata = get_user_input()
+
+    # Confirm setup
+    if not confirm_setup(project_dir, project_name, app_names, metadata):
+        UIFormatter.print_info("Setup cancelled by user.")
+        return
+
+    # Run setup
+    console.print()
+    UIFormatter.print_info("Starting Django project setup...")
+    console.print()
+
+    django_cli = Cli(project_dir, project_name, primary_app, app_names, metadata)
+    success = django_cli.run_setup()
+
+    # Display completion summary
+    UIFormatter.create_summary_panel(project_dir, project_name, app_names, True)
+
+    # Exit with appropriate code
+    sys.exit(0 if success else 1)
+
+
+if __name__ == "__main__":
+    main()

djinit/scripts/app_generator.py

@@ -0,0 +1,254 @@
+"""
+App management for djinit.
+Handles creation of Django apps and updating settings.
+"""
+
+import os
+import subprocess
+from typing import Optional
+
+from djinit.scripts.console_ui import UIFormatter
+from djinit.scripts.template_engine import template_engine
+from djinit.utils import change_cwd, create_file_with_content
+
+
+class AppManager:
+    def __init__(self, app_name: str):
+        self.app_name = app_name
+        self.current_dir = os.getcwd()
+        self.manage_py_path = os.path.join(self.current_dir, "manage.py")
+
+    def create_app(self) -> bool:
+        if not self._is_django_project():
+            UIFormatter.print_error(
+                "Not in a Django project directory. Please run this command from your Django project root."
+            )
+            return False
+
+        if self._app_exists():
+            UIFormatter.print_error(f"Django app '{self.app_name}' already exists.")
+            return False
+
+        if not self._create_django_app():
+            return False
+
+        if not self._add_to_installed_apps():
+            return False
+
+        if not self._create_additional_files():
+            return False
+
+        UIFormatter.print_success(f"Django app '{self.app_name}' created and configured successfully!")
+        return True
+
+    def _is_django_project(self) -> bool:
+        return os.path.exists(self.manage_py_path)
+
+    def _app_exists(self) -> bool:
+        # Detect project structure to check in correct location
+        is_nested, nested_dir, apps_base_dir = self._detect_project_structure()
+        app_path = os.path.join(apps_base_dir, self.app_name)
+        return os.path.exists(app_path)
+
+    def _create_django_app(self) -> bool:
+        # Detect project structure
+        is_nested, nested_dir, apps_base_dir = self._detect_project_structure()
+
+        # manage.py is always in the project root (current_dir), not in the project directory
+        manage_py_path = os.path.join(self.current_dir, "manage.py")
+        if not os.path.exists(manage_py_path):
+            UIFormatter.print_error("Could not find manage.py file in project root")
+            return False
+
+        # Create app in the correct location
+        with change_cwd(apps_base_dir):
+            subprocess.run(["django-admin", "startapp", self.app_name], capture_output=True, text=True, check=True)
+
+        UIFormatter.print_success(f"Created Django app '{self.app_name}' in {apps_base_dir}")
+        return True
+
+    def _add_to_installed_apps(self) -> bool:
+        settings_path = self._find_settings_path()
+        if not settings_path:
+            UIFormatter.print_error("Could not find Django settings directory")
+            return False
+
+        base_settings_path = os.path.join(settings_path, "base.py")
+        if not os.path.exists(base_settings_path):
+            UIFormatter.print_error("Could not find base.py settings file")
+            return False
+
+        with open(base_settings_path) as f:
+            content = f.read()
+
+        # Detect project structure to determine the correct app module path
+        is_nested, nested_dir, apps_base_dir = self._detect_project_structure()
+
+        # Determine the correct module path for the app
+        if is_nested and nested_dir:
+            app_module_path = f"{nested_dir}.{self.app_name}"
+        else:
+            app_module_path = self.app_name
+
+        # Check if app is already in USER_DEFINED_APPS section specifically
+        lines = content.split("\n")
+        in_user_apps = False
+        app_already_exists = False
+
+        for line in lines:
+            if "USER_DEFINED_APPS" in line and "=" in line:
+                in_user_apps = True
+            elif in_user_apps and line.strip() == "]":
+                in_user_apps = False
+            elif in_user_apps and (f'"{app_module_path}"' in line or f"'{app_module_path}'" in line):
+                app_already_exists = True
+                break
+
+        if app_already_exists:
+            UIFormatter.print_success(f"App '{app_module_path}' already configured in USER_DEFINED_APPS")
+            return True
+
+        if "USER_DEFINED_APPS" not in content:
+            UIFormatter.print_error("Could not find USER_DEFINED_APPS section in base.py")
+            return False
+
+        lines = content.split("\n")
+        new_lines = []
+        in_user_apps = False
+        apps_added = False
+
+        for line in lines:
+            if "USER_DEFINED_APPS" in line and "=" in line:
+                in_user_apps = True
+                new_lines.append(line)
+            elif in_user_apps and line.strip() == "]":
+                new_lines.append(f'    "{app_module_path}",')
+                new_lines.append(line)
+                in_user_apps = False
+                apps_added = True
+            else:
+                new_lines.append(line)
+
+        if not apps_added:
+            UIFormatter.print_error("Could not find USER_DEFINED_APPS section in base.py")
+            return False
+
+        with open(base_settings_path, "w") as f:
+            f.write("\n".join(new_lines))
+
+        UIFormatter.print_success(f"Added '{app_module_path}' to USER_DEFINED_APPS in base.py")
+        return True
+
+    def _find_settings_path(self) -> Optional[str]:
+        # Look for project directories that contain settings
+        for item in os.listdir(self.current_dir):
+            if os.path.isdir(item) and not item.startswith(".") and item != "__pycache__":
+                # Check if this directory contains Django project files
+                project_path = os.path.join(self.current_dir, item)
+                settings_path = os.path.join(project_path, "settings")
+
+                # Check if settings directory exists with base.py
+                if os.path.exists(settings_path) and os.path.exists(os.path.join(settings_path, "base.py")):
+                    return settings_path
+
+        # Fallback: look for settings in current directory
+        settings_path = os.path.join(self.current_dir, "settings")
+        if os.path.exists(settings_path) and os.path.exists(os.path.join(settings_path, "base.py")):
+            return settings_path
+
+        return None
+
+    def _detect_project_structure(self) -> tuple[bool, Optional[str], str]:
+        # Step 1: find project directory containing settings/base.py
+        project_dir: Optional[str] = None
+        settings_base_path: Optional[str] = None
+        for item in os.listdir(self.current_dir):
+            if os.path.isdir(item) and not item.startswith(".") and item != "__pycache__":
+                candidate = os.path.join(self.current_dir, item)
+                base_py = os.path.join(candidate, "settings", "base.py")
+                if os.path.exists(base_py):
+                    project_dir = candidate
+                    settings_base_path = base_py
+                    break
+
+        # Fallback: current_dir/settings/base.py
+        if project_dir is None:
+            base_py = os.path.join(self.current_dir, "settings", "base.py")
+            if os.path.exists(base_py):
+                project_dir = self.current_dir
+                settings_base_path = base_py
+
+        if project_dir is None:
+            # Not a Django project structure
+            return False, None, self.current_dir
+
+        # Step 2: try to infer nested_dir from USER_DEFINED_APPS in base.py
+        try:
+            if settings_base_path and os.path.exists(settings_base_path):
+                with open(settings_base_path) as f:
+                    base_content = f.read()
+                # Find lines inside USER_DEFINED_APPS and extract first dotted app
+                in_user_apps = False
+                for line in base_content.splitlines():
+                    if "USER_DEFINED_APPS" in line and "=" in line:
+                        in_user_apps = True
+                        continue
+                    if in_user_apps and "]" in line:
+                        break
+                    if in_user_apps:
+                        line_stripped = line.strip().strip(",")
+                        if line_stripped.startswith('"') or line_stripped.startswith("'"):
+                            app_label = line_stripped.strip("\"'")
+                            if "." in app_label:
+                                prefix = app_label.split(".", 1)[0]
+                                nested_path = os.path.join(self.current_dir, prefix)
+                                if os.path.isdir(nested_path):
+                                    return True, prefix, nested_path
+        except Exception:
+            # Ignore parsing issues and continue with heuristics
+            pass
+
+        # Step 3: look for existing package directories in project root
+        preferred = ["apps", "modules", "packages"]
+        for name in preferred:
+            nested_path = os.path.join(self.current_dir, name)
+            if os.path.isdir(nested_path) and os.path.exists(os.path.join(nested_path, "__init__.py")):
+                return True, name, nested_path
+
+        # Any other directory with __init__.py qualifies as a package
+        for item in os.listdir(self.current_dir):
+            if item in ("__pycache__",) or item.startswith("."):
+                continue
+            nested_path = os.path.join(self.current_dir, item)
+            if os.path.isdir(nested_path) and os.path.exists(os.path.join(nested_path, "__init__.py")):
+                return True, item, nested_path
+
+        # Step 4: fallback
+        return False, None, self.current_dir
+
+    def _create_additional_files(self) -> bool:
+        """Create additional files for the app (serializers.py, routes.py)."""
+        # Detect project structure to get correct app path
+        is_nested, nested_dir, apps_base_dir = self._detect_project_structure()
+        app_path = os.path.join(apps_base_dir, self.app_name)
+
+        # Create serializers.py
+        context = {"app_name": self.app_name}
+        serializers_content = template_engine.render_template("serializers.j2", context)
+        create_file_with_content(
+            os.path.join(app_path, "serializers.py"),
+            serializers_content,
+            f"Created {self.app_name}/serializers.py",
+            should_format=True,
+        )
+
+        # Create routes.py
+        routes_content = template_engine.render_template("routes.j2", context)
+        create_file_with_content(
+            os.path.join(app_path, "routes.py"),
+            routes_content,
+            f"Created {self.app_name}/routes.py",
+            should_format=True,
+        )
+
+        return True

djinit/scripts/cicd_config_generator.py

@@ -0,0 +1,41 @@
+"""
+CI/CD pipeline manager for djinit
+Handles creation of Github Actions and GitLab CI onfigurations
+"""
+
+import os
+
+from djinit.scripts.template_engine import template_engine
+from djinit.utils import change_cwd, create_file_with_content
+
+
+class CICDConfigGenerator:
+    def __init__(self, project_root: str, project_name: str):
+        self.project_root = project_root
+        self.project_name = project_name
+
+    def create_github_actions(self) -> bool:
+        with change_cwd(self.project_root):
+            github_dir = os.path.join(self.project_root, ".github", "workflows")
+            os.makedirs(github_dir, exist_ok=True)
+
+            context = {"project_name": self.project_name}
+            workflow_content = template_engine.render_template("github_actions_ci.j2", context)
+            workflow_file = os.path.join(github_dir, "ci.yml")
+            create_file_with_content(
+                workflow_file,
+                workflow_content,
+                "Created Github Actions workflow (ci.yml)",
+            )
+        return True
+
+    def create_gitlab_ci(self) -> bool:
+        with change_cwd(self.project_root):
+            context = {"project_name": self.project_name}
+            gitlab_ci_content = template_engine.render_template("gitlab_ci.j2", context)
+            create_file_with_content(
+                ".gitlab-ci.yml",
+                gitlab_ci_content,
+                "Created GitLab CI configuration (.gitlab-ci.yml)",
+            )
+        return True

djinit/scripts/command_handler.py

@@ -0,0 +1,140 @@
+"""
+Command handlers for Django project setup CLI.
+Handles different commands like secret key generation and app creation.
+"""
+
+import argparse
+import sys
+
+from djinit.scripts.console_ui import UIColors, UIFormatter, console
+from djinit.scripts.name_validator import validate_app_name
+
+
+def parse_arguments() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Django project setup tool", prog="django-init")
+
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # Setup command (default)
+    setup_parser = subparsers.add_parser("setup", help="Create a new Django project")
+    setup_parser.add_argument("--project", help="Django project name")
+    setup_parser.add_argument("--app", help="Django app name")
+
+    # Secret command
+    secret_parser = subparsers.add_parser("secret", help="Generate Django secret keys")
+    secret_parser.add_argument("--count", type=int, default=3, help="Number of keys to generate")
+    secret_parser.add_argument("--length", type=int, default=50, help="Length of each secret key")
+
+    # App command
+    app_parser = subparsers.add_parser("app", help="Create one or more Django apps (comma or space separated)")
+    app_parser.add_argument(
+        "app_name",
+        nargs="+",
+        help=(
+            "App name(s) or comma-separated list. Examples: \n"
+            "  djinit app users \n"
+            "  djinit app users,products,orders \n"
+            "  djinit app users products orders \n"
+            "  djinit app users, products, orders"
+        ),
+    )
+
+    return parser.parse_args()
+
+
+def handle_secret_command(args: argparse.Namespace) -> None:
+    from djinit.scripts.secretkey_generator import display_secret_keys, generate_multiple_keys
+
+    # Generate keys
+    keys = generate_multiple_keys(args.count, args.length)
+
+    # Display results
+    UIFormatter.print_info("")
+    display_secret_keys(keys)
+
+    # Show usage instructions
+    from rich.panel import Panel
+    from rich.text import Text
+
+    instructions = Text()
+    instructions.append("📋 Usage Instructions:\n", style=UIColors.ACCENT)
+    instructions.append("1. Copy the appropriate secret key for your environment\n")
+    instructions.append("2. Add it to your .env file:\n")
+    instructions.append("   SECRET_KEY=your_secret_key_here\n", style=UIColors.CODE)
+    instructions.append("3. Or set it as an environment variable:\n")
+    instructions.append("   export SECRET_KEY=your_secret_key_here\n", style=UIColors.CODE)
+    instructions.append("4. Never commit secret keys to version control!\n", style=UIColors.WARNING)
+
+    console.print(Panel(instructions, title="💡 How to Use", border_style="blue"))
+    console.print()
+
+
+def handle_app_command(args: argparse.Namespace) -> None:
+    from djinit.scripts.app_generator import AppManager
+
+    # Display welcome message
+    UIFormatter.print_info("")
+    UIFormatter.print_header("Django App Creation")
+    UIFormatter.print_info("")
+
+    # Parse comma-separated names and validate
+    # args.app_name is a list due to nargs="+"; split each token by comma
+    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
+
+    # If no comma, keep single name behavior
+    if not app_names:
+        UIFormatter.print_error("App name cannot be empty")
+        sys.exit(1)
+
+    # Deduplicate while preserving order
+    seen = set()
+    deduped_names = []
+    for name in app_names:
+        if name not in seen:
+            deduped_names.append(name)
+            seen.add(name)
+
+    # Validate all names first
+    for name in deduped_names:
+        is_valid, error_msg = validate_app_name(name)
+        if not is_valid:
+            UIFormatter.print_error(f"Invalid app name '{name}': {error_msg}")
+            sys.exit(1)
+
+    # Create apps sequentially
+    any_failure = False
+    for name in deduped_names:
+        app_manager = AppManager(name)
+        success = app_manager.create_app()
+        if not success:
+            UIFormatter.print_error(f"Failed to create Django app '{name}'")
+            any_failure = True
+            break
+        UIFormatter.print_success(f"Django app '{name}' created successfully!")
+
+    if any_failure:
+        sys.exit(1)
+
+    # Show next steps
+    from rich.panel import Panel
+    from rich.text import Text
+
+    instructions = Text()
+    instructions.append("🚀 Next Steps:\n", style=UIColors.ACCENT)
+    instructions.append("1. The app(s) have been added to INSTALLED_APPS in settings/base.py\n")
+    instructions.append("2. Create your models in each app's models.py\n")
+    instructions.append("3. Run migrations: python manage.py makemigrations\n")
+    instructions.append("4. Apply migrations: python manage.py migrate\n")
+    instructions.append("5. Create views, serializers and routes(URLs) for your app(s)\n")
+
+    console.print(Panel(instructions, title="💡 What's Next", border_style="green"))
+    UIFormatter.print_info("")