change mypy codes to ty codes

Author: svlandeg

sqlmodel/main.py

@@ -100,7 +100,7 @@ def __dataclass_transform__(
     return lambda a: a
 
 
-class FieldInfo(PydanticFieldInfo):  # type: ignore[misc]
+class FieldInfo(PydanticFieldInfo):  # ty: ignore[subclass-of-final-class]
     # mypy - ignore that PydanticFieldInfo is @final
     def __init__(self, default: Any = Undefined, **kwargs: Any) -> None:
         primary_key = kwargs.pop("primary_key", False)
@@ -608,10 +608,10 @@ def get_config(name: str) -> Any:
             # This could be done by reading new_cls.model_config['table'] in FastAPI, but
             # that's very specific about SQLModel, so let's have another config that
             # other future tools based on Pydantic can use.
-            new_cls.model_config["read_from_attributes"] = True  # type: ignore[typeddict-unknown-key]
+            new_cls.model_config["read_from_attributes"] = True  # ty: ignore[invalid-key]
             # For compatibility with older versions
             # TODO: remove this in the future
-            new_cls.model_config["read_with_orm_mode"] = True  # type: ignore[typeddict-unknown-key]
+            new_cls.model_config["read_with_orm_mode"] = True  # ty: ignore[invalid-key]
 
         config_registry = get_config("registry")
         if config_registry is not Undefined:
@@ -867,7 +867,7 @@ def __tablename__(cls) -> str:
         return cls.__name__.lower()
 
     @classmethod
-    def model_validate(  # type: ignore[override]
+    def model_validate(  # ty: ignore[invalid-method-override]
         cls: type[_TSQLModel],
         obj: Any,
         *,

sqlmodel/sql/expression.py

@@ -48,30 +48,30 @@
 
 
 def all_(expr: _ColumnExpressionArgument[_T] | _T) -> CollectionAggregate[bool]:
-    return sqlalchemy.all_(expr)  # type: ignore[arg-type]
+    return sqlalchemy.all_(expr)  # ty: ignore[invalid-argument-type]
 
 
 def and_(
     initial_clause: Literal[True] | _ColumnExpressionArgument[bool] | bool,
     *clauses: _ColumnExpressionArgument[bool] | bool,
 ) -> ColumnElement[bool]:
-    return sqlalchemy.and_(initial_clause, *clauses)  # type: ignore[arg-type]
+    return sqlalchemy.and_(initial_clause, *clauses)  # ty: ignore[invalid-argument-type]
 
 
 def any_(expr: _ColumnExpressionArgument[_T] | _T) -> CollectionAggregate[bool]:
-    return sqlalchemy.any_(expr)  # type: ignore[arg-type]
+    return sqlalchemy.any_(expr)  # ty: ignore[invalid-argument-type]
 
 
 def asc(
     column: _ColumnExpressionOrStrLabelArgument[_T] | _T,
 ) -> UnaryExpression[_T]:
-    return sqlalchemy.asc(column)  # type: ignore[arg-type]
+    return sqlalchemy.asc(column)  # ty: ignore[invalid-argument-type]
 
 
 def collate(
     expression: _ColumnExpressionArgument[str] | str, collation: str
 ) -> BinaryExpression[str]:
-    return sqlalchemy.collate(expression, collation)  # type: ignore[arg-type]
+    return sqlalchemy.collate(expression, collation)  # ty: ignore[invalid-argument-type]
 
 
 def between(
@@ -84,15 +84,15 @@ def between(
 
 
 def not_(clause: _ColumnExpressionArgument[_T] | _T) -> ColumnElement[_T]:
-    return sqlalchemy.not_(clause)  # type: ignore[arg-type]
+    return sqlalchemy.not_(clause)  # ty: ignore[no-matching-overload]
 
 
 def case(
     *whens: tuple[_ColumnExpressionArgument[bool] | bool, Any] | Mapping[Any, Any],
     value: Any | None = None,
     else_: Any | None = None,
 ) -> Case[Any]:
-    return sqlalchemy.case(*whens, value=value, else_=else_)  # type: ignore[arg-type]
+    return sqlalchemy.case(*whens, value=value, else_=else_)  # ty: ignore[invalid-argument-type]
 
 
 def cast(
@@ -112,15 +112,15 @@ def try_cast(
 def desc(
     column: _ColumnExpressionOrStrLabelArgument[_T] | _T,
 ) -> UnaryExpression[_T]:
-    return sqlalchemy.desc(column)  # type: ignore[arg-type]
+    return sqlalchemy.desc(column)  # ty: ignore[invalid-argument-type]
 
 
 def distinct(expr: _ColumnExpressionArgument[_T] | _T) -> UnaryExpression[_T]:
-    return sqlalchemy.distinct(expr)  # type: ignore[arg-type]
+    return sqlalchemy.distinct(expr)  # ty: ignore[invalid-argument-type]
 
 
 def bitwise_not(expr: _ColumnExpressionArgument[_T] | _T) -> UnaryExpression[_T]:
-    return sqlalchemy.bitwise_not(expr)  # type: ignore[arg-type]
+    return sqlalchemy.bitwise_not(expr)  # ty: ignore[invalid-argument-type]
 
 
 def extract(field: str, expr: _ColumnExpressionArgument[Any] | Any) -> Extract:
@@ -130,32 +130,32 @@ def extract(field: str, expr: _ColumnExpressionArgument[Any] | Any) -> Extract:
 def funcfilter(
     func: FunctionElement[_T], *criterion: _ColumnExpressionArgument[bool] | bool
 ) -> FunctionFilter[_T]:
-    return sqlalchemy.funcfilter(func, *criterion)  # type: ignore[arg-type]
+    return sqlalchemy.funcfilter(func, *criterion)  # ty: ignore[invalid-argument-type]
 
 
 def label(
     name: str,
     element: _ColumnExpressionArgument[_T] | _T,
     type_: Optional["_TypeEngineArgument[_T]"] = None,
 ) -> Label[_T]:
-    return sqlalchemy.label(name, element, type_=type_)  # type: ignore[arg-type]
+    return sqlalchemy.label(name, element, type_=type_)  # ty: ignore[invalid-argument-type]
 
 
 def nulls_first(
     column: _ColumnExpressionArgument[_T] | _T,
 ) -> UnaryExpression[_T]:
-    return sqlalchemy.nulls_first(column)  # type: ignore[arg-type]
+    return sqlalchemy.nulls_first(column)  # ty: ignore[invalid-argument-type]
 
 
 def nulls_last(column: _ColumnExpressionArgument[_T] | _T) -> UnaryExpression[_T]:
-    return sqlalchemy.nulls_last(column)  # type: ignore[arg-type]
+    return sqlalchemy.nulls_last(column)  # ty: ignore[invalid-argument-type]
 
 
 def or_(
     initial_clause: Literal[False] | _ColumnExpressionArgument[bool] | bool,
     *clauses: _ColumnExpressionArgument[bool] | bool,
 ) -> ColumnElement[bool]:
-    return sqlalchemy.or_(initial_clause, *clauses)  # type: ignore[arg-type]
+    return sqlalchemy.or_(initial_clause, *clauses)  # ty: ignore[invalid-argument-type]
 
 
 def over(