moose-lib 0.6.90__py3-none-any.whl → 0.6.283__py3-none-any.whl

tests/test_secrets.py

@@ -0,0 +1,239 @@
+"""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 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."""
+
+    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"]

tests/test_simple_aggregate.py

@@ -0,0 +1,114 @@
+import datetime
+from pydantic import BaseModel
+
+from moose_lib import simple_aggregated, Key
+from moose_lib.data_models import SimpleAggregateFunction, _to_columns
+
+
+def test_simple_aggregated_helper():
+    """Test that simple_aggregated helper creates correct annotation"""
+    annotated_type = simple_aggregated("sum", int)
+
+    # Check that it's annotated
+    assert hasattr(annotated_type, "__metadata__")
+    metadata = annotated_type.__metadata__[0]
+
+    # Check metadata is SimpleAggregateFunction instance
+    assert isinstance(metadata, SimpleAggregateFunction)
+    assert metadata.agg_func == "sum"
+    assert metadata.arg_type == int
+
+
+def test_simple_aggregate_function_to_dict():
+    """Test that SimpleAggregateFunction.to_dict() creates correct structure"""
+    func = SimpleAggregateFunction(agg_func="sum", arg_type=int)
+    result = func.to_dict()
+
+    assert result["functionName"] == "sum"
+    assert "argumentType" in result
+    # unless Annotated, Python int becomes `Int64`
+    assert result["argumentType"] == "Int64"
+
+
+def test_simple_aggregate_function_to_dict_with_different_types():
+    """Test SimpleAggregateFunction.to_dict() with various types"""
+    # Test with float
+    func_float = SimpleAggregateFunction(agg_func="max", arg_type=float)
+    result_float = func_float.to_dict()
+    assert result_float["functionName"] == "max"
+    assert result_float["argumentType"] == "Float64"
+
+    # Test with str
+    func_str = SimpleAggregateFunction(agg_func="anyLast", arg_type=str)
+    result_str = func_str.to_dict()
+    assert result_str["functionName"] == "anyLast"
+    assert result_str["argumentType"] == "String"
+
+
+def test_dataclass_with_simple_aggregated():
+    """Test that BaseModel with simple_aggregated field converts correctly"""
+
+    class TestModel(BaseModel):
+        date_stamp: Key[datetime.datetime]
+        table_name: Key[str]
+        row_count: simple_aggregated("sum", int)
+
+    columns = _to_columns(TestModel)
+
+    # Find the row_count column
+    row_count_col = next(c for c in columns if c.name == "row_count")
+
+    # Check basic type - Python int maps to "Int64" by default
+    assert row_count_col.data_type == "Int64"
+
+    # Check annotation
+    simple_agg_annotation = next(
+        (a for a in row_count_col.annotations if a[0] == "simpleAggregationFunction"),
+        None,
+    )
+    assert simple_agg_annotation is not None
+    assert simple_agg_annotation[1]["functionName"] == "sum"
+    assert simple_agg_annotation[1]["argumentType"] == "Int64"
+
+
+def test_multiple_simple_aggregated_fields():
+    """Test BaseModel with multiple SimpleAggregateFunction fields"""
+
+    class StatsModel(BaseModel):
+        timestamp: Key[datetime.datetime]
+        total_count: simple_aggregated("sum", int)
+        max_value: simple_aggregated("max", int)
+        min_value: simple_aggregated("min", int)
+        last_seen: simple_aggregated("anyLast", datetime.datetime)
+
+    columns = _to_columns(StatsModel)
+
+    # Test sum
+    sum_col = next(c for c in columns if c.name == "total_count")
+    sum_annotation = next(
+        a for a in sum_col.annotations if a[0] == "simpleAggregationFunction"
+    )
+    assert sum_annotation[1]["functionName"] == "sum"
+
+    # Test max
+    max_col = next(c for c in columns if c.name == "max_value")
+    max_annotation = next(
+        a for a in max_col.annotations if a[0] == "simpleAggregationFunction"
+    )
+    assert max_annotation[1]["functionName"] == "max"
+
+    # Test min
+    min_col = next(c for c in columns if c.name == "min_value")
+    min_annotation = next(
+        a for a in min_col.annotations if a[0] == "simpleAggregationFunction"
+    )
+    assert min_annotation[1]["functionName"] == "min"
+
+    # Test anyLast with datetime
+    last_col = next(c for c in columns if c.name == "last_seen")
+    assert last_col.data_type == "DateTime"
+    last_annotation = next(
+        a for a in last_col.annotations if a[0] == "simpleAggregationFunction"
+    )
+    assert last_annotation[1]["functionName"] == "anyLast"
+    assert last_annotation[1]["argumentType"] == "DateTime"

tests/test_web_app.py

@@ -0,0 +1,227 @@
+"""
+Unit tests for WebApp SDK functionality.
+"""
+
+import pytest
+from moose_lib.dmv2 import WebApp, WebAppConfig, WebAppMetadata
+from moose_lib.dmv2._registry import _web_apps
+
+
+# Mock FastAPI app for testing
+class MockFastAPIApp:
+    """Mock FastAPI application for testing."""
+
+    pass
+
+
+@pytest.fixture(autouse=True)
+def clear_registry():
+    """Clear the WebApp registry before each test."""
+    _web_apps.clear()
+    yield
+    _web_apps.clear()
+
+
+def test_webapp_basic_creation():
+    """Test basic WebApp creation with required mount_path."""
+    app = MockFastAPIApp()
+    config = WebAppConfig(mount_path="/test")
+    webapp = WebApp("test_app", app, config)
+
+    assert webapp.name == "test_app"
+    assert webapp.app is app
+    assert webapp.config.mount_path == "/test"
+    assert webapp.config.inject_moose_utils is True
+    assert "test_app" in _web_apps
+
+
+def test_webapp_with_custom_mount_path():
+    """Test WebApp with custom mount path."""
+    app = MockFastAPIApp()
+    config = WebAppConfig(mount_path="/myapi")
+    webapp = WebApp("test_app", app, config)
+
+    assert webapp.config.mount_path == "/myapi"
+
+
+def test_webapp_with_metadata():
+    """Test WebApp with metadata."""
+    app = MockFastAPIApp()
+    config = WebAppConfig(
+        mount_path="/api",
+        metadata=WebAppMetadata(description="My API"),
+    )
+
+    with pytest.raises(ValueError, match="cannot begin with a reserved path"):
+        WebApp("test_app", app, config)
+
+    # Now test with valid mount path
+    config.mount_path = "/myapi"
+    webapp = WebApp("test_app", app, config)
+    assert webapp.config.metadata.description == "My API"
+
+
+def test_webapp_duplicate_name():
+    """Test that duplicate WebApp names are rejected."""
+    app1 = MockFastAPIApp()
+    app2 = MockFastAPIApp()
+
+    WebApp("test_app", app1, WebAppConfig(mount_path="/test1"))
+
+    with pytest.raises(ValueError, match="WebApp with name 'test_app' already exists"):
+        WebApp("test_app", app2, WebAppConfig(mount_path="/test2"))
+
+
+def test_webapp_trailing_slash_validation():
+    """Test that trailing slashes are rejected."""
+    app = MockFastAPIApp()
+    config = WebAppConfig(mount_path="/myapi/")
+
+    with pytest.raises(ValueError, match="mountPath cannot end with a trailing slash"):
+        WebApp("test_app", app, config)
+
+
+def test_webapp_root_path_rejected():
+    """Test that root path '/' is rejected to prevent overlap with reserved paths."""
+    app = MockFastAPIApp()
+    config = WebAppConfig(mount_path="/")
+
+    with pytest.raises(
+        ValueError,
+        match='mountPath cannot be "/" as it would allow routes to overlap with reserved paths',
+    ):
+        WebApp("test_app", app, config)
+
+
+def test_webapp_reserved_paths():
+    """Test that reserved paths are rejected."""
+    reserved_paths = [
+        "/admin",
+        "/api",
+        "/consumption",
+        "/health",
+        "/ingest",
+        "/moose",
+        "/ready",
+        "/workflows",
+    ]
+
+    for path in reserved_paths:
+        app = MockFastAPIApp()
+        config = WebAppConfig(mount_path=path)
+
+        with pytest.raises(ValueError, match="cannot begin with a reserved path"):
+            WebApp(f"test_{path}", app, config)
+
+
+def test_webapp_reserved_path_prefix():
+    """Test that paths starting with reserved prefixes are rejected."""
+    app = MockFastAPIApp()
+    config = WebAppConfig(mount_path="/api/v1")
+
+    with pytest.raises(ValueError, match="cannot begin with a reserved path"):
+        WebApp("test_app", app, config)
+
+
+def test_webapp_duplicate_mount_path():
+    """Test that duplicate mount paths are rejected."""
+    app1 = MockFastAPIApp()
+    app2 = MockFastAPIApp()
+
+    config1 = WebAppConfig(mount_path="/myapi")
+    WebApp("app1", app1, config1)
+
+    config2 = WebAppConfig(mount_path="/myapi")
+    with pytest.raises(
+        ValueError, match='WebApp with mountPath "/myapi" already exists'
+    ):
+        WebApp("app2", app2, config2)
+
+
+def test_webapp_different_mount_paths():
+    """Test that WebApps with different mount paths can coexist."""
+    app1 = MockFastAPIApp()
+    app2 = MockFastAPIApp()
+
+    WebApp("app1", app1, WebAppConfig(mount_path="/api1"))
+    WebApp("app2", app2, WebAppConfig(mount_path="/api2"))
+
+    assert len(_web_apps) == 2
+
+
+def test_webapp_inject_moose_utils_false():
+    """Test WebApp with inject_moose_utils disabled."""
+    app = MockFastAPIApp()
+    config = WebAppConfig(mount_path="/test", inject_moose_utils=False)
+    webapp = WebApp("test_app", app, config)
+
+    assert webapp.config.inject_moose_utils is False
+
+
+def test_webapp_repr():
+    """Test WebApp string representation."""
+    app = MockFastAPIApp()
+    webapp = WebApp("test_app", app, WebAppConfig(mount_path="/myapi"))
+
+    assert "test_app" in repr(webapp)
+    assert "/myapi" in repr(webapp)
+
+
+def test_webapp_mount_path_required():
+    """Test that mount_path is required."""
+    app = MockFastAPIApp()
+
+    with pytest.raises(ValueError, match="mountPath is required"):
+        WebApp("test_app", app, WebAppConfig(mount_path=""))
+
+
+def test_webapp_serialization():
+    """Test that WebApps can be serialized via internal.py."""
+    from moose_lib.internal import to_infra_map
+    from moose_lib.dmv2 import get_web_apps
+
+    app = MockFastAPIApp()
+    WebApp(
+        "test_app",
+        app,
+        WebAppConfig(
+            mount_path="/myapi", metadata=WebAppMetadata(description="Test API")
+        ),
+    )
+
+    # Verify it's in the registry
+    web_apps = get_web_apps()
+    assert "test_app" in web_apps
+
+    # Serialize to infra map
+    infra_map = to_infra_map()
+
+    assert "webApps" in infra_map
+    assert "test_app" in infra_map["webApps"]
+    assert infra_map["webApps"]["test_app"]["name"] == "test_app"
+    assert infra_map["webApps"]["test_app"]["mountPath"] == "/myapi"
+    assert infra_map["webApps"]["test_app"]["metadata"]["description"] == "Test API"
+
+
+def test_webapp_serialization_with_mount_path():
+    """Test WebApp serialization with explicit mount path."""
+    from moose_lib.internal import to_infra_map
+
+    app = MockFastAPIApp()
+    WebApp("test_app", app, WebAppConfig(mount_path="/testpath"))
+
+    infra_map = to_infra_map()
+
+    assert infra_map["webApps"]["test_app"]["mountPath"] == "/testpath"
+
+
+def test_webapp_serialization_no_metadata():
+    """Test WebApp serialization without metadata."""
+    from moose_lib.internal import to_infra_map
+
+    app = MockFastAPIApp()
+    WebApp("test_app", app, WebAppConfig(mount_path="/myapi"))
+
+    infra_map = to_infra_map()
+
+    assert infra_map["webApps"]["test_app"]["metadata"] is None

moose_lib-0.6.90.dist-info/RECORD

@@ -1,42 +0,0 @@
-moose_lib/__init__.py,sha256=RyZnXIB7-eo-pxTXvKE8tqK9IHJuI5CmBadFY0nI9n4,766
-moose_lib/blocks.py,sha256=78u_ufWJmObijMMjLe7pDrZtrCVkeyNBe78mKgWVsMA,9789
-moose_lib/commons.py,sha256=FUpRv8D3-LeGcjhcqtDyiimz5izwpCq53h50ydxC_uA,3711
-moose_lib/data_models.py,sha256=TMa6t9wLBKhHk1-KjCHDzt2SFS9Eo-ALnKUHEQUSkU0,10910
-moose_lib/dmv2_serializer.py,sha256=CL_Pvvg8tJOT8Qk6hywDNzY8MYGhMVdTOw8arZi3jng,49
-moose_lib/internal.py,sha256=ngUsuczYrD7Vzr_WhO23vVwnJMJAegORi5uTw3x9p7U,21139
-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/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
-moose_lib/config/config_file.py,sha256=NyjY6YFraBel7vBk18lLkpGaPR1viKMAEv4ZldyfLIA,2585
-moose_lib/config/runtime.py,sha256=h4SXRn4Mlbeh02lKN7HX2Mdp3QzySnZOeSvm8G-B3ko,3857
-moose_lib/dmv2/__init__.py,sha256=3DVAtNMZUoP94CMJBFhuXfYEQXDbQUNKSgg9XnKqae0,2768
-moose_lib/dmv2/_registry.py,sha256=gsLuWOvekgQRVvjVjPRHW2hN48LWyOWpLSpS2I-CWHc,708
-moose_lib/dmv2/consumption.py,sha256=sWfGwgCBQIIrhFEbx1CULfoN3rFFoy8uCBUefu4ejiw,12928
-moose_lib/dmv2/ingest_api.py,sha256=XhvHHgGPXp-BuRpAALth-FRhanwy-zJQ_83Cg_RLolM,2586
-moose_lib/dmv2/ingest_pipeline.py,sha256=VOkHaCrmalBGJkWy4iI93WJ_tyaXmHRSSIHBflms6F0,7432
-moose_lib/dmv2/life_cycle.py,sha256=wl0k6yzwU1MJ_fO_UkN29buoY5G6ChYZvfwigP9fVfM,1254
-moose_lib/dmv2/materialized_view.py,sha256=wTam1V5CC2rExt7YrdK_Cz4rRTONm2keKOF951LlCP4,4875
-moose_lib/dmv2/olap_table.py,sha256=YY5zgMrijPnRDaEkM5DbnqSzVRcP8s2bHCFFXISrUE0,34062
-moose_lib/dmv2/registry.py,sha256=SZOXhSC3kizhPHKQN6ZWzoMZHl90AUG3H_WKVev5zIU,2680
-moose_lib/dmv2/sql_resource.py,sha256=kUZoGqxhZMHMthtBZGYJBxTFjXkspXiWLXhJRYXgGUM,1864
-moose_lib/dmv2/stream.py,sha256=IGrUdWBEHjZ9nYz3-TChq-x9P98V9dH6TbamQ2oz_TE,11725
-moose_lib/dmv2/types.py,sha256=3YZ5Kbz2eOn94GWMTYT6Ix69Ekwe6aoUR4DiETQjv9E,4633
-moose_lib/dmv2/view.py,sha256=fVbfbJgc2lvhjpGvpfKcFUqZqxKuLD4X59jdupxIe94,1350
-moose_lib/dmv2/workflow.py,sha256=_FY4-VRo7uWxRtoipxGSo04qzBb4pbP30iQei1W0Ios,6287
-moose_lib/streaming/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-moose_lib/streaming/streaming_function_runner.py,sha256=Qv3vTSowo5Y_SeGu2XxcK5NeL_ZW0Um0ZgHxHpZ9VGM,23693
-moose_lib/utilities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-moose_lib/utilities/sql.py,sha256=kbg1DT5GdsIwgTsMzbsd6SAVf9aWER8DqmT_eKS3XN4,904
-tests/__init__.py,sha256=0Gh4yzPkkC3TzBGKhenpMIxJcRhyrrCfxLSfpTZnPMQ,53
-tests/conftest.py,sha256=ZVJNbnr4DwbcqkTmePW6U01zAzE6QD0kNAEZjPG1f4s,169
-tests/test_moose.py,sha256=mBsx_OYWmL8ppDzL_7Bd7xR6qf_i3-pCIO3wm2iQNaA,2136
-tests/test_query_builder.py,sha256=O3imdFSaqU13kbK1jSQaHbBgynhVmJaApT8DlRqYwJU,1116
-tests/test_redis_client.py,sha256=d9_MLYsJ4ecVil_jPB2gW3Q5aWnavxmmjZg2uYI3LVo,3256
-tests/test_s3queue_config.py,sha256=F05cnD61S2wBKPabcpEJxf55-DJGF4nLqwBb6aFbprc,9741
-moose_lib-0.6.90.dist-info/METADATA,sha256=HtKY83Dl-nuR8s2XqXt0jEo1e7K8bWSZmUYYshb4GLI,766
-moose_lib-0.6.90.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-moose_lib-0.6.90.dist-info/top_level.txt,sha256=XEns2-4aCmGp2XjJAeEH9TAUcGONLnSLy6ycT9FSJh8,16
-moose_lib-0.6.90.dist-info/RECORD,,