Utilities and Helpers

def get_current_language():
    """
    Get the currently active language code.
    
    Returns:
        str: Current language code (e.g., 'en', 'de', 'fr')
    """

def get_default_language(site_id=None):
    """
    Get the default language for a site.
    
    Args:
        site_id (int, optional): Site ID, uses current site if None
        
    Returns:
        str: Default language code
    """

def get_language_list(site_id=None):
    """
    Get list of available language codes for site.
    
    Args:
        site_id (int, optional): Site ID, uses current site if None
        
    Returns:
        list: Available language codes
    """

def get_language_from_request(request, current_page=None):
    """
    Determine language from request context.
    
    Args:
        request (HttpRequest): Current request
        current_page (Page, optional): Current CMS page
        
    Returns:
        str: Resolved language code
    """

def force_language(new_lang):
    """
    Context manager to temporarily change active language.
    
    Args:
        new_lang (str): Language code to activate
        
    Returns:
        ContextManager: Language context manager
    """

def get_fallback_languages(language, site_id=None):
    """
    Get language fallback chain for given language.
    
    Args:
        language (str): Primary language code
        site_id (int, optional): Site ID
        
    Returns:
        list: Ordered list of fallback language codes
    """

def get_languages(site_id=None):
    """
    Get complete language configuration for site.
    
    Args:
        site_id (int, optional): Site ID
        
    Returns:
        dict: Language configuration with names and settings
    """

def get_public_languages(site_id=None):
    """
    Get only publicly visible languages.
    
    Args:
        site_id (int, optional): Site ID
        
    Returns:
        list: Public language codes
    """

def hide_untranslated(language, site_id=None):
    """
    Check if untranslated content should be hidden.
    
    Args:
        language (str): Language code
        site_id (int, optional): Site ID
        
    Returns:
        bool: Whether to hide untranslated content
    """

def get_page_from_request(request, use_path=None, clean_path=None):
    """
    Resolve CMS page from current request.
    
    Args:
        request (HttpRequest): Current request
        use_path (str, optional): Specific path to resolve
        clean_path (bool, optional): Whether to clean URL path
        
    Returns:
        Page: Resolved page or None
    """

def get_available_slug(site, path, language, suffix=None):
    """
    Generate unique page slug for given parameters.
    
    Args:
        site (Site): Target site
        path (str): Desired URL path
        language (str): Language code
        suffix (str, optional): Slug suffix
        
    Returns:
        str: Available unique slug
    """

def get_clean_username(user):
    """
    Get safely formatted username for storage.
    
    Args:
        user (User): User instance
        
    Returns:
        str: Clean username string
    """

def get_page_queryset(site=None, draft=True, published=True):
    """
    Get filtered page queryset.
    
    Args:
        site (Site, optional): Site filter
        draft (bool): Include draft pages
        published (bool): Include published pages
        
    Returns:
        QuerySet: Filtered page queryset
    """

def get_cms_setting(name):
    """
    Get CMS setting value with framework defaults.
    
    Args:
        name (str): Setting name (without CMS_ prefix)
        
    Returns:
        Any: Setting value or default
    """

def get_templates():
    """
    Get available CMS template configurations.
    
    Returns:
        list: Template configuration tuples (identifier, name)
    """

def get_cache_durations():
    """
    Get cache duration settings for CMS components.
    
    Returns:
        dict: Cache duration configuration
    """

def get_site_id(site):
    """
    Normalize site ID from various input types.
    
    Args:
        site (Site|int|str): Site object, ID, or identifier
        
    Returns:
        int: Site ID
    """

def admin_reverse(viewname, args=None, kwargs=None, current_app=None):
    """
    Generate admin URLs with proper namespace handling.
    
    Args:
        viewname (str): Admin view name
        args (tuple, optional): URL arguments
        kwargs (dict, optional): URL keyword arguments
        current_app (str, optional): Current app namespace
        
    Returns:
        str: Generated admin URL
    """

def add_url_parameters(url, *args, **params):
    """
    Add query parameters to existing URL.
    
    Args:
        url (str): Base URL
        *args: Positional parameters
        **params: Query parameters as key-value pairs
        
    Returns:
        str: URL with added parameters
    """

def levelize_path(path):
    """
    Split URL path into hierarchical components.
    
    Args:
        path (str): URL path to process
        
    Returns:
        list: Path components as hierarchy levels
    """

def urljoin(*segments):
    """
    Join URL segments with proper slash handling.
    
    Args:
        *segments: URL segments to join
        
    Returns:
        str: Joined URL with correct slashes
    """

def is_media_request(request):
    """
    Check if request is for media files.
    
    Args:
        request (HttpRequest): Request to check
        
    Returns:
        bool: Whether request targets media
    """

def static_with_version(path):
    """
    Add CMS version parameter to static file paths.
    
    Args:
        path (str): Static file path
        
    Returns:
        str: Versioned static file URL
    """

def copy_plugins_to_placeholder(plugins, placeholder, language, root_plugin=None):
    """
    Copy plugin tree to target placeholder.
    
    Args:
        plugins (QuerySet): Source plugins to copy
        placeholder (Placeholder): Target placeholder
        language (str): Language code
        root_plugin (CMSPlugin, optional): Root plugin for nesting
        
    Returns:
        list: Created plugin instances
    """

def get_bound_plugins(plugins):
    """
    Get plugin instances with their implementation classes.
    
    Args:
        plugins (QuerySet): Plugin queryset
        
    Returns:
        list: Plugin instances with bound classes
    """

def has_reached_plugin_limit(placeholder, plugin_type, language, template=None):
    """
    Check if plugin limit reached for placeholder.
    
    Args:
        placeholder (Placeholder): Target placeholder
        plugin_type (str): Plugin type identifier
        language (str): Language code
        template (str, optional): Template identifier
        
    Returns:
        bool: Whether limit is reached
    """

def get_placeholder_conf(setting, placeholder, template=None, default=None):
    """
    Get placeholder configuration setting.
    
    Args:
        setting (str): Configuration setting name
        placeholder (str): Placeholder slot name
        template (str, optional): Template identifier
        default (Any, optional): Default value
        
    Returns:
        Any: Configuration value or default
    """

def get_placeholders(template):
    """
    Extract placeholder names from template.
    
    Args:
        template (str): Template path or content
        
    Returns:
        list: Placeholder slot names found in template
    """

def validate_dependencies():
    """
    Check for required package dependencies.
    
    Raises:
        ImportError: If required packages are missing
    """

def validate_settings():
    """
    Validate Django and CMS configuration.
    
    Raises:
        ImproperlyConfigured: If settings are invalid
    """

def setup():
    """
    Run all CMS validation and setup checks.
    
    Performs dependency checking, settings validation,
    and environment preparation.
    """

def setup_cms_apps():
    """
    Configure CMS-enabled applications.
    
    Initializes app hooks and CMS integration
    for registered applications.
    """

from cms.utils import get_current_language, get_fallback_languages, force_language
from cms.utils.i18n import get_language_from_request

# Get current language context
current_lang = get_current_language()
print(f"Current language: {current_lang}")

# Get language from request
def my_view(request):
    page_language = get_language_from_request(request)
    fallbacks = get_fallback_languages(page_language)
    
    # Try to get content in preferred language, fall back if needed
    content = get_content_in_language(page_language)
    if not content:
        for fallback_lang in fallbacks:
            content = get_content_in_language(fallback_lang)
            if content:
                break
    
    return render(request, 'page.html', {'content': content})

# Temporary language switching
with force_language('de'):
    # Operations here run in German context
    german_title = get_localized_title()
    german_url = reverse('page_detail', args=[page.id])

from cms.utils.page import get_page_from_request, get_available_slug
from cms.utils.urlutils import admin_reverse, add_url_parameters

def custom_middleware(get_response):
    def middleware(request):
        # Resolve current CMS page
        current_page = get_page_from_request(request)
        request.current_page = current_page
        
        response = get_response(request)
        return response
    return middleware

# Generate unique slugs
from django.contrib.sites.models import Site

site = Site.objects.get_current()
base_slug = "my-new-page"
unique_slug = get_available_slug(site, base_slug, "en")

# Admin URL generation
edit_url = admin_reverse('cms_page_change', args=[page.id])
add_url = admin_reverse('cms_page_add')

# Add parameters to URLs
search_url = add_url_parameters(
    '/search/',
    q='django cms',
    category='documentation'
)

from cms.utils.conf import get_cms_setting, get_templates

# Get CMS settings
templates = get_cms_setting('TEMPLATES')
languages = get_cms_setting('LANGUAGES')
cache_duration = get_cms_setting('CACHE_DURATIONS')

# Template configuration
available_templates = get_templates()
for template_id, template_name in available_templates:
    print(f"Template: {template_name} ({template_id})")

# Custom settings with defaults
def get_my_cms_setting(name, default=None):
    """Get custom CMS setting with fallback."""
    try:
        return get_cms_setting(name)
    except KeyError:
        return default

# Site-specific configuration
from cms.utils import get_current_site

current_site = get_current_site()
site_languages = get_cms_setting('LANGUAGES').get(current_site.id, {})

from cms.utils.plugins import (
    copy_plugins_to_placeholder,
    get_bound_plugins,
    has_reached_plugin_limit
)

# Copy content between pages
source_page = Page.objects.get(reverse_id='template-page')
target_page = Page.objects.get(reverse_id='new-page')

source_placeholder = source_page.get_placeholders('en').get(slot='content')
target_placeholder = target_page.get_placeholders('en').get(slot='content')

# Copy all plugins
source_plugins = source_placeholder.get_plugins('en')
copied_plugins = copy_plugins_to_placeholder(
    plugins=source_plugins,
    placeholder=target_placeholder,
    language='en'
)

# Check plugin limits before adding
def add_plugin_with_limit_check(placeholder, plugin_type, language, **data):
    if has_reached_plugin_limit(placeholder, plugin_type, language):
        raise ValueError(f"Plugin limit reached for {plugin_type}")
    
    return add_plugin(placeholder, plugin_type, language, **data)

# Work with bound plugins
plugins = placeholder.get_plugins('en')
bound_plugins = get_bound_plugins(plugins)

for bound_plugin in bound_plugins:
    plugin_instance, plugin_class = bound_plugin
    print(f"Plugin: {plugin_class.name} - {plugin_instance}")

from cms.utils.setup import validate_dependencies, validate_settings, setup

# In Django app configuration
class MyAppConfig(AppConfig):
    name = 'myapp'
    
    def ready(self):
        # Validate CMS setup during app initialization
        try:
            validate_dependencies()
            validate_settings()
        except Exception as e:
            logger.error(f"CMS setup validation failed: {e}")

# Manual setup validation
def health_check():
    """Check CMS health and configuration."""
    try:
        setup()  # Run all validations
        return {'status': 'healthy', 'cms': 'configured'}
    except Exception as e:
        return {'status': 'error', 'message': str(e)}

class CMSSite:
    """
    CMS site configuration wrapper.
    
    Provides access to site-specific settings
    and language configuration.
    """

class LanguageConfig:
    """
    Language configuration object.
    
    Attributes:
        code: Language code (e.g., 'en')
        name: Display name (e.g., 'English')
        public: Whether language is publicly visible
        fallbacks: List of fallback language codes
        redirect_on_fallback: Whether to redirect to fallback
    """

class PlaceholderConfig:
    """
    Placeholder configuration object.
    
    Contains placeholder-specific settings like
    plugin limits, inheritance rules, and rendering options.
    """