ntc-dev-kit 1.1.0__tar.gz → 1.2.0__tar.gz

{ntc_dev_kit-1.1.0/ntc_dev_kit.egg-info → ntc_dev_kit-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ntc-dev-kit
-Version: 1.1.0
+Version: 1.2.0
 Summary: Nexent Toolkit Console - A CLI tool for scaffolding Django REST Framework, React, Next.js, and Flutter projects
 Home-page: https://github.com/nexent/ntc
 Author: Nexent
@@ -97,7 +97,31 @@ ntc init --technology flutter
 ntc init
 ```
 
-Navigate menus with **arrow keys**, select with **Enter**, exit with **Escape**.
+A few questions, asked inline: project name, what you're building, where it goes, then the
+options for that technology (sign-in and Python environment for Django; installing dependencies
+for the others), a summary, and **Create?**. The defaults are already selected, so Enter takes
+them; **↑/↓** move, a **number key** picks an option at once, **Esc** cancels without writing
+anything. Each answer collapses to one line, and the only progress shown is for real work
+(creating the environment, installing packages).
+
+### Without questions
+
+Every answer can be given as a flag; with `--yes` nothing is asked (scripts, CI, AI agents):
+
+```bash
+ntc init -t django --name shop-api --with-auth --env venv --yes
+ntc init -t nextjs --name site --install --yes
+```
+
+| Flag | Meaning |
+|------|---------|
+| `-t`, `--technology` | `django`, `nextjs`, `react-admin`, `react`, `flutter` |
+| `--name` | Project name (`.` = the current folder) |
+| `--path` | Folder to create the project in (default: current folder) |
+| `--with-auth` / `--no-auth` | Django: include the sign-in app (custom User model, JWT, migration included) |
+| `--env` | Django: `venv`, `conda`, `existing` (the active virtualenv) or `skip` |
+| `--install` / `--no-install` | Others: run `npm install` / `flutter pub get` |
+| `--yes`, `-y` | Ask nothing; needs `--name` and `--technology` |
 
 ### Technology Options
 

{ntc_dev_kit-1.1.0 → ntc_dev_kit-1.2.0}/README.md

@@ -57,7 +57,31 @@ ntc init --technology flutter
 ntc init
 ```
 
-Navigate menus with **arrow keys**, select with **Enter**, exit with **Escape**.
+A few questions, asked inline: project name, what you're building, where it goes, then the
+options for that technology (sign-in and Python environment for Django; installing dependencies
+for the others), a summary, and **Create?**. The defaults are already selected, so Enter takes
+them; **↑/↓** move, a **number key** picks an option at once, **Esc** cancels without writing
+anything. Each answer collapses to one line, and the only progress shown is for real work
+(creating the environment, installing packages).
+
+### Without questions
+
+Every answer can be given as a flag; with `--yes` nothing is asked (scripts, CI, AI agents):
+
+```bash
+ntc init -t django --name shop-api --with-auth --env venv --yes
+ntc init -t nextjs --name site --install --yes
+```
+
+| Flag | Meaning |
+|------|---------|
+| `-t`, `--technology` | `django`, `nextjs`, `react-admin`, `react`, `flutter` |
+| `--name` | Project name (`.` = the current folder) |
+| `--path` | Folder to create the project in (default: current folder) |
+| `--with-auth` / `--no-auth` | Django: include the sign-in app (custom User model, JWT, migration included) |
+| `--env` | Django: `venv`, `conda`, `existing` (the active virtualenv) or `skip` |
+| `--install` / `--no-install` | Others: run `npm install` / `flutter pub get` |
+| `--yes`, `-y` | Ask nothing; needs `--name` and `--technology` |
 
 ### Technology Options
 

{ntc_dev_kit-1.1.0 → ntc_dev_kit-1.2.0}/ntc/__init__.py

@@ -1,5 +1,5 @@
 """NTC - Nexent Toolkit Console."""
 
-__version__ = "1.1.0"
+__version__ = "1.2.0"
 __author__ = "Nexent"
 __license__ = "MIT"

ntc_dev_kit-1.2.0/ntc/cli_enhanced.py

@@ -0,0 +1,421 @@
+import argparse
+import os
+import sys
+import time
+from colorama import Fore, Style, init
+from ntc.utils.validation import is_valid_project_name
+
+# Commands import their generators when they run, so `ntc --help` and the first question of
+# `ntc init` appear without loading every template module first.
+
+# Initialize colorama for cross-platform colored output
+init(autoreset=True)
+
+def print_banner():
+    """Display minimal welcome banner."""
+    print(f"\n{Fore.WHITE}{Style.BRIGHT}  ntc{Style.RESET_ALL} {Fore.LIGHTBLACK_EX}— project scaffolding tool{Style.RESET_ALL}")
+    print()
+
+def print_success(message):
+    """Print success message with green color and checkmark."""
+    print(f"{Fore.GREEN}✅ {message}{Style.RESET_ALL}")
+
+def print_error(message):
+    """Print error message with red color and X mark."""
+    print(f"{Fore.RED}❌ {message}{Style.RESET_ALL}")
+
+def print_warning(message):
+    """Print warning message with yellow color and warning sign."""
+    print(f"{Fore.YELLOW}⚠️  {message}{Style.RESET_ALL}")
+
+def print_info(message):
+    """Print info message with blue color and info icon."""
+    print(f"{Fore.CYAN}ℹ️  {message}{Style.RESET_ALL}")
+
+def animate_dependency_install(requirements_path=None, pip_command=None, env_type="system"):
+    """Show real dependency installation with progress animation."""
+    import subprocess
+    import threading
+    
+    if not requirements_path or not os.path.exists(requirements_path):
+        # Fallback to simulation if no requirements file
+        dependencies = [
+            "Resolving dependencies",
+            "Downloading packages", 
+            "Installing Django",
+            "Installing DRF",
+            "Installing Celery",
+            "Installing CORS headers",
+            "Configuring environment",
+            "Setting up database",
+            "Creating migrations",
+            "Finalizing setup"
+        ]
+        
+        print(f"\n{Fore.MAGENTA}📦 Installing Dependencies{Style.RESET_ALL}")
+        
+        for i, dep in enumerate(dependencies, 1):
+            progress = int((i / len(dependencies)) * 100)
+            
+            # Show animation for each dependency
+            for j in range(5):  # 5 animation cycles per dependency
+                frame = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"][j % 10]
+                # Clear line and print new content
+                print(f"\r{' ' * 80}\r{Fore.CYAN}{frame} {dep}... {Fore.YELLOW}[{progress}%]{Style.RESET_ALL}", end="", flush=True)
+                time.sleep(0.2)
+        
+        print(f"\r{' ' * 80}\r{Fore.GREEN}✅ All dependencies installed successfully! {Fore.YELLOW}[100%]{Style.RESET_ALL}")
+        print()
+        return
+    
+    # Real dependency installation with animation
+    print(f"\n{Fore.MAGENTA}📦 Installing Dependencies{Style.RESET_ALL}")
+    
+    # Determine the pip command to use
+    if pip_command is None:
+        # Default to system pip
+        pip_command = [sys.executable, "-m", "pip", "install", "-r", requirements_path]
+    
+    # Animation state
+    animation_running = True
+    install_complete = False
+    install_success = False
+    error_message = ""
+    
+    def run_pip_install():
+        nonlocal install_complete, install_success, error_message
+        try:
+            # Run pip install with suppressed output
+            result = subprocess.run(
+                pip_command,
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            install_success = True
+        except subprocess.CalledProcessError as e:
+            install_success = False
+            error_message = str(e)
+        finally:
+            install_complete = True
+    
+    # Start installation in background thread
+    install_thread = threading.Thread(target=run_pip_install)
+    install_thread.start()
+    
+    # Show animation while installation runs
+    frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+    frame_index = 0
+    
+    while not install_complete:
+        frame = frames[frame_index % len(frames)]
+        # Clear line completely before writing new content
+        env_msg = f" ({env_type} environment)" if env_type != "system" else ""
+        print(f"\r{' ' * 80}\r{Fore.CYAN}{frame} Installing packages{env_msg}...{Style.RESET_ALL}", end="", flush=True)
+        time.sleep(0.1)
+        frame_index += 1
+    
+    # Wait for thread to complete
+    install_thread.join()
+    
+    # Show final result
+    if install_success:
+        print(f"\r{' ' * 80}\r{Fore.GREEN}✅ All dependencies installed successfully!{Style.RESET_ALL}")
+    else:
+        print(f"\r{' ' * 80}\r{Fore.RED}❌ Failed to install dependencies: {error_message}{Style.RESET_ALL}")
+        print(f"{Fore.YELLOW}💡 You can manually install later with: pip install -r requirements.txt{Style.RESET_ALL}")
+    
+    print()
+
+def run_doctor():
+    """Check setup and fix common issues like PATH configuration."""
+    import shutil
+    import site
+
+    # Nexent brand palette
+    DIM = Fore.LIGHTBLACK_EX
+    ACCENT = Fore.WHITE
+    OK = Fore.GREEN
+    WARN = Fore.YELLOW
+    ERR = Fore.RED
+    BOLD = Style.BRIGHT
+    RESET = Style.RESET_ALL
+
+    def _ok(text):
+        print(f"  {OK}  {text}{RESET}")
+
+    def _err(text):
+        print(f"  {ERR}  {text}{RESET}")
+
+    def _warn(text):
+        print(f"  {WARN}  {text}{RESET}")
+
+    def _dim(text):
+        print(f"  {DIM}{text}{RESET}")
+
+    # Minimal Nexent header
+    print(f"\n{BOLD}{Fore.WHITE}  NEXENT{RESET}")
+    print(f"  {DIM}Future Awaits{RESET}")
+    print(f"  {DIM}{'─' * 50}{RESET}")
+    print(f"  {Fore.WHITE}SETUP DIAGNOSTICS{RESET}\n")
+
+    issues_found = 0
+    issues_fixed = 0
+
+    # 1. Python
+    print(f"  {Fore.WHITE}Python{RESET}")
+    py_version = sys.version_info
+    if py_version >= (3, 10):
+        _ok(f"{py_version.major}.{py_version.minor}.{py_version.micro}")
+    else:
+        _err(f"{py_version.major}.{py_version.minor} — >= 3.10 required")
+        issues_found += 1
+
+    # 2. Dependencies
+    print(f"\n  {Fore.WHITE}Dependencies{RESET}")
+    deps_ok = True
+    for mod, name in [("colorama", "colorama"), ("yaml", "pyyaml")]:
+        try:
+            __import__(mod)
+            _ok(name)
+        except ImportError:
+            _err(name)
+            deps_ok = False
+    if not deps_ok:
+        issues_found += 1
+        _dim("  Run: pip install colorama pyyaml")
+
+    # 3. Command accessibility
+    print(f"\n  {Fore.WHITE}Command{RESET}")
+    ntc_path = shutil.which("ntc")
+    if ntc_path:
+        _ok("ntc found")
+        _dim(f"  {ntc_path}")
+    else:
+        _err("ntc not in PATH")
+        issues_found += 1
+
+    # 4. Scripts directory
+    print(f"\n  {Fore.WHITE}Scripts Directory{RESET}")
+    scripts_dir = os.path.join(site.USER_BASE, "Scripts")
+    if os.path.exists(scripts_dir):
+        _ok(scripts_dir)
+    else:
+        _warn("missing — creating...")
+        os.makedirs(scripts_dir, exist_ok=True)
+        _ok("created")
+        issues_fixed += 1
+
+    # 5. PATH
+    if os.name == "nt":
+        print(f"\n  {Fore.WHITE}PATH{RESET}")
+        current_path = os.environ.get("PATH", "")
+        if scripts_dir.lower() in current_path.lower():
+            _ok("Scripts directory in PATH")
+        else:
+            _warn("Scripts directory not in PATH")
+            try:
+                import winreg
+                with winreg.OpenKey(
+                    winreg.HKEY_CURRENT_USER, "Environment", 0,
+                    winreg.KEY_READ | winreg.KEY_WRITE,
+                ) as key:
+                    existing, _ = winreg.QueryValueEx(key, "PATH")
+                    if scripts_dir.lower() not in existing.lower():
+                        new_path = f"{existing};{scripts_dir}"
+                        winreg.SetValueEx(key, "PATH", 0, winreg.REG_EXPAND_SZ, new_path)
+                        os.environ["PATH"] = new_path
+                        _ok("added to registry")
+                        issues_fixed += 1
+                    else:
+                        _ok("in registry (restart needed)")
+            except Exception as e:
+                _err(f"registry edit failed: {e}")
+                _dim(f"  Add manually: {scripts_dir}")
+                issues_found += 1
+
+    # 6. Package version
+    print(f"\n  {Fore.WHITE}Package{RESET}")
+    try:
+        import ntc
+        _ok(f"ntc-dev-kit {ntc.__version__}")
+    except (ImportError, AttributeError):
+        _err("ntc-dev-kit not installed")
+        issues_found += 1
+
+    # Summary
+    print(f"\n  {DIM}{'─' * 50}{RESET}")
+    if issues_found == 0 and issues_fixed == 0:
+        print(f"  {OK}Ready.{RESET}")
+    elif issues_fixed > 0:
+        print(f"  {OK}Fixed {issues_fixed}.{RESET}")
+        if issues_found > 0:
+            print(f"  {WARN}{issues_found} remaining.{RESET}")
+        else:
+            print(f"  {DIM}Restart terminal for changes.{RESET}")
+    else:
+        print(f"  {ERR}{issues_found} issue(s) found.{RESET}")
+        print(f"  {DIM}Run 'ntc doctor' again after fixing.{RESET}")
+    print(f"  {DIM}{'─' * 50}{RESET}\n")
+
+
+def _use_utf8_console():
+    """Print emoji and box-drawing characters on any console.
+
+    A Windows console on cp1252 (the default, and what scripts, CI and editor terminals get)
+    can't encode them: the very first print raised UnicodeEncodeError and ntc init crashed.
+    Characters the console truly can't show are replaced instead of raising."""
+    for stream in (sys.stdout, sys.stderr):
+        try:
+            stream.reconfigure(encoding='utf-8', errors='replace')
+        except (AttributeError, ValueError):
+            pass  # not a reconfigurable text stream (redirected to an object, Python < 3.7)
+
+
+def main():
+    _use_utf8_console()
+    parser = argparse.ArgumentParser(
+        description="ntc — project scaffolding tool",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  ntc init                      # New project: a few questions, defaults pre-selected
+  ntc init -t django            # Skip the "what are you building" question
+  ntc init -t django --name shop-api --with-auth --env venv --yes
+                                # No questions at all (scripts, CI, AI agents)
+  ntc init -t nextjs --name site --install --yes
+  ntc compose myproject         # Compose full-stack project with multiple components
+  ntc start                     # Start all services from ntc.yml configuration
+  ntc create app myapp          # Create new Django app
+  ntc drf init path name        # Legacy Django REST Framework initialization
+        """
+    )
+    
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+    
+    # Enhanced init command
+    init_parser = subparsers.add_parser("init", help="Interactive project initialization")
+    init_parser.add_argument('--technology', '-t', type=str, 
+                        choices=['django', 'react', 'react-admin', 'nextjs', 'flutter'],
+                        help='Technology to use (django, react, react-admin, nextjs, flutter)')
+    init_parser.add_argument("--backend", 
+                           choices=["django", "drf", "laravel"],
+                           help="Backend technology")
+    init_parser.add_argument("--frontend", 
+                           choices=["react", "react-admin", "nextjs", "flutter"],
+                           help="Frontend technology")
+    init_parser.add_argument("--name", help="Project name ('.' = the current directory's name)")
+    init_parser.add_argument("--path", help="Directory to create the project in (default: current directory)")
+    auth_group = init_parser.add_mutually_exclusive_group()
+    auth_group.add_argument("--with-auth", dest="with_auth", action="store_true", default=None,
+                            help="Django: include the authentication app (custom User model, JWT endpoints)")
+    auth_group.add_argument("--no-auth", dest="with_auth", action="store_false",
+                            help="Django: no authentication app")
+    init_parser.add_argument("--env", choices=["venv", "conda", "existing", "skip"],
+                             help="Django: Python environment - create a venv/conda env, install into the "
+                                  "active one, or skip")
+    install_group = init_parser.add_mutually_exclusive_group()
+    install_group.add_argument("--install", dest="install", action="store_true", default=None,
+                               help="Next.js/React/Flutter: install dependencies (npm install / flutter pub get)")
+    install_group.add_argument("--no-install", dest="install", action="store_false",
+                               help="Next.js/React/Flutter: don't install dependencies")
+    init_parser.add_argument("--yes", "-y", action="store_true",
+                             help="Don't ask: use the options given and defaults for the rest "
+                                  "(requires --name and --technology)")
+    
+    # Create command for apps
+    create_parser = subparsers.add_parser("create", help="Create new components")
+    create_subparsers = create_parser.add_subparsers(dest="create_type", help="Type of component to create")
+    
+    # Create app subcommand
+    app_parser = create_subparsers.add_parser("app", help="Create new Django app with NTC structure")
+    app_parser.add_argument("app_name", help="Name of the app to create")
+    url_group = app_parser.add_mutually_exclusive_group()
+    url_group.add_argument("--no-url", action="store_true",
+                           help="Don't add the app's URLs anywhere; include them yourself")
+    url_group.add_argument("--url-prefix", default=None,
+                           help="Add the app's URLs at the root urlpatterns under this prefix "
+                                "(e.g. 'api/v2/'). Default: the project's api_v1 list (/api/v1/<app>/)")
+    
+    # Legacy DRF command for backward compatibility
+    drf_parser = subparsers.add_parser("drf", help="Django REST Framework commands (legacy)")
+    drf_subparsers = drf_parser.add_subparsers(dest="drf_action")
+    drf_init_parser = drf_subparsers.add_parser("init", help="Initialize DRF project")
+    drf_init_parser.add_argument("path", help="Base path to create the project")
+    drf_init_parser.add_argument("name", help="Project name")
+    
+    # Composer command for full-stack project composition
+    composer_parser = subparsers.add_parser("compose", help="Compose a full-stack project with multiple components")
+    composer_parser.add_argument("project_name", help="Name of the project")
+    composer_parser.add_argument("--path", help="Base path to create the project (default: current directory)")
+    
+    # Start services command
+    start_parser = subparsers.add_parser("start", help="Start all services defined in ntc.yml")
+    start_parser.add_argument("--path", help="Path to project root directory (default: current directory)")
+
+    # Doctor command for setup diagnostics
+    doctor_parser = subparsers.add_parser("doctor", help="Check setup and fix common issues")
+
+    # TUI command for interactive terminal UI
+    tui_parser = subparsers.add_parser("tui", help="Launch interactive terminal UI")
+
+    args = parser.parse_args()
+    
+    if args.command == "init":
+        technology = args.technology or args.frontend or args.backend
+        technology = {"drf": "django", "laravel": "django"}.get(technology, technology)
+        if args.yes and not (args.name and technology):
+            print_error("--yes needs --name and --technology, so there is nothing left to ask.")
+            sys.exit(2)
+        from ntc.wizard import run as run_wizard
+        created = run_wizard(technology=technology, name=args.name, path=args.path, with_auth=args.with_auth,
+                             env_choice=args.env, install=args.install, assume_yes=args.yes)
+        sys.exit(0 if created else 1)
+    elif args.command == "create" and args.create_type == "app":
+        if not is_valid_project_name(args.app_name):
+            print_error("App name may only contain letters, numbers, underscores, and hyphens!")
+            sys.exit(1)
+        from ntc.app_creator import create_app_structure
+        create_app_structure(args.app_name, add_urls=not args.no_url, url_prefix=args.url_prefix)
+    elif args.command == "drf" and args.drf_action == "init":
+        # Legacy support
+        if not is_valid_project_name(args.name):
+            print_error("Project name may only contain letters, numbers, underscores, and hyphens!")
+            sys.exit(1)
+        from ntc.templates.drf_structure.main import init_drf_project
+        init_drf_project(args.path, args.name)
+    elif args.command == "compose":
+        # Composer for full-stack project composition
+        if not is_valid_project_name(args.project_name):
+            print_error("Project name may only contain letters, numbers, underscores, and hyphens!")
+            sys.exit(1)
+        from ntc.composer.main import compose_project
+        if args.path:
+            compose_project(args.project_name, args.path)
+        else:
+            compose_project(args.project_name)
+    elif args.command == "start":
+        # Start services from ntc.yml configuration
+        from ntc.composer.main import start_services
+        if args.path:
+            start_services(args.path)
+        else:
+            start_services()
+    elif args.command == "doctor":
+        run_doctor()
+    elif args.command == "tui":
+        from ntc.ui.app import run_tui
+        run_tui()
+    else:
+        # Show help if no command provided
+        print_banner()
+        print(f"\n  {Fore.LIGHTBLACK_EX}Quick Start:{Style.RESET_ALL}")
+        print(f"  {Fore.WHITE}ntc tui{Style.RESET_ALL}               {Fore.LIGHTBLACK_EX}interactive terminal UI{Style.RESET_ALL}")
+        print(f"  {Fore.WHITE}ntc init{Style.RESET_ALL}              {Fore.LIGHTBLACK_EX}interactive setup{Style.RESET_ALL}")
+        print(f"  {Fore.WHITE}ntc init -t django{Style.RESET_ALL}    {Fore.LIGHTBLACK_EX}Django project{Style.RESET_ALL}")
+        print(f"  {Fore.WHITE}ntc doctor{Style.RESET_ALL}            {Fore.LIGHTBLACK_EX}check setup{Style.RESET_ALL}")
+        print()
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()

{ntc_dev_kit-1.1.0 → ntc_dev_kit-1.2.0}/ntc/main.py

@@ -37,8 +37,8 @@ modules_to_register = [
     ("ntc.templates.flutter", os.path.join(this_dir, "templates", "flutter", "__init__.py")),
     ("ntc.templates.flutter.main", os.path.join(this_dir, "templates", "flutter", "main.py")),
     ("ntc.templates.auth_app", os.path.join(this_dir, "templates", "auth_app", "__init__.py")),
-    ("ntc.ui", os.path.join(this_dir, "ui", "__init__.py")),
-    ("ntc.ui.app", os.path.join(this_dir, "ui", "app.py")),
+    # Not ntc.ui / ntc.ui.app: they import textual (most of a second), and `ntc tui` imports
+    # them itself when it runs.
 ]
 
 for modname, file_path in modules_to_register:

ntc_dev_kit-1.2.0/ntc/templates/auth_app/migrations/0001_initial.py

@@ -0,0 +1,50 @@
+# Generated by Django 5.2.7 on 2026-10-20 14:53
+
+import django.contrib.auth.models
+import django.contrib.auth.validators
+import django.utils.timezone
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ('auth', '0012_alter_user_first_name_max_length'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='User',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('password', models.CharField(max_length=128, verbose_name='password')),
+                ('last_login', models.DateTimeField(blank=True, null=True, verbose_name='last login')),
+                ('is_superuser', models.BooleanField(default=False, help_text='Designates that this user has all permissions without explicitly assigning them.', verbose_name='superuser status')),
+                ('username', models.CharField(error_messages={'unique': 'A user with that username already exists.'}, help_text='Required. 150 characters or fewer. Letters, digits and @/./+/-/_ only.', max_length=150, unique=True, validators=[django.contrib.auth.validators.UnicodeUsernameValidator()], verbose_name='username')),
+                ('is_staff', models.BooleanField(default=False, help_text='Designates whether the user can log into this admin site.', verbose_name='staff status')),
+                ('is_active', models.BooleanField(default=True, help_text='Designates whether this user should be treated as active. Unselect this instead of deleting accounts.', verbose_name='active')),
+                ('date_joined', models.DateTimeField(default=django.utils.timezone.now, verbose_name='date joined')),
+                ('email', models.EmailField(max_length=254, unique=True)),
+                ('first_name', models.CharField(blank=True, max_length=30)),
+                ('last_name', models.CharField(blank=True, max_length=30)),
+                ('phone_number', models.CharField(blank=True, max_length=15)),
+                ('date_of_birth', models.DateField(blank=True, null=True)),
+                ('profile_picture', models.ImageField(blank=True, null=True, upload_to='profile_pics/')),
+                ('is_verified', models.BooleanField(default=False)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('groups', models.ManyToManyField(blank=True, help_text='The groups this user belongs to. A user will get all permissions granted to each of their groups.', related_name='user_set', related_query_name='user', to='auth.group', verbose_name='groups')),
+                ('user_permissions', models.ManyToManyField(blank=True, help_text='Specific permissions for this user.', related_name='user_set', related_query_name='user', to='auth.permission', verbose_name='user permissions')),
+            ],
+            options={
+                'verbose_name': 'User',
+                'verbose_name_plural': 'Users',
+                'db_table': 'auth_user',
+            },
+            managers=[
+                ('objects', django.contrib.auth.models.UserManager()),
+            ],
+        ),
+    ]

{ntc_dev_kit-1.1.0 → ntc_dev_kit-1.2.0}/ntc/templates/drf_structure/main.py

@@ -8,8 +8,13 @@ import platform
 from colorama import Fore, Style
 from ntc.utils.output import print_success, print_error, print_warning, print_info, print_progress, print_package, print_download
 
-def sanitize_project_name(name):
-    """Sanitize project name by removing TLD and replacing dots with underscores."""
+def sanitize_project_name(name, quiet=False):
+    """Sanitize project name by removing TLD and replacing dots with underscores.
+    quiet: don't print what changed (the setup wizard shows the resulting folder instead)."""
+    if quiet:
+        from ntc.utils import output
+        with output.silenced():
+            return sanitize_project_name(name)
     # Common TLDs to remove
     tlds = ['.com', '.org', '.net', '.io', '.co', '.app', '.dev', '.tech', '.ai', '.ly', '.me', '.tv', '.co.tz', '.tz', '.or.tz']
     
@@ -90,15 +95,6 @@ def activate_env(env_type, env_dir):
     print_success("Virtual environment created and dependencies installed!")
     print_info(f"To activate your environment, run: {activate_cmd}")
     
-    # Optionally open a new terminal (non-blocking) for user convenience
-    try:
-        if platform.system() == "Windows":
-            # No shell=True: passing args as a list lets Python quote each
-            # argument correctly instead of interpolating into a shell string.
-            subprocess.Popen(["cmd", "/c", "start", "cmd", "/k", activate_cmd])
-            print_info("A new terminal window has been opened with the environment activated.")
-    except Exception:
-        pass
 
 def create_virtual_env(env_type, project_root):
     """
@@ -241,9 +237,10 @@ def install_requirements(env_type, env_dir, project_root):
             print("❌ Python not found in PATH. Cannot create venv.")
             sys.exit(1)
 
-        print("📦 Creating virtual environment using venv...")
-        subprocess.run([sys.executable, "-m", "venv", env_dir], check=True)
-        print(f"✅ Virtual environment created at: {env_dir}")
+        # create_virtual_env() has normally made it already; making it again cost a few seconds.
+        if not os.path.exists(env_dir):
+            subprocess.run([sys.executable, "-m", "venv", env_dir], check=True)
+            print(f"✅ Virtual environment created at: {env_dir}")
 
         pip_path = os.path.join(env_dir, "Scripts" if os.name == "nt" else "bin", "pip")
         
@@ -251,8 +248,8 @@ def install_requirements(env_type, env_dir, project_root):
         from ntc.cli_enhanced import animate_dependency_install
         pip_command = [pip_path, "install", "-r", requirements_path]
         animate_dependency_install(requirements_path, pip_command, "venv")
- 
-        update_requirements_versioning(env_type, project_root)
+        # requirements.txt is already pinned: a pip freeze here would replace it with every
+        # transitive package. And no extra terminal window - the command is printed instead.
         activate_env(env_type, env_dir)
         return  # Stop here after venv setup
 
@@ -260,14 +257,14 @@ def install_requirements(env_type, env_dir, project_root):
     if env_type == "conda":
         conda_executable = find_conda_executable()
         print("📦 Creating conda environment...")
-        subprocess.run([conda_executable, "create", "-p", env_dir, "python=3.12", "-y"], check=True)
+        if not os.path.exists(env_dir):  # create_virtual_env() usually made it already
+            subprocess.run([conda_executable, "create", "-p", env_dir, "python=3.12", "-y"], check=True)
         print("✅ Conda environment created successfully.")
 
         # Use animated dependency installer for conda
         from ntc.cli_enhanced import animate_dependency_install
         pip_command = [conda_executable, "run", "-p", env_dir, "pip", "install", "-r", requirements_path]
         animate_dependency_install(requirements_path, pip_command, "conda")
-        update_requirements_versioning(env_type, project_root)
         activate_env(env_type, env_dir)
 
 def get_pip_path(env_dir):
@@ -294,7 +291,10 @@ def get_pip_path(env_dir):
         print("❌ pip still not found after ensurepip.")
         return None
         
-AUTH_APP_FILES = ('apps.py', 'models.py', 'serializers.py', 'views.py', 'urls.py', 'admin.py', 'tests.py')
+# The initial migration ships with the app, so a new project's first `migrate` creates the users
+# table - no makemigrations step to know about.
+AUTH_APP_FILES = ('apps.py', 'models.py', 'serializers.py', 'views.py', 'urls.py', 'admin.py', 'tests.py',
+                  os.path.join('migrations', '0001_initial.py'))
 
 
 def _auth_variables(with_auth):