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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ntc-dev-kit
-Version: 1.1.0
+Version: 1.2.1
 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.1}/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.1}/ntc/__init__.py

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

ntc_dev_kit-1.2.1/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.1}/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.1/ntc/templates/auth_app/migrations/0001_initial.py

@@ -0,0 +1,51 @@
+# Generated by Django 5.2.7 on 2026-10-20 16:26
+
+import apps.authentication.models
+import django.contrib.auth.validators
+import django.db.models.functions.text
+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')),
+                ('first_name', models.CharField(blank=True, max_length=150, verbose_name='first name')),
+                ('last_name', models.CharField(blank=True, max_length=150, verbose_name='last name')),
+                ('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)),
+                ('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',
+                'constraints': [models.UniqueConstraint(django.db.models.functions.text.Lower('email'), name='authentication_user_email_ci_unique')],
+            },
+            managers=[
+                ('objects', apps.authentication.models.UserManager()),
+            ],
+        ),
+    ]

ntc_dev_kit-1.2.1/ntc/templates/auth_app/models.py

@@ -0,0 +1,54 @@
+from django.contrib.auth.models import AbstractUser, UserManager as DjangoUserManager
+from django.db import models
+from django.db.models.functions import Lower
+
+
+def normalize_email(email):
+    """Emails are stored lowercase: A@x.com and a@x.com are the same person, and sign-in and
+    password resets look them up exactly."""
+    return (email or '').strip().lower()
+
+
+class UserManager(DjangoUserManager):
+    def _create_user(self, username, email, password, **extra_fields):
+        return super()._create_user(username, normalize_email(email), password, **extra_fields)
+
+    def get_by_natural_key(self, username):
+        # USERNAME_FIELD is the email: sign-in matches it whatever the case typed.
+        return self.get(email=normalize_email(username))
+
+
+class User(AbstractUser):
+    """Custom User model extending AbstractUser. first_name/last_name keep AbstractUser's 150 characters."""
+    email = models.EmailField(unique=True)
+    phone_number = models.CharField(max_length=15, blank=True)
+    date_of_birth = models.DateField(null=True, blank=True)
+    # Stored in R2 when it's configured (STORAGES in settings), on disk in development.
+    profile_picture = models.ImageField(upload_to='profile_pics/', null=True, blank=True)
+    is_verified = models.BooleanField(default=False)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    objects = UserManager()
+
+    USERNAME_FIELD = 'email'
+    REQUIRED_FIELDS = ['username']
+
+    class Meta:
+        verbose_name = 'User'
+        verbose_name_plural = 'Users'
+        constraints = [
+            # Belt and braces with the lowercase normalization: no two accounts differ only by case.
+            models.UniqueConstraint(Lower('email'), name='authentication_user_email_ci_unique'),
+        ]
+
+    def save(self, *args, **kwargs):
+        self.email = normalize_email(self.email)
+        super().save(*args, **kwargs)
+
+    def __str__(self):
+        return self.email
+
+    @property
+    def full_name(self) -> str:
+        return f"{self.first_name} {self.last_name}".strip()

{ntc_dev_kit-1.1.0 → ntc_dev_kit-1.2.1}/ntc/templates/auth_app/serializers.py

@@ -1,7 +1,7 @@
 from rest_framework import serializers
 from django.contrib.auth import authenticate
 from django.contrib.auth.password_validation import validate_password
-from .models import User
+from .models import User, normalize_email
 
 
 class UserRegistrationSerializer(serializers.ModelSerializer):
@@ -13,6 +13,13 @@ class UserRegistrationSerializer(serializers.ModelSerializer):
         model = User
         fields = ('email', 'username', 'password', 'password_confirm', 'first_name', 'last_name')
 
+    def validate_email(self, value):
+        # Case-insensitive, like the database constraint: A@x.com is already taken by a@x.com.
+        value = normalize_email(value)
+        if User.objects.filter(email=value).exists():
+            raise serializers.ValidationError('An account with this email already exists.')
+        return value
+
     def validate(self, attrs):
         if attrs['password'] != attrs['password_confirm']:
             raise serializers.ValidationError({'password_confirm': "Passwords don't match."})