Support hybrid_property, column_property, declared_attr

.gitignore

@@ -12,3 +12,7 @@ site
 *.db
 .cache
 .venv*
+uv.lock
+.timetracker
+pdm.lock
+.pdm-python

pyproject.toml

@@ -134,3 +134,12 @@ known-third-party = ["sqlmodel", "sqlalchemy", "pydantic", "fastapi"]
 [tool.ruff.lint.pyupgrade]
 # Preserve types, even if a file imports `from __future__ import annotations`.
 keep-runtime-typing = true
+
+[dependency-groups]
+dev = [
+    "coverage>=7.2.7",
+    "dirty-equals>=0.7.1.post0",
+    "fastapi>=0.103.2",
+    "httpx>=0.24.1",
+    "pytest>=7.4.4",
+]

sqlmodel/__init__.py

@@ -117,6 +117,7 @@
 from .main import Field as Field
 from .main import Relationship as Relationship
 from .main import SQLModel as SQLModel
+from .main import SQLModelConfig as SQLModelConfig
 from .orm.session import Session as Session
 from .sql.expression import all_ as all_
 from .sql.expression import and_ as and_

sqlmodel/_compat.py

@@ -19,7 +19,7 @@
 )
 
 from pydantic import VERSION as P_VERSION
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict
 from pydantic.fields import FieldInfo
 from typing_extensions import Annotated, get_args, get_origin
 
@@ -289,6 +289,10 @@ def sqlmodel_table_construct(
             value = values.get(key, Undefined)
             if value is not Undefined:
                 setattr(self_instance, key, value)
+        for key in self_instance.__sqlalchemy_association_proxies__:
+            value = values.get(key, Undefined)
+            if value is not Undefined:
+                setattr(self_instance, key, value)
         # End SQLModel override
         return self_instance
 
@@ -339,7 +343,20 @@ def sqlmodel_validate(
         # Get and set any relationship objects
         if is_table_model_class(cls):
             for key in new_obj.__sqlmodel_relationships__:
-                value = getattr(use_obj, key, Undefined)
+                # Handle both dict and object access
+                if isinstance(use_obj, dict):
+                    value = use_obj.get(key, Undefined)
+                else:
+                    value = getattr(use_obj, key, Undefined)
+                if value is not Undefined:
+                    setattr(new_obj, key, value)
+            # Get and set any association proxy objects
+            for key in new_obj.__sqlalchemy_association_proxies__:
+                # Handle both dict and object access
+                if isinstance(use_obj, dict):
+                    value = use_obj.get(key, Undefined)
+                else:
+                    value = getattr(use_obj, key, Undefined)
                 if value is not Undefined:
                     setattr(new_obj, key, value)
         return new_obj
@@ -385,7 +402,7 @@ def sqlmodel_init(*, self: "SQLModel", data: Dict[str, Any]) -> None:
         Representation as Representation,
     )
 
-    class SQLModelConfig(BaseConfig):  # type: ignore[no-redef]
+    class SQLModelConfig(ConfigDict):  # type: ignore[no-redef]
         table: Optional[bool] = None  # type: ignore[misc]
         registry: Optional[Any] = None  # type: ignore[misc]
 
@@ -403,12 +420,12 @@ def set_config_value(
         setattr(model.__config__, parameter, value)  # type: ignore
 
     def get_model_fields(model: InstanceOrType[BaseModel]) -> Dict[str, "FieldInfo"]:
-        return model.__fields__  # type: ignore
+        return model.model_fields
 
     def get_fields_set(
         object: InstanceOrType["SQLModel"],
-    ) -> Union[Set[str], Callable[[BaseModel], Set[str]]]:
-        return object.__fields_set__
+    ) -> Union[Set[str], property]:
+        return object.model_fields_set
 
     def init_pydantic_private_attrs(new_object: InstanceOrType["SQLModel"]) -> None:
         object.__setattr__(new_object, "__fields_set__", set())
@@ -479,7 +496,7 @@ def _calculate_keys(
             # Do not include relationships as that would easily lead to infinite
             # recursion, or traversing the whole database
             return (
-                self.__fields__.keys()  # noqa
+                self.model_fields.keys()  # noqa
             )  # | self.__sqlmodel_relationships__.keys()
 
         keys: AbstractSet[str]
@@ -492,7 +509,7 @@ def _calculate_keys(
             # Do not include relationships as that would easily lead to infinite
             # recursion, or traversing the whole database
             keys = (
-                self.__fields__.keys()  # noqa
+                self.model_fields.keys()  # noqa
             )  # | self.__sqlmodel_relationships__.keys()
         if include is not None:
             keys &= include.keys()
@@ -548,16 +565,27 @@ def sqlmodel_validate(
                 setattr(m, key, value)
         # Continue with standard Pydantic logic
         object.__setattr__(m, "__fields_set__", fields_set)
+        # Handle non-Pydantic fields like relationships and association proxies
+        if getattr(cls.__config__, "table", False):  # noqa
+            non_pydantic_keys = set(obj.keys()) - set(values.keys())
+            for key in non_pydantic_keys:
+                if (
+                    hasattr(m, "__sqlmodel_relationships__")
+                    and key in m.__sqlmodel_relationships__
+                ):
+                    setattr(m, key, obj[key])
+                elif (
+                    hasattr(m, "__sqlalchemy_association_proxies__")
+                    and key in m.__sqlalchemy_association_proxies__
+                ):
+                    setattr(m, key, obj[key])
         m._init_private_attributes()  # type: ignore[attr-defined] # noqa
         return m
 
     def sqlmodel_init(*, self: "SQLModel", data: Dict[str, Any]) -> None:
         values, fields_set, validation_error = validate_model(self.__class__, data)
         # Only raise errors if not a SQLModel model
-        if (
-            not is_table_model_class(self.__class__)  # noqa
-            and validation_error
-        ):
+        if not is_table_model_class(self.__class__) and validation_error:  # noqa
             raise validation_error
         if not is_table_model_class(self.__class__):
             object.__setattr__(self, "__dict__", values)
@@ -573,3 +601,5 @@ def sqlmodel_init(*, self: "SQLModel", data: Dict[str, Any]) -> None:
             for key in non_pydantic_keys:
                 if key in self.__sqlmodel_relationships__:
                     setattr(self, key, data[key])
+                elif key in self.__sqlalchemy_association_proxies__:
+                    setattr(self, key, data[key])