Fix black formatting and _FunctionFilter type annotation

- Run black on 5 files that failed formatting check
- Fix _FunctionFilter.__init__ value param: str -> Any (matches
  _format_value which handles int, float, datetime, etc.)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: tpellissier

examples/advanced/walkthrough.py

@@ -264,62 +264,66 @@ def _run_walkthrough(client):
     # Basic fluent query: active records sorted by amount (flat iteration)
     log_call("client.query.builder(...).select().filter_eq().order_by().execute()")
     print("Querying incomplete records ordered by amount (fluent builder)...")
-    qb_records = list(backoff(
-        lambda: client.query.builder(table_name)
-        .select("new_Title", "new_Amount", "new_Priority")
-        .filter_eq("new_Completed", False)
-        .order_by("new_Amount", descending=True)
-        .top(10)
-        .execute()
-    ))
+    qb_records = list(
+        backoff(
+            lambda: client.query.builder(table_name)
+            .select("new_Title", "new_Amount", "new_Priority")
+            .filter_eq("new_Completed", False)
+            .order_by("new_Amount", descending=True)
+            .top(10)
+            .execute()
+        )
+    )
     print(f"[OK] QueryBuilder found {len(qb_records)} incomplete records:")
     for rec in qb_records[:5]:
         print(f"  - '{rec.get('new_title')}' Amount={rec.get('new_amount')}")
 
     # filter_in: records with specific priorities
     log_call("client.query.builder(...).filter_in('new_Priority', [HIGH, LOW]).execute()")
     print("Querying records with HIGH or LOW priority (filter_in)...")
-    priority_records = list(backoff(
-        lambda: client.query.builder(table_name)
-        .select("new_Title", "new_Priority")
-        .filter_in("new_Priority", [Priority.HIGH, Priority.LOW])
-        .execute()
-    ))
+    priority_records = list(
+        backoff(
+            lambda: client.query.builder(table_name)
+            .select("new_Title", "new_Priority")
+            .filter_in("new_Priority", [Priority.HIGH, Priority.LOW])
+            .execute()
+        )
+    )
     print(f"[OK] Found {len(priority_records)} records with HIGH or LOW priority")
     for rec in priority_records[:5]:
         print(f"  - '{rec.get('new_title')}' Priority={rec.get('new_priority')}")
 
     # filter_between: amount in a range
     log_call("client.query.builder(...).filter_between('new_Amount', 500, 1500).execute()")
     print("Querying records with amount between 500 and 1500 (filter_between)...")
-    range_records = list(backoff(
-        lambda: client.query.builder(table_name)
-        .select("new_Title", "new_Amount")
-        .filter_between("new_Amount", 500, 1500)
-        .execute()
-    ))
+    range_records = list(
+        backoff(
+            lambda: client.query.builder(table_name)
+            .select("new_Title", "new_Amount")
+            .filter_between("new_Amount", 500, 1500)
+            .execute()
+        )
+    )
     print(f"[OK] Found {len(range_records)} records with amount in [500, 1500]")
     for rec in range_records:
         print(f"  - '{rec.get('new_title')}' Amount={rec.get('new_amount')}")
 
     # Composable expression tree with where()
     log_call("client.query.builder(...).where((eq(...) | eq(...)) & gt(...)).execute()")
     print("Querying with composable expression tree (where)...")
-    expr_records = list(backoff(
-        lambda: client.query.builder(table_name)
-        .select("new_Title", "new_Amount", "new_Quantity")
-        .where(
-            (eq("new_Completed", False) & gt("new_Amount", 100))
+    expr_records = list(
+        backoff(
+            lambda: client.query.builder(table_name)
+            .select("new_Title", "new_Amount", "new_Quantity")
+            .where((eq("new_Completed", False) & gt("new_Amount", 100)))
+            .order_by("new_Amount", descending=True)
+            .top(5)
+            .execute()
         )
-        .order_by("new_Amount", descending=True)
-        .top(5)
-        .execute()
-    ))
+    )
     print(f"[OK] Expression tree query found {len(expr_records)} records:")
     for rec in expr_records:
-        print(
-            f"  - '{rec.get('new_title')}' Amount={rec.get('new_amount')} Qty={rec.get('new_quantity')}"
-        )
+        print(f"  - '{rec.get('new_title')}' Amount={rec.get('new_amount')} Qty={rec.get('new_quantity')}")
 
     # Combined: fluent filters + expression tree + paging (by_page=True)
     log_call("client.query.builder(...).filter_eq().where(between()).page_size().execute(by_page=True)")
@@ -339,9 +343,7 @@ def _run_walkthrough(client):
         combined_record_count += len(page)
         titles = [r.get("new_title", "?") for r in page]
         print(f"  Page {combined_page_count}: {len(page)} records - {titles}")
-    print(
-        f"[OK] Combined query: {combined_record_count} records across {combined_page_count} page(s)"
-    )
+    print(f"[OK] Combined query: {combined_record_count} records across {combined_page_count} page(s)")
 
     # ============================================================================
     # 8. SQL QUERY

src/PowerPlatform/Dataverse/models/filters.py

@@ -36,7 +36,6 @@
 from datetime import date, datetime, timezone
 from typing import Any, Sequence
 
-
 __all__ = [
     "FilterExpression",
     "eq",
@@ -160,7 +159,7 @@ class _FunctionFilter(FilterExpression):
 
     __slots__ = ("func_name", "column", "value")
 
-    def __init__(self, func_name: str, column: str, value: str) -> None:
+    def __init__(self, func_name: str, column: str, value: Any) -> None:
         self.func_name = func_name
         self.column = column.lower()
         self.value = value

src/PowerPlatform/Dataverse/models/query_builder.py

@@ -43,7 +43,6 @@
 
 from .filters import FilterExpression, _format_value
 
-
 __all__ = ["QueryBuilder"]
 
 
@@ -249,9 +248,7 @@ def filter_between(self, column: str, low: Any, high: Any) -> QueryBuilder:
             # Produces: (revenue ge 100000 and revenue le 500000)
         """
         col = column.lower()
-        self._filter_parts.append(
-            f"({col} ge {_format_value(low)} and {col} le {_format_value(high)})"
-        )
+        self._filter_parts.append(f"({col} ge {_format_value(low)} and {col} le {_format_value(high)})")
         return self
 
     def filter_raw(self, filter_string: str) -> QueryBuilder:
@@ -298,9 +295,7 @@ def where(self, expression: FilterExpression) -> QueryBuilder:
                             & gt("revenue", 100000)))
         """
         if not isinstance(expression, FilterExpression):
-            raise TypeError(
-                f"where() requires a FilterExpression, got {type(expression).__name__}"
-            )
+            raise TypeError(f"where() requires a FilterExpression, got {type(expression).__name__}")
         self._filter_parts.append(expression)
         return self
 

tests/unit/models/test_query_builder.py

@@ -191,11 +191,7 @@ def test_filter_between_returns_self(self):
         self.assertIs(qb.filter_between("revenue", 100, 500), qb)
 
     def test_filter_between_combined_with_other_filters(self):
-        qb = (
-            QueryBuilder("account")
-            .filter_eq("statecode", 0)
-            .filter_between("revenue", 100000, 500000)
-        )
+        qb = QueryBuilder("account").filter_eq("statecode", 0).filter_between("revenue", 100000, 500000)
         self.assertEqual(
             qb.build()["filter"],
             "statecode eq 0 and (revenue ge 100000 and revenue le 500000)",
@@ -249,12 +245,7 @@ def test_where_preserves_call_order(self):
         """Interleaved filter_*() and where() should preserve call order."""
         from PowerPlatform.Dataverse.models.filters import eq, gt
 
-        qb = (
-            QueryBuilder("account")
-            .where(eq("a", 1))
-            .filter_eq("b", 2)
-            .where(gt("c", 3))
-        )
+        qb = QueryBuilder("account").where(eq("a", 1)).filter_eq("b", 2).where(gt("c", 3))
         self.assertEqual(qb.build()["filter"], "a eq 1 and b eq 2 and c gt 3")
 
     def test_where_returns_self(self):
@@ -436,9 +427,9 @@ def test_execute_calls_get_multiple(self):
 
         qb = QueryBuilder("account")
         qb._query_ops = mock_query_ops
-        qb.select("name", "revenue").filter_eq("statecode", 0).order_by(
-            "revenue", descending=True
-        ).top(100).page_size(50).expand("primarycontactid")
+        qb.select("name", "revenue").filter_eq("statecode", 0).order_by("revenue", descending=True).top(100).page_size(
+            50
+        ).expand("primarycontactid")
 
         result = list(qb.execute())
 
@@ -459,9 +450,7 @@ def test_execute_returns_flat_records_by_default(self):
         mock_client._scoped_odata.return_value.__enter__ = MagicMock(return_value=mock_odata)
         mock_client._scoped_odata.return_value.__exit__ = MagicMock(return_value=False)
 
-        mock_odata._get_multiple.return_value = iter(
-            [[{"name": "A"}, {"name": "B"}], [{"name": "C"}]]
-        )
+        mock_odata._get_multiple.return_value = iter([[{"name": "A"}, {"name": "B"}], [{"name": "C"}]])
 
         qb = QueryBuilder("account")
         qb._query_ops = mock_query_ops

tests/unit/test_query_operations.py

@@ -69,17 +69,9 @@ def test_builder_returns_query_builder(self):
 
     def test_builder_execute_flat_default(self):
         """builder().execute() should return flat records by default."""
-        self.client._odata._get_multiple.return_value = iter(
-            [[{"accountid": "1", "name": "Test"}]]
-        )
+        self.client._odata._get_multiple.return_value = iter([[{"accountid": "1", "name": "Test"}]])
 
-        records = list(
-            self.client.query.builder("account")
-            .select("name")
-            .filter_eq("statecode", 0)
-            .top(10)
-            .execute()
-        )
+        records = list(self.client.query.builder("account").select("name").filter_eq("statecode", 0).top(10).execute())
 
         self.client._odata._get_multiple.assert_called_once_with(
             "account",
@@ -95,9 +87,7 @@ def test_builder_execute_flat_default(self):
 
     def test_builder_execute_flat_multiple_pages(self):
         """execute() should flatten records from multiple pages."""
-        self.client._odata._get_multiple.return_value = iter(
-            [[{"accountid": "1"}], [{"accountid": "2"}]]
-        )
+        self.client._odata._get_multiple.return_value = iter([[{"accountid": "1"}], [{"accountid": "2"}]])
 
         records = list(self.client.query.builder("account").execute())
 
@@ -111,9 +101,7 @@ def test_builder_execute_by_page(self):
         page2 = [{"accountid": "2"}]
         self.client._odata._get_multiple.return_value = iter([page1, page2])
 
-        pages = list(
-            self.client.query.builder("account").execute(by_page=True)
-        )
+        pages = list(self.client.query.builder("account").execute(by_page=True))
 
         self.assertEqual(len(pages), 2)
         self.assertEqual(pages[0], page1)