codex-django-cli 0.2.0__py3-none-any.whl

codex_django_cli/blueprints/project/core/logger.py.j2

@@ -0,0 +1,57 @@
+import logging
+from typing import TYPE_CHECKING, Union
+
+from django.conf import settings
+
+if TYPE_CHECKING:
+    from loguru import Logger
+
+# Declare logger with a Union type to satisfy mypy
+logger: Union[logging.Logger, "Logger"]
+
+try:
+    from codex_core.common.loguru_setup import setup_logging
+    from loguru import logger as loguru_logger
+
+    logger = loguru_logger
+    LOGURU_AVAILABLE = True
+except ImportError:
+    logger = logging.getLogger(__name__)
+    LOGURU_AVAILABLE = False
+
+
+class DjangoLoggingSettingsAdapter:
+    """Adapts Django settings to codex-core LoggingSettingsProtocol."""
+
+    def __init__(self) -> None:
+        self.log_level_console = getattr(settings, "LOG_LEVEL_CONSOLE", "INFO")
+        self.log_level_file = getattr(settings, "LOG_LEVEL_FILE", "DEBUG")
+        self.log_rotation = getattr(settings, "LOG_ROTATION", "10 MB")
+        self.log_dir = getattr(settings, "LOG_DIR", "logs")
+        self.debug = getattr(settings, "DEBUG", False)
+
+
+def init_logging() -> None:
+    """Initialize logging based on project settings and available libraries."""
+    if not LOGURU_AVAILABLE:
+        # Fallback to standard Django LOGGING already configured in settings
+        if isinstance(logger, logging.Logger):
+            logger.info("Loguru or codex-core not found. Using standard Django logging.")
+        return
+
+    # Use codex-core setup
+    service_name = getattr(settings, "PROJECT_NAME", "django-backend")
+    adapter = DjangoLoggingSettingsAdapter()
+
+    setup_logging(
+        settings=adapter,
+        service_name=service_name,
+        intercept_loggers=["django", "django.server", "django.db.backends"],
+        log_levels={
+            "django.db.backends": logging.WARNING,
+            "django.utils.autoreload": logging.WARNING,
+        },
+    )
+
+    if not isinstance(logger, logging.Logger):
+        logger.info(f"Loguru initialized via codex-core for {service_name}")

codex_django_cli/blueprints/project/core/redis.py.j2

@@ -0,0 +1,4 @@
+from codex_django.core.redis.managers.base import BaseDjangoRedisManager
+
+# Initialize the base manager which wraps the platform's RedisService
+redis_manager = BaseDjangoRedisManager()

codex_django_cli/blueprints/project/core/settings/__init__.py.j2

@@ -0,0 +1,4 @@
+"""
+Core project settings module.
+"""
+from .base import *  # noqa

codex_django_cli/blueprints/project/core/settings/base.py.j2

@@ -0,0 +1,67 @@
+"""
+Cloud-Native Django Settings.
+Supports layered configuration: Environment Variables > Project .env > Common .env.
+Ready for Docker Compose, Swarm, and Kubernetes.
+"""
+
+import os
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+# ═══════════════════════════════════════════
+# Paths & Project Identity
+# ═══════════════════════════════════════════
+
+# Root of Django project (where manage.py is)
+BASE_DIR = Path(__file__).resolve().parent.parent.parent
+
+# 1. Try to load Common .env (Infrastructure level)
+# Path can be overridden via ENV_COMMON_PATH for Swarm/K8s
+common_env = os.environ.get("ENV_COMMON_PATH")
+if common_env and os.path.exists(common_env):
+    load_dotenv(common_env)
+else:
+    # Fallback for local dev: look 2 levels up
+    load_dotenv(BASE_DIR.parent.parent / ".env")
+
+# 2. Try to load Project-specific .env
+# override=True ensures project settings take precedence
+project_env = os.environ.get("ENV_PROJECT_PATH")
+if project_env and os.path.exists(project_env):
+    load_dotenv(project_env, override=True)
+else:
+    # Fallback for local dev: look in current folder
+    load_dotenv(BASE_DIR / ".env", override=True)
+
+# 3. Project Identity
+# Must be set in .env or by Orchestrator. Fallback to folder name.
+PROJECT_NAME = os.environ.get("PROJECT_NAME", BASE_DIR.name)
+
+# ═══════════════════════════════════════════
+# Core Django Settings (MUST be defined early)
+# ═══════════════════════════════════════════
+ROOT_URLCONF = "{{ project_name }}.core.urls"
+WSGI_APPLICATION = "{{ project_name }}.core.wsgi.application"
+DEFAULT_AUTO_FIELD = "django.db.models.BigAutoField"
+
+# ═══════════════════════════════════════════
+# Import Modules
+# ═══════════════════════════════════════════
+
+from .modules.security import *  # noqa
+from .modules.apps import *  # noqa
+from .modules.middleware import *  # noqa
+from .modules.database import *  # noqa
+from .modules.cache import *  # noqa
+from .modules.internationalization import *  # noqa
+from .modules.static import *  # noqa
+from .modules.templates import *  # noqa
+from .modules.logging import *  # noqa
+from .modules.admin import *  # noqa
+from .modules.sitemap import *  # noqa
+from .modules.codex import *  # noqa
+
+# ═══════════════════════════════════════════
+# General Settings
+# ═══════════════════════════════════════════

codex_django_cli/blueprints/project/core/settings/dev.py.j2

@@ -0,0 +1,56 @@
+"""
+{{ project_name }} — Development Settings.
+
+Inherits from base.py. SQLite, DEBUG=True, verbose logging.
+"""
+
+from .base import *  # noqa: F403
+
+# ═══════════════════════════════════════════
+# Debug
+# ═══════════════════════════════════════════
+
+DEBUG = True
+
+# ═══════════════════════════════════════════
+# Cache — LocMemCache (no Redis needed in dev)
+# ═══════════════════════════════════════════
+
+CACHES = {
+    "default": {
+        "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
+    }
+}
+SESSION_ENGINE = "django.contrib.sessions.backends.db"
+
+# ═══════════════════════════════════════════
+# CSRF Trusted Origins
+# ═══════════════════════════════════════════
+
+CSRF_TRUSTED_ORIGINS = ["http://localhost:8080"]
+
+# ═══════════════════════════════════════════
+# Database — SQLite
+# ═══════════════════════════════════════════
+
+# SQLite is already configured in base.py as default.
+# No changes needed here unless you want to override.
+
+# ═══════════════════════════════════════════
+# Logging
+# ═══════════════════════════════════════════
+
+# In dev, we might want more verbose logging to console
+LOGGING = {
+    "version": 1,
+    "disable_existing_loggers": False,
+    "handlers": {
+        "console": {
+            "class": "logging.StreamHandler",
+        },
+    },
+    "root": {
+        "handlers": ["console"],
+        "level": "DEBUG",
+    },
+}

codex_django_cli/blueprints/project/core/settings/modules/__init__.py.j2

@@ -0,0 +1 @@
+# Settings modules package

codex_django_cli/blueprints/project/core/settings/modules/admin.py.j2

@@ -0,0 +1,72 @@
+import os
+from pathlib import Path
+
+# Root of Django project: src/backend_django
+BASE_DIR = Path(__file__).resolve().parent.parent.parent.parent
+PROJECT_NAME = os.environ.get("PROJECT_NAME", BASE_DIR.name)
+
+UNFOLD = {
+    "SITE_TITLE": os.environ.get("ADMIN_SITE_TITLE", f"{PROJECT_NAME.replace('_', ' ').title()} Admin"),
+    "SITE_HEADER": os.environ.get("ADMIN_SITE_HEADER", PROJECT_NAME.replace("_", " ").title()),
+    "SITE_SYMBOL": "dashboard",
+    "COLORS": {
+        "primary": {
+            "50": "239, 246, 255",
+            "100": "219, 234, 254",
+            "200": "191, 219, 254",
+            "300": "147, 197, 253",
+            "400": "96, 165, 250",
+            "500": "59, 130, 246",
+            "600": "37, 99, 235",
+            "700": "29, 78, 216",
+            "800": "30, 64, 175",
+            "900": "30, 58, 138",
+            "950": "23, 37, 84",
+        },
+    },
+    "SIDEBAR": {
+        "show_search": True,
+        "show_all_applications": False,
+        "navigation": [
+            {
+                "title": "Leads & Contacts",
+                "items": [
+                    {
+                        "title": "Contact Requests",
+                        "icon": "mail",
+                        "link": "/admin/main/contactrequest/",
+                    },
+                ],
+            },
+            {
+                "title": "System & Settings",
+                "items": [
+                    {
+                        "title": "Site Settings",
+                        "icon": "settings",
+                        "link": "/admin/system/sitesettings/",
+                        "permission": lambda request: request.user.is_superuser,
+                    },
+                    {
+                        "title": "Static Translations",
+                        "icon": "translate",
+                        "link": "/admin/system/statictranslation/",
+                        "permission": lambda request: request.user.is_superuser,
+                    },
+                    {
+                        "title": "SEO Pages",
+                        "icon": "search",
+                        "link": "/admin/system/staticpageseo/",
+                        "permission": lambda request: request.user.is_superuser,
+                    },
+                    {
+                        "title": "Users",
+                        "icon": "person",
+                        "link": "/admin/auth/user/",
+                        "permission": lambda request: request.user.is_superuser,
+                    },
+                ],
+            },
+        ],
+    },
+}

codex_django_cli/blueprints/project/core/settings/modules/apps.py.j2

@@ -0,0 +1,64 @@
+# ═══════════════════════════════════════════
+# Application definition
+# ═══════════════════════════════════════════
+
+DJANGO_APPS = [
+    "django.contrib.admin",
+    "django.contrib.auth",
+    "django.contrib.contenttypes",
+    "django.contrib.sessions",
+    "django.contrib.messages",
+    "django.contrib.staticfiles",
+    "django.contrib.sitemaps",
+]
+
+THIRD_PARTY_APPS = [
+    # Auth
+    "allauth",
+    "allauth.account",
+    "allauth.socialaccount",
+    "allauth.socialaccount.providers.google",
+    # Admin
+    "unfold",
+    "unfold.contrib.filters",
+    "unfold.contrib.forms",
+    "unfold.contrib.inlines",
+    "unfold.contrib.import_export",
+    "unfold.contrib.guardian",
+    "unfold.contrib.simple_history",
+    "django_prometheus",
+    "ninja",
+]
+
+{%- if enable_i18n %}
+THIRD_PARTY_APPS.insert(0, "modeltranslation")
+{%- endif %}
+
+# ═══════════════════════════════════════════
+# Codex Library Apps
+# ═══════════════════════════════════════════
+CODEX_APPS = [
+    "codex_django.cabinet",
+    "codex_django.showcase",
+]
+
+# ═══════════════════════════════════════════
+# Codex Library Settings
+# ═══════════════════════════════════════════
+CODEX_SITE_SETTINGS_MODEL = "system.SiteSettings"
+{%- if enable_i18n %}
+CODEX_STATIC_TRANSLATION_MODEL = "system.StaticTranslation"
+{%- endif %}
+CODEX_STATIC_PAGE_SEO_MODEL = "system.StaticPageSeo"
+
+LOCAL_APPS = [
+    "core",
+    "system",
+    "cabinet",
+    "features.main",
+{%- if with_booking %}
+    "booking",
+{%- endif %}
+]
+
+INSTALLED_APPS = CODEX_APPS + THIRD_PARTY_APPS + DJANGO_APPS + LOCAL_APPS

codex_django_cli/blueprints/project/core/settings/modules/cache.py.j2

@@ -0,0 +1,49 @@
+import os
+from pathlib import Path
+from urllib.parse import quote_plus
+
+# In container: /app. Locally: src/backend_django
+BASE_DIR = Path(__file__).resolve().parent.parent.parent.parent
+PROJECT_NAME = BASE_DIR.name
+
+# ═══════════════════════════════════════════
+# Redis & ARQ
+# ═══════════════════════════════════════════
+
+REDIS_HOST = os.environ.get("REDIS_HOST", "localhost")
+REDIS_PORT = int(os.environ.get("REDIS_PORT", 6379))
+REDIS_PASSWORD = os.environ.get("REDIS_PASSWORD", None)
+
+IS_INSIDE_DOCKER = os.path.exists("/.dockerenv")
+if REDIS_HOST == "localhost" and IS_INSIDE_DOCKER:
+    REDIS_HOST = "redis"
+
+if REDIS_PASSWORD:
+    clean_password = REDIS_PASSWORD.strip("'\"").strip()
+    encoded_password = quote_plus(clean_password)
+    REDIS_URL = f"redis://:{encoded_password}@{REDIS_HOST}:{REDIS_PORT}/0"
+else:
+    REDIS_URL = f"redis://{REDIS_HOST}:{REDIS_PORT}/0"
+
+# ═══════════════════════════════════════════
+# Cache & Sessions (Isolated by PROJECT_NAME)
+# ═══════════════════════════════════════════
+
+CACHES = {
+    "default": {
+        "BACKEND": "django_redis.cache.RedisCache",
+        "LOCATION": REDIS_URL,
+        "KEY_PREFIX": PROJECT_NAME,
+        "OPTIONS": {
+            "CLIENT_CLASS": "django_redis.client.DefaultClient",
+        },
+    }
+}
+
+SESSION_ENGINE = "django.contrib.sessions.backends.cache"
+SESSION_CACHE_ALIAS = "default"
+SESSION_COOKIE_NAME = f"sessionid_{PROJECT_NAME}"
+
+# --- Ratelimit ---
+RATELIMIT_USE_CACHE = "default"
+RATELIMIT_VIEW = "features.main.views.legal.ratelimit_view"

codex_django_cli/blueprints/project/core/settings/modules/codex.py.j2

@@ -0,0 +1,39 @@
+import os
+
+# ═══════════════════════════════════════════
+# Authentication & django-allauth
+# ═══════════════════════════════════════════
+
+AUTHENTICATION_BACKENDS = [
+    "django.contrib.auth.backends.ModelBackend",
+    "allauth.account.auth_backends.AuthenticationBackend",
+]
+
+ACCOUNT_LOGIN_METHODS = {"email"}
+ACCOUNT_SIGNUP_FIELDS = ["email*", "password1*", "password2*"]
+ACCOUNT_EMAIL_VERIFICATION = "optional"
+ACCOUNT_UNIQUE_EMAIL = True
+
+LOGIN_URL = "/cabinet/login/"
+LOGIN_REDIRECT_URL = "/cabinet/"
+LOGOUT_REDIRECT_URL = "/cabinet/login/"
+
+SOCIALACCOUNT_PROVIDERS = {
+    "google": {
+        "APP": {
+            "client_id": os.environ.get("GOOGLE_CLIENT_ID", ""),
+            "secret":    os.environ.get("GOOGLE_CLIENT_SECRET", ""),
+        },
+        "SCOPE": ["profile", "email"],
+        "AUTH_PARAMS": {"access_type": "online"},
+    }
+}
+
+# ═══════════════════════════════════════════
+# Client Cabinet  [codex-django add client-cabinet]
+# Uncomment after running the scaffold command
+# ═══════════════════════════════════════════
+
+# ACCOUNT_ADAPTER = "cabinet.adapters.CabinetAccountAdapter"
+# CABINET_DEFAULT_URL = "/cabinet/"
+# CABINET_CLIENT_URL  = "/cabinet/my/"

codex_django_cli/blueprints/project/core/settings/modules/database.py.j2

@@ -0,0 +1,49 @@
+import os
+from pathlib import Path
+
+import dj_database_url
+
+# Root of Django project: src/backend_django
+BASE_DIR = Path(__file__).resolve().parent.parent.parent.parent
+PROJECT_NAME = BASE_DIR.name
+
+# ═══════════════════════════════════════════
+# Database
+# ═══════════════════════════════════════════
+
+DATABASE_URL = os.environ.get("DATABASE_URL")
+DEBUG = os.environ.get("DEBUG", "False").lower() in ("true", "1", "t")
+IS_DOCKER = os.environ.get("IS_DOCKER", "False").lower() in ("true", "1", "t")
+
+if DATABASE_URL:
+    # Production (Neon or other)
+    DATABASES = {
+        "default": dj_database_url.config(
+            default=DATABASE_URL,
+            conn_max_age=600,
+            conn_health_checks=True,
+        )
+    }
+elif IS_DOCKER and DEBUG:
+    # Local Postgres in Docker Cluster (infra)
+    DATABASES = {
+        "default": {
+            "ENGINE": "django.db.backends.postgresql",
+            "NAME": os.environ.get("POSTGRES_DB", "landing_cluster"),
+            "USER": os.environ.get("POSTGRES_USER", "postgres"),
+            "PASSWORD": os.environ.get("POSTGRES_PASSWORD", "postgres"),
+            "HOST": os.environ.get("POSTGRES_HOST", "db"),
+            "PORT": os.environ.get("POSTGRES_PORT", "5432"),
+        }
+    }
+else:
+    # Fallback to SQLite for local development without Docker
+    data_dir = BASE_DIR.parent.parent / "data" / "db"
+    data_dir.mkdir(parents=True, exist_ok=True)
+
+    DATABASES = {
+        "default": {
+            "ENGINE": "django.db.backends.sqlite3",
+            "NAME": str(data_dir / f"{PROJECT_NAME}.sqlite3"),
+        }
+    }

codex_django_cli/blueprints/project/core/settings/modules/internationalization.py.j2

@@ -0,0 +1,43 @@
+import os
+from pathlib import Path
+
+from codex_django.core.i18n.discovery import discover_locale_paths
+
+# Root of Django project: src/backend_django
+BASE_DIR = Path(__file__).resolve().parent.parent.parent.parent
+
+# ═══════════════════════════════════════════
+# Internationalization
+# ═══════════════════════════════════════════
+
+LANGUAGE_CODE = os.environ.get("LANGUAGE_CODE", "{{ languages[0] }}")
+TIME_ZONE = os.environ.get("TIME_ZONE", "UTC")
+USE_I18N = {{ enable_i18n }}
+USE_TZ = True
+
+{%- if enable_i18n %}
+LANGUAGES = [
+{%- for lang in languages %}
+    {%- if lang == 'en' %}
+    ("en", "English"),
+    {%- elif lang == 'ru' %}
+    ("ru", "Russian"),
+    {%- elif lang == 'de' %}
+    ("de", "Deutsch"),
+    {%- elif lang == 'uk' %}
+    ("uk", "Ukrainian"),
+    {%- else %}
+    ("{{ lang }}", "{{ lang }}"),
+    {%- endif %}
+{%- endfor %}
+]
+
+try:
+    import modeltranslation  # noqa
+    MODELTRANSLATION_DEFAULT_LANGUAGE = LANGUAGE_CODE.split("-")[0]
+    MODELTRANSLATION_LANGUAGES = ({% for lang in languages %}"{{ lang }}"{% if not loop.last %}, {% endif %}{% endfor %})
+except ImportError:
+    pass
+
+LOCALE_PATHS = discover_locale_paths(BASE_DIR)
+{%- endif %}

codex_django_cli/blueprints/project/core/settings/modules/logging.py.j2

@@ -0,0 +1,45 @@
+import os
+from pathlib import Path
+
+# Root of Django project: src/backend_django
+BASE_DIR = Path(__file__).resolve().parent.parent.parent.parent
+
+# ═══════════════════════════════════════════
+# Logging (codex-core compatible)
+# ═══════════════════════════════════════════
+
+# Loguru / codex-core compatible fields (used in core/logger.py)
+LOG_LEVEL_CONSOLE = os.environ.get("LOG_LEVEL_CONSOLE", "INFO")
+LOG_LEVEL_FILE = os.environ.get("LOG_LEVEL_FILE", "DEBUG")
+LOG_ROTATION = os.environ.get("LOG_ROTATION", "10 MB")
+LOG_DIR = os.environ.get("LOG_DIR", str(BASE_DIR.parent.parent / "logs"))
+
+# Standard Django LOGGING (fallback if loguru is disabled/missing)
+LOGGING = {
+    "version": 1,
+    "disable_existing_loggers": False,
+    "formatters": {
+        "verbose": {
+            "format": "{levelname} {asctime} {module} {process:d} {thread:d} {message}",
+            "style": "{",
+        },
+        "simple": {
+            "format": "{levelname} {message}",
+            "style": "{",
+        },
+    },
+    "handlers": {
+        "console": {
+            "level": LOG_LEVEL_CONSOLE,
+            "class": "logging.StreamHandler",
+            "formatter": "simple",
+        },
+    },
+    "loggers": {
+        "django": {
+            "handlers": ["console"],
+            "level": "INFO",
+            "propagate": True,
+        },
+    },
+}

codex_django_cli/blueprints/project/core/settings/modules/middleware.py.j2

@@ -0,0 +1,17 @@
+# ═══════════════════════════════════════════
+# Middleware definition
+# ═══════════════════════════════════════════
+
+MIDDLEWARE = [
+    "django_prometheus.middleware.PrometheusBeforeMiddleware",
+    "django.middleware.security.SecurityMiddleware",
+    "django.contrib.sessions.middleware.SessionMiddleware",
+    "django.middleware.locale.LocaleMiddleware",
+    "django.middleware.common.CommonMiddleware",
+    "django.middleware.csrf.CsrfViewMiddleware",
+    "django.contrib.auth.middleware.AuthenticationMiddleware",
+    "django.contrib.messages.middleware.MessageMiddleware",
+    "django.middleware.clickjacking.XFrameOptionsMiddleware",
+    "django_prometheus.middleware.PrometheusAfterMiddleware",
+    "allauth.account.middleware.AccountMiddleware",
+]

codex_django_cli/blueprints/project/core/settings/modules/security.py.j2

@@ -0,0 +1,53 @@
+import os
+from urllib.parse import urlparse
+
+# ═══════════════════════════════════════════
+# Security
+# ═══════════════════════════════════════════
+
+SECRET_KEY = os.environ.get("SECRET_KEY", "django-insecure-CHANGE-ME")
+FIELD_ENCRYPTION_KEY = os.environ.get("FIELD_ENCRYPTION_KEY", "")
+
+# Main switch for the whole system
+DEBUG = os.environ.get("DEBUG", "True").lower() in ("true", "1", "yes")
+
+# --- Smart ALLOWED_HOSTS ---
+ALLOWED_HOSTS = ["localhost", "127.0.0.1", "backend"]
+
+env_hosts = os.environ.get("ALLOWED_HOSTS", "")
+if env_hosts:
+    ALLOWED_HOSTS.extend([h.strip() for h in env_hosts.split(",") if h.strip()])
+
+SITE_BASE_URL = os.environ.get("SITE_BASE_URL", "http://127.0.0.1:8000/")
+if not SITE_BASE_URL.endswith("/"):
+    SITE_BASE_URL += "/"
+
+# CSRF: include the configured site URL + common local dev ports
+CSRF_TRUSTED_ORIGINS = [SITE_BASE_URL.rstrip("/")]
+if DEBUG:
+    CSRF_TRUSTED_ORIGINS += [
+        "http://127.0.0.1:8000",
+        "http://localhost:8000",
+        "http://127.0.0.1:8080",
+        "http://localhost:8080",
+    ]
+
+# Canonical domain for SEO (no trailing slash)
+CANONICAL_DOMAIN = os.environ.get("CANONICAL_DOMAIN", "")
+if CANONICAL_DOMAIN.endswith("/"):
+    CANONICAL_DOMAIN = CANONICAL_DOMAIN[:-1]
+
+domain = urlparse(SITE_BASE_URL).netloc
+if domain:
+    clean_domain = domain.split(":")[0]
+    if clean_domain not in ALLOWED_HOSTS:
+        ALLOWED_HOSTS.append(clean_domain)
+
+    if not clean_domain.startswith("www."):
+        www_domain = f"www.{clean_domain}"
+        if www_domain not in ALLOWED_HOSTS:
+            ALLOWED_HOSTS.append(www_domain)
+
+if DEBUG:
+    # Allow local tunnels dynamically to ease development
+    ALLOWED_HOSTS.extend([".ngrok-free.app", ".ngrok-free.dev", ".ngrok.io", ".loca.lt"])

codex_django_cli/blueprints/project/core/settings/modules/sitemap.py.j2

@@ -0,0 +1,14 @@
+# ═══════════════════════════════════════════
+# Sitemap Settings
+# ═══════════════════════════════════════════
+
+# List of named URLs to include in the static sitemap
+SITEMAP_STATIC_PAGES = [
+    "home",
+    "contacts",
+    "impressum",
+    "datenschutz",
+]
+
+# Default language for x-default in sitemap
+SITEMAP_DEFAULT_LANGUAGE = "de"