moose-lib 0.6.148.dev3442438466__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

@@ -7,106 +7,108 @@ 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)
+    annotated_type = simple_aggregated("sum", int)
 
     # Check that it's annotated
-    assert hasattr(annotated_type, '__metadata__')
+    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.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)
+    func = SimpleAggregateFunction(agg_func="sum", arg_type=int)
     result = func.to_dict()
 
-    assert result['functionName'] == 'sum'
-    assert 'argumentType' in result
-    # Python int maps to "Int" by default (not "Int64")
-    assert result['argumentType'] == 'Int'
+    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)
+    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'
+    assert result_float["functionName"] == "max"
+    assert result_float["argumentType"] == "Float64"
 
     # Test with str
-    func_str = SimpleAggregateFunction(agg_func='anyLast', arg_type=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'
+    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)
+        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')
+    row_count_col = next(c for c in columns if c.name == "row_count")
 
-    # Check basic type - Python int maps to "Int"
-    assert row_count_col.data_type == 'Int'
+    # 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
+        (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'] == 'Int'
+    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)
+        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_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'
+        a for a in sum_col.annotations if a[0] == "simpleAggregationFunction"
     )
-    assert sum_annotation[1]['functionName'] == 'sum'
+    assert sum_annotation[1]["functionName"] == "sum"
 
     # Test max
-    max_col = next(c for c in columns if c.name == 'max_value')
+    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'
+        a for a in max_col.annotations if a[0] == "simpleAggregationFunction"
     )
-    assert max_annotation[1]['functionName'] == 'max'
+    assert max_annotation[1]["functionName"] == "max"
 
     # Test min
-    min_col = next(c for c in columns if c.name == 'min_value')
+    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'
+        a for a in min_col.annotations if a[0] == "simpleAggregationFunction"
     )
-    assert min_annotation[1]['functionName'] == 'min'
+    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_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'
+        a for a in last_col.annotations if a[0] == "simpleAggregationFunction"
     )
-    assert last_annotation[1]['functionName'] == 'anyLast'
-    assert last_annotation[1]['argumentType'] == 'DateTime'
+    assert last_annotation[1]["functionName"] == "anyLast"
+    assert last_annotation[1]["argumentType"] == "DateTime"

tests/test_web_app.py

@@ -1,6 +1,7 @@
 """
 Unit tests for WebApp SDK functionality.
 """
+
 import pytest
 from moose_lib.dmv2 import WebApp, WebAppConfig, WebAppMetadata
 from moose_lib.dmv2._registry import _web_apps
@@ -9,6 +10,7 @@ from moose_lib.dmv2._registry import _web_apps
 # Mock FastAPI app for testing
 class MockFastAPIApp:
     """Mock FastAPI application for testing."""
+
     pass
 
 
@@ -84,7 +86,10 @@ def test_webapp_root_path_rejected():
     app = MockFastAPIApp()
     config = WebAppConfig(mount_path="/")
 
-    with pytest.raises(ValueError, match='mountPath cannot be "/" as it would allow routes to overlap with reserved paths'):
+    with pytest.raises(
+        ValueError,
+        match='mountPath cannot be "/" as it would allow routes to overlap with reserved paths',
+    ):
         WebApp("test_app", app, config)
 
 
@@ -127,7 +132,9 @@ def test_webapp_duplicate_mount_path():
     WebApp("app1", app1, config1)
 
     config2 = WebAppConfig(mount_path="/myapi")
-    with pytest.raises(ValueError, match='WebApp with mountPath "/myapi" already exists'):
+    with pytest.raises(
+        ValueError, match='WebApp with mountPath "/myapi" already exists'
+    ):
         WebApp("app2", app2, config2)
 
 
@@ -178,9 +185,8 @@ def test_webapp_serialization():
         "test_app",
         app,
         WebAppConfig(
-            mount_path="/myapi",
-            metadata=WebAppMetadata(description="Test API")
-        )
+            mount_path="/myapi", metadata=WebAppMetadata(description="Test API")
+        ),
     )
 
     # Verify it's in the registry

moose_lib-0.6.148.dev3442438466.dist-info/RECORD

@@ -1,47 +0,0 @@
-moose_lib/__init__.py,sha256=swNNCec7czJO62pYKeRyonMR4QlzgCN74GLFFI3NDxs,917
-moose_lib/blocks.py,sha256=Cwjx7UX5qXLVpxF5eBomBLzIoxVn769jfZRJfJnqPyw,14423
-moose_lib/commons.py,sha256=YDMzRO3ySa_iQRknmFwwE539KgSyjWhYJ-E3jIsfSgc,6585
-moose_lib/data_models.py,sha256=t_RL658-l9iCau2NXdnCSbt_MFH9S-vYNCmimZfWZ_o,15509
-moose_lib/dmv2_serializer.py,sha256=CL_Pvvg8tJOT8Qk6hywDNzY8MYGhMVdTOw8arZi3jng,49
-moose_lib/internal.py,sha256=FMd4GuQ2uRXiV7_9JrTYN1xx2HFagMbEY9uu_Kb4omg,27742
-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=x6Gm3MkhPYLcaZefgNTpZCFnnqSWVlLz2JVoISxG7rI,3885
-moose_lib/config/runtime.py,sha256=zfd58p6tTIIkcjeMYtQJNMzXGVbXGBHGmq7FX7GLoXc,8130
-moose_lib/dmv2/__init__.py,sha256=BQf-WUA2AY0X5h6ITZ_BrTGul2vDnflbIiSl_m7thhE,3312
-moose_lib/dmv2/_registry.py,sha256=ACc_Cr__tZJEQfp6uTVx7O8nF62IrHt_i-X6w1s4QQA,739
-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=R8NRrfD9zkEzwWEJKIrNL9Nk18DdGc7wdAakae_2-7o,8459
-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=o8wNZ9qTrbNB8mz8VnQTSme7AsNQ8KofDI2erywnSa0,35763
-moose_lib/dmv2/registry.py,sha256=5V8HRKBJXKLIi5tdIC2tKEmsGELQ1C2fBrMjns8a3ao,2947
-moose_lib/dmv2/sql_resource.py,sha256=kUZoGqxhZMHMthtBZGYJBxTFjXkspXiWLXhJRYXgGUM,1864
-moose_lib/dmv2/stream.py,sha256=pDryS1x5zMkDSJsFlGqm8quwKTl1ctAL-a_U8ySgqQI,18043
-moose_lib/dmv2/types.py,sha256=3YZ5Kbz2eOn94GWMTYT6Ix69Ekwe6aoUR4DiETQjv9E,4633
-moose_lib/dmv2/view.py,sha256=fVbfbJgc2lvhjpGvpfKcFUqZqxKuLD4X59jdupxIe94,1350
-moose_lib/dmv2/web_app.py,sha256=BPJIKMGNJqezThw56maVpjLwinJ8afDaBAoRgLiTGQA,5487
-moose_lib/dmv2/web_app_helpers.py,sha256=3HUDTUmNwvOLQHrOcvo_ocXD6HBfyKEprPYAqT0kVnI,2895
-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=A4XrfawOR432hSfJr86-s1-aXsN6jAvwTyJcoY2Hos4,23171
-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=tsBozrzGuJUO7dRGVcIxCjqi-l77I-DvYnzpbKtmGzE,1003
-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=F05cnD61S2wBKPabcpEJxf55-DJGF4nLqwBb6aFbprc,9741
-tests/test_simple_aggregate.py,sha256=yyFSYHUXskA1aTcwC-KQ9XmgOikeQ8wKXzntsUBIC6w,4055
-tests/test_web_app.py,sha256=iL86sg0NS2k6nP8jIGKZvrtg0BjvaqNTRp7-4T1TTck,6557
-moose_lib-0.6.148.dev3442438466.dist-info/METADATA,sha256=zgGu8QHz4E6NOqio2tEqoteLxLhnf1YKTBwjWkgOvDQ,841
-moose_lib-0.6.148.dev3442438466.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-moose_lib-0.6.148.dev3442438466.dist-info/top_level.txt,sha256=XEns2-4aCmGp2XjJAeEH9TAUcGONLnSLy6ycT9FSJh8,16
-moose_lib-0.6.148.dev3442438466.dist-info/RECORD,,