datajunction-server 0.0.1a87__tar.gz → 0.0.1a87.dev0__tar.gz

{datajunction_server-0.0.1a87 → datajunction_server-0.0.1a87.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.3
 Name: datajunction-server
-Version: 0.0.1a87
+Version: 0.0.1a87.dev0
 Summary: DataJunction server library for running to a DataJunction server
 Project-URL: Homepage, https://datajunction.io
 Project-URL: Repository, https://github.com/DataJunction/dj

datajunction_server-0.0.1a87.dev0/datajunction_server/__about__.py

@@ -0,0 +1,5 @@
+"""
+Version for Hatch
+"""
+
+__version__ = "0.0.1a87.dev0"

datajunction_server-0.0.1a87.dev0/datajunction_server/internal/caching/cachelib_cache.py

@@ -0,0 +1,44 @@
+"""
+Cachelib-based cache implementation
+"""
+
+from typing import Any, Optional
+
+from cachelib import SimpleCache
+from fastapi import Request
+
+from datajunction_server.internal.caching.interface import Cache, CacheInterface
+from datajunction_server.internal.caching.noop_cache import noop_cache
+
+
+class CachelibCache(Cache):
+    """A standard implementation of CacheInterface that uses cachelib"""
+
+    def __init__(self):
+        super().__init__()
+        self.cache = SimpleCache()
+
+    def get(self, key: str) -> Optional[Any]:
+        """Get a cached value from the simple cache"""
+        super().get(key)
+        return self.cache.get(key)
+
+    def set(self, key: str, value: Any, timeout: int = 3600) -> None:
+        """Cache a value in the simple cache"""
+        super().set(key, value, timeout)
+        self.cache.set(key, value, timeout=timeout)
+
+    def delete(self, key: str) -> None:
+        """Delete a key in the simple cache"""
+        super().delete(key)
+        self.cache.delete(key)
+
+
+cachelib_cache = CachelibCache()
+
+
+def get_cache(request: Request) -> Optional[CacheInterface]:
+    """Dependency for retrieving a cachelib-based cache implementation"""
+    cache_control = request.headers.get("Cache-Control", "")
+    skip_cache = "no-cache" in cache_control
+    return noop_cache if skip_cache else cachelib_cache

datajunction_server-0.0.1a87.dev0/datajunction_server/internal/caching/interface.py

@@ -0,0 +1,51 @@
+"""
+Caching interface and logging wrapper
+"""
+
+import logging
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+
+
+class CacheInterface(ABC):
+    """Cache interface"""
+
+    @abstractmethod
+    def get(self, key: str) -> Optional[Any]:
+        """Get a cached value"""
+
+    @abstractmethod
+    def set(self, key: str, value: Any, timeout: int = 300) -> None:
+        """Cache a value"""
+
+    @abstractmethod
+    def delete(self, key: str) -> None:
+        """Delete a cache key"""
+
+
+class Cache(CacheInterface):
+    """A wrapper for the cache interface to ensure standardized logging"""
+
+    def __init__(self):
+        self.logger = logging.getLogger(self.__class__.__name__)
+
+    def get(self, key: str) -> Optional[Any]:  # type: ignore
+        """Log the cache check and then use the implemented cache"""
+        self.logger.info(
+            "%s: Getting cached value for key %s",
+            self.__class__.__name__,
+            key,
+        )
+
+    def set(self, key: str, value: Any, timeout: int = 300) -> None:
+        """Log the cache attempt and then use the implemented cache"""
+        self.logger.info(
+            "%s: Setting value for key %s with timeout: %s",
+            self.__class__.__name__,
+            key,
+            timeout,
+        )
+
+    def delete(self, key: str) -> None:
+        """Log the cache deletion attempt and then use the implemented cache"""
+        self.logger.info("%s: Deleting key %s", self.__class__.__name__, key)

datajunction_server-0.0.1a87.dev0/datajunction_server/internal/caching/noop_cache.py

@@ -0,0 +1,12 @@
+"""
+NoOp cache implementation
+"""
+
+from datajunction_server.internal.caching.interface import Cache
+
+
+class NoOpCache(Cache):
+    """A NoOp implementation of CacheInterface that returns None for get and set"""
+
+
+noop_cache = NoOpCache()

{datajunction_server-0.0.1a87 → datajunction_server-0.0.1a87.dev0}/datajunction_server/internal/cube_materializations.py

@@ -4,6 +4,7 @@ import itertools
 
 from sqlalchemy.ext.asyncio import AsyncSession
 
+from datajunction_server.sql.parsing.backends.antlr4 import parse
 from datajunction_server.construction.build_v2 import get_measures_query
 from datajunction_server.database.node import Column, NodeRevision
 from datajunction_server.errors import DJInvalidInputException
@@ -137,6 +138,20 @@ def _combine_measures_join_criteria(left_table, right_table, query_grain):
     )
 
 
+def _extract_expression(metric_query: str) -> str:
+    """
+    Extract only the derived metric expression from a metric query.
+    """
+    expression = parse(metric_query).select.projection[0]
+    return str(
+        expression.child
+        if isinstance(expression, ast.Alias)
+        else expression.without_aliases()
+        if isinstance(expression, ast.Expression)
+        else expression,
+    )
+
+
 async def build_cube_materialization(
     session: AsyncSession,
     current_revision: NodeRevision,
@@ -247,12 +262,14 @@ async def build_cube_materialization(
         cube=NodeNameVersion(
             name=current_revision.name,
             version=current_revision.version,
+            display_name=current_revision.display_name,
         ),
         metrics=[
             CubeMetric(
                 metric=NodeNameVersion(
                     name=metric.name,
                     version=metric.current_version,
+                    display_name=metric.current.display_name,
                 ),
                 required_measures=[
                     MeasureKey(
@@ -262,6 +279,9 @@ async def build_cube_materialization(
                     for measure in metrics_mapping.get(metric.name)[1][0]  # type: ignore
                 ],
                 derived_expression=metrics_mapping.get(metric.name)[1][1],  # type: ignore
+                metric_expression=_extract_expression(
+                    metrics_mapping.get(metric.name)[1][1],  # type: ignore
+                ),
             )
             for metric in current_revision.cube_metrics()
         ],

{datajunction_server-0.0.1a87 → datajunction_server-0.0.1a87.dev0}/datajunction_server/models/cube_materialization.py

@@ -207,7 +207,13 @@ class CubeMetric(BaseModel):
     )
     derived_expression: str = Field(
         description=(
-            "The expression for rewriting the original metric query "
+            "The query for rewriting the original metric query "
+            "using the materialized measures."
+        ),
+    )
+    metric_expression: str = Field(
+        description=(
+            "SQL expression for rewriting the original metric query "
             "using the materialized measures."
         ),
     )

{datajunction_server-0.0.1a87 → datajunction_server-0.0.1a87.dev0}/datajunction_server/models/node_type.py

@@ -43,6 +43,7 @@ class NodeNameVersion(BaseModel):
 
     name: str
     version: str
+    display_name: str | None
 
     class Config:
         orm_mode = True

{datajunction_server-0.0.1a87 → datajunction_server-0.0.1a87.dev0}/tests/api/cubes_test.py

@@ -2213,6 +2213,7 @@ async def test_cube_materialization_metadata(
     assert results["cube"] == {
         "name": "default.example_repairs_cube",
         "version": "v1.0",
+        "display_name": "Example Repairs Cube",
     }
     assert results["job"] == "DRUID_CUBE"
     assert results["lookback_window"] == "1 DAY"
@@ -2232,9 +2233,12 @@ async def test_cube_materialization_metadata(
             "derived_expression": "SELECT  CAST(sum(discount_sum_62846f49) AS DOUBLE) / "
             "SUM(count_3389dae3) AS default_DOT_discounted_orders_rate  FROM "
             "default.repair_orders_fact",
+            "metric_expression": "CAST(sum(discount_sum_62846f49) AS DOUBLE) / "
+            "SUM(count_3389dae3)",
             "metric": {
                 "name": "default.discounted_orders_rate",
                 "version": "v1.0",
+                "display_name": "Discounted Orders Rate",
             },
             "required_measures": [
                 {
@@ -2242,6 +2246,7 @@ async def test_cube_materialization_metadata(
                     "node": {
                         "name": "default.repair_orders_fact",
                         "version": "v1.0",
+                        "display_name": "Repair Orders Fact",
                     },
                 },
                 {
@@ -2249,6 +2254,7 @@ async def test_cube_materialization_metadata(
                     "node": {
                         "name": "default.repair_orders_fact",
                         "version": "v1.0",
+                        "display_name": "Repair Orders Fact",
                     },
                 },
             ],
@@ -2256,9 +2262,11 @@ async def test_cube_materialization_metadata(
         {
             "derived_expression": "SELECT  SUM(repair_order_id_count_0b7dfba0)  FROM "
             "default.repair_orders_fact",
+            "metric_expression": "SUM(repair_order_id_count_0b7dfba0)",
             "metric": {
                 "name": "default.num_repair_orders",
                 "version": "v1.0",
+                "display_name": "Num Repair Orders",
             },
             "required_measures": [
                 {
@@ -2266,6 +2274,7 @@ async def test_cube_materialization_metadata(
                     "node": {
                         "name": "default.repair_orders_fact",
                         "version": "v1.0",
+                        "display_name": "Repair Orders Fact",
                     },
                 },
             ],
@@ -2273,9 +2282,11 @@ async def test_cube_materialization_metadata(
         {
             "derived_expression": "SELECT  SUM(price_sum_78a5eb43) / SUM(price_count_78a5eb43)  FROM "
             "default.repair_orders_fact",
+            "metric_expression": "SUM(price_sum_78a5eb43) / SUM(price_count_78a5eb43)",
             "metric": {
                 "name": "default.avg_repair_price",
                 "version": "v1.0",
+                "display_name": "Avg Repair Price",
             },
             "required_measures": [
                 {
@@ -2283,6 +2294,7 @@ async def test_cube_materialization_metadata(
                     "node": {
                         "name": "default.repair_orders_fact",
                         "version": "v1.0",
+                        "display_name": "Repair Orders Fact",
                     },
                 },
                 {
@@ -2290,6 +2302,7 @@ async def test_cube_materialization_metadata(
                     "node": {
                         "name": "default.repair_orders_fact",
                         "version": "v1.0",
+                        "display_name": "Repair Orders Fact",
                     },
                 },
             ],
@@ -2297,9 +2310,11 @@ async def test_cube_materialization_metadata(
         {
             "derived_expression": "SELECT  sum(total_repair_cost_sum_9bdaf803)  FROM "
             "default.repair_orders_fact",
+            "metric_expression": "sum(total_repair_cost_sum_9bdaf803)",
             "metric": {
                 "name": "default.total_repair_cost",
                 "version": "v1.0",
+                "display_name": "Total Repair Cost",
             },
             "required_measures": [
                 {
@@ -2307,6 +2322,7 @@ async def test_cube_materialization_metadata(
                     "node": {
                         "name": "default.repair_orders_fact",
                         "version": "v1.0",
+                        "display_name": "Repair Orders Fact",
                     },
                 },
             ],
@@ -2314,9 +2330,11 @@ async def test_cube_materialization_metadata(
         {
             "derived_expression": "SELECT  sum(price_discount_sum_017d55a8)  FROM "
             "default.repair_orders_fact",
+            "metric_expression": "sum(price_discount_sum_017d55a8)",
             "metric": {
                 "name": "default.total_repair_order_discounts",
                 "version": "v1.0",
+                "display_name": "Total Repair Order Discounts",
             },
             "required_measures": [
                 {
@@ -2324,6 +2342,7 @@ async def test_cube_materialization_metadata(
                     "node": {
                         "name": "default.repair_orders_fact",
                         "version": "v1.0",
+                        "display_name": "Repair Orders Fact",
                     },
                 },
             ],
@@ -2332,9 +2351,11 @@ async def test_cube_materialization_metadata(
             "derived_expression": "SELECT  sum(price_sum_78a5eb43) + sum(price_sum_78a5eb43) AS "
             "default_DOT_double_total_repair_cost  FROM "
             "default.repair_order_details",
+            "metric_expression": "sum(price_sum_78a5eb43) + sum(price_sum_78a5eb43)",
             "metric": {
                 "name": "default.double_total_repair_cost",
                 "version": "v1.0",
+                "display_name": "Double Total Repair Cost",
             },
             "required_measures": [
                 {
@@ -2342,6 +2363,7 @@ async def test_cube_materialization_metadata(
                     "node": {
                         "name": "default.repair_order_details",
                         "version": "v1.0",
+                        "display_name": "default.roads.repair_order_details",
                     },
                 },
             ],
@@ -2550,6 +2572,7 @@ async def test_cube_materialization_metadata(
             "node": {
                 "name": "default.repair_orders_fact",
                 "version": "v1.0",
+                "display_name": "Repair Orders Fact",
             },
             "output_table_name": "default_repair_orders_fact_v1_0_c9390406463b348e",
             "query": mock.ANY,
@@ -2666,6 +2689,7 @@ async def test_cube_materialization_metadata(
             "node": {
                 "name": "default.repair_order_details",
                 "version": "v1.0",
+                "display_name": "default.roads.repair_order_details",
             },
             "output_table_name": "default_repair_order_details_v1_0_5bf367d2fc7c255d",
             "query": mock.ANY,
@@ -3081,6 +3105,7 @@ async def test_cube_materialization_metadata(
                 },
             ],
             "node": {
+                "display_name": "Example Repairs Cube",
                 "name": "default.example_repairs_cube",
                 "version": "v1.0",
             },

{datajunction_server-0.0.1a87 → datajunction_server-0.0.1a87.dev0}/tests/api/materializations_test.py

@@ -803,6 +803,7 @@ async def test_druid_cube_incremental(
     assert mat.cube == NodeNameVersion(
         name="default.repairs_cube__default_incremental",
         version="v1.0",
+        display_name="Repairs Cube  Default Incremental",
     )
     assert mat.dimensions == [
         "default.repair_orders_fact.order_date",
@@ -812,37 +813,50 @@ async def test_druid_cube_incremental(
     ]
     assert mat.metrics == [
         CubeMetric(
-            metric=NodeNameVersion(name="default.num_repair_orders", version="v1.0"),
+            metric=NodeNameVersion(
+                name="default.num_repair_orders",
+                version="v1.0",
+                display_name="Num Repair Orders",
+            ),
             required_measures=[
                 MeasureKey(
                     node=NodeNameVersion(
                         name="default.repair_orders_fact",
                         version=ANY_STRING,
+                        display_name="Repair Orders Fact",
                     ),
                     measure_name="repair_order_id_count_0b7dfba0",
                 ),
             ],
             derived_expression="SELECT  SUM(repair_order_id_count_0b7dfba0)"
             "  FROM default.repair_orders_fact",
+            metric_expression="SUM(repair_order_id_count_0b7dfba0)",
         ),
         CubeMetric(
-            metric=NodeNameVersion(name="default.total_repair_cost", version="v1.0"),
+            metric=NodeNameVersion(
+                name="default.total_repair_cost",
+                version="v1.0",
+                display_name="Total Repair Cost",
+            ),
             required_measures=[
                 MeasureKey(
                     node=NodeNameVersion(
                         name="default.repair_orders_fact",
                         version=ANY_STRING,
+                        display_name="Repair Orders Fact",
                     ),
                     measure_name="total_repair_cost_sum_9bdaf803",
                 ),
             ],
             derived_expression="SELECT  sum(total_repair_cost_sum_9bdaf803)"
             "  FROM default.repair_orders_fact",
+            metric_expression="sum(total_repair_cost_sum_9bdaf803)",
         ),
     ]
     assert mat.measures_materializations[0].node == NodeNameVersion(
         name="default.repair_orders_fact",
         version=ANY_STRING,
+        display_name="Repair Orders Fact",
     )
     assert mat.measures_materializations[0].grain == [
         "default_DOT_repair_orders_fact_DOT_order_date",
@@ -942,6 +956,7 @@ async def test_druid_cube_incremental(
     assert mat.combiners[0].node == NodeNameVersion(
         name="default.repair_orders_fact",
         version=ANY_STRING,
+        display_name="Repair Orders Fact",
     )
     assert mat.combiners[0].query is None
     assert mat.combiners[0].columns == [

datajunction_server-0.0.1a87.dev0/tests/internal/caching/cachelib_cache_test.py

@@ -0,0 +1,62 @@
+"""
+Tests for cachelib cache implementation
+"""
+
+from starlette.requests import Headers, Request
+
+from datajunction_server.internal.caching.cachelib_cache import CachelibCache, get_cache
+from datajunction_server.internal.caching.noop_cache import NoOpCache
+
+
+def test_cachelib_cache():
+    """
+    Test getting, setting, and deleting using the cachelib implementation
+    """
+    cache = CachelibCache()
+    assert cache.set(key="foo", value="bar", timeout=300) is None
+    assert cache.get(key="foo") == "bar"
+    assert cache.delete(key="foo") is None
+    assert cache.get(key="foo") is None
+
+
+def test_cachelib_cache_nocache_headers():
+    """Test cachelib cache with various request headers"""
+
+    # Test with "no-cache" in headers
+    nocache_request = Request(
+        {
+            "type": "http",
+            "method": "GET",
+            "path": "/",
+            "headers": Headers({"Cache-Control": "no-cache"}).raw,
+            "query_string": b"",
+        },
+    )
+    get_cache(nocache_request)
+    assert isinstance(get_cache(nocache_request), NoOpCache)
+
+    # Test without "no-cache" in headers
+    request = Request(
+        {
+            "type": "http",
+            "method": "GET",
+            "path": "/",
+            "headers": Headers({"Cache-Control": "max-age=3600"}).raw,
+            "query_string": b"",
+        },
+    )
+    get_cache(request)
+    assert isinstance(get_cache(request), CachelibCache)
+
+    # Test with no headers at all
+    headerless_request = Request(
+        {
+            "type": "http",
+            "method": "GET",
+            "path": "/",
+            "headers": [],
+            "query_string": b"",
+        },
+    )
+
+    assert isinstance(get_cache(headerless_request), CachelibCache)

datajunction_server-0.0.1a87.dev0/tests/internal/caching/noop_cache_test.py

@@ -0,0 +1,17 @@
+"""
+Tests for noop cache
+"""
+
+from datajunction_server.internal.caching.noop_cache import NoOpCache
+
+
+def test_noop_cache():
+    """
+    Test getting, setting, and deleting using a NoOpCache implementation
+    """
+    cache = NoOpCache()
+    assert cache.set(key="foo", value="bar") is None
+    assert (
+        cache.get(key="foo") is None
+    )  # Returns None because NoOp doesn't actually cache
+    assert cache.delete(key="foo") is None

{datajunction_server-0.0.1a87 → datajunction_server-0.0.1a87.dev0}/tests/service_clients_test.py

@@ -790,6 +790,7 @@ class TestQueryServiceClient:
                     metric=NodeNameVersion(
                         name="default.num_repair_orders",
                         version="v1.0",
+                        display_name=None,
                     ),
                     required_measures=[
                         MeasureKey(
@@ -800,12 +801,14 @@ class TestQueryServiceClient:
                             measure_name="count",
                         ),
                     ],
-                    derived_expression="SUM(count)",
+                    derived_expression="SELECT SUM(count) FROM default.repair_orders",
+                    metric_expression="SUM(count)",
                 ),
                 CubeMetric(
                     metric=NodeNameVersion(
                         name="default.avg_repair_price",
                         version="v1.0",
+                        display_name=None,
                     ),
                     required_measures=[
                         MeasureKey(
@@ -816,7 +819,8 @@ class TestQueryServiceClient:
                             measure_name="sum_price_123abc",
                         ),
                     ],
-                    derived_expression="SUM(sum_price_123abc)",
+                    derived_expression="SELECT SUM(sum_price_123abc) FROM default.repair_orders",
+                    metric_expression="SUM(sum_price_123abc)",
                 ),
             ],
             measures_materializations=[],

datajunction_server-0.0.1a87/datajunction_server/__about__.py

@@ -1,5 +0,0 @@
-"""
-Version for Hatch
-"""
-
-__version__ = "0.0.1a87"