datajunction-server 0.0.1a46.dev3__tar.gz → 0.0.1a47__tar.gz

{datajunction_server-0.0.1a46.dev3 → datajunction_server-0.0.1a47}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: datajunction-server
-Version: 0.0.1a46.dev3
+Version: 0.0.1a47
 Summary: DataJunction server library for running to a DataJunction server
 Project-URL: repository, https://github.com/DataJunction/dj
 Author-email: DataJunction Authors <yian.shang@gmail.com>

datajunction_server-0.0.1a47/alembic/versions/2024_05_09_1420-9b1227ff17f4_update_backfill_spec.py

@@ -0,0 +1,43 @@
+"""Update backfill spec
+
+Revision ID: 9b1227ff17f4
+Revises: de7ec1c82fe0
+Create Date: 2024-05-09 14:20:26.707322+00:00
+
+"""
+# pylint: disable=no-member, invalid-name, missing-function-docstring, unused-import, no-name-in-module
+
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "9b1227ff17f4"
+down_revision = "de7ec1c82fe0"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    with op.batch_alter_table("backfill", schema=None) as batch_op:
+        batch_op.alter_column(
+            "spec",
+            existing_type=postgresql.JSON(astext_type=sa.Text()),
+            nullable=False,
+        )
+
+        # Update the backfill `spec` column to be a JSON list of partitions
+        op.execute("UPDATE backfill SET spec = jsonb_build_array(spec)")
+
+
+def downgrade():
+    with op.batch_alter_table("backfill", schema=None) as batch_op:
+        batch_op.alter_column(
+            "spec",
+            existing_type=postgresql.JSON(astext_type=sa.Text()),
+            nullable=True,
+        )
+
+        # This will cause data loss
+        op.execute("UPDATE backfill SET spec = spec->0")

datajunction_server-0.0.1a47/datajunction_server/__about__.py

@@ -0,0 +1,4 @@
+"""
+Version for Hatch
+"""
+__version__ = "0.0.1a47"

{datajunction_server-0.0.1a46.dev3 → datajunction_server-0.0.1a47}/datajunction_server/api/helpers.py

@@ -371,7 +371,9 @@ async def validate_cube(  # pylint: disable=too-many-locals
             metric_names,
             options=[
                 joinedload(Node.current).options(
-                    selectinload(NodeRevision.columns),
+                    selectinload(NodeRevision.columns).options(
+                        selectinload(Column.node_revisions),
+                    ),
                     joinedload(NodeRevision.catalog),
                     selectinload(NodeRevision.parents),
                 ),
@@ -726,7 +728,11 @@ async def build_sql_for_multiple_metrics(  # pylint: disable=too-many-arguments,
             upstream_tables=[
                 f"{leading_metric_node.current.catalog.name}.{tbl.identifier()}"  # type: ignore
                 for tbl in query_ast.find_all(ast.Table)
-                if tbl.dj_node and tbl.dj_node.type == NodeType.SOURCE
+                # If a table has a corresponding node, then we can use it as dependency.
+                # It must be either a Source node or some type of Materialized node.
+                # Even if there is no availability state for it right now, this qery may be built
+                # for future execution, so we don't need to check for availability state here.
+                if tbl.dj_node
             ],
         ),
         engine,

{datajunction_server-0.0.1a46.dev3 → datajunction_server-0.0.1a47}/datajunction_server/api/materializations.py

@@ -36,6 +36,7 @@ from datajunction_server.models.materialization import (
 )
 from datajunction_server.models.node_type import NodeType
 from datajunction_server.models.partition import PartitionBackfill
+from datajunction_server.naming import amenable_name
 from datajunction_server.service_clients import QueryServiceClient
 from datajunction_server.typing import UTCDatetime
 from datajunction_server.utils import (
@@ -105,7 +106,7 @@ async def upsert_materialization(  # pylint: disable=too-many-locals
 
     if data.strategy == MaterializationStrategy.INCREMENTAL_TIME:
         if not node.current.temporal_partition_columns():  # type: ignore
-            raise DJException(  # pragma: no cover
+            raise DJException(
                 http_status_code=HTTPStatus.BAD_REQUEST,
                 message="Cannot create materialization with strategy "
                 f"`{data.strategy}` without specifying a time partition column!",
@@ -148,6 +149,13 @@ async def upsert_materialization(  # pylint: disable=too-many-locals
             current_revision.version,  # type: ignore
             new_materialization.name,  # type: ignore
         )
+        # refresh existing materialization job
+        await schedule_materialization_jobs(
+            session,
+            node_revision_id=current_revision.id,
+            materialization_names=[new_materialization.name],
+            query_service_client=query_service_client,
+        )
         return JSONResponse(
             status_code=HTTPStatus.CREATED,
             content={
@@ -201,9 +209,11 @@ async def upsert_materialization(  # pylint: disable=too-many-locals
     )
     await session.commit()
 
-    materialization_response = schedule_materialization_jobs(
-        [new_materialization],
-        query_service_client,
+    materialization_response = await schedule_materialization_jobs(
+        session,
+        node_revision_id=current_revision.id,
+        materialization_names=[new_materialization.name],
+        query_service_client=query_service_client,
     )
     return JSONResponse(
         status_code=200,
@@ -319,7 +329,7 @@ async def deactivate_node_materializations(
 async def run_materialization_backfill(  # pylint: disable=too-many-locals
     node_name: str,
     materialization_name: str,
-    backfill_spec: PartitionBackfill,
+    backfill_partitions: List[PartitionBackfill],
     *,
     session: AsyncSession = Depends(get_session),
     query_service_client: QueryServiceClient = Depends(get_query_service_client),
@@ -359,11 +369,17 @@ async def run_materialization_backfill(  # pylint: disable=too-many-locals
     temporal_partitions = {
         col.name: col for col in node_revision.temporal_partition_columns()
     }
-    if backfill_spec.column_name not in temporal_partitions:
-        raise DJDoesNotExistException(  # pragma: no cover
-            f"Partition with name {backfill_spec.column_name} does not exist on node",
-        )
-
+    categorical_partitions = {
+        col.name: col for col in node_revision.categorical_partition_columns()
+    }
+    for backfill_spec in backfill_partitions:
+        if backfill_spec.column_name not in set(temporal_partitions).union(
+            set(categorical_partitions),
+        ):
+            raise DJDoesNotExistException(  # pragma: no cover
+                f"Partition with name {backfill_spec.column_name} does not exist on node",
+            )
+        backfill_spec.column_name = amenable_name(backfill_spec.column_name)
     materialization_jobs = {
         cls.__name__: cls for cls in MaterializationJob.__subclasses__()
     }
@@ -375,12 +391,12 @@ async def run_materialization_backfill(  # pylint: disable=too-many-locals
 
     materialization_output = clazz().run_backfill(  # type: ignore
         materialization,
-        backfill_spec,
+        backfill_partitions,
         query_service_client,
     )
     backfill = Backfill(
         materialization=materialization,
-        spec=backfill_spec.dict(),
+        spec=[backfill_partition.dict() for backfill_partition in backfill_partitions],
         urls=materialization_output.urls,
     )
     materialization.backfills.append(backfill)
@@ -391,7 +407,9 @@ async def run_materialization_backfill(  # pylint: disable=too-many-locals
         activity_type=ActivityType.CREATE,
         details={
             "materialization": materialization_name,
-            "partition": backfill_spec.dict(),
+            "partition": [
+                backfill_partition.dict() for backfill_partition in backfill_partitions
+            ],
         },
         user=current_user.username if current_user else None,
     )

{datajunction_server-0.0.1a46.dev3 → datajunction_server-0.0.1a47}/datajunction_server/construction/build.py

@@ -1,5 +1,4 @@
-# pylint: disable=too-many-arguments,too-many-locals,too-many-nested-blocks,too-many-branches,R0401
-# pylint: disable=too-many-lines,protected-access
+# pylint: disable=too-many-arguments,too-many-locals,too-many-nested-blocks,too-many-branches,R0401,too-many-lines,protected-access,line-too-long
 """Functions for building DJ node queries"""
 import collections
 import logging

{datajunction_server-0.0.1a46.dev3 → datajunction_server-0.0.1a47}/datajunction_server/database/backfill.py

@@ -24,7 +24,7 @@ class Backfill(Base):  # type: ignore  # pylint: disable=too-few-public-methods
         primary_key=True,
     )
 
-    # The column reference that this partition is defined on
+    # The column reference that this backfill is defined on
     materialization_id: Mapped[int] = mapped_column(
         ForeignKey(
             "materialization.id",
@@ -37,9 +37,9 @@ class Backfill(Base):  # type: ignore  # pylint: disable=too-few-public-methods
     )
 
     # Backfilled values and range
-    spec: Mapped[Optional[PartitionBackfill]] = mapped_column(
+    spec: Mapped[List[PartitionBackfill]] = mapped_column(
         JSON,
-        default={},
+        default=[],
     )
 
     urls: Mapped[Optional[List[str]]] = mapped_column(

{datajunction_server-0.0.1a46.dev3 → datajunction_server-0.0.1a47}/datajunction_server/database/materialization.py

@@ -2,9 +2,20 @@
 from typing import TYPE_CHECKING, List, Optional, Union
 
 import sqlalchemy as sa
-from sqlalchemy import JSON, DateTime, Enum, ForeignKey, String, UniqueConstraint
-from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy import (
+    JSON,
+    DateTime,
+    Enum,
+    ForeignKey,
+    String,
+    UniqueConstraint,
+    and_,
+    select,
+)
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import Mapped, joinedload, mapped_column, relationship
 
+from datajunction_server.database import Column
 from datajunction_server.database.backfill import Backfill
 from datajunction_server.database.base import Base
 from datajunction_server.models.materialization import (
@@ -84,3 +95,34 @@ class Materialization(Base):  # pylint: disable=too-few-public-methods
         cascade="all, delete",
         lazy="selectin",
     )
+
+    @classmethod
+    async def get_by_names(
+        cls,
+        session: AsyncSession,
+        node_revision_id: int,
+        materialization_names: List[str],
+    ) -> List["Materialization"]:
+        """
+        Get materializations by name and node revision id.
+        """
+        from datajunction_server.database.node import (  # pylint: disable=import-outside-toplevel
+            NodeRevision,
+        )
+
+        statement = (
+            select(cls)
+            .where(
+                and_(
+                    cls.name.in_(materialization_names),
+                    cls.node_revision_id == node_revision_id,
+                ),
+            )
+            .options(
+                joinedload(cls.node_revision).options(
+                    joinedload(NodeRevision.columns).joinedload(Column.partition),
+                ),
+            )
+        )
+        result = await session.execute(statement)
+        return result.unique().scalars().all()

{datajunction_server-0.0.1a46.dev3 → datajunction_server-0.0.1a47}/datajunction_server/database/partition.py

@@ -1,4 +1,5 @@
 """Partition database schema."""
+import re
 from typing import Optional
 
 from sqlalchemy import BigInteger, Enum, ForeignKey, Integer
@@ -7,6 +8,8 @@ from sqlalchemy.orm import Mapped, mapped_column, relationship
 from datajunction_server.database.base import Base
 from datajunction_server.database.column import Column
 from datajunction_server.models.partition import Granularity, PartitionType
+from datajunction_server.naming import amenable_name
+from datajunction_server.sql.functions import Function, function_registry
 from datajunction_server.sql.parsing.types import TimestampType
 
 
@@ -94,3 +97,35 @@ class Partition(Base):  # type: ignore  # pylint: disable=too-few-public-methods
                 data_type=self.column.type,  # pylint: disable=no-member
             )
         return None  # pragma: no cover
+
+    def categorical_expression(self):
+        """
+        Expression for the categorical partition
+        """
+        from datajunction_server.sql.parsing import (  # pylint: disable=import-outside-toplevel
+            ast,
+        )
+
+        # Register a DJ function (inherits the `datajunction_server.sql.functions.Function` class)
+        # that has the partition column name as the function name. This will be substituted at
+        # runtime with the partition column name
+        amenable_partition_name = amenable_name(self.column.name)
+        clazz = type(
+            amenable_partition_name,
+            (Function,),
+            {
+                "is_runtime": True,
+                "substitute": staticmethod(lambda: f"${{{amenable_partition_name}}}"),
+            },
+        )
+        snake_cased = re.sub(r"(?<!^)(?=[A-Z])", "_", clazz.__name__)
+        function_registry[clazz.__name__.upper()] = clazz
+        function_registry[snake_cased.upper()] = clazz
+
+        return ast.Cast(
+            expression=ast.Function(
+                name=ast.Name(amenable_partition_name),
+                args=[],
+            ),
+            data_type=self.column.type,
+        )

{datajunction_server-0.0.1a46.dev3 → datajunction_server-0.0.1a47}/datajunction_server/internal/materializations.py

@@ -233,6 +233,7 @@ async def create_new_materialization(
             upsert,
         )
 
+    categorical_partitions = current_revision.categorical_partition_columns()
     if current_revision.type == NodeType.CUBE:
         if not temporal_partition and not timestamp_columns:
             raise DJInvalidInputException(
@@ -249,6 +250,8 @@ async def create_new_materialization(
     materialization_name = (
         f"{upsert.job.name.lower()}__{upsert.strategy.name.lower()}"
         + (f"__{temporal_partition[0].name}" if temporal_partition else "")
+        + ("__" if categorical_partitions else "")
+        + ("__".join([partition.name for partition in categorical_partitions]))
     )
     return Materialization(
         name=materialization_name,
@@ -260,13 +263,20 @@ async def create_new_materialization(
     )
 
 
-def schedule_materialization_jobs(
-    materializations: List[Materialization],
+async def schedule_materialization_jobs(
+    session: AsyncSession,
+    node_revision_id: int,
+    materialization_names: List[str],
     query_service_client: QueryServiceClient,
 ) -> Dict[str, MaterializationInfo]:
     """
     Schedule recurring materialization jobs
     """
+    materializations = await Materialization.get_by_names(
+        session,
+        node_revision_id,
+        materialization_names,
+    )
     materialization_jobs = {
         cls.__name__: cls for cls in MaterializationJob.__subclasses__()
     }

{datajunction_server-0.0.1a46.dev3 → datajunction_server-0.0.1a47}/datajunction_server/internal/nodes.py

@@ -641,7 +641,11 @@ async def update_node_with_query(
             )
         background_tasks.add_task(
             schedule_materialization_jobs,
-            materializations=node.current.materializations,  # type: ignore
+            session=session,
+            node_revision_id=node.current.id,  # type: ignore
+            materialization_names=[
+                mat.name for mat in node.current.materializations  # type: ignore
+            ],
             query_service_client=query_service_client,
         )
         session.add(new_revision)
@@ -803,21 +807,31 @@ async def update_cube_node(  # pylint: disable=too-many-locals
                     user=current_user.username if current_user else None,
                 ),
             )
-        if background_tasks:
-            background_tasks.add_task(
-                schedule_materialization_jobs,
-                materializations=new_cube_revision.materializations,
-                query_service_client=query_service_client,
-            )
-        else:
-            schedule_materialization_jobs(  # pragma: no cover
-                materializations=new_cube_revision.materializations,
-                query_service_client=query_service_client,
-            )
     session.add(new_cube_revision)
     session.add(new_cube_revision.node)
     await session.commit()
 
+    await session.refresh(new_cube_revision, ["materializations"])
+    if background_tasks:
+        background_tasks.add_task(  # pragma: no cover
+            schedule_materialization_jobs,
+            session=session,
+            node_revision_id=new_cube_revision.id,
+            materialization_names=[
+                mat.name for mat in new_cube_revision.materializations
+            ],
+            query_service_client=query_service_client,
+        )
+    else:
+        await schedule_materialization_jobs(  # pragma: no cover
+            session=session,
+            node_revision_id=new_cube_revision.id,
+            materialization_names=[
+                mat.name for mat in new_cube_revision.materializations
+            ],
+            query_service_client=query_service_client,
+        )
+
     await session.refresh(new_cube_revision)
     await session.refresh(new_cube_revision.node)
     await session.refresh(new_cube_revision.node.current)

{datajunction_server-0.0.1a46.dev3 → datajunction_server-0.0.1a47}/datajunction_server/materialization/jobs/cube_materialization.py

@@ -130,6 +130,7 @@ def build_materialization_query(
         ),
         ctes=cube_materialization_query_ast.ctes,
     )
+
     if materialization.strategy == MaterializationStrategy.INCREMENTAL_TIME:
         temporal_partitions = node_revision.temporal_partition_columns()
         temporal_partition_col = [
@@ -137,13 +138,38 @@ def build_materialization_query(
             for col in cube_materialization_query_ast.select.projection
             if col.alias_or_name.name == amenable_name(temporal_partitions[0].name)  # type: ignore
         ]
-        final_query.select.where = ast.BinaryOp(
+        temporal_op = ast.BinaryOp(
             left=ast.Column(
                 name=ast.Name(temporal_partition_col[0].alias_or_name.name),  # type: ignore
             ),
             right=temporal_partitions[0].partition.temporal_expression(),
             op=ast.BinaryOpKind.Eq,
         )
+
+        categorical_partitions = node_revision.categorical_partition_columns()
+        print("categorical_partitions", categorical_partitions)
+        if categorical_partitions:
+            categorical_partition_col = [
+                col
+                for col in cube_materialization_query_ast.select.projection
+                if col.alias_or_name.name  # type: ignore
+                == amenable_name(categorical_partitions[0].name)  # type: ignore
+            ]
+            categorical_op = ast.BinaryOp(
+                left=ast.Column(
+                    name=ast.Name(categorical_partition_col[0].alias_or_name.name),  # type: ignore
+                ),
+                right=categorical_partitions[0].partition.categorical_expression(),
+                op=ast.BinaryOpKind.Eq,
+            )
+            final_query.select.where = ast.BinaryOp(
+                left=temporal_op,
+                right=categorical_op,
+                op=ast.BinaryOpKind.And,
+            )
+        else:
+            final_query.select.where = temporal_op
+
     combiner_cte = ast.Query(select=cube_materialization_query_ast.select).set_alias(
         ast.Name("combiner_query"),
     )
@@ -155,4 +181,5 @@ def build_materialization_query(
     final_query.select.from_ = ast.From(
         relations=[ast.Relation(primary=ast.Table(name=ast.Name("combiner_query")))],
     )
+    print("final_queryfinal_query", final_query)
     return final_query

{datajunction_server-0.0.1a46.dev3 → datajunction_server-0.0.1a47}/datajunction_server/materialization/jobs/materialization_job.py

@@ -2,7 +2,7 @@
 Available materialization jobs.
 """
 import abc
-from typing import Optional
+from typing import List, Optional
 
 from datajunction_server.database.materialization import Materialization
 from datajunction_server.models.engine import Dialect
@@ -13,6 +13,7 @@ from datajunction_server.models.materialization import (
     MaterializationStrategy,
 )
 from datajunction_server.models.partition import PartitionBackfill
+from datajunction_server.naming import amenable_name
 from datajunction_server.service_clients import QueryServiceClient
 from datajunction_server.sql.parsing import ast
 from datajunction_server.sql.parsing.backends.antlr4 import parse
@@ -34,7 +35,7 @@ class MaterializationJob(abc.ABC):  # pylint: disable=too-few-public-methods
     def run_backfill(
         self,
         materialization: Materialization,
-        backfill: PartitionBackfill,
+        partitions: List[PartitionBackfill],
         query_service_client: QueryServiceClient,
     ) -> MaterializationInfo:
         """
@@ -43,7 +44,7 @@ class MaterializationJob(abc.ABC):  # pylint: disable=too-few-public-methods
         return query_service_client.run_backfill(
             materialization.node_revision.name,
             materialization.name,  # type: ignore
-            backfill,
+            partitions,
         )
 
     @abc.abstractmethod
@@ -93,6 +94,29 @@ class SparkSqlMaterializationJob(  # pylint: disable=too-few-public-methods # pr
                 for col in query_ast.select.projection
                 if col.alias_or_name.name.endswith(temporal_partitions[0].name)  # type: ignore
             ]
+            temporal_op = (
+                ast.BinaryOp(
+                    left=ast.Column(
+                        name=ast.Name(
+                            temporal_partition_col[0].alias_or_name.name,  # type: ignore
+                        ),
+                    ),
+                    right=temporal_partitions[0].partition.temporal_expression(),
+                    op=ast.BinaryOpKind.Eq,
+                )
+                if not generic_config.lookback_window
+                else ast.Between(
+                    expr=ast.Column(
+                        name=ast.Name(
+                            temporal_partition_col[0].alias_or_name.name,  # type: ignore
+                        ),
+                    ),
+                    low=temporal_partitions[0].partition.temporal_expression(
+                        interval=generic_config.lookback_window,
+                    ),
+                    high=temporal_partitions[0].partition.temporal_expression(),
+                )
+            )
             final_query = ast.Query(
                 select=ast.Select(
                     projection=[
@@ -100,31 +124,36 @@ class SparkSqlMaterializationJob(  # pylint: disable=too-few-public-methods # pr
                         for col in query_ast.select.projection
                     ],
                     from_=query_ast.select.from_,
-                    where=ast.BinaryOp(
-                        left=ast.Column(
-                            name=ast.Name(
-                                temporal_partition_col[0].alias_or_name.name,  # type: ignore
-                            ),
-                        ),
-                        right=temporal_partitions[0].partition.temporal_expression(),
-                        op=ast.BinaryOpKind.Eq,
-                    )
-                    if not generic_config.lookback_window
-                    else ast.Between(
-                        expr=ast.Column(
-                            name=ast.Name(
-                                temporal_partition_col[0].alias_or_name.name,  # type: ignore
-                            ),
-                        ),
-                        low=temporal_partitions[0].partition.temporal_expression(
-                            interval=generic_config.lookback_window,
-                        ),
-                        high=temporal_partitions[0].partition.temporal_expression(),
-                    ),
+                    where=temporal_op,
                 ),
                 ctes=query_ast.ctes,
             )
 
+            categorical_partitions = (
+                materialization.node_revision.categorical_partition_columns()
+            )
+            if categorical_partitions:
+                categorical_partition_col = [
+                    col
+                    for col in final_query.select.projection
+                    if col.alias_or_name.name  # type: ignore
+                    == amenable_name(categorical_partitions[0].name)  # type: ignore
+                ]
+                categorical_op = ast.BinaryOp(
+                    left=ast.Column(
+                        name=ast.Name(
+                            categorical_partition_col[0].alias_or_name.name,  # type: ignore
+                        ),
+                    ),
+                    right=categorical_partitions[0].partition.categorical_expression(),
+                    op=ast.BinaryOpKind.Eq,
+                )
+                final_query.select.where = ast.BinaryOp(
+                    left=temporal_op,
+                    right=categorical_op,
+                    op=ast.BinaryOpKind.And,
+                )
+
         result = query_service_client.materialize(
             GenericMaterializationInput(
                 name=materialization.name,  # type: ignore

{datajunction_server-0.0.1a46.dev3 → datajunction_server-0.0.1a47}/datajunction_server/models/materialization.py

@@ -208,7 +208,7 @@ class GenericMaterializationConfig(GenericMaterializationConfigInput):
                 type_=PartitionType.CATEGORICAL,
             )
             for col in self.columns  # type: ignore
-            if col.column in user_defined_categorical_columns
+            if col.semantic_entity in user_defined_categorical_columns
         ]
 
 

{datajunction_server-0.0.1a46.dev3 → datajunction_server-0.0.1a47}/datajunction_server/models/node.py

@@ -124,7 +124,7 @@ class NodeRevisionBase(BaseModel):
     name: str
     display_name: Optional[str]
     type: NodeType
-    description: str = ""
+    description: Optional[str] = ""
     query: Optional[str] = None
     mode: NodeMode = NodeMode.PUBLISHED
 

{datajunction_server-0.0.1a46.dev3 → datajunction_server-0.0.1a47}/datajunction_server/models/partition.py

@@ -99,7 +99,7 @@ class BackfillOutput(BaseModel):
     Output model for backfills
     """
 
-    spec: Optional[PartitionBackfill]
+    spec: Optional[List[PartitionBackfill]]
     urls: Optional[List[str]]
 
     class Config:  # pylint: disable=missing-class-docstring, too-few-public-methods

{datajunction_server-0.0.1a46.dev3 → datajunction_server-0.0.1a47}/datajunction_server/service_clients.py

@@ -192,11 +192,7 @@ class QueryServiceClient:  # pylint: disable=too-few-public-methods
         Deactivates the specified node materialization
         """
         response = self.requests_session.delete(
-            "/materialization/",
-            params={
-                "node_name": node_name,
-                "materialization_name": materialization_name,
-            },
+            f"/materialization/{node_name}/{materialization_name}/",
         )
         if response.status_code not in (200, 201):  # pragma: no cover
             return MaterializationInfo(urls=[], output_tables=[])
@@ -224,12 +220,12 @@ class QueryServiceClient:  # pylint: disable=too-few-public-methods
         self,
         node_name: str,
         materialization_name: str,
-        backfill: PartitionBackfill,
+        partitions: List[PartitionBackfill],
     ) -> MaterializationInfo:
         """Kicks off a backfill with the given backfill spec"""
         response = self.requests_session.post(
             f"/materialization/run/{node_name}/{materialization_name}/",
-            json=backfill.dict(),
+            json=[partition.dict() for partition in partitions],
             timeout=20,
         )
         if response.status_code not in (200, 201):

{datajunction_server-0.0.1a46.dev3 → datajunction_server-0.0.1a47}/pyproject.toml

@@ -124,3 +124,6 @@ profile = 'black'
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
+testpaths = [
+    "tests",
+]