fix(core,auth,management): fix Python 3.6 compatibility and authentication issues

- Fix walrus operator usage in conf/__init__.py and other modules
- Replace functools.cache with functools.lru_cache for Python 3.6
- Fix removesuffix/removeprefix methods for Python 3.6
- Fix subprocess.run capture_output parameter for Python 3.6
- Fix async_sessionmaker compatibility with SQLAlchemy 1.4
- Fix asynccontextmanager compatibility for Python 3.6
- Fix createsuperuser command to work with async ORM
- Fix authentication redirect issues with logout routes
- Add GET routes for logout endpoints
- Update pyproject.toml and setup.py for Python 3.6 compatibility
- Fix static file serving and template rendering
- Ensure full Python 3.6 compatibility across the framework

Author: ForceFledgling

src/cotlette/__init__.py

@@ -68,7 +68,14 @@ def include_static(self):
         internal_static_dir = os.path.join(self.cotlette_directory, "contrib", "static")
         self.mount("/admin_static", StaticFiles(directory=internal_static_dir), name="admin_static")
 
-        # Include static files specified by user in SETTINGS
-        if self.settings.STATIC_URL:
+        # Include static files from STATICFILES_DIRS
+        if hasattr(self.settings, 'STATICFILES_DIRS') and self.settings.STATICFILES_DIRS:
+            for static_dir in self.settings.STATICFILES_DIRS:
+                if os.path.exists(static_dir):
+                    self.mount("/static", StaticFiles(directory=static_dir), name="static")
+                    break  # Mount only the first existing directory
+        # Fallback to default static directory
+        elif self.settings.STATIC_URL:
             static_dir = os.path.join(self.settings.BASE_DIR, self.settings.STATIC_URL)
-            self.mount("/static", StaticFiles(directory=static_dir), name="static")
+            if os.path.exists(static_dir):
+                self.mount("/static", StaticFiles(directory=static_dir), name="static")

src/cotlette/contrib/auth/users/views.py

@@ -3,7 +3,7 @@
 # Create your views here.
 
 # --- API ROUTES (moved from api.py) ---
-from typing import Union
+from typing import Union, List
 
 from fastapi import APIRouter, Depends, HTTPException, status
 from pydantic import BaseModel
@@ -116,7 +116,7 @@ async def create_user(user: UserCreate):
 
 
 # Get all users (GET)
-@router.get("/", response_model=list[User])
+@router.get("/", response_model=List[User])
 async def get_users():
     users = await UserModel.objects.all().execute()  # type: ignore
     return [User(name=user.name, age=user.age, email=user.email) for user in users]

src/cotlette/core/database/sqlalchemy.py

@@ -234,21 +234,12 @@ async def initialize_async(self):
 
         self._async_initialized = True
 
-    @asynccontextmanager
     async def get_async_session(self) -> AsyncSession:
-        """Асинхронный контекстный менеджер для получения сессии базы данных."""
+        """Получает асинхронную сессию базы данных."""
         if not self._async_initialized:
             await self.initialize_async()
 
-        session = self.AsyncSessionLocal()
-        try:
-            yield session
-            await session.commit()
-        except Exception:
-            await session.rollback()
-            raise
-        finally:
-            await session.close()
+        return self.AsyncSessionLocal()
 
     async def execute_async(self, query: str, params: tuple = None, fetch: bool = False):
         """
@@ -262,7 +253,8 @@ async def execute_async(self, query: str, params: tuple = None, fetch: bool = Fa
         if not self._async_initialized:
             await self.initialize_async()
 
-        async with self.get_async_session() as session:
+        session = await self.get_async_session()
+        try:
             # Оборачиваем SQL запрос в text() для SQLAlchemy
             sql_text = text(query)
 
@@ -272,6 +264,8 @@ async def execute_async(self, query: str, params: tuple = None, fetch: bool = Fa
             if fetch:
                 return result.fetchall()
             return result
+        finally:
+            await session.close()
 
     async def create_table_async(self, table_name: str, columns: List[Dict[str, Any]]) -> Table:
         """
@@ -349,19 +343,25 @@ async def lastrowid_async(self):
         if not self._async_initialized:
             await self.initialize_async()
 
-        async with self.get_async_session() as session:
+        session = await self.get_async_session()
+        try:
             # Для разных баз данных нужны разные подходы
             if self.database_url.startswith('sqlite://'):
                 result = await session.execute(text("SELECT last_insert_rowid()"))
-                return result.scalar()
+                row = result.fetchone()
+                return row[0] if row else None
             elif self.database_url.startswith('postgresql://'):
                 result = await session.execute(text("SELECT lastval()"))
-                return result.scalar()
+                row = result.fetchone()
+                return row[0] if row else None
             elif self.database_url.startswith('mysql://'):
                 result = await session.execute(text("SELECT LAST_INSERT_ID()"))
-                return result.scalar()
+                row = result.fetchone()
+                return row[0] if row else None
             else:
                 return None
+        finally:
+            await session.close()
 
 def get_database_url_from_settings():
     """

src/cotlette/core/management/commands/createsuperuser.py

@@ -67,36 +67,71 @@ def handle(self, **options):
             email = self._get_email(email)
             password = self._get_password()
 
-        # Check if user already exists
-        existing_user = UserModel.objects.filter(email=email).first()
-        if existing_user:
-            raise CommandError(f"User with email '{email}' already exists.")
+        # Run async operations
+        import asyncio
+        
+        async def create_superuser_async():
+            # Check if user already exists
+            existing_user = await UserModel.objects.filter(email=email).first()
+            if existing_user:
+                raise CommandError(f"User with email '{email}' already exists.")
 
-        # Hash the password
-        try:
-            import bcrypt
-            hashed_password = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
-        except ImportError:
-            # Fallback to simple hash if bcrypt is not available
-            import hashlib
-            hashed_password = hashlib.sha256(password.encode('utf-8')).hexdigest()
+            # Hash the password
+            try:
+                import bcrypt
+                hashed_password = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
+            except ImportError:
+                # Fallback to simple hash if bcrypt is not available
+                import hashlib
+                hashed_password = hashlib.sha256(password.encode('utf-8')).hexdigest()
 
-        # Create the superuser
-        try:
-            superuser = UserModel.objects.create(
-                name=username,
-                email=email,
-                password_hash=hashed_password,
-                # Add any other required fields with default values
-                age=0,  # Default age
-                organization="Admin",  # Default organization
-                group=1,  # Default group ID (you might need to adjust this)
-            )
-            self.stdout.write(
-                f"Superuser '{username}' created successfully."
-            )
-        except Exception as e:
-            raise CommandError(f"Error creating superuser: {e}")
+            # Get or create group
+            from cotlette.core.database.models import ModelMeta
+            GroupModel = ModelMeta.get_model("GroupModel")
+            if GroupModel:
+                group = await GroupModel.objects.filter(id=1).first()
+                if not group:
+                    group = await GroupModel.objects.create(
+                        name="Admin",
+                        description="Administrator group"
+                    )
+                group_id = group.id
+            else:
+                group_id = 1
+
+            # Create the superuser using ORM
+            try:
+                # Создаем пользователя без ожидания возврата объекта
+                fields = []
+                values = []
+                for field_name, value in [
+                    ('name', username),
+                    ('email', email),
+                    ('password_hash', hashed_password),
+                    ('age', 0),
+                    ('organization', 'Admin'),
+                    ('group', group_id)
+                ]:
+                    if field_name in UserModel._fields:
+                        fields.append(f'"{field_name}"')
+                        if isinstance(value, str):
+                            values.append(f"'{value}'")
+                        else:
+                            values.append(str(value))
+                
+                insert_query = f'INSERT INTO "{UserModel.get_table_name()}" ({", ".join(fields)}) VALUES ({", ".join(values)})'
+                
+                # Выполняем запрос напрямую через базу данных
+                from cotlette.core.database.sqlalchemy import db
+                await db.execute_async(insert_query)
+                
+                self.stdout.write(f"Superuser '{username}' created successfully.")
+            except Exception as e:
+                raise CommandError(f"Error creating superuser: {e}")
+
+        # Run the async function
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(create_superuser_async())
 
     def _get_username(self, username=None):
         """Get username from user input."""

src/cotlette/core/management/commands/makemigrations.py

@@ -1,6 +1,6 @@
 from cotlette.core.management.base import BaseCommand
 from cotlette.core.database.migrations import migration_manager
-from cotlette.core.database.models_sqlalchemy import ModelMeta
+from cotlette.core.database.models import ModelMeta
 import sys