from django_rls.models import RLSModel

class MyModel(RLSModel):
    # Your fields here

    class Meta:
        rls_policies = [
            # List of policies
        ]

from django_rls.policies import BasePolicy

class CustomPolicy(BasePolicy):
    def get_sql_expression(self) -> str:
        return "your SQL expression"

from django_rls.policies import UserPolicy

UserPolicy(
    name='owner_policy',
    user_field='owner',  # Foreign key field name
    operation='ALL',
    permissive=True
)

from django_rls.policies import TenantPolicy

TenantPolicy(
    name='tenant_isolation',
    tenant_field='tenant',  # Foreign key field name
    operation='ALL',
    permissive=False  # Often restrictive for tenant isolation
)

from django_rls.policies import ModelPolicy
from django_rls.policies import RLS
from django.db.models import Q

ModelPolicy(
    name='pythonic_policy',
    filters=Q(owner=RLS.user_id()) | Q(is_public=True)
)

from django_rls.policies import CustomPolicy

CustomPolicy(
    name='complex_policy',
    expression="status = 'active' AND (is_public OR owner_id = current_setting('rls.user_id')::int)"
)

MIDDLEWARE = [
    # ... other middleware
    'django_rls.middleware.RLSContextMiddleware',
]

from django_rls.middleware import RLSContextMiddleware

class CustomRLSMiddleware(RLSContextMiddleware):
    def _get_tenant_id(self, request):
        # Custom tenant extraction logic
        return tenant_id

    def _set_rls_context(self, request):
        super()._set_rls_context(request)
        # Set additional context

from django_rls.db.functions import set_rls_context

set_rls_context('user_id', 123)
set_rls_context('tenant_id', 456)
set_rls_context('custom_var', 'value', is_local=True)

from django_rls.db.functions import get_rls_context

user_id = get_rls_context('user_id')
tenant_id = get_rls_context('tenant_id', default=None)

from django_rls.db.functions import RLSContext

with RLSContext(user_id=123, tenant_id=456):
    # Code executed with this context
    documents = Document.objects.all()
# Context automatically cleared

from django_rls.backends.postgresql import RLSDatabaseSchemaEditor

with connection.schema_editor() as schema_editor:
    schema_editor.enable_rls(Model)
    schema_editor.create_policy(Model, policy)

from django_rls.migration_operations import EnableRLS

operations = [
    EnableRLS('myapp', 'MyModel'),
]

from django_rls.migration_operations import DisableRLS

operations = [
    DisableRLS('myapp', 'MyModel'),
]

from django_rls.migration_operations import CreatePolicy
from django_rls.policies import UserPolicy

operations = [
    CreatePolicy(
        'myapp',
        'MyModel',
        UserPolicy('owner_policy', user_field='owner')
    ),
]

from django_rls.migration_operations import DropPolicy

operations = [
    DropPolicy('myapp', 'MyModel', 'policy_name'),
]

from django_rls.exceptions import PolicyError

try:
    policy = UserPolicy('invalid_policy', user_field='')
except PolicyError as e:
    print(f"Invalid policy: {e}")

from django_rls.exceptions import ConfigurationError

try:
    class BadModel(RLSModel):
        class Meta:
            rls_policies = "not_a_list"  # Should be a list
except ConfigurationError as e:
    print(f"Configuration error: {e}")

from django_rls.test import RLSTestMixin
from django.test import TestCase

class MyTest(RLSTestMixin, TestCase):
    def test_something(self):
        with self.disable_rls(Model):
            # Test with RLS disabled

        with self.as_user(user):
            # Test with specific user context

        with self.with_context(user_id=1, tenant_id=2):
            # Test with custom context

DJANGO_RLS = {
    'DEFAULT_SCHEMA_EDITOR': 'django_rls.backends.postgresql.RLSDatabaseSchemaEditor',
    'CONTEXT_PROCESSOR': 'myapp.rls.custom_context_processor', # Deprecated
    'AUTO_ENABLE_RLS': True,  # Enable RLS automatically in migrations
    'POLICY_NAMING_CONVENTION': '{model_name}_{policy_type}_policy',
}

# settings.py
RLS_CONTEXT_PROCESSORS = [
    'myapp.context.user_email_processor',
    'myapp.context.subscription_status_processor',
]

from django_rls.signals import pre_enable_rls

@receiver(pre_enable_rls)
def before_enable_rls(sender, model, **kwargs):
    print(f"About to enable RLS for {model}")

from django_rls.signals import post_enable_rls

@receiver(post_enable_rls)
def after_enable_rls(sender, model, **kwargs):
    print(f"RLS enabled for {model}")