moose-lib 0.6.157__tar.gz → 0.6.158__tar.gz

{moose_lib-0.6.157 → moose_lib-0.6.158}/PKG-INFO

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

{moose_lib-0.6.157 → moose_lib-0.6.158}/moose_lib/__init__.py

@@ -4,6 +4,8 @@ from .blocks import *
 
 from .commons import *
 
+from .secrets import moose_runtime_env
+
 from .data_models import *
 
 from .dmv2 import *

{moose_lib-0.6.157 → moose_lib-0.6.158}/moose_lib/dmv2/olap_table.py

@@ -143,6 +143,7 @@ class OlapConfig(BaseModel):
         granularity: int = 1
 
     indexes: list[TableIndex] = []
+    database: Optional[str] = None  # Optional database name for multi-database support
 
     def model_post_init(self, __context):
         has_fields = bool(self.order_by_fields)

{moose_lib-0.6.157 → moose_lib-0.6.158}/moose_lib/internal.py

@@ -171,6 +171,7 @@ class TableConfig(BaseModel):
     table_settings: Optional[dict[str, str]] = None
     indexes: list[OlapConfig.TableIndex] = []
     ttl: Optional[str] = None
+    database: Optional[str] = None
 
 
 class TopicConfig(BaseModel):
@@ -613,6 +614,7 @@ def to_infra_map() -> dict:
             table_settings=table_settings if table_settings else None,
             indexes=table.config.indexes,
             ttl=table.config.ttl,
+            database=table.config.database,
         )
 
     for name, stream in get_streams().items():
@@ -716,7 +718,7 @@ def to_infra_map() -> dict:
         web_apps=web_apps
     )
 
-    return infra_map.model_dump(by_alias=True)
+    return infra_map.model_dump(by_alias=True, exclude_none=False)
 
 
 def load_models():

moose_lib-0.6.158/moose_lib/secrets.py

@@ -0,0 +1,100 @@
+"""Utilities for runtime environment variable resolution.
+
+This module provides functionality to mark values that should be resolved
+from environment variables at runtime by the Moose CLI, rather than being
+embedded at build time.
+
+Example:
+    >>> from moose_lib import S3QueueEngine, moose_runtime_env
+    >>>
+    >>> engine = S3QueueEngine(
+    ...     s3_path="s3://bucket/data/*.json",
+    ...     format="JSONEachRow",
+    ...     aws_access_key_id=moose_runtime_env.get("AWS_ACCESS_KEY_ID"),
+    ...     aws_secret_access_key=moose_runtime_env.get("AWS_SECRET_ACCESS_KEY")
+    ... )
+"""
+
+#: Prefix used to mark values for runtime environment variable resolution.
+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.
+
+    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.
+
+    This is useful for:
+    - Credentials that should never be embedded in Docker images
+    - Configuration that can be rotated without rebuilding
+    - Different values for different environments (dev, staging, prod)
+    - Any runtime configuration in infrastructure elements (Tables, Topics, etc.)
+
+    Args:
+        env_var_name: Name of the environment variable to resolve
+
+    Returns:
+        A marker string that Moose CLI will resolve at runtime
+
+    Raises:
+        ValueError: If the environment variable name is empty
+
+    Example:
+        >>> # Instead of this (evaluated at build time):
+        >>> import os
+        >>> aws_key = os.environ.get("AWS_ACCESS_KEY_ID")
+        >>>
+        >>> # Use this (evaluated at runtime):
+        >>> aws_key = moose_runtime_env.get("AWS_ACCESS_KEY_ID")
+    """
+    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}"
+
+
+class MooseRuntimeEnv:
+    """Utilities for marking values to be resolved from environment variables at runtime.
+
+    This class provides a namespace for runtime environment variable resolution.
+    Use the singleton instance `moose_runtime_env` rather than instantiating this class directly.
+
+    Attributes:
+        get: Static method for creating runtime environment variable markers
+    """
+
+    @staticmethod
+    def get(env_var_name: str) -> str:
+        """Marks a value to be resolved from an environment variable at runtime.
+
+        Args:
+            env_var_name: Name of the environment variable to resolve
+
+        Returns:
+            A marker string that Moose CLI will resolve at runtime
+
+        Raises:
+            ValueError: If the environment variable name is empty
+        """
+        return get(env_var_name)
+
+
+# Export singleton instance for module-level access
+moose_runtime_env = MooseRuntimeEnv()
+
+# Legacy exports for backwards compatibility
+MooseEnvSecrets = MooseRuntimeEnv  # Deprecated: Use MooseRuntimeEnv instead
+moose_env_secrets = moose_runtime_env  # Deprecated: Use moose_runtime_env instead
+MOOSE_ENV_SECRET_PREFIX = MOOSE_RUNTIME_ENV_PREFIX  # Deprecated: Use MOOSE_RUNTIME_ENV_PREFIX instead
+
+__all__ = [
+    "moose_runtime_env",
+    "MooseRuntimeEnv",
+    "get",
+    "MOOSE_RUNTIME_ENV_PREFIX",
+    # Legacy exports (deprecated)
+    "moose_env_secrets",
+    "MooseEnvSecrets",
+    "MOOSE_ENV_SECRET_PREFIX",
+]

{moose_lib-0.6.157 → moose_lib-0.6.158}/moose_lib.egg-info/PKG-INFO

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

{moose_lib-0.6.157 → moose_lib-0.6.158}/moose_lib.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ moose_lib/internal.py
 moose_lib/main.py
 moose_lib/query_builder.py
 moose_lib/query_param.py
+moose_lib/secrets.py
 moose_lib.egg-info/PKG-INFO
 moose_lib.egg-info/SOURCES.txt
 moose_lib.egg-info/dependency_links.txt
@@ -46,5 +47,6 @@ tests/test_olap_table_versioning.py
 tests/test_query_builder.py
 tests/test_redis_client.py
 tests/test_s3queue_config.py
+tests/test_secrets.py
 tests/test_simple_aggregate.py
 tests/test_web_app.py

moose_lib-0.6.158/tests/test_secrets.py

@@ -0,0 +1,221 @@
+"""Tests for the moose_lib.secrets module.
+
+This module tests the runtime environment variable marker functionality,
+which allows users to defer secret resolution until runtime rather than
+embedding secrets at build time.
+"""
+
+import pytest
+from moose_lib.secrets import moose_runtime_env, get, MOOSE_RUNTIME_ENV_PREFIX
+
+
+class TestMooseRuntimeEnvGet:
+    """Tests for the moose_runtime_env.get() method."""
+
+    def test_creates_marker_with_correct_prefix(self):
+        """Should create a marker string with the correct prefix."""
+        var_name = "AWS_ACCESS_KEY_ID"
+        result = moose_runtime_env.get(var_name)
+
+        assert result == f"{MOOSE_RUNTIME_ENV_PREFIX}{var_name}"
+        assert result == "__MOOSE_RUNTIME_ENV__:AWS_ACCESS_KEY_ID"
+
+    def test_handles_different_variable_names(self):
+        """Should handle different environment variable names correctly."""
+        test_cases = [
+            "AWS_SECRET_ACCESS_KEY",
+            "DATABASE_PASSWORD",
+            "API_KEY",
+            "MY_CUSTOM_SECRET",
+        ]
+
+        for var_name in test_cases:
+            result = moose_runtime_env.get(var_name)
+            assert result == f"{MOOSE_RUNTIME_ENV_PREFIX}{var_name}"
+            assert var_name in result
+
+    def test_raises_error_for_empty_string(self):
+        """Should raise ValueError for empty string."""
+        with pytest.raises(ValueError, match="Environment variable name cannot be empty"):
+            moose_runtime_env.get("")
+
+    def test_raises_error_for_whitespace_only(self):
+        """Should raise ValueError for whitespace-only string."""
+        with pytest.raises(ValueError, match="Environment variable name cannot be empty"):
+            moose_runtime_env.get("   ")
+
+    def test_raises_error_for_tabs_only(self):
+        """Should raise ValueError for string with only tabs."""
+        with pytest.raises(ValueError, match="Environment variable name cannot be empty"):
+            moose_runtime_env.get("\t\t")
+
+    def test_allows_underscores_in_variable_names(self):
+        """Should allow variable names with underscores."""
+        var_name = "MY_LONG_VAR_NAME"
+        result = moose_runtime_env.get(var_name)
+
+        assert result == f"{MOOSE_RUNTIME_ENV_PREFIX}{var_name}"
+
+    def test_allows_numbers_in_variable_names(self):
+        """Should allow variable names with numbers."""
+        var_name = "API_KEY_123"
+        result = moose_runtime_env.get(var_name)
+
+        assert result == f"{MOOSE_RUNTIME_ENV_PREFIX}{var_name}"
+
+    def test_preserves_exact_casing(self):
+        """Should preserve exact variable name casing."""
+        var_name = "MixedCase_VarName"
+        result = moose_runtime_env.get(var_name)
+
+        assert var_name in result
+        assert var_name.lower() not in result  # Ensure casing wasn't changed
+
+    def test_can_be_used_in_s3queue_config(self):
+        """Should create markers that can be used in S3Queue configuration."""
+        access_key_marker = moose_runtime_env.get("AWS_ACCESS_KEY_ID")
+        secret_key_marker = moose_runtime_env.get("AWS_SECRET_ACCESS_KEY")
+
+        config = {
+            "aws_access_key_id": access_key_marker,
+            "aws_secret_access_key": secret_key_marker,
+        }
+
+        assert "AWS_ACCESS_KEY_ID" in config["aws_access_key_id"]
+        assert "AWS_SECRET_ACCESS_KEY" in config["aws_secret_access_key"]
+
+
+class TestModuleLevelGetFunction:
+    """Tests for the module-level get() function."""
+
+    def test_module_level_get_creates_marker(self):
+        """The module-level get function should create markers."""
+        var_name = "TEST_SECRET"
+        result = get(var_name)
+
+        assert result == f"{MOOSE_RUNTIME_ENV_PREFIX}{var_name}"
+
+    def test_module_level_get_matches_class_method(self):
+        """Module-level get should produce same result as class method."""
+        var_name = "MY_SECRET"
+
+        result_module = get(var_name)
+        result_class = moose_runtime_env.get(var_name)
+
+        assert result_module == result_class
+
+    def test_module_level_get_raises_error_for_empty(self):
+        """Module-level get should raise ValueError for empty string."""
+        with pytest.raises(ValueError, match="Environment variable name cannot be empty"):
+            get("")
+
+
+class TestMooseRuntimeEnvPrefix:
+    """Tests for the MOOSE_RUNTIME_ENV_PREFIX constant."""
+
+    def test_has_expected_value(self):
+        """Should have the expected prefix value."""
+        assert MOOSE_RUNTIME_ENV_PREFIX == "__MOOSE_RUNTIME_ENV__:"
+
+    def test_is_string(self):
+        """Should be a string."""
+        assert isinstance(MOOSE_RUNTIME_ENV_PREFIX, str)
+
+    def test_is_not_empty(self):
+        """Should not be empty."""
+        assert len(MOOSE_RUNTIME_ENV_PREFIX) > 0
+
+
+class TestMarkerFormatValidation:
+    """Tests for marker format validation and parsing."""
+
+    def test_creates_easily_detectable_markers(self):
+        """Should create markers that are easily detectable."""
+        marker = moose_runtime_env.get("TEST_VAR")
+
+        assert marker.startswith("__MOOSE_RUNTIME_ENV__:")
+
+    def test_markers_can_be_split_to_extract_variable_name(self):
+        """Should create markers that can be split to extract variable name."""
+        var_name = "MY_SECRET"
+        marker = moose_runtime_env.get(var_name)
+
+        parts = marker.split(MOOSE_RUNTIME_ENV_PREFIX)
+        assert len(parts) == 2
+        assert parts[1] == var_name
+
+    def test_markers_are_json_serializable(self):
+        """Should create markers that are JSON serializable."""
+        import json
+
+        marker = moose_runtime_env.get("TEST_VAR")
+        json_str = json.dumps({"secret": marker})
+        parsed = json.loads(json_str)
+
+        assert parsed["secret"] == marker
+
+    def test_markers_work_with_dict_serialization(self):
+        """Should work correctly with dictionary serialization."""
+        marker = moose_runtime_env.get("DATABASE_PASSWORD")
+
+        config = {
+            "password": marker,
+            "other_field": "value"
+        }
+
+        # Verify the marker is preserved in the dict
+        assert config["password"] == marker
+        assert MOOSE_RUNTIME_ENV_PREFIX in config["password"]
+
+
+class TestIntegrationScenarios:
+    """Integration tests for real-world usage scenarios."""
+
+    def test_s3queue_engine_with_secrets(self):
+        """Should work correctly in S3Queue engine configuration."""
+        from moose_lib.blocks import S3QueueEngine
+
+        engine = S3QueueEngine(
+            s3_path="s3://my-bucket/data/*.json",
+            format="JSONEachRow",
+            aws_access_key_id=moose_runtime_env.get("AWS_ACCESS_KEY_ID"),
+            aws_secret_access_key=moose_runtime_env.get("AWS_SECRET_ACCESS_KEY"),
+        )
+
+        # Verify markers were set correctly
+        assert engine.aws_access_key_id == "__MOOSE_RUNTIME_ENV__:AWS_ACCESS_KEY_ID"
+        assert engine.aws_secret_access_key == "__MOOSE_RUNTIME_ENV__:AWS_SECRET_ACCESS_KEY"
+
+    def test_multiple_secrets_in_same_config(self):
+        """Should handle multiple secrets in the same configuration."""
+        config = {
+            "username": moose_runtime_env.get("DB_USERNAME"),
+            "password": moose_runtime_env.get("DB_PASSWORD"),
+            "api_key": moose_runtime_env.get("API_KEY"),
+        }
+
+        # All should have the correct prefix
+        for value in config.values():
+            assert value.startswith(MOOSE_RUNTIME_ENV_PREFIX)
+
+        # Each should have the correct variable name
+        assert "DB_USERNAME" in config["username"]
+        assert "DB_PASSWORD" in config["password"]
+        assert "API_KEY" in config["api_key"]
+
+    def test_mixed_secret_and_plain_values(self):
+        """Should handle mix of secret markers and plain values."""
+        config = {
+            "region": "us-east-1",  # Plain value
+            "access_key": moose_runtime_env.get("AWS_ACCESS_KEY_ID"),  # Secret
+            "bucket": "my-bucket",  # Plain value
+            "secret_key": moose_runtime_env.get("AWS_SECRET_ACCESS_KEY"),  # Secret
+        }
+
+        # Plain values should be unchanged
+        assert config["region"] == "us-east-1"
+        assert config["bucket"] == "my-bucket"
+
+        # Secrets should have markers
+        assert MOOSE_RUNTIME_ENV_PREFIX in config["access_key"]
+        assert MOOSE_RUNTIME_ENV_PREFIX in config["secret_key"]