fastapi-fsp 0.2.2__py3-none-any.whl → 0.2.3__py3-none-any.whl

fastapi_fsp/fsp.py

@@ -228,10 +228,54 @@ class FSPManager:
         if col_id not in self._type_cache:
             try:
                 self._type_cache[col_id] = getattr(column.type, "python_type", None)
-            except Exception:
+            except (AttributeError, NotImplementedError):
+                # For computed fields (hybrid_property, etc.), type inference may fail
                 self._type_cache[col_id] = None
         return self._type_cache[col_id]
 
+    @staticmethod
+    def _get_entity_attribute(query: Select, field: str) -> Optional[ColumnElement[Any]]:
+        """
+        Try to get a column-like attribute from the query's entity.
+
+        This enables filtering/sorting on computed fields like hybrid_property
+        that have SQL expressions defined.
+
+        Args:
+            query: SQLAlchemy Select query
+            field: Name of the field/attribute to get
+
+        Returns:
+            Optional[ColumnElement]: The SQL expression if available, None otherwise
+        """
+        try:
+            # Get the entity class from the query
+            column_descriptions = query.column_descriptions
+            if not column_descriptions:
+                return None
+
+            entity = column_descriptions[0].get("entity")
+            if entity is None:
+                return None
+
+            # Get the attribute from the entity class
+            attr = getattr(entity, field, None)
+            if attr is None:
+                return None
+
+            # Check if it's directly usable as a ColumnElement (hybrid_property with expression)
+            # When accessing a hybrid_property on the class, it returns the SQL expression
+            if isinstance(attr, ColumnElement):
+                return attr
+
+            # Some expressions may need to call __clause_element__
+            if hasattr(attr, "__clause_element__"):
+                return attr.__clause_element__()
+
+            return None
+        except Exception:
+            return None
+
     def paginate(self, query: Select, session: Session) -> Any:
         """
         Execute pagination on a query.
@@ -591,6 +635,11 @@ class FSPManager:
         for f in filters:
             # filter of `filters` has been validated in the `_parse_filters`
             column = columns_map.get(f.field)
+
+            # Fall back to computed fields (hybrid_property, etc.) if not in columns_map
+            if column is None:
+                column = FSPManager._get_entity_attribute(query, f.field)
+
             if column is None:
                 if self.strict_mode:
                     available = ", ".join(sorted(columns_map.keys()))
@@ -635,11 +684,10 @@ class FSPManager:
         """
         if sorting and sorting.sort_by:
             column = columns_map.get(sorting.sort_by)
+
+            # Fall back to computed fields (hybrid_property, etc.) if not in columns_map
             if column is None:
-                try:
-                    column = getattr(query.column_descriptions[0]["entity"], sorting.sort_by, None)
-                except Exception:
-                    pass
+                column = FSPManager._get_entity_attribute(query, sorting.sort_by)
 
             if column is None:
                 if self.strict_mode:

{fastapi_fsp-0.2.2.dist-info → fastapi_fsp-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-fsp
-Version: 0.2.2
+Version: 0.2.3
 Summary: Filter, Sort, and Paginate (FSP) utilities for FastAPI + SQLModel
 Project-URL: Homepage, https://github.com/fromej-dev/fastapi-fsp
 Project-URL: Repository, https://github.com/fromej-dev/fastapi-fsp
@@ -146,6 +146,65 @@ Notes:
 - Both formats are equivalent; the indexed format takes precedence if present.
 - If any filter is incomplete (missing operator or value in the indexed form, or mismatched counts of simple triplets), the API responds with HTTP 400.
 
+## Filtering on Computed Fields
+
+You can filter (and sort) on SQLAlchemy `hybrid_property` fields that have a SQL expression defined. This enables filtering on calculated or derived values at the database level.
+
+### Defining a Computed Field
+
+```python
+from typing import ClassVar, Optional
+from sqlalchemy import func
+from sqlalchemy.ext.hybrid import hybrid_property
+from sqlmodel import Field, SQLModel
+
+class HeroBase(SQLModel):
+    name: str = Field(index=True)
+    secret_name: str
+    age: Optional[int] = Field(default=None)
+    full_name: ClassVar[str]  # Required: declare as ClassVar for Pydantic
+
+    @hybrid_property
+    def full_name(self) -> str:
+        """Python-level implementation (used on instances)."""
+        return f"{self.name}-{self.secret_name}"
+
+    @full_name.expression
+    def full_name(cls):
+        """SQL-level implementation (used in queries)."""
+        return func.concat(cls.name, "-", cls.secret_name)
+
+class Hero(HeroBase, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True)
+
+class HeroPublic(HeroBase):
+    id: int
+    full_name: str  # Include in response model
+```
+
+### Querying Computed Fields
+
+Once defined, you can filter and sort on the computed field like any regular field:
+
+```
+# Filter by computed field
+GET /heroes/?field=full_name&operator=eq&value=Spider-Man
+GET /heroes/?field=full_name&operator=ilike&value=%man
+GET /heroes/?field=full_name&operator=contains&value=Spider
+
+# Sort by computed field
+GET /heroes/?sort_by=full_name&order=asc
+
+# Combine with other filters
+GET /heroes/?field=full_name&operator=starts_with&value=Spider&field=age&operator=gte&value=21
+```
+
+### Requirements
+
+- The `hybrid_property` must have an `.expression` decorator that returns a valid SQL expression
+- The field should be declared as `ClassVar[type]` in the SQLModel base class to work with Pydantic
+- Only computed fields with SQL expressions are supported; Python-only properties cannot be filtered at the database level
+
 ## Response model
 
 ```

fastapi_fsp-0.2.3.dist-info/RECORD

@@ -0,0 +1,7 @@
+fastapi_fsp/__init__.py,sha256=0I_XN_ptNu1NyNRpjdyVm6nwvrilAB8FyT2EfgVF_QA,215
+fastapi_fsp/fsp.py,sha256=b6OuHgbTpWrFtxGKm7fcPpjHtD3Cdjrs22m3IYOBhp4,23986
+fastapi_fsp/models.py,sha256=1MwLBQFmUP8OwO3Gqby1u7s9ruimCR2XGfUzAqF4Tj4,2034
+fastapi_fsp-0.2.3.dist-info/METADATA,sha256=w4wfXs3hye-UI0-h2a81OjkG3yzzZWUq91n1HhmyUi4,8224
+fastapi_fsp-0.2.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+fastapi_fsp-0.2.3.dist-info/licenses/LICENSE,sha256=Btzdu2kIoMbdSp6OyCLupB1aRgpTCJ_szMimgEnpkkE,1056
+fastapi_fsp-0.2.3.dist-info/RECORD,,

fastapi_fsp-0.2.2.dist-info/RECORD

@@ -1,7 +0,0 @@
-fastapi_fsp/__init__.py,sha256=0I_XN_ptNu1NyNRpjdyVm6nwvrilAB8FyT2EfgVF_QA,215
-fastapi_fsp/fsp.py,sha256=nPubvF7IStCWG0hdCeZX-1JgcHDyGkZa_XoAM7lq1Xw,22166
-fastapi_fsp/models.py,sha256=1MwLBQFmUP8OwO3Gqby1u7s9ruimCR2XGfUzAqF4Tj4,2034
-fastapi_fsp-0.2.2.dist-info/METADATA,sha256=zrje4Au8BOM4ids9JnX61jrP52ierjYuJxLGqvtCxFU,6235
-fastapi_fsp-0.2.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-fastapi_fsp-0.2.2.dist-info/licenses/LICENSE,sha256=Btzdu2kIoMbdSp6OyCLupB1aRgpTCJ_szMimgEnpkkE,1056
-fastapi_fsp-0.2.2.dist-info/RECORD,,