ntc-dev-kit 1.0.0__py3-none-any.whl

ntc/templates/auth_app/views.py

@@ -0,0 +1,175 @@
+from rest_framework import status
+from rest_framework.decorators import api_view, permission_classes
+from rest_framework.permissions import IsAuthenticated, AllowAny
+from rest_framework.response import Response
+from rest_framework_simplejwt.tokens import RefreshToken
+from django.contrib.auth import login as django_login, logout as django_logout
+from django.contrib.auth.tokens import default_token_generator
+from django.core.mail import send_mail
+from django.conf import settings
+from .models import User
+from .serializers import (
+    UserRegistrationSerializer, UserLoginSerializer, UserProfileSerializer,
+    UpdateProfileSerializer, ChangePasswordSerializer, ResetPasswordSerializer,
+    ResetPasswordConfirmSerializer
+)
+
+
+def get_tokens_for_user(user):
+    """Generate JWT tokens for user."""
+    refresh = RefreshToken.for_user(user)
+    return {
+        'refresh': str(refresh),
+        'access': str(refresh.access_token),
+    }
+
+
+@api_view(['POST'])
+@permission_classes([AllowAny])
+def register(request):
+    """User registration endpoint."""
+    serializer = UserRegistrationSerializer(data=request.data)
+    if serializer.is_valid():
+        user = serializer.save()
+        tokens = get_tokens_for_user(user)
+        return Response({
+            'message': 'User registered successfully',
+            'user': UserProfileSerializer(user).data,
+            'tokens': tokens
+        }, status=status.HTTP_201_CREATED)
+    return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+
+@api_view(['POST'])
+@permission_classes([AllowAny])
+def login(request):
+    """User login endpoint."""
+    serializer = UserLoginSerializer(data=request.data)
+    if serializer.is_valid():
+        user = serializer.validated_data['user']
+        django_login(request, user)
+        tokens = get_tokens_for_user(user)
+        return Response({
+            'message': 'Login successful',
+            'user': UserProfileSerializer(user).data,
+            'tokens': tokens
+        }, status=status.HTTP_200_OK)
+    return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+
+@api_view(['POST'])
+@permission_classes([IsAuthenticated])
+def logout(request):
+    """User logout endpoint."""
+    try:
+        refresh_token = request.data.get('refresh_token')
+        if refresh_token:
+            token = RefreshToken(refresh_token)
+            token.blacklist()
+        django_logout(request)
+        return Response({'message': 'Logout successful'}, status=status.HTTP_200_OK)
+    except Exception as e:
+        return Response({'error': 'Invalid token'}, status=status.HTTP_400_BAD_REQUEST)
+
+
+@api_view(['POST'])
+@permission_classes([AllowAny])
+def refresh(request):
+    """Token refresh endpoint."""
+    try:
+        refresh_token = request.data.get('refresh')
+        if not refresh_token:
+            return Response({'error': 'Refresh token required'}, status=status.HTTP_400_BAD_REQUEST)
+        
+        token = RefreshToken(refresh_token)
+        return Response({
+            'access': str(token.access_token),
+        }, status=status.HTTP_200_OK)
+    except Exception as e:
+        return Response({'error': 'Invalid refresh token'}, status=status.HTTP_400_BAD_REQUEST)
+
+
+@api_view(['GET'])
+@permission_classes([IsAuthenticated])
+def me(request):
+    """Get current user profile."""
+    serializer = UserProfileSerializer(request.user)
+    return Response(serializer.data, status=status.HTTP_200_OK)
+
+
+@api_view(['PUT', 'PATCH'])
+@permission_classes([IsAuthenticated])
+def update_profile(request):
+    """Update user profile."""
+    serializer = UpdateProfileSerializer(request.user, data=request.data, partial=True)
+    if serializer.is_valid():
+        serializer.save()
+        return Response({
+            'message': 'Profile updated successfully',
+            'user': UserProfileSerializer(request.user).data
+        }, status=status.HTTP_200_OK)
+    return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+
+@api_view(['POST'])
+@permission_classes([IsAuthenticated])
+def change_password(request):
+    """Change user password."""
+    serializer = ChangePasswordSerializer(data=request.data, context={'request': request})
+    if serializer.is_valid():
+        user = request.user
+        user.set_password(serializer.validated_data['new_password'])
+        user.save()
+        return Response({'message': 'Password changed successfully'}, status=status.HTTP_200_OK)
+    return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+
+@api_view(['POST'])
+@permission_classes([AllowAny])
+def reset_password(request):
+    """Request password reset."""
+    serializer = ResetPasswordSerializer(data=request.data)
+    if serializer.is_valid():
+        email = serializer.validated_data['email']
+        try:
+            user = User.objects.get(email=email)
+            token = default_token_generator.make_token(user)
+            
+            # Send email (you'll need to configure email settings)
+            reset_url = f"{settings.FRONTEND_URL}/reset-password-confirm?token={token}&user_id={user.id}"
+            send_mail(
+                'Password Reset Request',
+                f'Click the link to reset your password: {reset_url}',
+                settings.DEFAULT_FROM_EMAIL,
+                [email],
+                fail_silently=False,
+            )
+            
+            return Response({'message': 'Password reset email sent'}, status=status.HTTP_200_OK)
+        except User.DoesNotExist:
+            # Don't reveal if email exists or not for security
+            return Response({'message': 'Password reset email sent'}, status=status.HTTP_200_OK)
+    return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+
+@api_view(['POST'])
+@permission_classes([AllowAny])
+def reset_password_confirm(request):
+    """Confirm password reset."""
+    serializer = ResetPasswordConfirmSerializer(data=request.data)
+    if serializer.is_valid():
+        token = serializer.validated_data['token']
+        new_password = serializer.validated_data['new_password']
+        user_id = request.data.get('user_id')
+        
+        try:
+            user = User.objects.get(id=user_id)
+            if default_token_generator.check_token(user, token):
+                user.set_password(new_password)
+                user.save()
+                return Response({'message': 'Password reset successful'}, status=status.HTTP_200_OK)
+            else:
+                return Response({'error': 'Invalid or expired token'}, status=status.HTTP_400_BAD_REQUEST)
+        except User.DoesNotExist:
+            return Response({'error': 'Invalid user'}, status=status.HTTP_400_BAD_REQUEST)
+    return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

ntc/templates/drf_structure/__init__.py

@@ -0,0 +1 @@
+from .main import init_drf_project, init_drf_project_in_current_dir

ntc/templates/drf_structure/drf_structure.md

@@ -0,0 +1,83 @@
+Project/
+├── .env
+├── .gitignore
+├── manage.py
+├── requirements.txt
+├── docker-compose.yml
+├── Dockerfile.
+├── captain-definition.
+├── README.md
+├── {project_name}/
+│   ├── __init__.py
+│   ├── asgi.py
+│   ├── wsgi.py
+│   ├── schema.py
+│   ├── urls.py
+│   ├── celery.py
+│   ├── settings/
+│   │   ├── __init__.py
+│   │   ├── base.py
+│   │   ├── dev.py
+│   │   └── prod.py
+├── apps/
+│   ├── common/
+│   │   ├── models.py
+│   │   ├── serializers/
+│   │   ├── services/
+│   │   ├── tests/
+│   ├── app/
+│   │   ├── __init__.py
+│   │   ├── permissions/
+│   │   ├── serializers/
+│   │   ├── selectors/
+│   │   ├── services/
+│   │   ├── socket/
+│   │   ├── tasks/
+│   │   ├── tests/
+│   │   ├── admin.py
+│   │   ├── apps.py
+│   │   ├── models.py
+│   │   ├── urls.py
+│   │   └── views.py
+│   └── app2/
+│       ├── __init__.py
+│       ├── permissions/
+│       ├── serializers/
+│       ├── selectors/
+│       ├── services/
+│       ├── socket/
+│       ├── tasks/
+│       ├── tests/
+│       ├── admin.py
+│       ├── apps.py
+│       ├── models.py
+│       ├── urls.py
+│       └── views.py
+├── core/
+│   ├── __init__.py
+│   ├── pagination.py
+│   ├── base_model.py
+│   ├── response_wrapper.py
+│   ├── permissions/
+│   ├── exceptions/
+│   ├── signals/
+│   ├── utils/
+│   ├── middlewares/
+│   ├── services/
+│   │   ├── __init__.py
+│   │   ├── azure/
+│   │   │   ├── __init__.py
+│   │   │   ├── email/
+│   │   │   ├── sms/
+│   │   │   ├── storage/
+│   │   │   ├── test.py
+│   │   ├── aws/
+│   │   │   ├── __init__.py
+│   │   │   ├── email/
+│   │   │   ├── sms/
+│   │   │   ├── storage/
+│   │   │   ├── test.py
+│   ├── logging/
+│   │   ├── __init__.py
+│   │   ├── formatter.py
+│   │   ├── logger.py

ntc/templates/drf_structure/main.py

@@ -0,0 +1,389 @@
+import os
+import subprocess
+import sys
+import json
+import secrets
+import shutil
+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."""
+    # Common TLDs to remove
+    tlds = ['.com', '.org', '.net', '.io', '.co', '.app', '.dev', '.tech', '.ai', '.ly', '.me', '.tv', '.co.tz', '.tz', '.or.tz']
+    
+    # Remove TLD if present
+    original_name = name
+    for tld in tlds:
+        if name.lower().endswith(tld):
+            name = name[:-len(tld)]
+            print_info(f"Removed TLD '{tld}' from project name: '{original_name}' -> '{name}'")
+            break
+    
+    # Replace dots with underscores
+    if '.' in name:
+        name = name.replace('.', '_')
+        print_info(f"Replaced dots with underscores in project name: '{name}'")
+    
+    # Remove any other invalid characters and ensure it starts with a letter
+    import re
+    sanitized = re.sub(r'[^a-zA-Z0-9_]', '_', name)
+    if sanitized and sanitized[0].isdigit():
+        sanitized = 'project_' + sanitized
+        
+    if sanitized != name:
+        print_info(f"Sanitized project name: '{name}' -> '{sanitized}'")
+        
+    return sanitized.lower()
+
+def replace_variables(content, variables):
+    """Replace placeholders with actual variables."""
+    for key, value in variables.items():
+        content = content.replace(f"{{{key}}}", value)
+    return content
+
+def get_template_content(template_name, variables):
+    """Load template content and replace variables."""
+    # Remove 'drf_structure/' prefix if present since we're already in that directory
+    if template_name.startswith("drf_structure/"):
+        template_name = template_name[len("drf_structure/"):]
+    
+    template_path = os.path.join(os.path.dirname(__file__), template_name)
+    if not os.path.exists(template_path):
+        return ""
+    with open(template_path, "r", encoding="utf-8") as f:
+        content = f.read()
+    return replace_variables(content, variables)
+
+def create_from_json(base_path, structure, variables):
+    """Recursively create directories and files from JSON."""
+    for name, content in structure.items():
+        name = replace_variables(name, variables)
+        full_path = os.path.join(base_path, name)
+
+        if isinstance(content, dict):
+            if "template" in content:
+                os.makedirs(os.path.dirname(full_path), exist_ok=True)
+                with open(full_path, "w", encoding="utf-8") as f:
+                    f.write(get_template_content(content["template"], variables))
+            else:
+                os.makedirs(full_path, exist_ok=True)
+                create_from_json(full_path, content, variables)
+        else:
+            os.makedirs(os.path.dirname(full_path), exist_ok=True)
+            with open(full_path, "w", encoding="utf-8") as f:
+                f.write(replace_variables(content or "", variables))
+
+def activate_env(env_type, env_dir):
+    """
+    Print activation instructions and optionally open a non-blocking new terminal.
+    """
+    if env_type == "venv":
+        if os.name == "nt":
+            activate_cmd = f"{env_dir}\\Scripts\\activate"
+        else:
+            activate_cmd = f"source {env_dir}/bin/activate"
+    else:
+        activate_cmd = f"conda activate {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":
+            subprocess.Popen(["start", "cmd", "/k", activate_cmd], shell=True)
+            print_info("A new terminal window has been opened with the environment activated.")
+    except Exception:
+        pass
+
+def create_virtual_env(env_type, project_root):
+    """
+    Creates a virtual environment using venv (default) or conda.
+    Skips creation if the environment already exists.
+    Returns the path to the environment.
+    """
+    env_dir = os.path.join(project_root, "env")
+
+    if os.path.exists(env_dir):
+        print_info(f"Virtual environment already exists at: {env_dir}. Skipping creation.")
+        return env_dir
+
+    if env_type == "venv":
+        print_package("Creating virtual environment using venv...")
+        try:
+            subprocess.run([sys.executable, "-m", "venv", env_dir], check=True)
+            print_success(f"Virtual environment created at: {env_dir}")
+        except subprocess.CalledProcessError as e:
+            print_error(f"Failed to create venv: {e}")
+            sys.exit(1)
+    elif env_type == "conda":
+        conda_executable = find_conda_executable()
+        if conda_executable is None:
+            print_error("Conda not found. Falling back to venv.")
+            subprocess.run([sys.executable, "-m", "venv", env_dir], check=True)
+            print_success(f"Virtual environment created at: {env_dir}")
+        else:
+            print_package("Creating conda environment...")
+            try:
+                subprocess.run([conda_executable, "create", "-p", env_dir, "python=3.12", "-y"], check=True)
+                print_success(f"Conda environment created at: {env_dir}")
+            except subprocess.CalledProcessError as e:
+                print_error(f"Failed to create conda env: {e}")
+                sys.exit(1)
+    else:
+        print_warning(f"Unknown environment type '{env_type}'. Using venv by default.")
+        try:
+            subprocess.run([sys.executable, "-m", "venv", env_dir], check=True)
+        except subprocess.CalledProcessError as e:
+            print_error(f"Failed to create venv: {e}")
+            sys.exit(1)
+
+    return env_dir
+
+def update_requirements_versioning(env_type, project_root):
+    """
+    Updates requirements.txt after installing dependencies with exact installed versions.
+    Works for both venv and conda.
+    """
+    # Determine pip path
+    if env_type == "venv":
+        pip_path = os.path.join(project_root, "env", "Scripts", "pip") if os.name == "nt" else os.path.join(project_root, "env", "bin", "pip")
+    elif env_type == "conda":
+        pip_path = "pip"  # Will run inside conda environment later
+    else:
+        print(f"⚠️ Unknown env type {env_type}. Skipping requirements update.")
+        return
+
+    # Check if pip exists (only for venv)
+    if env_type == "venv" and not os.path.exists(pip_path):
+        print("⚠️ pip not found in the environment. Trying to install it...")
+        try:
+            subprocess.run([sys.executable, "-m", "ensurepip", "--upgrade"], check=True)
+        except subprocess.CalledProcessError as e:
+            print(f"❌ Could not install pip: {e}")
+            return
+
+    print("📦 Freezing installed packages to requirements.txt...")
+
+    try:
+        if env_type == "venv":
+            result = subprocess.run(
+                [pip_path, "freeze"],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                check=True
+            )
+        else:  # conda
+            # Run pip freeze inside conda env
+            conda_executable = find_conda_executable()
+            env_dir = os.path.join(project_root, "env")
+            result = subprocess.run(
+                [conda_executable, "run", "-p", env_dir, "pip", "freeze"],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                check=True
+            )
+
+        requirements_txt = os.path.join(project_root, "requirements.txt")
+        with open(requirements_txt, "w", encoding="utf-8") as f:
+            f.write(result.stdout)
+
+        print(f"✅ requirements.txt updated with installed package versions at: {requirements_txt}")
+
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Error freezing packages: {e.stderr}")
+
+def find_conda_executable():
+    """Find conda executable on the system."""
+    # Common conda locations on Windows
+    conda_paths = [
+        "conda",
+        "conda.exe",
+        os.path.expanduser("~/anaconda3/Scripts/conda.exe"),
+        os.path.expanduser("~/miniconda3/Scripts/conda.exe"),
+        os.path.expanduser("~/AppData/Local/anaconda3/Scripts/conda.exe"),
+        os.path.expanduser("~/AppData/Local/miniconda3/Scripts/conda.exe"),
+        "C:/ProgramData/Anaconda3/Scripts/conda.exe",
+        "C:/ProgramData/Miniconda3/Scripts/conda.exe",
+    ]
+    
+    for conda_path in conda_paths:
+        if shutil.which(conda_path):
+            return conda_path
+        elif os.path.exists(conda_path):
+            return conda_path
+    
+    return None
+
+def install_requirements(env_type, env_dir, project_root):
+    requirements_path = os.path.join(project_root, "requirements.txt")
+
+    # === Handle conda availability ===
+    if env_type == "conda":
+        conda_executable = find_conda_executable()
+        if conda_executable is None:
+            print_error("❌ Conda not found in common locations.")
+            print_info("Please ensure conda is installed and accessible.")
+            print_info("Falling back to venv...")
+            env_type = "venv"
+        else:
+            print_info(f"Found conda at: {conda_executable}")
+
+    # === VENV setup ===
+    if env_type == "venv":
+        if not shutil.which("python"):
+            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}")
+
+        pip_path = os.path.join(env_dir, "Scripts" if os.name == "nt" else "bin", "pip")
+        
+        # Use animated dependency installer for venv
+        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)
+        activate_env(env_type, env_dir)
+        return  # Stop here after venv setup
+
+    # === CONDA setup ===
+    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)
+        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):
+    # Check standard locations for pip inside the venv
+    if os.name == "nt":
+        pip_path = os.path.join(env_dir, "Scripts", "pip.exe")
+        python_path = os.path.join(env_dir, "Scripts", "python.exe")
+    else:
+        pip_path = os.path.join(env_dir, "bin", "pip")
+        python_path = os.path.join(env_dir, "bin", "python")
+    
+    # If pip doesn't exist, bootstrap it using ensurepip
+    if not os.path.exists(pip_path):
+        print("⚠️ pip not found in the environment. Bootstrapping pip...")
+        try:
+            subprocess.run([python_path, "-m", "ensurepip", "--upgrade"], check=True)
+        except subprocess.CalledProcessError as e:
+            print(f"❌ Failed to install pip: {e}")
+            return None
+
+    if os.path.exists(pip_path):
+        return pip_path
+    else:
+        print("❌ pip still not found after ensurepip.")
+        return None
+        
+def init_drf_project(base_path, project_name):
+    """Initialize DRF project structure and setup environment."""
+    # Sanitize project name
+    original_name = project_name
+    project_name = sanitize_project_name(project_name)
+    
+    structure_file = os.path.join(os.path.dirname(__file__), "structure.json")
+
+    if not os.path.exists(structure_file):
+        print_error(f"Structure file not found: {structure_file}")
+        return
+
+    with open(structure_file, "r", encoding="utf-8") as f:
+        structure = json.load(f)
+
+    project_root = os.path.join(base_path, project_name)
+    os.makedirs(project_root, exist_ok=True)
+
+    variables = {
+        "project_name": project_name,
+        "original_name": original_name,
+        "secret_key": secrets.token_urlsafe(50),
+    }
+
+    # Create root-level files (outside the Django project directory)
+    root_level_keys = [".env", ".gitignore", "requirements.txt", "CLAUDE.md", "Dockerfile", "docker-compose.yml", ".knowledge", ".entry", "config", "apps", "core"]
+    for key in root_level_keys:
+        if key in structure:
+            create_from_json(project_root, {key: structure[key]}, variables)
+    
+    # Create Django project directory
+    django_project_path = os.path.join(project_root, project_name)
+    os.makedirs(django_project_path, exist_ok=True)
+    create_from_json(django_project_path, structure["{project_name}"], variables)
+    
+    print_success(f"Django DRF project '{project_name}' initialized at: {project_root}")
+
+    # Use shared environment setup
+    from ntc.utils.environment import setup_environment
+    setup_environment(project_root)
+
+def init_drf_project_in_current_dir(project_name):
+    """Initialize DRF project structure in the current directory."""
+    structure_file = os.path.join(os.path.dirname(__file__), "structure.json")
+
+    if not os.path.exists(structure_file):
+        print_error(f"Structure file not found: {structure_file}")
+        return
+
+    with open(structure_file, "r", encoding="utf-8") as f:
+        structure = json.load(f)
+
+    project_root = os.getcwd()  # Use current directory as parent
+    
+    project_name = sanitize_project_name(project_name)
+
+    variables = {
+        "project_name": project_name,
+        "secret_key": secrets.token_urlsafe(50),
+    }
+
+    # Check if current directory is empty or ask for confirmation
+    existing_files = [f for f in os.listdir(project_root) if not f.startswith('.')]
+    if existing_files:
+        print_warning(f"Current directory is not empty. Found {len(existing_files)} files/folders.")
+        print_info("Existing items: " + ", ".join(existing_files[:5]) + ("..." if len(existing_files) > 5 else ""))
+        
+        confirm = input(f"{Fore.WHITE}{Style.BRIGHT}❓ Continue anyway? (y/N): {Style.RESET_ALL}").strip().lower()
+        if confirm != 'y':
+            print_info("Project initialization cancelled.")
+            return
+
+    # Create root-level files (outside the Django project directory)
+    root_level_keys = [".env", ".gitignore", "requirements.txt", "CLAUDE.md", "Dockerfile", "docker-compose.yml", ".knowledge", ".entry", "config", "apps", "core", "manage.py"]
+    for key in root_level_keys:
+        if key in structure:
+            print_info(f"Creating root item: {key}")
+            create_from_json(project_root, {key: structure[key]}, variables)
+        else:
+            print_warning(f"Missing root item in structure: {key}")
+    
+    # Create Django project directory structure
+    django_project_path = os.path.join(project_root, project_name)
+    os.makedirs(django_project_path, exist_ok=True)
+    print_info(f"Creating Django project in: {django_project_path}")
+    if "{project_name}" in structure:
+        create_from_json(django_project_path, structure["{project_name}"], variables)
+    else:
+        print_error("Missing {project_name} key in structure!")
+    
+    print_success(f"Django DRF project '{project_name}' initialized in current directory: {project_root}")
+
+    # Use shared environment setup
+    from ntc.utils.environment import setup_environment
+    setup_environment(project_root)