Add implementation of AsyncSession.run_sync()

Currently, `sqlmodel.ext.asyncio.session.AsyncSession` doesn't implement
`run_sync()`, which means that any call to `run_sync()` on a sqlmodel
`AsyncSession` will be dispatched to the parent
`sqlalchemy.ext.asyncio.AsyncSession`.

The first argument to sqlalchemy's `AsyncSession.run_sync()` is a
callable whose first argument is a `sqlalchemy.orm.Session`
object. If we're using this in a repo that uses sqlmodel, we'll actually
be passing a callable whose first argument is a
`sqlmodel.orm.session.Session`.

In practice this works fine - because `sqlmodel.orm.session.Session` is
derived from `sqlalchemy.orm.Session`, the implementation of
`sqlalchemy.ext.asyncio.AsyncSession.run_sync()` can use the sqlmodel
`Session` object in place of the sqlalchemy `Session` object. However,
static analysers will complain that the argument to `run_sync()` is of
the wrong type. For example, here's a warning from pyright:

```
Pyright: Error: Argument of type "(session: Session, id: UUID) -> int" cannot be assigned to parameter "fn" of type "(Session, **_P@run_sync) -> _T@run_sync" in function "run_sync"
  Type "(session: Session, id: UUID) -> int" is not assignable to type "(Session, id: UUID) -> int"
    Parameter 1: type "Session" is incompatible with type "Session"
      "sqlalchemy.orm.session.Session" is not assignable to "sqlmodel.orm.session.Session" [reportArgumentType]
```

This commit implements a `run_sync()` method on
`sqlmodel.ext.asyncio.session.AsyncSession`, which casts the callable to
the correct type before dispatching it to the base class. This satisfies
the static type checks.

Author: jnewbery

sqlmodel/ext/asyncio/session.py

@@ -1,5 +1,6 @@
 from typing import (
     Any,
+    Callable,
     Dict,
     Mapping,
     Optional,
@@ -15,12 +16,14 @@
 from sqlalchemy.engine.interfaces import _CoreAnyExecuteParams
 from sqlalchemy.engine.result import Result, ScalarResult, TupleResult
 from sqlalchemy.ext.asyncio import AsyncSession as _AsyncSession
+from sqlalchemy.orm import Session as _Session
 from sqlalchemy.ext.asyncio.result import _ensure_sync_result
 from sqlalchemy.ext.asyncio.session import _EXECUTE_OPTIONS
 from sqlalchemy.orm._typing import OrmExecuteOptionsParameter
 from sqlalchemy.sql.base import Executable as _Executable
 from sqlalchemy.util.concurrency import greenlet_spawn
 from typing_extensions import deprecated
+from typing import Concatenate
 
 from ...orm.session import Session
 from ...sql.base import Executable
@@ -29,6 +32,7 @@
 _TSelectParam = TypeVar("_TSelectParam", bound=Any)
 
 
+
 class AsyncSession(_AsyncSession):
     sync_session_class: Type[Session] = Session
     sync_session: Session
@@ -148,3 +152,18 @@ async def execute(  # type: ignore
             _parent_execute_state=_parent_execute_state,
             _add_event=_add_event,
         )
+
+    async def run_sync[**P, T](
+        self,
+        fn: Callable[Concatenate[Session, P], T],
+        *arg: P.args,
+        **kw: P.kwargs,
+    ) -> T:
+
+        base_fn = cast(Callable[Concatenate[_Session, P], T], fn)
+
+        return await super().run_sync(
+            base_fn,
+            *arg,
+            **kw,
+        )