moose-lib 0.6.72__tar.gz → 0.6.74__tar.gz

{moose_lib-0.6.72 → moose_lib-0.6.74}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: moose_lib
-Version: 0.6.72
+Version: 0.6.74
 Home-page: https://www.fiveonefour.com/moose
 Author: Fiveonefour Labs Inc.
 Author-email: support@fiveonefour.com

{moose_lib-0.6.72 → moose_lib-0.6.74}/moose_lib/dmv2/materialized_view.py

@@ -7,7 +7,7 @@ including their SQL statements, target tables, and dependencies.
 from typing import Any, Optional, Union, Generic, TypeVar
 from pydantic import BaseModel, ConfigDict, model_validator
 
-from moose_lib import ClickHouseEngines
+from ..blocks import ClickHouseEngines
 from ..utilities.sql import quote_identifier
 from .types import BaseTypedResource, T
 from .olap_table import OlapTable, OlapConfig

{moose_lib-0.6.72 → moose_lib-0.6.74}/moose_lib/dmv2/olap_table.py

@@ -12,12 +12,11 @@ from clickhouse_connect.driver.exceptions import ClickHouseError
 from dataclasses import dataclass
 from pydantic import BaseModel
 from typing import List, Optional, Any, Literal, Union, Tuple, TypeVar, Generic, Iterator
-from moose_lib import ClickHouseEngines
-from ..blocks import EngineConfig  # Add import for EngineConfig
-from ..commons import Logger  # Add import for Moose logging
+from ..blocks import ClickHouseEngines, EngineConfig
+from ..commons import Logger
 from ..config.runtime import RuntimeClickHouseConfig
 from ..utilities.sql import quote_identifier
-from .types import TypedMooseResource, T
+from .types import TypedMooseResource, T, Cols
 from ._registry import _tables
 from ..data_models import Column, is_array_nested_type, is_nested_type, _to_columns
 from .life_cycle import LifeCycle
@@ -140,12 +139,16 @@ class OlapTable(TypedMooseResource, Generic[T]):
     _memoized_client: Optional[Client] = None
     _config_hash: Optional[str] = None
     _cached_table_name: Optional[str] = None
+    _column_list: list[Column]
+    _cols: Cols
 
     def __init__(self, name: str, config: OlapConfig = OlapConfig(), **kwargs):
         super().__init__()
         self._set_type(name, self._get_type(kwargs))
         self.config = config
         self.metadata = config.metadata
+        self._column_list = _to_columns(self._t)
+        self._cols = Cols(self._column_list)
         _tables[name] = self
         
         # Check if using legacy enum-based engine configuration
@@ -180,6 +183,10 @@ class OlapTable(TypedMooseResource, Generic[T]):
                 stacklevel=2
             )
 
+    @property
+    def cols(self):
+        return self._cols
+
     def _generate_table_name(self) -> str:
         """Generate the versioned table name following Moose's naming convention.
 

{moose_lib-0.6.72 → moose_lib-0.6.74}/moose_lib/dmv2/types.py

@@ -6,8 +6,11 @@ the dmv2 package, including generic type parameters, type aliases, and base
 resource classes.
 """
 from typing import Any, Generic, TypeVar, Union
+
+import typing_extensions
 from pydantic import BaseModel
 from pydantic.fields import FieldInfo
+from ..data_models import Column
 
 T = TypeVar('T', bound=BaseModel)
 U = TypeVar('U', bound=BaseModel)
@@ -15,6 +18,41 @@ T_none = TypeVar('T_none', bound=Union[BaseModel, None])
 U_none = TypeVar('U_none', bound=Union[BaseModel, None])
 type ZeroOrMany[T] = Union[T, list[T], None]
 
+
+class Cols:
+    """Provides runtime checked column name access for Moose resources.
+
+    Instead of using string literals for column names, you can use attribute access
+    on this object, which will verify the name against the Pydantic model's fields.
+
+    Example:
+        >>> class MyModel(BaseModel):
+        ...     user_id: int
+        ...     event_name: str
+        >>> table = OlapTable[MyModel]("my_models")
+        >>> print(table.cols.user_id)  # Output: a column object
+        >>> print(table.cols.non_existent) # Raises AttributeError
+    """
+    _columns: dict[str, Column]
+
+    def __init__(self, columns: list[Column]):
+        self._columns = {c.name: c for c in columns}
+
+    def __getattr__(self, item: str) -> Column:
+        if item in self._columns:
+            return self._columns[item]
+        raise AttributeError(f"{item} is not a valid column name")
+
+    def __getitem__(self, item: str) -> Column:
+        """Allow bracket access to columns, equivalent to attribute access.
+
+        Example:
+            table.cols["user_id"] is the same as table.cols.user_id
+        """
+        return self.__getattr__(item)
+
+
+@typing_extensions.deprecated('use cols in OlapTable instead')
 class Columns(Generic[T]):
     """Provides runtime checked column name access for Moose resources.
 
@@ -42,6 +80,7 @@ class Columns(Generic[T]):
             return item  # or some Column representation
         raise AttributeError(f"{item} is not a valid column name")
 
+
 class BaseTypedResource(Generic[T]):
     """Base class for Moose resources that are typed with a Pydantic model.
 
@@ -79,6 +118,7 @@ class BaseTypedResource(Generic[T]):
 
         return curried_constructor
 
+
 class TypedMooseResource(BaseTypedResource, Generic[T]):
     """Base class for Moose resources that have columns derived from a Pydantic model.
 
@@ -88,8 +128,11 @@ class TypedMooseResource(BaseTypedResource, Generic[T]):
     Attributes:
         columns (Columns[T]): An object providing attribute access to column names.
     """
-    columns: Columns[T]
+
+    @property
+    @typing_extensions.deprecated('use cols in OlapTable instead', category=None)
+    def columns(self):
+        return Columns[T](self._t)
 
     def _set_type(self, name: str, t: type[T]):
         super()._set_type(name, t)
-        self.columns = Columns[T](self._t)

{moose_lib-0.6.72 → moose_lib-0.6.74}/moose_lib/internal.py

@@ -436,7 +436,7 @@ def to_infra_map() -> dict:
 
         tables[name] = TableConfig(
             name=name,
-            columns=_to_columns(table._t),
+            columns=table._column_list,
             order_by=table.config.order_by_fields,
             partition_by=table.config.partition_by,
             engine_config=engine_config,

{moose_lib-0.6.72 → moose_lib-0.6.74}/moose_lib/main.py

@@ -6,6 +6,7 @@ and utilities for defining data models and SQL queries.
 """
 from clickhouse_connect.driver.client import Client as ClickhouseClient
 from clickhouse_connect import get_client
+from moose_lib.dmv2 import OlapTable
 from pydantic import BaseModel
 from dataclasses import dataclass, asdict
 from enum import Enum
@@ -18,9 +19,11 @@ import asyncio
 from string import Formatter
 from temporalio.client import Client as TemporalClient, TLSConfig
 from temporalio.common import RetryPolicy, WorkflowIDConflictPolicy, WorkflowIDReusePolicy
-from datetime import timedelta
+from datetime import timedelta, datetime
 from time import perf_counter
 from humanfriendly import format_timespan
+
+from .data_models import Column
 from .config.runtime import RuntimeClickHouseConfig
 
 from moose_lib.commons import EnhancedJSONEncoder
@@ -183,7 +186,7 @@ class QueryClient:
 
     def execute(self, input, variables, row_type: Type[BaseModel] = None):
         params = {}
-        values = {}
+        values: dict[str, Any] = {}
         preview_params = {}
 
         for i, (_, variable_name, _, _) in enumerate(Formatter().parse(input)):
@@ -193,12 +196,29 @@ class QueryClient:
                     # handling passing the value of the query string dict directly to variables
                     value = value[0]
 
-                t = 'String' if isinstance(value, str) else \
-                    'Int64' if isinstance(value, int) else \
-                        'Float64' if isinstance(value, float) else "String"  # unknown type
-
-                params[variable_name] = f'{{p{i}: {t}}}'
-                values[f'p{i}'] = value
+                if isinstance(value, Column) or isinstance(value, OlapTable):
+                    params[variable_name] = f'{{p{i}: Identifier}}'
+                    values[f'p{i}'] = value.name
+                else:
+                    if isinstance(value, bool):
+                        params[variable_name] = f'{{p{i}: Bool}}'
+                        values[f'p{i}'] = value
+                    elif isinstance(value, datetime):
+                        params[variable_name] = f'{{p{i}: DateTime}}'
+                        values[f'p{i}'] = value
+                    elif isinstance(value, int):
+                        params[variable_name] = f'{{p{i}: Int64}}'
+                        values[f'p{i}'] = value
+                    elif isinstance(value, float):
+                        params[variable_name] = f'{{p{i}: Float64}}'
+                        values[f'p{i}'] = value
+                    elif isinstance(value, str):
+                        params[variable_name] = f'{{p{i}: String}}'
+                        values[f'p{i}'] = value
+                    else:
+                        print(f"unhandled type in QueryClient {type(value)}", file=sys.stderr)
+                        params[variable_name] = f'{{p{i}: String}}'
+                        values[f'p{i}'] = str(value)
                 preview_params[variable_name] = self._format_value_for_preview(value)
 
         clickhouse_query = input.format_map(params)
@@ -258,6 +278,13 @@ class QueryClient:
             escaped = value.replace('\\', '\\\\').replace("'", "\\'")
             return f"'{escaped}'"
 
+        # DateTime
+        if isinstance(value, datetime):
+            return f"'{value.strftime('%Y-%m-%d %H:%M:%S')}'"
+
+        if isinstance(value, Column) or isinstance(value, OlapTable):
+            return value.name
+
         # Lists / tuples (format as [item1, item2, ...])
         if isinstance(value, (list, tuple)):
             formatted_items = ', '.join(self._format_value_for_preview(v) for v in value)

{moose_lib-0.6.72 → moose_lib-0.6.74}/moose_lib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: moose_lib
-Version: 0.6.72
+Version: 0.6.74
 Home-page: https://www.fiveonefour.com/moose
 Author: Fiveonefour Labs Inc.
 Author-email: support@fiveonefour.com