chore: Fix linting with README update

Author: CuriousLearner

README.md

@@ -565,6 +565,39 @@ pip install -e .
 pip install -r requirements.txt
 ```
 
+### 🎮 Demo Application
+
+The package includes a fully-featured demo application showcasing all anonymization features:
+
+```bash
+# Set up the demo application
+cd example_project
+pip install -r requirements.txt
+
+# Run migrations
+python manage.py migrate
+
+# Create demo data
+python manage.py create_demo_data
+
+# Start the development server
+python manage.py runserver
+
+# Access the demo at http://localhost:8000
+```
+
+#### Demo Features:
+- 📊 **Interactive Dashboard** - Visual demonstrations of all anonymization methods
+- 🔄 **Context Manager Examples** - Live examples with syntax-highlighted code
+- 📝 **Copy-Ready Code Snippets** - Click-to-copy code blocks for quick integration
+- 🎭 **Real vs Anonymized Comparison** - Side-by-side data comparison views
+- 🛡️ **Role-Based Access Demo** - Automatic anonymization based on user groups
+- 🧪 **Function Validator** - Test anonymization functions with live feedback
+
+#### Demo Users:
+- **admin/admin** - Superuser with full access to all data
+- **testuser/testpassword** - Regular user in `view_masked_data` group (sees anonymized data)
+
 ### 🧪 Running Tests
 
 ```bash

django_postgres_anon/management/commands/anon_fix_permissions.py

@@ -3,7 +3,6 @@
 """
 
 from django.core.management.base import BaseCommand
-from django.db import connection
 
 from django_postgres_anon.models import MaskedRole
 from django_postgres_anon.utils import create_masked_role
@@ -29,20 +28,14 @@ def handle(self, *args, **options):
             # Fix specific role
             role_name = options["role"]
             if self.fix_role_permissions(role_name):
-                self.stdout.write(
-                    self.style.SUCCESS(f"Successfully fixed permissions for role: {role_name}")
-                )
+                self.stdout.write(self.style.SUCCESS(f"Successfully fixed permissions for role: {role_name}"))
             else:
-                self.stdout.write(
-                    self.style.ERROR(f"Failed to fix permissions for role: {role_name}")
-                )
+                self.stdout.write(self.style.ERROR(f"Failed to fix permissions for role: {role_name}"))
         elif options["all"]:
             # Fix all known roles
             roles = MaskedRole.objects.all()
             if not roles:
-                self.stdout.write(
-                    self.style.WARNING("No roles found in database")
-                )
+                self.stdout.write(self.style.WARNING("No roles found in database"))
                 return
 
             success_count = 0
@@ -51,25 +44,17 @@ def handle(self, *args, **options):
                     success_count += 1
                     self.stdout.write(f"Fixed permissions for: {role.role_name}")
                 else:
-                    self.stdout.write(
-                        self.style.ERROR(f"Failed to fix permissions for: {role.role_name}")
-                    )
+                    self.stdout.write(self.style.ERROR(f"Failed to fix permissions for: {role.role_name}"))
 
-            self.stdout.write(
-                self.style.SUCCESS(f"Fixed permissions for {success_count}/{len(roles)} roles")
-            )
+            self.stdout.write(self.style.SUCCESS(f"Fixed permissions for {success_count}/{len(roles)} roles"))
         else:
-            self.stdout.write(
-                self.style.ERROR("Please specify --role <name> or --all")
-            )
+            self.stdout.write(self.style.ERROR("Please specify --role <name> or --all"))
 
     def fix_role_permissions(self, role_name):
         """Fix permissions for a specific role"""
         try:
             # Use the create_masked_role function which now includes permission fixing
             return create_masked_role(role_name)
         except Exception as e:
-            self.stdout.write(
-                self.style.ERROR(f"Error fixing permissions for {role_name}: {e}")
-            )
-            return False
+            self.stdout.write(self.style.ERROR(f"Error fixing permissions for {role_name}: {e}"))
+            return False

django_postgres_anon/utils.py

@@ -117,20 +117,17 @@ def create_masked_role(role_name, inherit_from=None):
             # Always ensure the role has proper permissions to django_postgres_anon tables
             # This is needed for the role to access the app's models even when switching contexts
             django_postgres_anon_tables = [
-                'django_postgres_anon_maskingrule',
-                'django_postgres_anon_maskingpreset',
-                'django_postgres_anon_maskingpreset_rules',
-                'django_postgres_anon_maskedrole',
-                'django_postgres_anon_maskinglog'
+                "django_postgres_anon_maskingrule",
+                "django_postgres_anon_maskingpreset",
+                "django_postgres_anon_maskingpreset_rules",
+                "django_postgres_anon_maskedrole",
+                "django_postgres_anon_maskinglog",
             ]
 
             for table in django_postgres_anon_tables:
                 try:
                     # Check if table exists first
-                    cursor.execute(
-                        "SELECT 1 FROM information_schema.tables WHERE table_name = %s",
-                        [table]
-                    )
+                    cursor.execute("SELECT 1 FROM information_schema.tables WHERE table_name = %s", [table])
                     if cursor.fetchone():
                         # Grant SELECT permissions on django_postgres_anon tables
                         cursor.execute(
@@ -139,7 +136,7 @@ def create_masked_role(role_name, inherit_from=None):
 
                         # For the MaskedRole table, also grant INSERT and UPDATE permissions
                         # so roles can update their own status
-                        if table == 'django_postgres_anon_maskedrole':
+                        if table == "django_postgres_anon_maskedrole":
                             try:
                                 cursor.execute(
                                     f"GRANT INSERT, UPDATE ON TABLE {connection.ops.quote_name(table)} TO {connection.ops.quote_name(role_name)}"
@@ -148,7 +145,9 @@ def create_masked_role(role_name, inherit_from=None):
                                 cursor.execute(
                                     f"GRANT USAGE ON SEQUENCE {connection.ops.quote_name(table + '_id_seq')} TO {connection.ops.quote_name(role_name)}"
                                 )
-                                logger.debug(f"Granted INSERT, UPDATE, and USAGE on sequence for {table} to {role_name}")
+                                logger.debug(
+                                    f"Granted INSERT, UPDATE, and USAGE on sequence for {table} to {role_name}"
+                                )
                             except Exception as write_error:
                                 logger.warning(f"Failed to grant write permissions on {table}: {write_error}")
 
@@ -160,7 +159,9 @@ def create_masked_role(role_name, inherit_from=None):
 
             # Grant CONNECT permission on database
             try:
-                cursor.execute(f"GRANT CONNECT ON DATABASE {connection.ops.quote_name(connection.settings_dict['NAME'])} TO {connection.ops.quote_name(role_name)}")
+                cursor.execute(
+                    f"GRANT CONNECT ON DATABASE {connection.ops.quote_name(connection.settings_dict['NAME'])} TO {connection.ops.quote_name(role_name)}"
+                )
                 logger.debug(f"Granted CONNECT on database to {role_name}")
             except Exception as db_error:
                 logger.warning(f"Failed to grant CONNECT permission: {db_error}")
@@ -373,7 +374,7 @@ def switch_to_role(role_name: str, auto_create: bool = True):
             cursor.execute(f"SET ROLE {role_name}")
 
             # For masked roles, also set the search path to prioritize mask schema
-            if 'mask' in role_name.lower():
+            if "mask" in role_name.lower():
                 cursor.execute("SET search_path = mask, public")
                 logger.debug(f"Set search_path to 'mask, public' for role {role_name}")
 

example_project/example_project/urls.py

@@ -4,7 +4,6 @@
 
 from django.contrib import admin
 from django.urls import include, path
-
 from sample_app.masking_demo_views import test_user_data
 from sample_app.views import index
 

example_project/sample_app/masking_demo_views.py

@@ -8,14 +8,13 @@ def test_user_data(request):
     """Test view to see if dynamic masking works"""
     users = User.objects.all()[:5]
 
-    user_data = []
-    for user in users:
-        user_data.append(
-            {
-                "username": user.username,
-                "email": user.email,
-            }
-        )
+    user_data = [
+        {
+            "username": user.username,
+            "email": user.email,
+        }
+        for user in users
+    ]
 
     return JsonResponse(
         {

example_project/sample_app/urls.py

@@ -9,10 +9,12 @@
 
 app_name = "sample_app"
 
+
 def redirect_to_home(request):
     """Redirect /sample/ to / to avoid duplicate pages"""
     return redirect("/", permanent=True)
 
+
 urlpatterns = [
     path("", redirect_to_home, name="index"),
     path("customers/", views.customer_list, name="customer_list"),

example_project/sample_app/views.py

@@ -273,7 +273,7 @@ def anonymization_demo(request: HttpRequest) -> HttpResponse:
                     from django_postgres_anon import get_preset_path
 
                     preset_path = get_preset_path(preset_name)
-                    preset, rules_created = MaskingPreset.load_from_yaml(preset_path, f"{preset_name}_demo")
+                    _preset, rules_created = MaskingPreset.load_from_yaml(preset_path, f"{preset_name}_demo")
                     messages.success(request, f'Loaded preset "{preset_name}" with {rules_created} rules')
                 except Exception as e:
                     messages.error(request, f"Error loading preset: {e!s}")

pyproject.toml

@@ -310,7 +310,7 @@ ignore = [
 [tool.ruff.lint.per-file-ignores]
 "tests/*" = ["E501", "F403", "F405", "S", "PLR", "ERA"]
 "*/migrations/*" = ["E501", "ERA"]
-"example_project/*" = ["E501", "F403", "F405", "ERA"]
+"example_project/*" = ["E501", "F403", "F405", "ERA", "S311"]
 "__init__.py" = ["F401"]
 "conftest.py" = ["F401", "F403"]