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

moose_lib/main.py

@@ -4,6 +4,7 @@ This module provides foundational classes, enums, and functions used across the
 including configuration objects, clients for interacting with services (ClickHouse, Temporal),
 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
@@ -18,7 +19,11 @@ import hashlib
 import asyncio
 from string import Formatter
 from temporalio.client import Client as TemporalClient, TLSConfig
-from temporalio.common import RetryPolicy, WorkflowIDConflictPolicy, WorkflowIDReusePolicy
+from temporalio.common import (
+    RetryPolicy,
+    WorkflowIDConflictPolicy,
+    WorkflowIDReusePolicy,
+)
 from datetime import timedelta, datetime
 from time import perf_counter
 from humanfriendly import format_timespan
@@ -37,6 +42,7 @@ class StreamingFunction:
     Attributes:
         run: The callable function that performs the streaming logic.
     """
+
     run: Callable
 
 
@@ -49,6 +55,7 @@ class StorageConfig:
         order_by_fields: List of fields to use for ordering in the storage layer.
         deduplicate: Whether to enable deduplication based on the order_by_fields.
     """
+
     enabled: Optional[bool] = None
     order_by_fields: Optional[list[str]] = None
     deduplicate: Optional[bool] = None
@@ -63,6 +70,7 @@ class DataModelConfig:
     Attributes:
         storage: Configuration for how data is stored.
     """
+
     storage: Optional[StorageConfig] = None
 
 
@@ -112,21 +120,22 @@ def moose_data_model(arg: Any = None) -> Any:
     def get_file(t: type) -> Optional[str]:
         """Helper to get the file path of a type's definition."""
         module = sys.modules.get(t.__module__)
-        if module and hasattr(module, '__file__'):
+        if module and hasattr(module, "__file__"):
             return module.__file__
         return None
 
     def remove_null(d: dict) -> dict:
         """Recursively removes keys with None values from a dictionary."""
-        return {key: remove_null(value) if isinstance(value, dict) else value for key, value in d.items() if
-                not (value is None)}
+        return {
+            key: remove_null(value) if isinstance(value, dict) else value
+            for key, value in d.items()
+            if not (value is None)
+        }
 
     def decorator(data_class: type) -> type:
         expected_file_name = os.environ.get("MOOSE_PYTHON_DM_DUMP")
         if expected_file_name and expected_file_name == get_file(data_class):
-            output: dict[str, str | dict] = {
-                'class_name': data_class.__name__
-            }
+            output: dict[str, str | dict] = {"class_name": data_class.__name__}
             if arg:
                 output["config"] = remove_null(asdict(arg))
             output_json = json.dumps(output, cls=CustomEncoder, indent=4)
@@ -149,6 +158,7 @@ class ApiResult:
         status: The HTTP status code for the response.
         body: The response body, which should be JSON serializable.
     """
+
     status: int
     body: Any
 
@@ -165,11 +175,13 @@ class QueryClient:
         ch_client_or_config: Either an instance of the ClickHouse client or a RuntimeClickHouseConfig.
     """
 
-    def __init__(self, ch_client_or_config: Union[ClickhouseClient, RuntimeClickHouseConfig]):
+    def __init__(
+        self, ch_client_or_config: Union[ClickhouseClient, RuntimeClickHouseConfig]
+    ):
         if isinstance(ch_client_or_config, RuntimeClickHouseConfig):
             # Create ClickHouse client from configuration
             config = ch_client_or_config
-            interface = 'https' if config.use_ssl else 'http'
+            interface = "https" if config.use_ssl else "http"
             self.ch_client = get_client(
                 interface=interface,
                 host=config.host,
@@ -185,7 +197,9 @@ class QueryClient:
     def __call__(self, input, variables):
         return self.execute(input, variables)
 
-    def execute(self, input: Union[str, Query], variables = None, row_type: Type[BaseModel] = None):
+    def execute(
+        self, input: Union[str, Query], variables=None, row_type: Type[BaseModel] = None
+    ):
         """
         Execute a query.
 
@@ -212,7 +226,8 @@ class QueryClient:
         values: dict[str, Any] = {}
         preview_params = {}
 
-        for i, (_, variable_name, _, _) in enumerate(Formatter().parse(input)):
+        i = 0
+        for _, variable_name, _, _ in Formatter().parse(input):
             if variable_name:
                 value = variables[variable_name]
                 if isinstance(value, list) and len(value) == 1:
@@ -220,27 +235,36 @@ class QueryClient:
                     value = value[0]
 
                 if isinstance(value, Column) or isinstance(value, OlapTable):
-                    params[variable_name] = f'{{p{i}: Identifier}}'
-                    values[f'p{i}'] = value.name
+                    if isinstance(value, OlapTable) and value.config.database:
+                        params[variable_name] = (
+                            f"{{p{i}: Identifier}}.{{p{i + 1}: Identifier}}"
+                        )
+                        values[f"p{i}"] = value.config.database
+                        values[f"p{i + 1}"] = value.name
+                        i += 2
+                    else:
+                        params[variable_name] = f"{{p{i}: Identifier}}"
+                        values[f"p{i}"] = value.name
+                        i += 1
                 else:
                     from moose_lib.utilities.sql import clickhouse_param_type_for_value
+
                     ch_type = clickhouse_param_type_for_value(value)
-                    params[variable_name] = f'{{p{i}: {ch_type}}}'
-                    values[f'p{i}'] = value
+                    params[variable_name] = f"{{p{i}: {ch_type}}}"
+                    values[f"p{i}"] = value
+                    i += 1
                 preview_params[variable_name] = self._format_value_for_preview(value)
 
         clickhouse_query = input.format_map(params)
         preview_query = input.format_map(preview_params)
         print(f"[QueryClient] | Query: {' '.join(preview_query.split())}")
-        return self.execute_raw(
-            clickhouse_query, values, row_type
-        )
+        return self.execute_raw(clickhouse_query, values, row_type)
 
     def execute_raw(
-            self,
-            clickhouse_query: str,
-            parameters: Optional[dict[str, Any]],
-            row_type: Type[BaseModel] = None
+        self,
+        clickhouse_query: str,
+        parameters: Optional[dict[str, Any]],
+        row_type: Type[BaseModel] = None,
     ):
         """
         Uses raw clickhouse SQL syntax.
@@ -270,11 +294,11 @@ class QueryClient:
         """
         # NULL handling
         if value is None:
-            return 'NULL'
+            return "NULL"
 
         # Booleans (ClickHouse accepts true/false)
         if isinstance(value, bool):
-            return 'true' if value else 'false'
+            return "true" if value else "false"
 
         # Numbers
         if isinstance(value, (int, float)) and not isinstance(value, bool):
@@ -283,24 +307,29 @@ class QueryClient:
         # Strings
         if isinstance(value, str):
             # Escape backslashes and single quotes for ClickHouse single-quoted strings
-            escaped = value.replace('\\', '\\\\').replace("'", "\\'")
+            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, OlapTable) and value.config.database:
+            return f"{value.config.database}.{value.name}"
+
         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)
+            formatted_items = ", ".join(
+                self._format_value_for_preview(v) for v in value
+            )
             return f"[{formatted_items}]"
 
         # Fallback: stringify and single-quote
         fallback = str(value)
-        escaped_fallback = fallback.replace('\\', '\\\\').replace("'", "\\'")
+        escaped_fallback = fallback.replace("\\", "\\\\").replace("'", "\\'")
         return f"'{escaped_fallback}'"
 
     def close(self):
@@ -325,33 +354,26 @@ class WorkflowClient:
     # Test workflow executor in rust if this changes significantly
     def execute(self, name: str, input_data: Any) -> Dict[str, Any]:
         try:
-            workflow_id, run_id = asyncio.run(self._start_workflow_async(name, input_data))
+            workflow_id, run_id = asyncio.run(
+                self._start_workflow_async(name, input_data)
+            )
             print(f"WorkflowClient - started workflow: {name}")
             return {
                 "status": 200,
-                "body": f"Workflow started: {name}. View it in the Temporal dashboard: http://localhost:8080/namespaces/default/workflows/{workflow_id}/{run_id}/history"
+                "body": f"Workflow started: {name}. View it in the Temporal dashboard: http://localhost:8080/namespaces/default/workflows/{workflow_id}/{run_id}/history",
             }
         except Exception as e:
             print(f"WorkflowClient - error while starting workflow: {e}")
-            return {
-                "status": 400,
-                "body": str(e)
-            }
+            return {"status": 400, "body": str(e)}
 
     def terminate(self, workflow_id: str) -> Dict[str, Any]:
         try:
             asyncio.run(self._terminate_workflow_async(workflow_id))
             print(f"WorkflowClient - terminated workflow: {workflow_id}")
-            return {
-                "status": 200,
-                "body": f"Workflow terminated: {workflow_id}"
-            }
+            return {"status": 200, "body": f"Workflow terminated: {workflow_id}"}
         except Exception as e:
             print(f"WorkflowClient - error while terminating workflow: {e}")
-            return {
-                "status": 400,
-                "body": str(e)
-            }
+            return {"status": 400, "body": str(e)}
 
     async def _terminate_workflow_async(self, workflow_id: str):
         workflow_handle = self.temporal_client.get_workflow_handle(workflow_id)
@@ -365,11 +387,12 @@ class WorkflowClient:
         processed_input, workflow_id = self._process_input_data(name, input_data)
 
         # Create retry policy and timeout (common logic)
-        retry_policy = RetryPolicy(maximum_attempts=config['retry_count'])
-        run_timeout = self.parse_timeout_to_timedelta(config['timeout_str'])
+        retry_policy = RetryPolicy(maximum_attempts=config["retry_count"])
+        run_timeout = self.parse_timeout_to_timedelta(config["timeout_str"])
 
         print(
-            f"WorkflowClient - starting DMv2 workflow: {name} with retry policy: {retry_policy} and timeout: {run_timeout}")
+            f"WorkflowClient - starting DMv2 workflow: {name} with retry policy: {retry_policy} and timeout: {run_timeout}"
+        )
 
         # Start workflow with appropriate args
         workflow_args = self._build_workflow_args(name, processed_input)
@@ -388,8 +411,7 @@ class WorkflowClient:
             workflow_kwargs["run_timeout"] = run_timeout
 
         workflow_handle = await self.temporal_client.start_workflow(
-            "ScriptWorkflow",
-            **workflow_kwargs
+            "ScriptWorkflow", **workflow_kwargs
         )
 
         return workflow_id, workflow_handle.result_run_id
@@ -403,8 +425,8 @@ class WorkflowClient:
             raise ValueError(f"DMv2 workflow '{name}' not found")
 
         return {
-            'retry_count': dmv2_workflow.config.retries or 3,
-            'timeout_str': dmv2_workflow.config.timeout or "1h",
+            "retry_count": dmv2_workflow.config.retries or 3,
+            "timeout_str": dmv2_workflow.config.timeout or "1h",
         }
 
     def _process_input_data(self, name: str, input_data: Any) -> tuple[Any, str]:
@@ -438,11 +460,11 @@ class WorkflowClient:
     def parse_timeout_to_timedelta(self, timeout_str: str) -> Optional[timedelta]:
         if timeout_str == "never":
             return None  # Unlimited execution timeout
-        elif timeout_str.endswith('h'):
+        elif timeout_str.endswith("h"):
             return timedelta(hours=int(timeout_str[:-1]))
-        elif timeout_str.endswith('m'):
+        elif timeout_str.endswith("m"):
             return timedelta(minutes=int(timeout_str[:-1]))
-        elif timeout_str.endswith('s'):
+        elif timeout_str.endswith("s"):
             return timedelta(seconds=int(timeout_str[:-1]))
         else:
             raise ValueError(f"Unsupported timeout format: {timeout_str}")
@@ -463,7 +485,11 @@ class MooseClient:
         workflow (Optional[WorkflowClient]): Client for workflow operations (if configured).
     """
 
-    def __init__(self, ch_client: ClickhouseClient, temporal_client: Optional[TemporalClient] = None):
+    def __init__(
+        self,
+        ch_client: ClickhouseClient,
+        temporal_client: Optional[TemporalClient] = None,
+    ):
         self.query = QueryClient(ch_client)
         self.temporal_client = temporal_client
         if temporal_client:
@@ -508,15 +534,20 @@ class Sql:
                             between the strings.
     """
 
-    def __init__(self, raw_strings: list[str], raw_values: list['RawValue']):
+    def __init__(self, raw_strings: list[str], raw_values: list["RawValue"]):
         if len(raw_strings) - 1 != len(raw_values):
             if len(raw_strings) == 0:
                 raise TypeError("Expected at least 1 string")
-            raise TypeError(f"Expected {len(raw_strings)} strings to have {len(raw_strings) - 1} values")
+            raise TypeError(
+                f"Expected {len(raw_strings)} strings to have {len(raw_strings) - 1} values"
+            )
 
-        values_length = sum(1 if not isinstance(value, Sql) else len(value.values) for value in raw_values)
+        values_length = sum(
+            1 if not isinstance(value, Sql) else len(value.values)
+            for value in raw_values
+        )
 
-        self.values: list['Value'] = [None] * values_length
+        self.values: list["Value"] = [None] * values_length
         self.strings: list[str] = [None] * (values_length + 1)
 
         self.strings[0] = raw_strings[0]

moose_lib/query_builder.py

@@ -15,7 +15,9 @@ class Params:
         self._counter = 0
         self.bindings: dict[str, object] = {}
 
-    def bind(self, value: object, name: str | None = None, ch_type: str | None = None) -> sge.Expression:
+    def bind(
+        self, value: object, name: str | None = None, ch_type: str | None = None
+    ) -> sge.Expression:
         if name is None:
             name = f"p{self._counter}"
             self._counter += 1
@@ -56,7 +58,9 @@ class ColumnRef:
 
     def _binary_op(self, op_name: str, value: object) -> Predicate:
         def resolve(query: "Query") -> sge.Expression:
-            table_name = query._from_table.name if query._from_table is not None else None
+            table_name = (
+                query._from_table.name if query._from_table is not None else None
+            )
             left = to_column(self._column, table_name)
             right = query.params.bind(value)
             op = getattr(left, op_name)
@@ -84,7 +88,9 @@ class ColumnRef:
 
     def in_(self, values: list[object]) -> Predicate:
         def resolve(query: "Query") -> sge.Expression:
-            table_name = query._from_table.name if query._from_table is not None else None
+            table_name = (
+                query._from_table.name if query._from_table is not None else None
+            )
             left = to_column(self._column, table_name)
             rights = [query.params.bind(v) for v in values]
             return left.isin(*rights)
@@ -93,7 +99,9 @@ class ColumnRef:
 
     def is_null(self) -> Predicate:
         def resolve(query: "Query") -> sge.Expression:
-            table_name = query._from_table.name if query._from_table is not None else None
+            table_name = (
+                query._from_table.name if query._from_table is not None else None
+            )
             left = to_column(self._column, table_name)
             return left.is_(sge.Null())
 
@@ -116,7 +124,12 @@ class Query:
         return self
 
     def select(self, *cols: Column) -> "Query":
-        sge_cols = [to_column(c, self._from_table.name if self._from_table is not None else None) for c in cols]
+        sge_cols = [
+            to_column(
+                c, self._from_table.name if self._from_table is not None else None
+            )
+            for c in cols
+        ]
         self.inner = self.inner.select(*sge_cols)
         return self
 

moose_lib/query_param.py

@@ -5,7 +5,11 @@ from typing import Optional, Union, Any
 import inspect
 
 from pydantic import BaseModel
-from .data_models import DataEnum, py_type_to_column_type, ArrayType as DataModelArrayType
+from .data_models import (
+    DataEnum,
+    py_type_to_column_type,
+    ArrayType as DataModelArrayType,
+)
 
 scalar_types = Union[str, DataEnum]
 
@@ -40,18 +44,20 @@ def unwrap_optional(union_type):
 # dmV1 code, won't upgrade to include the rich types
 def parse_scalar_value(value: str, t: scalar_types) -> Any:
     match t:
-        case 'String':
+        case "String":
             return value
-        case 'Int':
+        case "Int" | "Int64":
             return int(value)
-        case 'Float' | 'Float64' | 'Float32':
+        case "Float" | "Float64" | "Float32":
             return float(value)
-        case 'Boolean':
+        case "Boolean":
             value_lower = value.lower()
-            if value_lower not in ('true', 'false'):
-                raise ValueError(f"Boolean value must be 'true' or 'false', got: {value}")
-            return value_lower == 'true'
-        case 'DateTime':
+            if value_lower not in ("true", "false"):
+                raise ValueError(
+                    f"Boolean value must be 'true' or 'false', got: {value}"
+                )
+            return value_lower == "true"
+        case "DateTime":
             return datetime.fromisoformat(value)
         case _:
             # enum parsing will not be added to dmV1 code
@@ -78,11 +84,21 @@ def convert_pydantic_definition(cls: type) -> list[QueryField]:
                 element_type = field_type.__args__[0]  # type: ignore
                 scala_type = to_scalar_type(element_type)
                 fields_list.append(
-                    QueryField(field_name, ArrayType(scala_type), has_default=not no_default, required=required))
+                    QueryField(
+                        field_name,
+                        ArrayType(scala_type),
+                        has_default=not no_default,
+                        required=required,
+                    )
+                )
                 continue
 
         scala_type = to_scalar_type(field_type)
-        fields_list.append(QueryField(field_name, scala_type, has_default=not no_default, required=required))
+        fields_list.append(
+            QueryField(
+                field_name, scala_type, has_default=not no_default, required=required
+            )
+        )
 
     return fields_list
 
@@ -98,7 +114,9 @@ def convert_dataclass_definition(cls: type) -> list[QueryField]:
 
         # Handle Optional types
         # Field is not required if it has a default value or is Optional
-        no_default = field_def.default == field_def.default_factory == dataclasses.MISSING
+        no_default = (
+            field_def.default == field_def.default_factory == dataclasses.MISSING
+        )
         required = no_default
 
         if hasattr(field_type, "__origin__"):
@@ -109,11 +127,21 @@ def convert_dataclass_definition(cls: type) -> list[QueryField]:
                 element_type = field_type.__args__[0]  # type: ignore
                 scala_type = to_scalar_type(element_type)
                 fields_list.append(
-                    QueryField(field_name, ArrayType(scala_type), has_default=not no_default, required=required))
+                    QueryField(
+                        field_name,
+                        ArrayType(scala_type),
+                        has_default=not no_default,
+                        required=required,
+                    )
+                )
                 continue
 
         scala_type = to_scalar_type(field_type)
-        fields_list.append(QueryField(field_name, scala_type, has_default=not no_default, required=required))
+        fields_list.append(
+            QueryField(
+                field_name, scala_type, has_default=not no_default, required=required
+            )
+        )
 
     return fields_list
 
@@ -129,14 +157,16 @@ def convert_api_param(module) -> Optional[tuple[type, list[QueryField]]]:
     elif issubclass(param_class, BaseModel):
         query_fields = convert_pydantic_definition(param_class)
     else:
-        raise ValueError(f"{param_class.__name__} is neither a Pydantic model or a dataclass")
+        raise ValueError(
+            f"{param_class.__name__} is neither a Pydantic model or a dataclass"
+        )
     return param_class, query_fields
 
 
 def map_params_to_class(
-        params: dict[str, list[str]],
-        field_def_list: list[QueryField],
-        cls: type,
+    params: dict[str, list[str]],
+    field_def_list: list[QueryField],
+    cls: type,
 ) -> Any:
     # Initialize an empty dict for the constructor arguments
     constructor_args: dict[str, Any] = {}
@@ -147,7 +177,9 @@ def map_params_to_class(
         elif is_dataclass(cls):
             return parse_scalar_value(param, t)
         else:
-            raise ValueError(f"{cls.__name__} is neither a Pydantic model or a dataclass")
+            raise ValueError(
+                f"{cls.__name__} is neither a Pydantic model or a dataclass"
+            )
 
     # Get field definitions from the dataclass
     for field_def in field_def_list:
@@ -167,7 +199,9 @@ def map_params_to_class(
         values = params[field_name]
 
         if isinstance(field_type, ArrayType):
-            constructor_args[field_name] = [parse(v, field_type.element_type) for v in values]
+            constructor_args[field_name] = [
+                parse(v, field_type.element_type) for v in values
+            ]
         else:
             if len(values) != 1:
                 raise ValueError(f"Expected a single element for {field_name}")

moose_lib/secrets.py

@@ -0,0 +1,122 @@
+"""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:
+    """Gets a value from an environment variable, with behavior depending on context.
+
+    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
+    - 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:
+        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):
+        >>> 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")
+    """
+    import os
+
+    if not env_var_name or not env_var_name.strip():
+        raise ValueError("Environment variable name cannot be empty")
+
+    # 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:
+    """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",
+]