wappa 0.1.0__py3-none-any.whl

wappa/database/adapters/mysql_adapter.py

@@ -0,0 +1,187 @@
+"""
+MySQL Database Adapter
+
+Provides MySQL-specific implementation for SQLModel/SQLAlchemy async connections
+using aiomysql as the async driver.
+"""
+
+from collections.abc import Callable
+from contextlib import asynccontextmanager
+from typing import Any, AsyncContextManager
+
+from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, create_async_engine
+from sqlalchemy.orm import sessionmaker
+from sqlmodel import SQLModel
+
+
+class MySQLAdapter:
+    """
+    MySQL adapter for SQLModel/SQLAlchemy async connections.
+
+    Uses aiomysql driver for async MySQL operations.
+    Provides connection pooling, health checks, and schema management
+    with MySQL-specific optimizations.
+    """
+
+    async def create_engine(self, connection_string: str, **kwargs: Any) -> AsyncEngine:
+        """
+        Create MySQL async engine with aiomysql driver.
+
+        Args:
+            connection_string: MySQL connection URL (mysql+aiomysql://...)
+            **kwargs: Engine configuration options
+
+        Returns:
+            Configured AsyncEngine for MySQL
+
+        Raises:
+            ValueError: If connection string is invalid
+            ConnectionError: If unable to create engine
+        """
+        # Ensure aiomysql driver is specified
+        if not connection_string.startswith("mysql+aiomysql://"):
+            # Convert standard mysql:// to aiomysql version
+            if connection_string.startswith("mysql://"):
+                connection_string = connection_string.replace(
+                    "mysql://", "mysql+aiomysql://", 1
+                )
+            else:
+                raise ValueError(
+                    "MySQL connection string must use mysql+aiomysql:// scheme"
+                )
+
+        # Default MySQL engine configuration
+        default_config = {
+            "pool_size": 20,
+            "max_overflow": 30,
+            "pool_timeout": 30,
+            "pool_recycle": 3600,
+            "pool_pre_ping": True,
+            "echo": False,
+            "connect_args": {
+                "charset": "utf8mb4",
+                "autocommit": False,
+            },
+        }
+        default_config.update(kwargs)
+
+        try:
+            engine = create_async_engine(connection_string, **default_config)
+            return engine
+        except Exception as e:
+            raise ConnectionError(f"Failed to create MySQL engine: {e}") from e
+
+    async def create_session_factory(
+        self, engine: AsyncEngine
+    ) -> Callable[[], AsyncContextManager[AsyncSession]]:
+        """
+        Create session factory for MySQL async sessions.
+
+        Args:
+            engine: MySQL AsyncEngine instance
+
+        Returns:
+            Session factory function that returns context manager
+        """
+        # Create async session maker
+        async_session_maker = sessionmaker(
+            engine,
+            class_=AsyncSession,
+            expire_on_commit=False,
+        )
+
+        @asynccontextmanager
+        async def session_factory():
+            async with async_session_maker() as session:
+                try:
+                    yield session
+                    await session.commit()
+                except Exception:
+                    await session.rollback()
+                    raise
+
+        return session_factory
+
+    async def initialize_schema(
+        self, engine: AsyncEngine, models: list[type[SQLModel]] = None
+    ) -> None:
+        """
+        Initialize MySQL schema from SQLModel definitions.
+
+        Args:
+            engine: MySQL AsyncEngine instance
+            models: List of SQLModel classes to create tables for
+
+        Raises:
+            DatabaseError: If schema creation fails
+        """
+        try:
+            async with engine.begin() as conn:
+                # Set MySQL specific settings for better compatibility
+                await conn.execute(
+                    "SET sql_mode = 'STRICT_TRANS_TABLES,NO_ZERO_DATE,NO_ZERO_IN_DATE,ERROR_FOR_DIVISION_BY_ZERO'"
+                )
+                # Create all tables from SQLModel metadata
+                await conn.run_sync(SQLModel.metadata.create_all)
+        except Exception as e:
+            raise RuntimeError(f"Failed to initialize MySQL schema: {e}") from e
+
+    async def health_check(self, engine: AsyncEngine) -> bool:
+        """
+        Perform MySQL health check.
+
+        Args:
+            engine: MySQL AsyncEngine instance
+
+        Returns:
+            True if database is healthy and responsive
+        """
+        try:
+            async with engine.begin() as conn:
+                result = await conn.execute("SELECT 1")
+                return result.scalar() == 1
+        except Exception:
+            return False
+
+    async def get_connection_info(self, engine: AsyncEngine) -> dict[str, Any]:
+        """
+        Get MySQL connection information.
+
+        Args:
+            engine: MySQL AsyncEngine instance
+
+        Returns:
+            Dictionary with MySQL connection details
+        """
+        try:
+            async with engine.begin() as conn:
+                version_result = await conn.execute("SELECT VERSION()")
+                version = version_result.scalar()
+
+                # Get character set info
+                charset_result = await conn.execute("SELECT @@character_set_database")
+                charset = charset_result.scalar()
+
+                # Get collation info
+                collation_result = await conn.execute("SELECT @@collation_database")
+                collation = collation_result.scalar()
+
+                return {
+                    "driver": "aiomysql",
+                    "database": "mysql",
+                    "version": version,
+                    "charset": charset,
+                    "collation": collation,
+                    "pool_size": engine.pool.size(),
+                    "pool_checked_in": engine.pool.checkedin(),
+                    "pool_checked_out": engine.pool.checkedout(),
+                    "pool_invalid": engine.pool.invalidated(),
+                    "healthy": True,
+                }
+        except Exception as e:
+            return {
+                "driver": "aiomysql",
+                "database": "mysql",
+                "error": str(e),
+                "healthy": False,
+            }

wappa/database/adapters/postgresql_adapter.py

@@ -0,0 +1,169 @@
+"""
+PostgreSQL Database Adapter
+
+Provides PostgreSQL-specific implementation for SQLModel/SQLAlchemy async connections
+using asyncpg as the async driver.
+"""
+
+from collections.abc import Callable
+from contextlib import asynccontextmanager
+from typing import Any, AsyncContextManager
+
+from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, create_async_engine
+from sqlalchemy.orm import sessionmaker
+from sqlmodel import SQLModel
+
+
+class PostgreSQLAdapter:
+    """
+    PostgreSQL adapter for SQLModel/SQLAlchemy async connections.
+
+    Uses asyncpg driver for optimal PostgreSQL async performance.
+    Provides connection pooling, health checks, and schema management.
+    """
+
+    async def create_engine(self, connection_string: str, **kwargs: Any) -> AsyncEngine:
+        """
+        Create PostgreSQL async engine with asyncpg driver.
+
+        Args:
+            connection_string: PostgreSQL connection URL (postgresql+asyncpg://...)
+            **kwargs: Engine configuration options
+
+        Returns:
+            Configured AsyncEngine for PostgreSQL
+
+        Raises:
+            ValueError: If connection string is invalid
+            ConnectionError: If unable to create engine
+        """
+        # Ensure asyncpg driver is specified
+        if not connection_string.startswith(
+            ("postgresql+asyncpg://", "postgres+asyncpg://")
+        ):
+            # Convert standard postgresql:// to asyncpg version
+            if connection_string.startswith(("postgresql://", "postgres://")):
+                connection_string = connection_string.replace(
+                    "postgresql://", "postgresql+asyncpg://", 1
+                ).replace("postgres://", "postgresql+asyncpg://", 1)
+            else:
+                raise ValueError(
+                    "PostgreSQL connection string must use postgresql+asyncpg:// scheme"
+                )
+
+        # Default PostgreSQL engine configuration
+        default_config = {
+            "pool_size": 20,
+            "max_overflow": 40,
+            "pool_timeout": 30,
+            "pool_recycle": 3600,
+            "pool_pre_ping": True,
+            "echo": False,
+        }
+        default_config.update(kwargs)
+
+        try:
+            engine = create_async_engine(connection_string, **default_config)
+            return engine
+        except Exception as e:
+            raise ConnectionError(f"Failed to create PostgreSQL engine: {e}") from e
+
+    async def create_session_factory(
+        self, engine: AsyncEngine
+    ) -> Callable[[], AsyncContextManager[AsyncSession]]:
+        """
+        Create session factory for PostgreSQL async sessions.
+
+        Args:
+            engine: PostgreSQL AsyncEngine instance
+
+        Returns:
+            Session factory function that returns context manager
+        """
+        # Create async session maker
+        async_session_maker = sessionmaker(
+            engine,
+            class_=AsyncSession,
+            expire_on_commit=False,
+        )
+
+        @asynccontextmanager
+        async def session_factory():
+            async with async_session_maker() as session:
+                try:
+                    yield session
+                    await session.commit()
+                except Exception:
+                    await session.rollback()
+                    raise
+
+        return session_factory
+
+    async def initialize_schema(
+        self, engine: AsyncEngine, models: list[type[SQLModel]] = None
+    ) -> None:
+        """
+        Initialize PostgreSQL schema from SQLModel definitions.
+
+        Args:
+            engine: PostgreSQL AsyncEngine instance
+            models: List of SQLModel classes to create tables for
+
+        Raises:
+            DatabaseError: If schema creation fails
+        """
+        try:
+            async with engine.begin() as conn:
+                # Create all tables from SQLModel metadata
+                await conn.run_sync(SQLModel.metadata.create_all)
+        except Exception as e:
+            raise RuntimeError(f"Failed to initialize PostgreSQL schema: {e}") from e
+
+    async def health_check(self, engine: AsyncEngine) -> bool:
+        """
+        Perform PostgreSQL health check.
+
+        Args:
+            engine: PostgreSQL AsyncEngine instance
+
+        Returns:
+            True if database is healthy and responsive
+        """
+        try:
+            async with engine.begin() as conn:
+                result = await conn.execute("SELECT 1")
+                return result.scalar() == 1
+        except Exception:
+            return False
+
+    async def get_connection_info(self, engine: AsyncEngine) -> dict[str, Any]:
+        """
+        Get PostgreSQL connection information.
+
+        Args:
+            engine: PostgreSQL AsyncEngine instance
+
+        Returns:
+            Dictionary with PostgreSQL connection details
+        """
+        try:
+            async with engine.begin() as conn:
+                version_result = await conn.execute("SELECT version()")
+                version = version_result.scalar()
+
+                return {
+                    "driver": "asyncpg",
+                    "database": "postgresql",
+                    "version": version,
+                    "pool_size": engine.pool.size(),
+                    "pool_checked_in": engine.pool.checkedin(),
+                    "pool_checked_out": engine.pool.checkedout(),
+                    "pool_invalid": engine.pool.invalidated(),
+                }
+        except Exception as e:
+            return {
+                "driver": "asyncpg",
+                "database": "postgresql",
+                "error": str(e),
+                "healthy": False,
+            }

wappa/database/adapters/sqlite_adapter.py

@@ -0,0 +1,174 @@
+"""
+SQLite Database Adapter
+
+Provides SQLite-specific implementation for SQLModel/SQLAlchemy async connections
+using aiosqlite as the async driver.
+"""
+
+from collections.abc import Callable
+from contextlib import asynccontextmanager
+from typing import Any, AsyncContextManager
+
+from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, create_async_engine
+from sqlalchemy.orm import sessionmaker
+from sqlmodel import SQLModel
+
+
+class SQLiteAdapter:
+    """
+    SQLite adapter for SQLModel/SQLAlchemy async connections.
+
+    Uses aiosqlite driver for async SQLite operations.
+    Provides connection management, health checks, and schema management
+    with SQLite-specific optimizations.
+    """
+
+    async def create_engine(self, connection_string: str, **kwargs: Any) -> AsyncEngine:
+        """
+        Create SQLite async engine with aiosqlite driver.
+
+        Args:
+            connection_string: SQLite connection URL (sqlite+aiosqlite://...)
+            **kwargs: Engine configuration options
+
+        Returns:
+            Configured AsyncEngine for SQLite
+
+        Raises:
+            ValueError: If connection string is invalid
+            ConnectionError: If unable to create engine
+        """
+        # Ensure aiosqlite driver is specified
+        if not connection_string.startswith("sqlite+aiosqlite://"):
+            # Convert standard sqlite:// to aiosqlite version
+            if connection_string.startswith("sqlite://"):
+                connection_string = connection_string.replace(
+                    "sqlite://", "sqlite+aiosqlite://", 1
+                )
+            else:
+                raise ValueError(
+                    "SQLite connection string must use sqlite+aiosqlite:// scheme"
+                )
+
+        # Default SQLite engine configuration
+        default_config = {
+            "echo": False,
+            "connect_args": {
+                "check_same_thread": False,  # Required for async
+                "timeout": 30,
+            },
+            # SQLite doesn't use connection pooling in the traditional sense
+            "poolclass": None,
+        }
+        default_config.update(kwargs)
+
+        try:
+            engine = create_async_engine(connection_string, **default_config)
+            return engine
+        except Exception as e:
+            raise ConnectionError(f"Failed to create SQLite engine: {e}") from e
+
+    async def create_session_factory(
+        self, engine: AsyncEngine
+    ) -> Callable[[], AsyncContextManager[AsyncSession]]:
+        """
+        Create session factory for SQLite async sessions.
+
+        Args:
+            engine: SQLite AsyncEngine instance
+
+        Returns:
+            Session factory function that returns context manager
+        """
+        # Create async session maker
+        async_session_maker = sessionmaker(
+            engine,
+            class_=AsyncSession,
+            expire_on_commit=False,
+        )
+
+        @asynccontextmanager
+        async def session_factory():
+            async with async_session_maker() as session:
+                try:
+                    yield session
+                    await session.commit()
+                except Exception:
+                    await session.rollback()
+                    raise
+
+        return session_factory
+
+    async def initialize_schema(
+        self, engine: AsyncEngine, models: list[type[SQLModel]] = None
+    ) -> None:
+        """
+        Initialize SQLite schema from SQLModel definitions.
+
+        Args:
+            engine: SQLite AsyncEngine instance
+            models: List of SQLModel classes to create tables for
+
+        Raises:
+            DatabaseError: If schema creation fails
+        """
+        try:
+            async with engine.begin() as conn:
+                # Enable foreign key support for SQLite
+                await conn.execute("PRAGMA foreign_keys=ON")
+                # Create all tables from SQLModel metadata
+                await conn.run_sync(SQLModel.metadata.create_all)
+        except Exception as e:
+            raise RuntimeError(f"Failed to initialize SQLite schema: {e}") from e
+
+    async def health_check(self, engine: AsyncEngine) -> bool:
+        """
+        Perform SQLite health check.
+
+        Args:
+            engine: SQLite AsyncEngine instance
+
+        Returns:
+            True if database is healthy and responsive
+        """
+        try:
+            async with engine.begin() as conn:
+                result = await conn.execute("SELECT 1")
+                return result.scalar() == 1
+        except Exception:
+            return False
+
+    async def get_connection_info(self, engine: AsyncEngine) -> dict[str, Any]:
+        """
+        Get SQLite connection information.
+
+        Args:
+            engine: SQLite AsyncEngine instance
+
+        Returns:
+            Dictionary with SQLite connection details
+        """
+        try:
+            async with engine.begin() as conn:
+                version_result = await conn.execute("SELECT sqlite_version()")
+                version = version_result.scalar()
+
+                # Get database file info
+                pragma_result = await conn.execute("PRAGMA database_list")
+                database_info = pragma_result.fetchall()
+
+                return {
+                    "driver": "aiosqlite",
+                    "database": "sqlite",
+                    "version": version,
+                    "database_file": database_info[0][2] if database_info else "memory",
+                    "foreign_keys_enabled": True,  # We enable this by default
+                    "healthy": True,
+                }
+        except Exception as e:
+            return {
+                "driver": "aiosqlite",
+                "database": "sqlite",
+                "error": str(e),
+                "healthy": False,
+            }

wappa/domain/__init__.py

@@ -0,0 +1,28 @@
+"""
+Domain layer for the Mimeia AI Agent Platform.
+
+This layer contains the core business logic, entities, and interfaces.
+It's independent of external concerns and defines the contract for
+infrastructure implementations.
+"""
+
+# Export domain interfaces
+from .interfaces import (
+    IBaseRepository,
+    IExpiryRepository,
+    IPubSubRepository,
+    IRepositoryFactory,
+    ISharedStateRepository,
+    IStateRepository,
+    IUserRepository,
+)
+
+__all__ = [
+    "IBaseRepository",
+    "IUserRepository",
+    "IStateRepository",
+    "ISharedStateRepository",
+    "IExpiryRepository",
+    "IPubSubRepository",
+    "IRepositoryFactory",
+]

wappa/domain/builders/__init__.py

@@ -0,0 +1,5 @@
+"""Domain builders package."""
+
+from .message_builder import MessageBuilder
+
+__all__ = ["MessageBuilder"]