aipostify 1.0.1__py3-none-any.whl

aipostify/__init__.py

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+"""
+AIPostify
+Laravel-Style Python MVC Framework with PTL (Postify Template Language).
+"""
+
+__title__ = "aipostify"
+__version__ = "1.0.1"
+__author__ = "AIPostify Contributors"
+__license__ = "MIT"
+__description__ = "Laravel-Style Python MVC Starter Framework with PTL Template Engine"
+
+from framework.kernel import bootstrap, get_wsgi_application, get_asgi_application
+
+__all__ = [
+    "bootstrap",
+    "get_wsgi_application",
+    "get_asgi_application",
+    "__version__",
+    "__author__",
+    "__license__",
+]

aipostify/cli.py

@@ -0,0 +1,167 @@
+# -*- coding: utf-8 -*-
+"""
+AIPostify CLI Entry Point
+Provides global 'aipostify' and 'artisan' command-line tools.
+"""
+
+import sys
+import os
+import shutil
+from pathlib import Path
+
+
+BANNER = r"""
+   ___    ____  ___              __   _  ____       
+  /   |  /  _/ / _ \___   ___  / /_ (_)/ __/__  __
+ / /| |  / /  / ___/ _ \ (_-< / __// // _/ / / / /
+/_/ |_|_/___//_/   \___//___//_/  /_//_/    \__, / 
+                                           /____/  
+   Laravel-Style Python MVC Framework • v1.0.1
+"""
+
+
+def _find_project_root():
+    """Look up directory tree for an artisan file to identify AIPostify project root."""
+    current = Path.cwd().resolve()
+    while current != current.parent:
+        if (current / "artisan").exists() and (current / "framework").exists():
+            return current
+        current = current.parent
+    return None
+
+
+def _create_new_project(project_name: str):
+    """Scaffold a brand new AIPostify project in the specified directory."""
+    target_dir = Path.cwd() / project_name
+    if target_dir.exists() and any(target_dir.iterdir()):
+        print(f"\033[91m[Error]\033[0m Directory [{project_name}] already exists and is not empty.")
+        return 1
+
+    print(f"\033[95m{BANNER}\033[0m")
+    print(f"\033[96mCreating a new AIPostify application in:\033[0m {target_dir}\n")
+
+    # Locate package template / source directory
+    cli_dir = Path(__file__).resolve().parent
+    template_dir = cli_dir / "project_template"
+    if not template_dir.exists():
+        # Fall back to repository root during development
+        template_dir = cli_dir.parent
+
+    target_dir.mkdir(parents=True, exist_ok=True)
+
+    # 1. Copy complete project structure from template
+    if template_dir.exists():
+        shutil.copytree(
+            template_dir,
+            target_dir,
+            dirs_exist_ok=True,
+            ignore=shutil.ignore_patterns(
+                "__pycache__",
+                "*.pyc",
+                "*.sqlite",
+                "*.sqlite3",
+                "*.log",
+                ".tmp*",
+                "dist",
+                "build",
+                "*.egg-info",
+                ".pytest_cache",
+            ),
+        )
+        print("  \033[92m+\033[0m Created application core and directories (app, config, database, framework, resources, routes, storage, tools)")
+
+    # 2. Create .env from .env.example
+    env_example = target_dir / ".env.example"
+    env_file = target_dir / ".env"
+    if env_example.exists() and not env_file.exists():
+        shutil.copy2(env_example, env_file)
+        print("  \033[92m+\033[0m Generated .env configuration")
+
+    # 3. Ensure all storage subdirectories exist with .gitkeep
+    storage_dirs = [
+        "logs",
+        "app/public",
+        "framework/cache",
+        "framework/sessions",
+        "framework/views",
+    ]
+    for sub in storage_dirs:
+        sub_path = target_dir / "storage" / sub
+        sub_path.mkdir(parents=True, exist_ok=True)
+        gitkeep = sub_path / ".gitkeep"
+        if not gitkeep.exists():
+            gitkeep.touch()
+
+    print("\n\033[92m[Success] AIPostify application created successfully!\033[0m")
+    print("\n\033[93mNext Steps:\033[0m")
+    print(f"  cd {project_name}")
+    print("  python artisan key:generate")
+    print("  python artisan migrate")
+    print("  python artisan serve\n")
+    return 0
+
+
+def main():
+    """Main CLI handler for 'aipostify' command."""
+    args = sys.argv[1:]
+
+    if not args or args[0] in ["-h", "--help", "help"]:
+        print(f"\033[95m{BANNER}\033[0m")
+        print("Usage:")
+        print("  aipostify new <project_name>   Create a new AIPostify project")
+        print("  aipostify --version, -v        Display AIPostify version")
+        print("  aipostify <command>            Run artisan command in current project")
+        print("\nExamples:")
+        print("  aipostify new myapp")
+        print("  aipostify serve")
+        print("  aipostify route:list")
+        return 0
+
+    if args[0] in ["-v", "--version", "version"]:
+        from . import __version__
+        print(f"AIPostify Framework v{__version__}")
+        return 0
+
+    if args[0] == "new":
+        if len(args) < 2:
+            print("\033[91m[Error]\033[0m Please provide a project name:")
+            print("  aipostify new <project_name>")
+            return 1
+        return _create_new_project(args[1])
+
+    # Check if we are inside an AIPostify project
+    project_root = _find_project_root()
+    if project_root:
+        artisan_path = project_root / "artisan"
+        cmd = [sys.executable, str(artisan_path)] + args
+        import subprocess
+        return subprocess.run(cmd).returncode
+    else:
+        print(f"\033[91m[Error]\033[0m Could not find an AIPostify project with an 'artisan' file.")
+        print("Run \033[96maipostify new <project_name>\033[0m to create a new application.")
+        return 1
+
+
+def artisan_main():
+    """Entry point for standalone 'artisan' command."""
+    project_root = _find_project_root()
+    if not project_root:
+        # Fall back to current working directory
+        project_root = Path.cwd().resolve()
+
+    if str(project_root) not in sys.path:
+        sys.path.insert(0, str(project_root))
+
+    try:
+        from framework.kernel import bootstrap
+        bootstrap(project_root)
+        from framework.console import Artisan
+        exit_code = Artisan.handle(sys.argv[1:])
+        return exit_code or 0
+    except Exception as e:
+        print(f"\033[91m[Artisan Error]\033[0m {e}")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

aipostify/project_template/.env.example

@@ -0,0 +1,23 @@
+APP_NAME=aipostify
+APP_ENV=local
+APP_DEBUG=true
+APP_KEY=
+APP_URL=http://127.0.0.1:8000
+APP_LOCALE=en
+
+# Database Connection: sqlite | mysql
+DB_CONNECTION=sqlite
+
+# --- SQLite (default) ---
+DB_SQLITE_PATH=database/database.sqlite
+
+# --- MySQL (Set DB_CONNECTION=mysql to use) ---
+DB_HOST=127.0.0.1
+DB_PORT=3306
+DB_DATABASE=aipostify
+DB_USERNAME=root
+DB_PASSWORD=
+
+QUEUE_CONNECTION=database
+CACHE_DRIVER=file
+SESSION_DRIVER=file

aipostify/project_template/.gitattributes

@@ -0,0 +1,2 @@
+*.ptl linguist-language=HTML
+*.ptl linguist-detectable=true

aipostify/project_template/.gitignore

@@ -0,0 +1,73 @@
+# AIPostify Git Ignore
+
+# Environment & Secrets (Crucial: Never commit .env)
+.env
+.env.backup
+.env.production
+
+# Python & Bytecode
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environments
+venv/
+.venv/
+env/
+ENV/
+env.bak/
+venv.bak/
+
+# Databases (Crucial: Keep local SQLite and transfer dumps out of git)
+*.sqlite
+*.sqlite3
+*.db
+database/*.sqlite
+database/*.sqlite3
+*.sql
+storage/app/db_transfer_dump.json
+
+# Storage Logs, Sessions, and Caches
+storage/logs/*.log
+storage/framework/cache/*
+storage/framework/sessions/*
+!storage/framework/cache/.gitkeep
+!storage/framework/sessions/.gitkeep
+!storage/logs/.gitkeep
+!storage/app/public/.gitkeep
+
+# Public Storage Symlink
+public/storage
+
+# Testing & Coverage
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+.nox/
+
+# IDE & Editor specific
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+.DS_Store
+Thumbs.db

aipostify/project_template/app/__init__.py

@@ -0,0 +1 @@
+default_app_config = "app.apps.UserAppConfig"

aipostify/project_template/app/apps.py

@@ -0,0 +1,12 @@
+from django.apps import AppConfig
+from pathlib import Path
+
+class UserAppConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "app"
+    verbose_name = "Application"
+
+    def ready(self):
+        from framework.auto_discovery import discover_models
+        from django.conf import settings
+        discover_models(settings.BASE_DIR)

aipostify/project_template/app/http/controllers/__init__.py

@@ -0,0 +1,4 @@
+from .controller import Controller
+from .welcome_controller import WelcomeController
+
+__all__ = ["Controller", "WelcomeController"]

aipostify/project_template/app/http/controllers/controller.py

@@ -0,0 +1,11 @@
+"""
+Base Controller
+"""
+
+from framework.http.controller import Controller as BaseController
+
+class Controller(BaseController):
+    """
+    Base controller class from which all application controllers inherit.
+    """
+    pass

aipostify/project_template/app/http/controllers/welcome_controller.py

@@ -0,0 +1,10 @@
+"""
+Welcome Controller
+Serves default Laravel welcome landing page
+"""
+
+from app.http.controllers.controller import Controller
+
+class WelcomeController(Controller):
+    def index(self, request):
+        return self.render(request, "welcome")

aipostify/project_template/app/models/__init__.py

@@ -0,0 +1,3 @@
+from .user import User
+
+__all__ = ["User"]

aipostify/project_template/app/models/user.py

@@ -0,0 +1,22 @@
+"""
+User Model
+Default Laravel-style User Model
+"""
+
+from framework.database.model import Model
+from framework.database.fields import String, Email, DateTime
+
+class User(Model):
+    name = String(max_length=255)
+    email = Email(unique=True)
+    password = String(max_length=255)
+    email_verified_at = DateTime(null=True, blank=True)
+    remember_token = String(max_length=100, null=True, blank=True)
+    created_at = DateTime(auto_now_add=True)
+    updated_at = DateTime(auto_now=True)
+
+    class Meta:
+        db_table = "users"
+
+    def __str__(self):
+        return self.name or self.email or f"User #{self.id}"

aipostify/project_template/artisan

@@ -0,0 +1,22 @@
+#!/usr/bin/env python
+"""
+AIPostify - Laravel-style Python MVC Starter Framework CLI
+"""
+
+import os
+import sys
+from pathlib import Path
+
+# Ensure project root is in python path
+ROOT_DIR = Path(__file__).resolve().parent
+if str(ROOT_DIR) not in sys.path:
+    sys.path.insert(0, str(ROOT_DIR))
+
+from framework.kernel import bootstrap
+bootstrap(ROOT_DIR)
+
+from framework.console import Artisan
+
+if __name__ == "__main__":
+    exit_code = Artisan.handle(sys.argv[1:])
+    sys.exit(exit_code or 0)

aipostify/project_template/config/app.py

@@ -0,0 +1,11 @@
+"""
+Application Configuration
+"""
+
+import os
+
+APP_NAME = os.getenv("APP_NAME", "AIPostify")
+APP_ENV = os.getenv("APP_ENV", "local")
+APP_DEBUG = os.getenv("APP_DEBUG", "true").lower() in ("true", "1", "yes")
+APP_URL = os.getenv("APP_URL", "http://127.0.0.1:8000")
+APP_LOCALE = os.getenv("APP_LOCALE", "en")

aipostify/project_template/config/database.py

@@ -0,0 +1,21 @@
+"""
+Database Configuration
+"""
+
+import os
+
+DB_CONNECTION = os.getenv("DB_CONNECTION", "sqlite")
+
+DATABASES = {
+    "sqlite": {
+        "database": os.getenv("DB_DATABASE", "database/database.sqlite"),
+    },
+    "mysql": {
+        "host": os.getenv("DB_HOST", "127.0.0.1"),
+        "port": int(os.getenv("DB_PORT", "3306")),
+        "database": os.getenv("DB_DATABASE", "aipostify"),
+        "username": os.getenv("DB_USERNAME", "root"),
+        "password": os.getenv("DB_PASSWORD", ""),
+        "charset": "utf8mb4",
+    },
+}

aipostify/project_template/config/mail.py

@@ -0,0 +1,14 @@
+"""
+Mail Configuration
+"""
+
+import os
+
+MAIL_MAILER = os.getenv("MAIL_MAILER", "smtp")
+MAIL_HOST = os.getenv("MAIL_HOST", "127.0.0.1")
+MAIL_PORT = int(os.getenv("MAIL_PORT", "1025"))
+MAIL_USERNAME = os.getenv("MAIL_USERNAME", "")
+MAIL_PASSWORD = os.getenv("MAIL_PASSWORD", "")
+MAIL_ENCRYPTION = os.getenv("MAIL_ENCRYPTION", "tls")
+MAIL_FROM_ADDRESS = os.getenv("MAIL_FROM_ADDRESS", "hello@aipostify.test")
+MAIL_FROM_NAME = os.getenv("APP_NAME", "AIPostify")

aipostify/project_template/config/queue.py

@@ -0,0 +1,7 @@
+"""
+Queue & Jobs Configuration
+"""
+
+import os
+
+QUEUE_CONNECTION = os.getenv("QUEUE_CONNECTION", "database")

aipostify/project_template/database/migrations/0001_initial.py

@@ -0,0 +1,29 @@
+# Generated for default Laravel database schema
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = []
+
+    operations = [
+        migrations.CreateModel(
+            name='User',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=255)),
+                ('email', models.EmailField(max_length=254, unique=True)),
+                ('password', models.CharField(max_length=255)),
+                ('email_verified_at', models.DateTimeField(blank=True, null=True)),
+                ('remember_token', models.CharField(blank=True, max_length=100, null=True)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+            ],
+            options={
+                'db_table': 'users',
+            },
+        ),
+    ]

aipostify/project_template/database/migrations/__init__.py

@@ -0,0 +1 @@
+# Database Migrations

aipostify/project_template/database/seeders/database_seeder.py

@@ -0,0 +1,10 @@
+"""
+Database Seeder
+"""
+
+from framework.database.seeder import Seeder
+from database.seeders.user_seeder import UserSeeder
+
+class DatabaseSeeder(Seeder):
+    def run(self):
+        self.call(UserSeeder)

aipostify/project_template/database/seeders/user_seeder.py

@@ -0,0 +1,21 @@
+"""
+User Seeder
+"""
+
+import os
+from framework.database import Seeder
+from django.contrib.auth import get_user_model
+
+class UserSeeder(Seeder):
+    def run(self):
+        env = os.getenv("APP_ENV", "local").lower()
+        if env in ("production", "prod"):
+            print("Skipping default demo/admin user creation in production environment.")
+            return
+
+        User = get_user_model()
+        if not User.objects.filter(username="admin").exists():
+            User.objects.create_superuser("admin", "admin@aipostify.test", "admin123")
+
+        if not User.objects.filter(username="demo").exists():
+            User.objects.create_user("demo", "demo@aipostify.test", "demo123")

aipostify/project_template/framework/__init__.py

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+AIPostify Framework Core
+Laravel-Style Python MVC Framework with PTL Template Engine.
+"""
+
+from .kernel import bootstrap, get_wsgi_application, get_asgi_application
+
+__version__ = "1.0.0"
+__all__ = ["bootstrap", "get_wsgi_application", "get_asgi_application", "__version__"]

aipostify/project_template/framework/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+class FrameworkConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "framework"
+    verbose_name = "AIPostify Framework"

aipostify/project_template/framework/auto_discovery.py

@@ -0,0 +1,46 @@
+"""
+AIPostify Auto-Discovery Engine
+Discovers Models, Controllers, Commands, Seeders, and Middleware without manual registration
+"""
+
+import os
+import sys
+import importlib
+import pkgutil
+from pathlib import Path
+
+def discover_models(base_dir: Path):
+    """Import all model modules in app/models to register them with Django ORM."""
+    models_dir = base_dir / "app" / "models"
+    if not models_dir.exists():
+        return
+
+    for _, module_name, _ in pkgutil.iter_modules([str(models_dir)]):
+        if module_name.startswith("__"):
+            continue
+        try:
+            importlib.import_module(f"app.models.{module_name}")
+        except Exception as e:
+            # Silently catch or log during initial discovery
+            pass
+
+def discover_commands(base_dir: Path) -> dict:
+    """Discover user custom commands in app/console/commands."""
+    commands_dir = base_dir / "app" / "console" / "commands"
+    commands = {}
+    if not commands_dir.exists():
+        return commands
+
+    for _, module_name, _ in pkgutil.iter_modules([str(commands_dir)]):
+        if module_name.startswith("__"):
+            continue
+        try:
+            mod = importlib.import_module(f"app.console.commands.{module_name}")
+            for attr_name in dir(mod):
+                attr = getattr(mod, attr_name)
+                if isinstance(attr, type) and hasattr(attr, "signature") and attr.signature:
+                    commands[attr.signature] = attr
+        except Exception:
+            pass
+
+    return commands

aipostify/project_template/framework/console/__init__.py

@@ -0,0 +1,4 @@
+from .artisan import Artisan
+from .command import Command
+
+__all__ = ["Artisan", "Command"]