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

moose_lib/dmv2/__init__.py

@@ -15,6 +15,10 @@ from .types import (
     ZeroOrMany,
 )
 
+from .moose_model import (
+    MooseModel,
+)
+
 from .olap_table import (
     OlapConfig,
     OlapTable,
@@ -28,6 +32,10 @@ from .stream import (
     Stream,
     DeadLetterModel,
     DeadLetterQueue,
+    SubjectLatest,
+    SubjectVersion,
+    SchemaById,
+    KafkaSchemaConfig,
 )
 
 from .ingest_api import (
@@ -76,6 +84,18 @@ from .life_cycle import (
     LifeCycle,
 )
 
+from .web_app import (
+    WebApp,
+    WebAppConfig,
+    WebAppMetadata,
+)
+
+from .web_app_helpers import (
+    ApiUtil,
+    get_moose_utils,
+    get_moose_dependency,
+)
+
 from .registry import (
     get_tables,
     get_table,
@@ -89,6 +109,8 @@ from .registry import (
     get_sql_resource,
     get_workflows,
     get_workflow,
+    get_web_apps,
+    get_web_app,
     # Backward compatibility aliases
     get_consumption_apis,
     get_consumption_api,
@@ -96,74 +118,80 @@ from .registry import (
 
 __all__ = [
     # Types
-    'BaseTypedResource',
-    'TypedMooseResource',
-    'Columns',
-    'T',
-    'U',
-    'T_none',
-    'U_none',
-    'ZeroOrMany',
-
+    "BaseTypedResource",
+    "TypedMooseResource",
+    "Columns",
+    "MooseModel",
+    "T",
+    "U",
+    "T_none",
+    "U_none",
+    "ZeroOrMany",
     # OLAP Tables
-    'OlapConfig',
-    'OlapTable',
-    'InsertOptions',
-
+    "OlapConfig",
+    "OlapTable",
+    "InsertOptions",
     # Streams
-    'StreamConfig',
-    'TransformConfig',
-    'ConsumerConfig',
-    'Stream',
-    'DeadLetterModel',
-    'DeadLetterQueue',
-
+    "StreamConfig",
+    "TransformConfig",
+    "ConsumerConfig",
+    "Stream",
+    "DeadLetterModel",
+    "DeadLetterQueue",
+    "SubjectLatest",
+    "SubjectVersion",
+    "SchemaById",
+    "KafkaSchemaConfig",
     # Ingestion
-    'IngestConfig',
-    'IngestConfigWithDestination',
-    'IngestPipelineConfig',
-    'IngestApi',
-    'IngestPipeline',
-
+    "IngestConfig",
+    "IngestConfigWithDestination",
+    "IngestPipelineConfig",
+    "IngestApi",
+    "IngestPipeline",
     # Consumption
-    'ApiConfig',
-    'Api',
-    'get_moose_base_url',
-    'set_moose_base_url',
+    "ApiConfig",
+    "Api",
+    "get_moose_base_url",
+    "set_moose_base_url",
     # Backward compatibility aliases (deprecated)
-    'ConsumptionApi',
-    'EgressConfig',
-
+    "ConsumptionApi",
+    "EgressConfig",
     # SQL
-    'SqlResource',
-    'View',
-    'MaterializedViewOptions',
-    'MaterializedView',
-
+    "SqlResource",
+    "View",
+    "MaterializedViewOptions",
+    "MaterializedView",
     # Workflow
-    'TaskContext',
-    'TaskConfig',
-    'Task',
-    'WorkflowConfig',
-    'Workflow',
-
+    "TaskContext",
+    "TaskConfig",
+    "Task",
+    "WorkflowConfig",
+    "Workflow",
     # Lifecycle
-    'LifeCycle',
-
+    "LifeCycle",
+    # WebApp
+    "WebApp",
+    "WebAppConfig",
+    "WebAppMetadata",
+    "ApiUtil",
+    "get_moose_utils",
+    "get_moose_dependency",
     # Registry
-    'get_tables',
-    'get_table',
-    'get_streams',
-    'get_stream',
-    'get_ingest_apis',
-    'get_ingest_api',
-    'get_apis',
-    'get_api',
-    'get_sql_resources',
-    'get_sql_resource',
-    'get_workflows',
-    'get_workflow',
+    "get_tables",
+    "get_table",
+    "get_streams",
+    "get_stream",
+    "get_ingest_apis",
+    "get_ingest_api",
+    "get_apis",
+    "get_api",
+    "get_sql_resources",
+    "get_sql_resource",
+    "get_workflows",
+    "get_workflow",
+    "get_web_apps",
+    "get_web_app",
     # Backward compatibility aliases (deprecated)
-    'get_consumption_apis',
-    'get_consumption_api',
+    "get_consumption_apis",
+    "get_consumption_api",
 ]

moose_lib/dmv2/_registry.py

@@ -4,6 +4,7 @@ Internal registry dictionaries for Moose Data Model v2 (dmv2) resources.
 This module maintains the raw dictionaries that store all registered resources.
 It has no imports from other dmv2 modules to avoid circular dependencies.
 """
+
 from typing import Dict, Any
 
 # Global registries for all resource types
@@ -16,4 +17,5 @@ _api_name_aliases: Dict[str, Any] = {}
 # Map from custom paths to API instances for path-based lookup
 _api_path_map: Dict[str, Any] = {}
 _sql_resources: Dict[str, Any] = {}
-_workflows: Dict[str, Any] = {}
+_workflows: Dict[str, Any] = {}
+_web_apps: Dict[str, Any] = {}

moose_lib/dmv2/_source_capture.py

@@ -0,0 +1,37 @@
+"""
+Utilities for capturing source file information from the call stack.
+
+This module provides functions to extract source file paths from Python's
+call stack, filtering out internal library paths.
+"""
+
+from typing import Optional
+import inspect
+
+
+def get_source_file_from_stack() -> Optional[str]:
+    """Extract the source file path from the call stack, skipping internal modules.
+
+    Returns the first file path that is not from internal moose_lib modules,
+    site-packages, or special Python frames.
+
+    Returns:
+        The absolute path to the user's source file, or None if not found.
+    """
+    try:
+        # Get the current call stack
+        stack = inspect.stack()
+        # Start from index 1 to skip this function itself
+        for frame_info in stack[1:]:
+            filename = frame_info.filename
+            # Skip internal modules and site-packages
+            if (
+                "site-packages" not in filename
+                and "moose_lib" not in filename
+                and "<" not in filename  # Skip special frames like <frozen importlib>
+            ):
+                return filename
+    except Exception:
+        # If anything goes wrong, just return None
+        pass
+    return None

moose_lib/dmv2/consumption.py

@@ -4,6 +4,7 @@ API definitions for Moose Data Model v2 (dmv2).
 This module provides classes for defining and configuring APIs
 that allow querying data through user-defined functions.
 """
+
 import os
 from typing import Any, Callable, Optional, Tuple, Generic
 
@@ -17,13 +18,14 @@ from ._registry import _apis, _api_name_aliases, _api_path_map
 # Global base URL configuration
 _global_base_url: Optional[str] = None
 
+
 def _generate_api_key(name: str, version: Optional[str] = None) -> str:
     return f"{name}:{version}" if version else name
 
 
 def set_moose_base_url(url: str) -> None:
     """Set the global base URL for API calls.
-    
+
     Args:
         url: The base URL to use for API calls
     """
@@ -33,14 +35,14 @@ def set_moose_base_url(url: str) -> None:
 
 def get_moose_base_url() -> Optional[str]:
     """Get the configured base URL from global setting or environment variable.
-    
+
     Returns:
         The base URL if configured, None otherwise
     """
     # Priority: programmatically set > environment variable
     if _global_base_url:
         return _global_base_url
-    return os.getenv('MOOSE_BASE_URL')
+    return os.getenv("MOOSE_BASE_URL")
 
 
 class ApiConfig(BaseModel):
@@ -51,6 +53,7 @@ class ApiConfig(BaseModel):
         path: Optional custom path for the API endpoint. If not specified, defaults to the API name.
         metadata: Optional metadata for the API.
     """
+
     version: Optional[str] = None
     path: Optional[str] = None
     metadata: Optional[dict] = None
@@ -78,6 +81,7 @@ class Api(BaseTypedResource, Generic[U]):
         model_type (type[T]): The Pydantic model for the input/query parameters.
         return_type (type[U]): The Pydantic model for the response body.
     """
+
     config: ApiConfig
     query_function: Callable[..., U]
     _u: type[U]
@@ -85,7 +89,9 @@ class Api(BaseTypedResource, Generic[U]):
     def __class_getitem__(cls, items):
         # Handle two type parameters
         if not isinstance(items, tuple) or len(items) != 2:
-            raise ValueError(f"Use `{cls.__name__}[T, U](name='...')` to supply both input and output types")
+            raise ValueError(
+                f"Use `{cls.__name__}[T, U](name='...')` to supply both input and output types"
+            )
         input_type, output_type = items
 
         def curried_constructor(*args, **kwargs):
@@ -93,19 +99,23 @@ class Api(BaseTypedResource, Generic[U]):
 
         return curried_constructor
 
-    def __init__(self, name: str, query_function: Callable[..., U], config: ApiConfig = None, version: str = None, **kwargs):
+    def __init__(
+        self,
+        name: str,
+        query_function: Callable[..., U],
+        config: ApiConfig = None,
+        version: str = None,
+        **kwargs,
+    ):
         super().__init__()
         self._set_type(name, self._get_type(kwargs))
-        
+
         # Handle config and version parameters properly
         if config is not None:
             # If config is provided, use it as base
             if version is not None:
                 # If version is also provided, update the config's version
-                self.config = ApiConfig(
-                    version=version,
-                    metadata=config.metadata
-                )
+                self.config = ApiConfig(version=version, metadata=config.metadata)
             else:
                 # Use the provided config as-is
                 self.config = config
@@ -117,7 +127,7 @@ class Api(BaseTypedResource, Generic[U]):
             self.config = ApiConfig()
 
         self.query_function = query_function
-        self.metadata = getattr(self.config, 'metadata', {}) or {}
+        self.metadata = getattr(self.config, "metadata", {}) or {}
         key = _generate_api_key(name, self.config.version)
 
         # Check for duplicate registration
@@ -143,13 +153,15 @@ class Api(BaseTypedResource, Generic[U]):
             else:
                 # For versioned APIs, check if version is already in the path
                 path_ends_with_version = (
-                    self.config.path.endswith(f"/{self.config.version}") or
-                    self.config.path == self.config.version or
-                    (self.config.path.endswith(self.config.version) and 
-                     len(self.config.path) > len(self.config.version) and
-                     self.config.path[-(len(self.config.version) + 1)] == '/')
+                    self.config.path.endswith(f"/{self.config.version}")
+                    or self.config.path == self.config.version
+                    or (
+                        self.config.path.endswith(self.config.version)
+                        and len(self.config.path) > len(self.config.version)
+                        and self.config.path[-(len(self.config.version) + 1)] == "/"
+                    )
                 )
-                
+
                 if path_ends_with_version:
                     # Path already contains version, check for collision
                     if self.config.path in _api_path_map:
@@ -161,8 +173,10 @@ class Api(BaseTypedResource, Generic[U]):
                     _api_path_map[self.config.path] = self
                 else:
                     # Path doesn't contain version, register with version appended
-                    path_with_version = f"{self.config.path.rstrip('/')}/{self.config.version}"
-                    
+                    path_with_version = (
+                        f"{self.config.path.rstrip('/')}/{self.config.version}"
+                    )
+
                     # Check for collision on versioned path
                     if path_with_version in _api_path_map:
                         existing = _api_path_map[path_with_version]
@@ -171,7 +185,7 @@ class Api(BaseTypedResource, Generic[U]):
                             f'this path is already used by API "{existing.name}"'
                         )
                     _api_path_map[path_with_version] = self
-                    
+
                     # Also register the unversioned path if not already claimed
                     # (This is intentionally more permissive - first API gets the unversioned path)
                     if self.config.path not in _api_path_map:
@@ -209,9 +223,11 @@ class Api(BaseTypedResource, Generic[U]):
 
     @classmethod
     def _get_type(cls, keyword_args: dict):
-        t = keyword_args.get('t')
+        t = keyword_args.get("t")
         if not isinstance(t, tuple) or len(t) != 2:
-            raise ValueError(f"Use `{cls.__name__}[T, U](name='...')` to supply both input and output types")
+            raise ValueError(
+                f"Use `{cls.__name__}[T, U](name='...')` to supply both input and output types"
+            )
 
         input_type, output_type = t
         if not isinstance(input_type, type) or not issubclass(input_type, BaseModel):
@@ -237,21 +253,22 @@ class Api(BaseTypedResource, Generic[U]):
             A dictionary representing the JSON schema.
         """
         from pydantic.type_adapter import TypeAdapter
+
         return TypeAdapter(self.return_type()).json_schema(
-            ref_template='#/components/schemas/{model}'
+            ref_template="#/components/schemas/{model}"
         )
 
     def call(self, params: T, base_url: Optional[str] = None) -> U:
         """Call the API with the given parameters.
-        
+
         Args:
             params: Parameters matching the input model T
             base_url: Optional base URL override. If not provided, uses the global
                      base URL set via set_base_url() or MOOSE_BASE_URL environment variable.
-            
+
         Returns:
             Response data matching the output model U
-            
+
         Raises:
             ValueError: If no base URL is configured
         """
@@ -268,11 +285,13 @@ class Api(BaseTypedResource, Generic[U]):
             # Check if the custom path already contains the version
             if self.config.version:
                 path_ends_with_version = (
-                    self.config.path.endswith(f"/{self.config.version}") or
-                    self.config.path == self.config.version or
-                    (self.config.path.endswith(self.config.version) and 
-                     len(self.config.path) > len(self.config.version) and
-                     self.config.path[-(len(self.config.version) + 1)] == '/')
+                    self.config.path.endswith(f"/{self.config.version}")
+                    or self.config.path == self.config.version
+                    or (
+                        self.config.path.endswith(self.config.version)
+                        and len(self.config.path) > len(self.config.version)
+                        and self.config.path[-(len(self.config.version) + 1)] == "/"
+                    )
                 )
                 if path_ends_with_version:
                     path = self.config.path
@@ -282,7 +301,11 @@ class Api(BaseTypedResource, Generic[U]):
                 path = self.config.path
         else:
             # Default to name with optional version
-            path = self.name if not self.config.version else f"{self.name}/{self.config.version}"
+            path = (
+                self.name
+                if not self.config.version
+                else f"{self.name}/{self.config.version}"
+            )
         url = f"{effective_base_url.rstrip('/')}/api/{path}"
 
         # Convert Pydantic model to dictionary

moose_lib/dmv2/ingest_api.py

@@ -4,6 +4,7 @@ Ingestion API definitions for Moose Data Model v2 (dmv2).
 This module provides classes for defining and configuring ingestion APIs
 that receive data and send it to streams.
 """
+
 import dataclasses
 from typing import Any, Optional, Generic
 from pydantic import BaseModel
@@ -12,6 +13,7 @@ from .types import TypedMooseResource, T
 from .stream import Stream, DeadLetterQueue
 from ._registry import _ingest_apis
 
+
 class IngestConfig(BaseModel):
     """Basic configuration for an ingestion point.
 
@@ -20,10 +22,12 @@ class IngestConfig(BaseModel):
         path: Optional custom path for the ingestion endpoint.
         metadata: Optional metadata for the ingestion point.
     """
+
     version: Optional[str] = None
     path: Optional[str] = None
     metadata: Optional[dict] = None
 
+
 @dataclasses.dataclass
 class IngestConfigWithDestination[T: BaseModel]:
     """Ingestion configuration that includes the mandatory destination stream.
@@ -35,12 +39,14 @@ class IngestConfigWithDestination[T: BaseModel]:
         path: Optional custom path for the ingestion endpoint.
         metadata: Optional metadata for the ingestion configuration.
     """
+
     destination: Stream[T]
     dead_letter_queue: Optional[DeadLetterQueue[T]] = None
     version: Optional[str] = None
     path: Optional[str] = None
     metadata: Optional[dict] = None
 
+
 class IngestApi(TypedMooseResource, Generic[T]):
     """Represents an Ingestion API endpoint typed with a Pydantic model.
 
@@ -59,11 +65,12 @@ class IngestApi(TypedMooseResource, Generic[T]):
         name (str): The name of the API.
         model_type (type[T]): The Pydantic model associated with this API's input.
     """
+
     config: IngestConfigWithDestination[T]
 
     def __init__(self, name: str, config: IngestConfigWithDestination[T], **kwargs):
         super().__init__()
         self._set_type(name, self._get_type(kwargs))
         self.config = config
-        self.metadata = getattr(config, 'metadata', None)
-        _ingest_apis[name] = self
+        self.metadata = getattr(config, "metadata", None)
+        _ingest_apis[name] = self

moose_lib/dmv2/ingest_pipeline.py

@@ -4,8 +4,10 @@ Ingestion Pipeline definitions for Moose Data Model v2 (dmv2).
 This module provides classes for defining and configuring complete ingestion pipelines,
 which combine tables, streams, and ingestion APIs into a single cohesive unit.
 """
+
+import warnings
 from typing import Any, Optional, Generic, TypeVar
-from pydantic import BaseModel
+from pydantic import BaseModel, model_validator
 
 from .types import TypedMooseResource, T
 from .olap_table import OlapTable, OlapConfig
@@ -13,6 +15,7 @@ from .stream import Stream, StreamConfig, DeadLetterQueue
 from .ingest_api import IngestApi, IngestConfig, IngestConfigWithDestination
 from .life_cycle import LifeCycle
 
+
 class IngestPipelineConfig(BaseModel):
     """Configuration for creating a complete ingestion pipeline.
 
@@ -23,22 +26,47 @@ class IngestPipelineConfig(BaseModel):
     Attributes:
         table: Configuration for the OLAP table component.
         stream: Configuration for the stream component.
-        ingest: Configuration for the ingest API component.
+        ingest_api: Configuration for the ingest API component.
         dead_letter_queue: Configuration for the dead letter queue.
         version: Optional version string applied to all created components.
         path: Optional custom path for the ingestion API endpoint.
         metadata: Optional metadata for the ingestion pipeline.
         life_cycle: Determines how changes in code will propagate to the resources.
     """
+
     table: bool | OlapConfig = True
     stream: bool | StreamConfig = True
-    ingest: bool | IngestConfig = True
+    ingest_api: bool | IngestConfig = True
     dead_letter_queue: bool | StreamConfig = True
     version: Optional[str] = None
     path: Optional[str] = None
     metadata: Optional[dict] = None
     life_cycle: Optional[LifeCycle] = None
 
+    # Legacy support - will be removed in future version
+    ingest: Optional[bool | IngestConfig] = None
+
+    @model_validator(mode="before")
+    @classmethod
+    def handle_legacy_ingest_param(cls, data):
+        """Handle backwards compatibility for the deprecated 'ingest' parameter."""
+        if isinstance(data, dict) and "ingest" in data:
+            warnings.warn(
+                "The 'ingest' parameter is deprecated and will be removed in a future version. "
+                "Please use 'ingest_api' instead.",
+                DeprecationWarning,
+                stacklevel=3,
+            )
+            # Make a copy first to avoid mutating the original dictionary
+            data = data.copy()
+            # If ingest_api is not explicitly set, use the ingest value
+            if "ingest_api" not in data:
+                data["ingest_api"] = data["ingest"]
+            # Remove the legacy parameter
+            del data["ingest"]
+        return data
+
+
 class IngestPipeline(TypedMooseResource, Generic[T]):
     """Creates and configures a linked Table, Stream, and Ingest API pipeline.
 
@@ -60,6 +88,7 @@ class IngestPipeline(TypedMooseResource, Generic[T]):
         name (str): The base name of the pipeline.
         model_type (type[T]): The Pydantic model associated with this pipeline.
     """
+
     table: Optional[OlapTable[T]] = None
     stream: Optional[Stream[T]] = None
     ingest_api: Optional[IngestApi[T]] = None
@@ -126,23 +155,37 @@ class IngestPipeline(TypedMooseResource, Generic[T]):
         stream_metadata = config.metadata
         ingest_metadata = config.metadata
         if config.table:
-            table_config = (config.table if isinstance(config.table, OlapConfig) else 
-                          OlapConfig(life_cycle=config.life_cycle))
+            table_config = (
+                config.table
+                if isinstance(config.table, OlapConfig)
+                else OlapConfig(life_cycle=config.life_cycle)
+            )
             if config.version:
                 table_config.version = config.version
             table_config.metadata = table_metadata
             self.table = OlapTable(name, table_config, t=self._t)
         if config.dead_letter_queue:
-            dlq_stream_config = StreamConfig() if config.dead_letter_queue is True else config.dead_letter_queue
+            dlq_stream_config = (
+                StreamConfig()
+                if config.dead_letter_queue is True
+                else config.dead_letter_queue
+            )
             if config.version:
                 dlq_stream_config.version = config.version
             dlq_stream_config.metadata = stream_metadata
-            self.dead_letter_queue = DeadLetterQueue(f"{name}DeadLetterQueue", dlq_stream_config, t=self._t)
+            self.dead_letter_queue = DeadLetterQueue(
+                f"{name}DeadLetterQueue", dlq_stream_config, t=self._t
+            )
         if config.stream:
-            stream_config = (config.stream if isinstance(config.stream, StreamConfig) else 
-                           StreamConfig(life_cycle=config.life_cycle))
+            stream_config = (
+                config.stream
+                if isinstance(config.stream, StreamConfig)
+                else StreamConfig(life_cycle=config.life_cycle)
+            )
             if config.table and stream_config.destination is not None:
-                raise ValueError("The destination of the stream should be the table created in the IngestPipeline")
+                raise ValueError(
+                    "The destination of the stream should be the table created in the IngestPipeline"
+                )
             stream_config.destination = self.table
             if self.dead_letter_queue is not None:
                 stream_config.default_dead_letter_queue = self.dead_letter_queue
@@ -150,11 +193,11 @@ class IngestPipeline(TypedMooseResource, Generic[T]):
                 stream_config.version = config.version
             stream_config.metadata = stream_metadata
             self.stream = Stream(name, stream_config, t=self._t)
-        if config.ingest:
+        if config.ingest_api:
             if self.stream is None:
                 raise ValueError("Ingest API needs a stream to write to.")
             ingest_config_dict = (
-                IngestConfig() if config.ingest is True else config.ingest
+                IngestConfig() if config.ingest_api is True else config.ingest_api
             ).model_dump()
             ingest_config_dict["destination"] = self.stream
             if config.version:
@@ -165,4 +208,4 @@ class IngestPipeline(TypedMooseResource, Generic[T]):
                 ingest_config_dict["dead_letter_queue"] = self.dead_letter_queue
             ingest_config_dict["metadata"] = ingest_metadata
             ingest_config = IngestConfigWithDestination(**ingest_config_dict)
-            self.ingest_api = IngestApi(name, ingest_config, t=self._t)
+            self.ingest_api = IngestApi(name, ingest_config, t=self._t)

moose_lib/dmv2/life_cycle.py

@@ -4,8 +4,10 @@ Lifecycle management definitions for Moose Data Model v2 (dmv2).
 This module defines how Moose manages the lifecycle of database resources
 when your code changes.
 """
+
 from enum import Enum
 
+
 class LifeCycle(Enum):
     """Defines how Moose manages the lifecycle of database resources when your code changes.
 
@@ -29,4 +31,4 @@ class LifeCycle(Enum):
     """External management - no automatic changes.
     Moose will not modify the database resources. You are responsible for managing
     the schema and ensuring it matches your code definitions manually.
-    """ 
+    """