New version (#3)

kaziamov · web-flow · commit a71befed6377 · 2025-05-19T19:09:30.000+04:00
* migrate to uv

* add test deps

* add database tools

* update database connection

* update testing tools
diff --git a/README.md b/README.md
@@ -11,56 +11,9 @@ pip install hexfrost-toolbox
 
 ## Usage
 
+### Tools
 
-### Create async generator from list
 
-```python
-from toolbox import create_async_generator
-
-
-async def main():
-    urls = ['https://example.com', 'https://example2.com']
-    
-    async_iterable = create_async_generator(urls)
-    
-    async for url in async_iterable:
-        await do_something(url)
-
-```
-
-### Create async function from sync function
-
-```python
-from toolbox import sync_to_async
-
-def some_blocking_function():
-    return 'Hello, World!'
-
-async def main():
-    async_function = sync_to_async(some_blocking_function)
-    
-    result = await async_function()
-    
-    print(result)
-
-```
-
-### Create sync function from async function
-
-```python
-from toolbox import async_to_sync
-
-async def some_async_function():
-    return 'Hello, World!'
-
-def main():
-    sync_function = async_to_sync(some_async_function)
-    
-    result = sync_function()
-    
-    print(result)
-
-```
 
 That's it! Enjoy! 🚀
 
diff --git a/poetry.lock b/poetry.lock
diff --git a/pyproject.toml b/pyproject.toml
@@ -1,18 +1,38 @@
-[tool.poetry]
-name = "hexfrost-toolbox"
-version = "0.1.3"
-description = "Open source library with useful utils for fast development"
-authors = ["Kaziamov <kaziamov@outlook.com>"]
-readme = "README.md"
-packages = [
-    { include = "toolbox" },
+[tool.pdm.build]
+includes = [
+    "toolbox",
 ]
+[build-system]
+requires = ["pdm-backend"]
+build-backend = "pdm.backend"
 
-[tool.poetry.dependencies]
-python = ">=3.8.1,<4.0"
-hexfrost-simplecrud = ">=0.3.0"
 
+[project]
+authors = [
+    {name = "Kaziamov", email = "kaziamov@outlook.com"},
+]
+requires-python = ">=3.9,<4.0"
+dependencies = [
+    "cryptography>=44.0.3",
+    "fastapi>=0.115.12",
+    "pydantic>=2.10.6",
+    "sqlalchemy>=2.0.40",
+]
+name = "hexfrost-toolbox"
+version = "0.1.4b"
+description = "Open source library with useful utils for fast development"
+readme = "README.md"
 
-[build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"
+[dependency-groups]
+dev = [
+    "pytest==8.0.0",
+    "pytest-asyncio==0.23.5",
+    "pytest-mock==3.12.0",
+    "pytest-cov>=6.0.0",
+    "pre-commit>=4.1.0",
+    "anyio[trio]>=3.7.1",
+    "httpx==0.28.1",
+    "asyncpg>=0.30.0",
+#    "pytest-postgresql>=7.0.2",
+#    "psycopg2-binary>=2.9.10",
+]
diff --git a/pytest.ini b/pytest.ini
@@ -0,0 +1,2 @@
+[pytest]
+asyncio_mode=auto
diff --git a/tests/__init__.py b/tests/__init__.py
diff --git a/tests/fixtures/__init__.py b/tests/fixtures/__init__.py
diff --git a/tests/fixtures/database.py b/tests/fixtures/database.py
@@ -0,0 +1,29 @@
+from unittest.mock import MagicMock
+
+import pytest
+from sqlalchemy.ext.asyncio import AsyncEngine
+
+from toolbox.sqlalchemy.connection import DatabaseConnectionSettings, DatabaseConnectionManager
+
+
+@pytest.fixture
+def db_settings():
+    class TestSettings(DatabaseConnectionSettings):
+        POSTGRES_USER = "postgres"
+        POSTGRES_PASSWORD = "postgres"
+        POSTGRES_HOST = "0.0.0.0"
+        POSTGRES_PORT = "5432"
+        POSTGRES_DB = "test_postgres"
+
+    return TestSettings
+
+
+@pytest.fixture
+def mock_engine():
+    return MagicMock(spec=AsyncEngine)
+
+
+@pytest.fixture(scope="function")
+def database_connector(db_settings):
+    dc = DatabaseConnectionManager(settings=db_settings)
+    return dc
diff --git a/tests/test_database.py b/tests/test_database.py
@@ -0,0 +1,87 @@
+from unittest.mock import MagicMock, patch
+
+import pytest
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from tests.fixtures.database import db_settings, mock_engine, database_connector
+
+
+@pytest.mark.asyncio
+async def test_database_manager_no_settings(database_connector):
+    database_connector._settings = None
+    database_connector._engine = None
+    database_connector._async_sessionmaker = None
+
+    with pytest.raises(RuntimeError, match="No settings available"):
+        database_connector._get_settings()
+
+
+def test_database_manager_set_engine(database_connector, mock_engine):
+    database_connector.set_engine(mock_engine)
+    assert database_connector._engine == mock_engine
+
+
+@patch('toolbox.sqlalchemy.connection.create_async_engine')
+def test_database_manager_get_engine_creates_new(mock_create_engine, database_connector, db_settings):
+    database_connector._engine = None
+
+    expected_url = f"postgresql+asyncpg://{db_settings.POSTGRES_USER}:{db_settings.POSTGRES_PASSWORD}@{db_settings.POSTGRES_HOST}:{db_settings.POSTGRES_PORT}/{db_settings.POSTGRES_DB}"
+
+    database_connector.get_engine()
+
+    mock_create_engine.assert_called_once()
+    call_args = mock_create_engine.call_args[0][0]
+    assert call_args == expected_url
+
+
+def test_database_manager_get_engine_returns_existing(database_connector, mock_engine):
+    database_connector.set_engine(mock_engine)
+    result = database_connector.get_engine()
+    assert result == mock_engine
+
+
+@patch('toolbox.sqlalchemy.connection.async_sessionmaker')
+def test_database_manager_get_session_maker(mock_sessionmaker, database_connector, mock_engine):
+    database_connector.set_engine(mock_engine)
+    database_connector._async_sessionmaker = None
+
+    database_connector.get_session_maker()
+
+    mock_sessionmaker.assert_called_once_with(
+        mock_engine,
+        expire_on_commit=False,
+        class_=AsyncSession
+    )
+
+
+def test_database_manager_get_session_maker_returns_existing(database_connector):
+    mock_sessionmaker = MagicMock()
+    database_connector._async_sessionmaker = mock_sessionmaker
+
+    result = database_connector.get_session_maker()
+    assert result == mock_sessionmaker
+
+
+async def test_fastapi_depends_itegration_test(database_connector):
+    from fastapi import Depends, FastAPI
+    app = FastAPI()
+    @app.get("/")
+    async def index(database_conn = Depends(database_connector)):
+        async with database_conn:
+            res = await database_conn.scalar(select(1))
+        return {"status": "ok"}
+
+    from httpx import ASGITransport, AsyncClient
+    async with AsyncClient(
+            transport=ASGITransport(app=app), base_url=f"http://test",
+    ) as client:
+        response1 = await client.get('/')
+        assert response1.status_code == 200
+
+
+
+
+async def test_get_db_connect_context_works(database_connector):
+    async with database_connector.get_db_session() as conn:
+        res = await conn.scalar(select(1))
diff --git a/tests/test_testing.py b/tests/test_testing.py
@@ -0,0 +1,18 @@
+from sqlalchemy import select
+
+from tests.fixtures.database import database_connector
+
+
+async def test_fastapi_depends_itegration_test_2(database_connector):
+    from fastapi import Depends, FastAPI
+    app = FastAPI()
+    @app.get("/")
+    async def index(database_conn = Depends(database_connector)):
+        async with database_conn:
+            res = await database_conn.scalar(select(1))
+        return {"status": "ok"}
+
+    from toolbox.testing import debug_client
+    async with debug_client(app) as client:
+        response1 = await client.get('/')
+        assert response1.status_code == 200
diff --git a/toolbox/__init__.py b/toolbox/__init__.py
@@ -1,5 +0,0 @@
-import simplecrud as crud
-from toolbox.decorators import async_to_sync, sync_to_async
-from toolbox.utils import create_async_generator
-
-__all__ = ["crud", "async_to_sync", "sync_to_async", "create_async_generator"]
diff --git a/toolbox/sqlalchemy/__init__.py b/toolbox/sqlalchemy/__init__.py
diff --git a/toolbox/sqlalchemy/connection.py b/toolbox/sqlalchemy/connection.py
@@ -0,0 +1,79 @@
+import logging
+from contextlib import asynccontextmanager
+from typing import AsyncGenerator
+
+from sqlalchemy.ext.asyncio import AsyncEngine
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.ext.asyncio import async_sessionmaker
+from sqlalchemy.ext.asyncio import create_async_engine
+from sqlalchemy.pool import NullPool
+
+logger = logging.getLogger(__name__)
+
+
+class DatabaseConnectionSettings:
+    POSTGRES_USER: str
+    POSTGRES_PASSWORD: str
+    POSTGRES_HOST: str
+    POSTGRES_PORT: str
+    POSTGRES_DB: str
+
+
+class DatabaseConnectionManager:
+    
+    def __init__(self, settings: DatabaseConnectionSettings):
+        self._engine = None
+        self._async_sessionmaker = None
+        self._settings = settings
+
+    def _get_settings(self):
+        if not self._settings:
+            raise RuntimeError('No settings available')
+        return self._settings
+
+    def set_engine(self, engine: AsyncEngine):
+        self._engine = engine
+
+    def get_engine(self) -> AsyncEngine:
+        if not self._engine:
+            s = self._settings
+            db_host = s.POSTGRES_HOST
+            self._engine = create_async_engine(
+                f"postgresql+asyncpg://{s.POSTGRES_USER}:{s.POSTGRES_PASSWORD}@{db_host}:{s.POSTGRES_PORT}/{s.POSTGRES_DB}",
+                poolclass=NullPool,
+            )
+        return self._engine
+
+    def get_session_maker(self):
+        if not self._async_sessionmaker:
+            self._async_sessionmaker = async_sessionmaker(
+                self.get_engine(),
+                expire_on_commit=False,
+                class_=AsyncSession,
+            )
+        return self._async_sessionmaker
+
+    @asynccontextmanager
+    async def get_db_session(self) -> AsyncGenerator[AsyncSession, None]:
+        session_maker = self.get_session_maker()
+        async with session_maker() as session:
+            try:
+                yield session
+                await session.commit()
+            except Exception:
+                await session.rollback()
+                raise
+            finally:
+                await session.close()
+
+    async def __call__(self):
+        session_maker = self.get_session_maker()
+        async with session_maker() as session:
+            try:
+                yield session
+                await session.commit()
+            except Exception:
+                await session.rollback()
+                raise
+            finally:
+                await session.close()
diff --git a/toolbox/sqlalchemy/repositories.py b/toolbox/sqlalchemy/repositories.py
@@ -0,0 +1,33 @@
+from typing import Annotated
+
+from sqlalchemy import select
+from fastapi import Depends
+
+from toolbox.sqlalchemy.connection import DatabaseConnectionManager
+from toolbox.schemes import SensitiveDataScheme, BaseScheme
+
+AnyPydanticModel = Annotated[BaseScheme, Depends(BaseScheme)]
+AnySQLAlchemyModel = Annotated[BaseScheme, Depends(SensitiveDataScheme)]
+
+
+class AbstractDatabaseCrudManager:
+    _alchemy_model = type[AnySQLAlchemyModel]
+    _pydantic_model = type[AnyPydanticModel]
+
+    @classmethod
+    async def add_one(cls, data_model: AnyPydanticModel) -> None:
+        obj = cls._alchemy_model(**data_model.encrypt_fields().model_dump())
+        connector = DatabaseConnectionManager()
+        session = connector.get_session_maker()
+        async with session() as conn:
+            conn.add(obj)
+            await conn.commit()
+            await conn.refresh(obj)
+
+    @classmethod
+    async def get_all(cls, limit: int = 100, offset: int = 0):
+        session = DatabaseConnectionManager.get_session_maker()
+        async with session() as conn:
+            query = select(cls._alchemy_model).limit(limit).offset(offset)
+            result = [v[0] for v in (await conn.execute(query)).all()]
+        return result
diff --git a/toolbox/testing.py b/toolbox/testing.py
@@ -0,0 +1,15 @@
+import logging
+from contextlib import asynccontextmanager
+
+
+logger = logging.getLogger(__name__)
+
+
+@asynccontextmanager
+async def debug_client(app, app_path: str = "http://test"):
+    from httpx import ASGITransport, AsyncClient
+    async with AsyncClient(
+            transport=ASGITransport(app=app), base_url=app_path,
+    ) as client:
+        yield client
+        pass
diff --git a/uv.lock b/uv.lock
