moose-lib 0.6.173__py3-none-any.whl → 0.6.188__py3-none-any.whl

moose_lib/__init__.py

@@ -30,7 +30,25 @@ from .blocks import (
     # Legacy enum (already exported via .blocks import, but explicit for clarity)
     ClickHouseEngines
 )
-from .data_models import Key, AggregateFunction, StringToEnumMixin, FixedString, ClickhouseFixedStringSize
+from .data_models import (
+    Key,
+    AggregateFunction,
+    StringToEnumMixin,
+    FixedString,
+    ClickhouseFixedStringSize,
+    # Integer types
+    Int8,
+    Int16,
+    Int32,
+    Int64,
+    UInt8,
+    UInt16,
+    UInt32,
+    UInt64,
+    # Float types
+    Float32,
+    Float64,
+)
 from .commons import Logger
 
 from .query_builder import *

moose_lib/data_models.py

@@ -15,6 +15,20 @@ import ipaddress
 type Key[T: (str, int)] = T
 type JWT[T] = T
 
+# Integer type aliases for ClickHouse integer types
+type Int8 = Annotated[int, "int8"]
+type Int16 = Annotated[int, "int16"]
+type Int32 = Annotated[int, "int32"]
+type Int64 = Annotated[int, "int64"]
+type UInt8 = Annotated[int, "uint8"]
+type UInt16 = Annotated[int, "uint16"]
+type UInt32 = Annotated[int, "uint32"]
+type UInt64 = Annotated[int, "uint64"]
+
+# Float type aliases for ClickHouse float types
+type Float32 = Annotated[float, "float32"]
+type Float64 = Annotated[float, "float64"]
+
 
 @dataclasses.dataclass(frozen=True)  # a BaseModel in the annotations will confuse pydantic
 class ClickhousePrecision:

moose_lib/secrets.py

@@ -20,11 +20,13 @@ MOOSE_RUNTIME_ENV_PREFIX = "__MOOSE_RUNTIME_ENV__:"
 
 
 def get(env_var_name: str) -> str:
-    """Marks a value to be resolved from an environment variable at runtime.
+    """Gets a value from an environment variable, with behavior depending on context.
 
-    When you use this function, the value is not read immediately. Instead,
-    a special marker is created that the Moose CLI will resolve when it
-    processes your infrastructure configuration.
+    When IS_LOADING_INFRA_MAP=true (infrastructure loading):
+      Returns a marker string that Moose CLI will resolve later
+
+    When IS_LOADING_INFRA_MAP is unset (function/workflow runtime):
+      Returns the actual value from the environment variable
 
     This is useful for:
     - Credentials that should never be embedded in Docker images
@@ -36,10 +38,11 @@ def get(env_var_name: str) -> str:
         env_var_name: Name of the environment variable to resolve
 
     Returns:
-        A marker string that Moose CLI will resolve at runtime
+        Either a marker string or the actual environment variable value
 
     Raises:
         ValueError: If the environment variable name is empty
+        KeyError: If the environment variable is not set (runtime mode only)
 
     Example:
         >>> # Instead of this (evaluated at build time):
@@ -49,9 +52,26 @@ def get(env_var_name: str) -> str:
         >>> # Use this (evaluated at runtime):
         >>> aws_key = moose_runtime_env.get("AWS_ACCESS_KEY_ID")
     """
+    import os
+    
     if not env_var_name or not env_var_name.strip():
         raise ValueError("Environment variable name cannot be empty")
-    return f"{MOOSE_RUNTIME_ENV_PREFIX}{env_var_name}"
+    
+    # Check if we're loading infrastructure map
+    is_loading_infra_map = os.environ.get("IS_LOADING_INFRA_MAP") == "true"
+    
+    if is_loading_infra_map:
+        # Return marker string for later resolution by Moose CLI
+        return f"{MOOSE_RUNTIME_ENV_PREFIX}{env_var_name}"
+    else:
+        # Return actual value from environment for runtime execution
+        value = os.environ.get(env_var_name)
+        if value is None:
+            raise KeyError(
+                f"Environment variable '{env_var_name}' is not set. "
+                f"This is required for runtime execution of functions/workflows."
+            )
+        return value
 
 
 class MooseRuntimeEnv:

{moose_lib-0.6.173.dist-info → moose_lib-0.6.188.dist-info}/METADATA

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

{moose_lib-0.6.173.dist-info → moose_lib-0.6.188.dist-info}/RECORD

@@ -1,13 +1,13 @@
-moose_lib/__init__.py,sha256=acIGHDFMHy8LNjwEr091htu7ep-mYH--Uj8MANz5EhE,997
+moose_lib/__init__.py,sha256=GyWPjIaU59OAq4cKzwLqDmGc-YTygmELZqBg36ctZn8,1176
 moose_lib/blocks.py,sha256=TJfaBJjDbCjGBVGpcV2HwVLWxiuqBC9lhx7FXCCbfsE,18238
 moose_lib/commons.py,sha256=YDMzRO3ySa_iQRknmFwwE539KgSyjWhYJ-E3jIsfSgc,6585
-moose_lib/data_models.py,sha256=YgcTALCacEe08OKcw-s9y8qLDghMZ6_a4GhlJfwOsFM,19293
+moose_lib/data_models.py,sha256=D9F8HV0BdAStNuMLx7j5i1e9g6Bj_cQzQ59dE5Vu-Ko,19781
 moose_lib/dmv2_serializer.py,sha256=CL_Pvvg8tJOT8Qk6hywDNzY8MYGhMVdTOw8arZi3jng,49
 moose_lib/internal.py,sha256=7T6PQyU2QLquSSPujO37e9t0tC_QYXpIK2CQom69li4,30453
 moose_lib/main.py,sha256=JWsgza52xEh25AyF61cO1ItJ8VXJHHz8j-4HG445Whg,20380
 moose_lib/query_builder.py,sha256=-L5p2dArBx3SBA-WZPkcCJPemKXnqJw60NHy-wn5wa4,6619
 moose_lib/query_param.py,sha256=kxcR09BMIsEg4o2qetjKrVu1YFRaLfMEzwzyGsKUpvA,6474
-moose_lib/secrets.py,sha256=upFjLorfAsiyL3F3UIl2STUFGjC6Pu0-Qe1FGs5S09c,3480
+moose_lib/secrets.py,sha256=Ykt_iJZrozMRXAirC_NclDerSJVE5WmGTSyyHrfsTFE,4249
 moose_lib/clients/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 moose_lib/clients/redis_client.py,sha256=BDYjJ582V-rW92qVQ4neZ9Pu7JtDNt8x8jBWApt1XUg,11895
 moose_lib/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -36,15 +36,16 @@ moose_lib/utilities/sql.py,sha256=kbg1DT5GdsIwgTsMzbsd6SAVf9aWER8DqmT_eKS3XN4,90
 tests/__init__.py,sha256=0Gh4yzPkkC3TzBGKhenpMIxJcRhyrrCfxLSfpTZnPMQ,53
 tests/conftest.py,sha256=tsBozrzGuJUO7dRGVcIxCjqi-l77I-DvYnzpbKtmGzE,1003
 tests/test_fixedstring.py,sha256=wQbQLEMXgWRx7B7jtLomkP6HEaNFhhfbRkfVReoJY-E,1552
+tests/test_int_types.py,sha256=2mZjWc0hf-58ECdHw5zCJjcGmYevnJaS5rR-Xgqezxo,6498
 tests/test_moose.py,sha256=mBsx_OYWmL8ppDzL_7Bd7xR6qf_i3-pCIO3wm2iQNaA,2136
 tests/test_olap_table_versioning.py,sha256=ffuJsO5TYKBd2aWV0GWDmosCwL4j518Y_MqYJdrfgDY,7041
 tests/test_query_builder.py,sha256=O3imdFSaqU13kbK1jSQaHbBgynhVmJaApT8DlRqYwJU,1116
 tests/test_redis_client.py,sha256=d9_MLYsJ4ecVil_jPB2gW3Q5aWnavxmmjZg2uYI3LVo,3256
 tests/test_s3queue_config.py,sha256=A-17Lir2kvYoUA0qEaNczOkLKhHPzyp3glka7YqnPws,14490
-tests/test_secrets.py,sha256=g5ZjtOyT7vTz_sRUB71Vd6s715u0gMc4C-_8m_59Mtg,8347
+tests/test_secrets.py,sha256=WFvmVsxwYsl5bD0SiOUR9ZELMBZ3CgY0NR4h7s9Oaww,8707
 tests/test_simple_aggregate.py,sha256=yyFSYHUXskA1aTcwC-KQ9XmgOikeQ8wKXzntsUBIC6w,4055
 tests/test_web_app.py,sha256=iL86sg0NS2k6nP8jIGKZvrtg0BjvaqNTRp7-4T1TTck,6557
-moose_lib-0.6.173.dist-info/METADATA,sha256=zSguPpMqeILfkpn9rEA9fo9WvcZRHhwufh6J5ZA3pKg,827
-moose_lib-0.6.173.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-moose_lib-0.6.173.dist-info/top_level.txt,sha256=XEns2-4aCmGp2XjJAeEH9TAUcGONLnSLy6ycT9FSJh8,16
-moose_lib-0.6.173.dist-info/RECORD,,
+moose_lib-0.6.188.dist-info/METADATA,sha256=pA-Ch_--rOTI4JeT55sonZEv1wMLE2sOQVVAMXGGym0,827
+moose_lib-0.6.188.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+moose_lib-0.6.188.dist-info/top_level.txt,sha256=XEns2-4aCmGp2XjJAeEH9TAUcGONLnSLy6ycT9FSJh8,16
+moose_lib-0.6.188.dist-info/RECORD,,

tests/test_int_types.py

@@ -0,0 +1,204 @@
+from datetime import datetime
+from typing import Annotated
+from pydantic import BaseModel
+from moose_lib import (
+    Key,
+    Int8, Int16, Int32, Int64,
+    UInt8, UInt16, UInt32, UInt64,
+    Float32, Float64,
+)
+from moose_lib.data_models import _to_columns
+
+
+def test_integer_type_aliases():
+    """Test that integer type aliases convert to correct ClickHouse types."""
+
+    class IntegerTypesTest(BaseModel):
+        id: Key[str]
+        created_at: datetime
+        tiny_int: Int8
+        small_int: Int16
+        medium_int: Int32
+        big_int: Int64
+        tiny_uint: UInt8
+        small_uint: UInt16
+        medium_uint: UInt32
+        big_uint: UInt64
+
+    columns = _to_columns(IntegerTypesTest)
+    by_name = {col.name: col for col in columns}
+
+    # Verify signed integer types
+    assert by_name["tiny_int"].data_type == "Int8"
+    assert by_name["small_int"].data_type == "Int16"
+    assert by_name["medium_int"].data_type == "Int32"
+    assert by_name["big_int"].data_type == "Int64"
+
+    # Verify unsigned integer types
+    assert by_name["tiny_uint"].data_type == "UInt8"
+    assert by_name["small_uint"].data_type == "UInt16"
+    assert by_name["medium_uint"].data_type == "UInt32"
+    assert by_name["big_uint"].data_type == "UInt64"
+
+    # Verify other fields still work
+    assert by_name["id"].data_type == "String"
+    assert by_name["created_at"].data_type == "DateTime"
+
+
+def test_float_type_aliases():
+    """Test that float type aliases convert to correct ClickHouse types."""
+
+    class FloatTypesTest(BaseModel):
+        id: Key[str]
+        precision_float: Float32
+        double_precision_float: Float64
+
+    columns = _to_columns(FloatTypesTest)
+    by_name = {col.name: col for col in columns}
+
+    assert by_name["precision_float"].data_type == "Float32"
+    assert by_name["double_precision_float"].data_type == "Float64"
+    assert by_name["id"].data_type == "String"
+
+
+def test_combined_numeric_types():
+    """Test combining integer and float types in a single model."""
+
+    class NumericTypesTest(BaseModel):
+        user_id: UInt64
+        age: UInt8
+        score: Int32
+        latitude: Float64
+        longitude: Float64
+        precision_value: Float32
+
+    columns = _to_columns(NumericTypesTest)
+    by_name = {col.name: col for col in columns}
+
+    assert by_name["user_id"].data_type == "UInt64"
+    assert by_name["age"].data_type == "UInt8"
+    assert by_name["score"].data_type == "Int32"
+    assert by_name["latitude"].data_type == "Float64"
+    assert by_name["longitude"].data_type == "Float64"
+    assert by_name["precision_value"].data_type == "Float32"
+
+
+def test_integer_types_as_keys():
+    """Test that integer types can be used as primary keys."""
+
+    class IntegerKeyTest(BaseModel):
+        user_id: Key[UInt64]
+        event_id: Key[Int64]
+        name: str
+
+    columns = _to_columns(IntegerKeyTest)
+    by_name = {col.name: col for col in columns}
+
+    assert by_name["user_id"].data_type == "UInt64"
+    assert by_name["user_id"].primary_key is True
+    assert by_name["event_id"].data_type == "Int64"
+    assert by_name["event_id"].primary_key is True
+    assert by_name["name"].data_type == "String"
+
+
+def test_optional_integer_types():
+    """Test that optional integer types work correctly."""
+    from typing import Optional
+
+    class OptionalIntTest(BaseModel):
+        required_count: UInt32
+        optional_count: Optional[UInt32]
+        optional_score: Optional[Int16]
+
+    columns = _to_columns(OptionalIntTest)
+    by_name = {col.name: col for col in columns}
+
+    assert by_name["required_count"].data_type == "UInt32"
+    assert by_name["required_count"].required is True
+
+    assert by_name["optional_count"].data_type == "UInt32"
+    assert by_name["optional_count"].required is False
+
+    assert by_name["optional_score"].data_type == "Int16"
+    assert by_name["optional_score"].required is False
+
+
+def test_uint_common_use_cases():
+    """Test common use cases for unsigned integers."""
+
+    class CommonUIntUseCases(BaseModel):
+        # User/entity IDs (always positive)
+        user_id: UInt64
+        # Counters (always positive or zero)
+        page_views: UInt32
+        click_count: UInt32
+        # Small enums/flags (0-255)
+        status_code: UInt8
+        # Port numbers (0-65535)
+        port: UInt16
+        # Timestamps as unix epoch
+        timestamp: UInt64
+
+    columns = _to_columns(CommonUIntUseCases)
+    by_name = {col.name: col for col in columns}
+
+    assert by_name["user_id"].data_type == "UInt64"
+    assert by_name["page_views"].data_type == "UInt32"
+    assert by_name["click_count"].data_type == "UInt32"
+    assert by_name["status_code"].data_type == "UInt8"
+    assert by_name["port"].data_type == "UInt16"
+    assert by_name["timestamp"].data_type == "UInt64"
+
+
+def test_int_common_use_cases():
+    """Test common use cases for signed integers."""
+
+    class CommonIntUseCases(BaseModel):
+        # Temperature (can be negative)
+        temperature: Int16
+        # Financial amounts (can be negative for debits)
+        balance: Int64
+        # Deltas/differences
+        delta: Int32
+        # Small range values
+        offset: Int8
+
+    columns = _to_columns(CommonIntUseCases)
+    by_name = {col.name: col for col in columns}
+
+    assert by_name["temperature"].data_type == "Int16"
+    assert by_name["balance"].data_type == "Int64"
+    assert by_name["delta"].data_type == "Int32"
+    assert by_name["offset"].data_type == "Int8"
+
+
+def test_default_int_still_works():
+    """Test that plain int without type annotation still works as before."""
+
+    class PlainIntTest(BaseModel):
+        plain_int: int
+        typed_int: UInt32
+
+    columns = _to_columns(PlainIntTest)
+    by_name = {col.name: col for col in columns}
+
+    # Plain int should still map to "Int" (default behavior)
+    assert by_name["plain_int"].data_type == "Int"
+    # Typed int should map to specific type
+    assert by_name["typed_int"].data_type == "UInt32"
+
+
+def test_default_float_still_works():
+    """Test that plain float without type annotation still works as before."""
+
+    class PlainFloatTest(BaseModel):
+        plain_float: float
+        typed_float: Float32
+
+    columns = _to_columns(PlainFloatTest)
+    by_name = {col.name: col for col in columns}
+
+    # Plain float should still map to "Float64" (default behavior)
+    assert by_name["plain_float"].data_type == "Float64"
+    # Typed float should map to specific type
+    assert by_name["typed_float"].data_type == "Float32"

tests/test_secrets.py

@@ -5,10 +5,20 @@ which allows users to defer secret resolution until runtime rather than
 embedding secrets at build time.
 """
 
+import os
 import pytest
 from moose_lib.secrets import moose_runtime_env, get, MOOSE_RUNTIME_ENV_PREFIX
 
 
+@pytest.fixture(scope="module", autouse=True)
+def set_infra_map_loading_for_secrets_tests():
+    """Set IS_LOADING_INFRA_MAP=true for secrets tests so moose_runtime_env.get() returns markers."""
+    os.environ["IS_LOADING_INFRA_MAP"] = "true"
+    yield
+    # Clean up after all tests in this module
+    os.environ.pop("IS_LOADING_INFRA_MAP", None)
+
+
 class TestMooseRuntimeEnvGet:
     """Tests for the moose_runtime_env.get() method."""