moose-lib 0.6.114__tar.gz → 0.6.116__tar.gz

{moose_lib-0.6.114 → moose_lib-0.6.116}/PKG-INFO

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

{moose_lib-0.6.114 → moose_lib-0.6.116}/moose_lib/__init__.py

@@ -19,6 +19,10 @@ from .blocks import (
     ReplacingMergeTreeEngine, 
     AggregatingMergeTreeEngine,
     SummingMergeTreeEngine,
+    ReplicatedMergeTreeEngine,
+    ReplicatedReplacingMergeTreeEngine,
+    ReplicatedAggregatingMergeTreeEngine,
+    ReplicatedSummingMergeTreeEngine,
     S3QueueEngine,
     EngineConfig,
     # Legacy enum (already exported via .blocks import, but explicit for clarity)

{moose_lib-0.6.114 → moose_lib-0.6.116}/moose_lib/blocks.py

@@ -14,6 +14,10 @@ class ClickHouseEngines(Enum):
     VersionedCollapsingMergeTree = "VersionedCollapsingMergeTree"
     GraphiteMergeTree = "GraphiteMergeTree"
     S3Queue = "S3Queue"
+    ReplicatedMergeTree = "ReplicatedMergeTree"
+    ReplicatedReplacingMergeTree = "ReplicatedReplacingMergeTree"
+    ReplicatedAggregatingMergeTree = "ReplicatedAggregatingMergeTree"
+    ReplicatedSummingMergeTree = "ReplicatedSummingMergeTree"
 
 # ==========================
 # New Engine Configuration Classes
@@ -51,8 +55,100 @@ class AggregatingMergeTreeEngine(EngineConfig):
 
 @dataclass
 class SummingMergeTreeEngine(EngineConfig):
-    """Configuration for SummingMergeTree engine"""
-    pass
+    """Configuration for SummingMergeTree engine
+    
+    Args:
+        columns: Optional list of column names to sum
+    """
+    columns: Optional[List[str]] = None
+
+@dataclass
+class ReplicatedMergeTreeEngine(EngineConfig):
+    """Configuration for ReplicatedMergeTree engine (replicated version of MergeTree)
+    
+    Args:
+        keeper_path: Keeper path for replication (e.g., '/clickhouse/tables/{database}/{shard}/table_name')
+                     Optional: omit for ClickHouse Cloud which manages replication automatically
+        replica_name: Replica name (e.g., '{replica}')
+                      Optional: omit for ClickHouse Cloud which manages replication automatically
+    
+    Note: Both keeper_path and replica_name must be provided together, or both omitted.
+    """
+    keeper_path: Optional[str] = None
+    replica_name: Optional[str] = None
+    
+    def __post_init__(self):
+        # Both must be provided or both must be None
+        if (self.keeper_path is None) != (self.replica_name is None):
+            raise ValueError("keeper_path and replica_name must both be provided or both be None")
+
+@dataclass
+class ReplicatedReplacingMergeTreeEngine(EngineConfig):
+    """Configuration for ReplicatedReplacingMergeTree engine (replicated version with deduplication)
+    
+    Args:
+        keeper_path: Keeper path for replication (e.g., '/clickhouse/tables/{database}/{shard}/table_name')
+                     Optional: omit for ClickHouse Cloud which manages replication automatically
+        replica_name: Replica name (e.g., '{replica}')
+                      Optional: omit for ClickHouse Cloud which manages replication automatically
+        ver: Optional column name for version tracking
+        is_deleted: Optional column name for deletion marking (requires ver)
+    
+    Note: Both keeper_path and replica_name must be provided together, or both omitted.
+    """
+    keeper_path: Optional[str] = None
+    replica_name: Optional[str] = None
+    ver: Optional[str] = None
+    is_deleted: Optional[str] = None
+    
+    def __post_init__(self):
+        # Both must be provided or both must be None
+        if (self.keeper_path is None) != (self.replica_name is None):
+            raise ValueError("keeper_path and replica_name must both be provided or both be None")
+        if self.is_deleted and not self.ver:
+            raise ValueError("is_deleted requires ver to be specified")
+
+@dataclass
+class ReplicatedAggregatingMergeTreeEngine(EngineConfig):
+    """Configuration for ReplicatedAggregatingMergeTree engine (replicated version for aggregations)
+    
+    Args:
+        keeper_path: Keeper path for replication (e.g., '/clickhouse/tables/{database}/{shard}/table_name')
+                     Optional: omit for ClickHouse Cloud which manages replication automatically
+        replica_name: Replica name (e.g., '{replica}')
+                      Optional: omit for ClickHouse Cloud which manages replication automatically
+    
+    Note: Both keeper_path and replica_name must be provided together, or both omitted.
+    """
+    keeper_path: Optional[str] = None
+    replica_name: Optional[str] = None
+    
+    def __post_init__(self):
+        # Both must be provided or both must be None
+        if (self.keeper_path is None) != (self.replica_name is None):
+            raise ValueError("keeper_path and replica_name must both be provided or both be None")
+
+@dataclass
+class ReplicatedSummingMergeTreeEngine(EngineConfig):
+    """Configuration for ReplicatedSummingMergeTree engine (replicated version for summation)
+    
+    Args:
+        keeper_path: Keeper path for replication (e.g., '/clickhouse/tables/{database}/{shard}/table_name')
+                     Optional: omit for ClickHouse Cloud which manages replication automatically
+        replica_name: Replica name (e.g., '{replica}')
+                      Optional: omit for ClickHouse Cloud which manages replication automatically
+        columns: Optional list of column names to sum
+    
+    Note: Both keeper_path and replica_name must be provided together, or both omitted.
+    """
+    keeper_path: Optional[str] = None
+    replica_name: Optional[str] = None
+    columns: Optional[List[str]] = None
+    
+    def __post_init__(self):
+        # Both must be provided or both must be None
+        if (self.keeper_path is None) != (self.replica_name is None):
+            raise ValueError("keeper_path and replica_name must both be provided or both be None")
 
 @dataclass
 class S3QueueEngine(EngineConfig):

{moose_lib-0.6.114 → moose_lib-0.6.116}/moose_lib/data_models.py

@@ -16,17 +16,17 @@ type Key[T: (str, int)] = T
 type JWT[T] = T
 
 
-@dataclasses.dataclass  # a BaseModel in the annotations will confuse pydantic
+@dataclasses.dataclass(frozen=True)  # a BaseModel in the annotations will confuse pydantic
 class ClickhousePrecision:
     precision: int
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(frozen=True)
 class ClickhouseSize:
     size: int
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(frozen=True)
 class ClickhouseDefault:
     expression: str
 
@@ -53,13 +53,13 @@ def aggregated[T](
         agg_func: str,
         param_types: list[type | GenericAlias | _BaseGenericAlias]
 ) -> Type[T]:
-    return Annotated[result_type, AggregateFunction(agg_func=agg_func, param_types=param_types)]
+    return Annotated[result_type, AggregateFunction(agg_func=agg_func, param_types=tuple(param_types))]
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(frozen=True)
 class AggregateFunction:
     agg_func: str
-    param_types: list[type | GenericAlias | _BaseGenericAlias]
+    param_types: tuple[type | GenericAlias | _BaseGenericAlias, ...]
 
     def to_dict(self):
         return {

{moose_lib-0.6.114 → moose_lib-0.6.116}/moose_lib/dmv2/olap_table.py

@@ -149,7 +149,12 @@ class OlapTable(TypedMooseResource, Generic[T]):
         self.metadata = config.metadata
         self._column_list = _to_columns(self._t)
         self._cols = Cols(self._column_list)
-        _tables[name] = self
+        registry_key = f"{name}_{config.version}" if config.version else name
+        if registry_key in _tables:
+            raise ValueError(
+                f"OlapTable with name {name} and version {config.version or 'unversioned'} already exists"
+            )
+        _tables[registry_key] = self
         
         # Check if using legacy enum-based engine configuration
         if config.engine and isinstance(config.engine, ClickHouseEngines):

{moose_lib-0.6.114 → moose_lib-0.6.116}/moose_lib/internal.py

@@ -83,6 +83,38 @@ class AggregatingMergeTreeConfigDict(BaseEngineConfigDict):
 class SummingMergeTreeConfigDict(BaseEngineConfigDict):
     """Configuration for SummingMergeTree engine."""
     engine: Literal["SummingMergeTree"] = "SummingMergeTree"
+    columns: Optional[List[str]] = None
+
+
+class ReplicatedMergeTreeConfigDict(BaseEngineConfigDict):
+    """Configuration for ReplicatedMergeTree engine."""
+    engine: Literal["ReplicatedMergeTree"] = "ReplicatedMergeTree"
+    keeper_path: Optional[str] = None
+    replica_name: Optional[str] = None
+
+
+class ReplicatedReplacingMergeTreeConfigDict(BaseEngineConfigDict):
+    """Configuration for ReplicatedReplacingMergeTree engine."""
+    engine: Literal["ReplicatedReplacingMergeTree"] = "ReplicatedReplacingMergeTree"
+    keeper_path: Optional[str] = None
+    replica_name: Optional[str] = None
+    ver: Optional[str] = None
+    is_deleted: Optional[str] = None
+
+
+class ReplicatedAggregatingMergeTreeConfigDict(BaseEngineConfigDict):
+    """Configuration for ReplicatedAggregatingMergeTree engine."""
+    engine: Literal["ReplicatedAggregatingMergeTree"] = "ReplicatedAggregatingMergeTree"
+    keeper_path: Optional[str] = None
+    replica_name: Optional[str] = None
+
+
+class ReplicatedSummingMergeTreeConfigDict(BaseEngineConfigDict):
+    """Configuration for ReplicatedSummingMergeTree engine."""
+    engine: Literal["ReplicatedSummingMergeTree"] = "ReplicatedSummingMergeTree"
+    keeper_path: Optional[str] = None
+    replica_name: Optional[str] = None
+    columns: Optional[List[str]] = None
 
 
 class S3QueueConfigDict(BaseEngineConfigDict):
@@ -102,6 +134,10 @@ EngineConfigDict = Union[
     ReplacingMergeTreeConfigDict,
     AggregatingMergeTreeConfigDict,
     SummingMergeTreeConfigDict,
+    ReplicatedMergeTreeConfigDict,
+    ReplicatedReplacingMergeTreeConfigDict,
+    ReplicatedAggregatingMergeTreeConfigDict,
+    ReplicatedSummingMergeTreeConfigDict,
     S3QueueConfigDict
 ]
 
@@ -318,6 +354,110 @@ def _map_sql_resource_ref(r: Any) -> InfrastructureSignatureJson:
         raise TypeError(f"Object {r} lacks a 'kind' attribute for dependency mapping.")
 
 
+def _convert_basic_engine_instance(engine: "EngineConfig") -> Optional[EngineConfigDict]:
+    """Convert basic MergeTree engine instances to config dict.
+    
+    Args:
+        engine: An EngineConfig instance
+        
+    Returns:
+        EngineConfigDict if matched, None otherwise
+    """
+    from moose_lib.blocks import (
+        MergeTreeEngine, ReplacingMergeTreeEngine,
+        AggregatingMergeTreeEngine, SummingMergeTreeEngine
+    )
+    
+    if isinstance(engine, MergeTreeEngine):
+        return MergeTreeConfigDict()
+    elif isinstance(engine, ReplacingMergeTreeEngine):
+        return ReplacingMergeTreeConfigDict(
+            ver=engine.ver,
+            is_deleted=engine.is_deleted
+        )
+    elif isinstance(engine, AggregatingMergeTreeEngine):
+        return AggregatingMergeTreeConfigDict()
+    elif isinstance(engine, SummingMergeTreeEngine):
+        return SummingMergeTreeConfigDict(columns=engine.columns)
+    return None
+
+
+def _convert_replicated_engine_instance(engine: "EngineConfig") -> Optional[EngineConfigDict]:
+    """Convert replicated MergeTree engine instances to config dict.
+    
+    Args:
+        engine: An EngineConfig instance
+        
+    Returns:
+        EngineConfigDict if matched, None otherwise
+    """
+    from moose_lib.blocks import (
+        ReplicatedMergeTreeEngine, ReplicatedReplacingMergeTreeEngine,
+        ReplicatedAggregatingMergeTreeEngine, ReplicatedSummingMergeTreeEngine
+    )
+    
+    if isinstance(engine, ReplicatedMergeTreeEngine):
+        return ReplicatedMergeTreeConfigDict(
+            keeper_path=engine.keeper_path,
+            replica_name=engine.replica_name
+        )
+    elif isinstance(engine, ReplicatedReplacingMergeTreeEngine):
+        return ReplicatedReplacingMergeTreeConfigDict(
+            keeper_path=engine.keeper_path,
+            replica_name=engine.replica_name,
+            ver=engine.ver,
+            is_deleted=engine.is_deleted
+        )
+    elif isinstance(engine, ReplicatedAggregatingMergeTreeEngine):
+        return ReplicatedAggregatingMergeTreeConfigDict(
+            keeper_path=engine.keeper_path,
+            replica_name=engine.replica_name
+        )
+    elif isinstance(engine, ReplicatedSummingMergeTreeEngine):
+        return ReplicatedSummingMergeTreeConfigDict(
+            keeper_path=engine.keeper_path,
+            replica_name=engine.replica_name,
+            columns=engine.columns
+        )
+    return None
+
+
+def _convert_engine_instance_to_config_dict(engine: "EngineConfig") -> EngineConfigDict:
+    """Convert an EngineConfig instance to config dict format.
+    
+    Args:
+        engine: An EngineConfig instance
+        
+    Returns:
+        EngineConfigDict with engine-specific configuration
+    """
+    from moose_lib.blocks import S3QueueEngine
+    
+    # Try S3Queue first
+    if isinstance(engine, S3QueueEngine):
+        return S3QueueConfigDict(
+            s3_path=engine.s3_path,
+            format=engine.format,
+            aws_access_key_id=engine.aws_access_key_id,
+            aws_secret_access_key=engine.aws_secret_access_key,
+            compression=engine.compression,
+            headers=engine.headers
+        )
+    
+    # Try basic engines
+    basic_config = _convert_basic_engine_instance(engine)
+    if basic_config:
+        return basic_config
+    
+    # Try replicated engines
+    replicated_config = _convert_replicated_engine_instance(engine)
+    if replicated_config:
+        return replicated_config
+    
+    # Fallback for any other EngineConfig subclass
+    return BaseEngineConfigDict(engine=engine.__class__.__name__.replace("Engine", ""))
+
+
 def _convert_engine_to_config_dict(engine: Union[ClickHouseEngines, EngineConfig],
                                    table: OlapTable) -> EngineConfigDict:
     """Convert engine enum or EngineConfig instance to new engine config format.
@@ -330,38 +470,12 @@ def _convert_engine_to_config_dict(engine: Union[ClickHouseEngines, EngineConfig
         EngineConfigDict with engine-specific configuration
     """
     from moose_lib import ClickHouseEngines
-    from moose_lib.blocks import (
-        EngineConfig, S3QueueEngine, MergeTreeEngine,
-        ReplacingMergeTreeEngine, AggregatingMergeTreeEngine,
-        SummingMergeTreeEngine
-    )
+    from moose_lib.blocks import EngineConfig
     from moose_lib.commons import Logger
 
     # Check if engine is an EngineConfig instance (new API)
     if isinstance(engine, EngineConfig):
-        if isinstance(engine, S3QueueEngine):
-            return S3QueueConfigDict(
-                s3_path=engine.s3_path,
-                format=engine.format,
-                aws_access_key_id=engine.aws_access_key_id,
-                aws_secret_access_key=engine.aws_secret_access_key,
-                compression=engine.compression,
-                headers=engine.headers
-            )
-        elif isinstance(engine, ReplacingMergeTreeEngine):
-            return ReplacingMergeTreeConfigDict(
-                ver=engine.ver,
-                is_deleted=engine.is_deleted
-            )
-        elif isinstance(engine, AggregatingMergeTreeEngine):
-            return AggregatingMergeTreeConfigDict()
-        elif isinstance(engine, SummingMergeTreeEngine):
-            return SummingMergeTreeConfigDict()
-        elif isinstance(engine, MergeTreeEngine):
-            return MergeTreeConfigDict()
-        else:
-            # Fallback for any other EngineConfig subclass - use base class
-            return BaseEngineConfigDict(engine=engine.__class__.__name__.replace("Engine", ""))
+        return _convert_engine_instance_to_config_dict(engine)
 
     # Handle legacy enum-based engine configuration
     if isinstance(engine, ClickHouseEngines):
@@ -393,6 +507,10 @@ def _convert_engine_to_config_dict(engine: Union[ClickHouseEngines, EngineConfig
         "ReplacingMergeTree": ReplacingMergeTreeConfigDict,
         "AggregatingMergeTree": AggregatingMergeTreeConfigDict,
         "SummingMergeTree": SummingMergeTreeConfigDict,
+        "ReplicatedMergeTree": ReplicatedMergeTreeConfigDict,
+        "ReplicatedReplacingMergeTree": ReplicatedReplacingMergeTreeConfigDict,
+        "ReplicatedAggregatingMergeTree": ReplicatedAggregatingMergeTreeConfigDict,
+        "ReplicatedSummingMergeTree": ReplicatedSummingMergeTreeConfigDict,
     }
 
     config_class = engine_map.get(engine_name)
@@ -421,7 +539,7 @@ def to_infra_map() -> dict:
     sql_resources = {}
     workflows = {}
 
-    for name, table in get_tables().items():
+    for _registry_key, table in get_tables().items():
         # Convert engine configuration to new format
         engine_config = None
         if table.config.engine:
@@ -436,8 +554,12 @@ def to_infra_map() -> dict:
             if "mode" not in table_settings:
                 table_settings["mode"] = "unordered"
 
-        tables[name] = TableConfig(
-            name=name,
+        id_key = (
+            f"{table.name}_{table.config.version}" if table.config.version else table.name
+        )
+
+        tables[id_key] = TableConfig(
+            name=table.name,
             columns=table._column_list,
             order_by=table.config.order_by_fields,
             partition_by=table.config.partition_by,

{moose_lib-0.6.114 → moose_lib-0.6.116}/moose_lib.egg-info/PKG-INFO

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

{moose_lib-0.6.114 → moose_lib-0.6.116}/moose_lib.egg-info/SOURCES.txt

@@ -40,6 +40,7 @@ moose_lib/utilities/sql.py
 tests/__init__.py
 tests/conftest.py
 tests/test_moose.py
+tests/test_olap_table_versioning.py
 tests/test_query_builder.py
 tests/test_redis_client.py
 tests/test_s3queue_config.py

moose_lib-0.6.116/tests/conftest.py

@@ -0,0 +1,42 @@
+import pytest
+import os
+import sys
+
+# Add the package root to Python path for imports
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+@pytest.fixture(autouse=True)
+def clear_registries():
+    """Clear all global registries before each test to prevent conflicts."""
+    from moose_lib.dmv2._registry import (
+        _tables,
+        _streams,
+        _ingest_apis,
+        _apis,
+        _api_name_aliases,
+        _api_path_map,
+        _sql_resources,
+        _workflows,
+    )
+    
+    # Clear all registries
+    _tables.clear()
+    _streams.clear()
+    _ingest_apis.clear()
+    _apis.clear()
+    _api_name_aliases.clear()
+    _api_path_map.clear()
+    _sql_resources.clear()
+    _workflows.clear()
+    
+    yield
+    
+    # Clean up after test (optional, but good practice)
+    _tables.clear()
+    _streams.clear()
+    _ingest_apis.clear()
+    _apis.clear()
+    _api_name_aliases.clear()
+    _api_path_map.clear()
+    _sql_resources.clear()
+    _workflows.clear()

moose_lib-0.6.116/tests/test_olap_table_versioning.py

@@ -0,0 +1,216 @@
+"""
+Tests for OlapTable versioning functionality.
+
+This test module verifies that multiple versions of OlapTables with the same name
+can coexist and that the infrastructure map generation handles versioned keys correctly.
+"""
+
+import pytest
+from moose_lib import OlapTable, OlapConfig, ClickHouseEngines, MergeTreeEngine, ReplacingMergeTreeEngine
+from moose_lib.dmv2.registry import get_tables
+from moose_lib.internal import to_infra_map
+from pydantic import BaseModel
+from typing import Optional
+
+
+class UserEvent(BaseModel):
+    """Sample model for testing OlapTable versioning."""
+    user_id: str
+    event_type: str
+    timestamp: float
+    metadata: Optional[str] = None
+
+
+class UserEventV2(BaseModel):
+    """Updated model with additional fields for version testing."""
+    user_id: str
+    event_type: str
+    timestamp: float
+    metadata: Optional[str] = None
+    session_id: str
+    user_agent: Optional[str] = None
+
+
+def test_multiple_olap_table_versions_can_coexist():
+    """Test that multiple versions of the same table can be registered simultaneously."""
+    # Create version 1.0 of the table
+    table_v1 = OlapTable[UserEvent](
+        "UserEvents",
+        OlapConfig(
+            version="1.0",
+            engine=MergeTreeEngine(),
+            order_by_fields=["user_id", "timestamp"]
+        )
+    )
+    
+    # Create version 2.0 of the table with different configuration
+    table_v2 = OlapTable[UserEventV2](
+        "UserEvents",
+        OlapConfig(
+            version="2.0",
+            engine=ReplacingMergeTreeEngine(),
+            order_by_fields=["user_id", "timestamp", "session_id"]
+        )
+    )
+    
+    # Both tables should be registered successfully
+    tables = get_tables()
+    assert "UserEvents_1.0" in tables
+    assert "UserEvents_2.0" in tables
+    
+    # Verify they are different instances
+    assert tables["UserEvents_1.0"] is table_v1
+    assert tables["UserEvents_2.0"] is table_v2
+    
+    # Verify configurations are different
+    assert table_v1.config.version == "1.0"
+    assert table_v2.config.version == "2.0"
+    assert isinstance(table_v1.config.engine, MergeTreeEngine)
+    assert isinstance(table_v2.config.engine, ReplacingMergeTreeEngine)
+
+
+def test_unversioned_and_versioned_tables_can_coexist():
+    """Test that unversioned and versioned tables with the same name can coexist."""
+    # Create unversioned table
+    unversioned_table = OlapTable[UserEvent](
+        "EventData",
+        OlapConfig(engine=MergeTreeEngine())
+    )
+    
+    # Create versioned table with same name
+    versioned_table = OlapTable[UserEvent](
+        "EventData", 
+        OlapConfig(
+            version="1.5",
+            engine=MergeTreeEngine()
+        )
+    )
+    
+    # Both should be registered
+    tables = get_tables()
+    assert "EventData" in tables  # Unversioned
+    assert "EventData_1.5" in tables  # Versioned
+    
+    assert tables["EventData"] is unversioned_table
+    assert tables["EventData_1.5"] is versioned_table
+
+
+def test_duplicate_version_registration_fails():
+    """Test that registering the same table name and version twice fails."""
+    # Create first table
+    OlapTable[UserEvent](
+        "DuplicateTest",
+        OlapConfig(version="1.0", engine=MergeTreeEngine())
+    )
+    
+    # Attempting to create another table with same name and version should fail
+    with pytest.raises(ValueError, match="OlapTable with name DuplicateTest and version 1.0 already exists"):
+        OlapTable[UserEvent](
+            "DuplicateTest",
+            OlapConfig(version="1.0", engine=MergeTreeEngine())
+        )
+
+
+def test_infrastructure_map_uses_versioned_keys():
+    """Test that infrastructure map generation uses versioned keys for tables."""
+    # Create multiple versions of tables
+    table_v1 = OlapTable[UserEvent](
+        "InfraMapTest",
+        OlapConfig(
+            version="1.0",
+            engine=MergeTreeEngine(),
+            order_by_fields=["user_id"]
+        )
+    )
+    
+    table_v2 = OlapTable[UserEvent](
+        "InfraMapTest",
+        OlapConfig(
+            version="2.0", 
+            engine=ReplacingMergeTreeEngine(),
+            order_by_fields=["user_id", "timestamp"]
+        )
+    )
+    
+    unversioned_table = OlapTable[UserEvent](
+        "UnversionedInfraTest",
+        OlapConfig(engine=MergeTreeEngine())
+    )
+    
+    # Generate infrastructure map
+    tables_registry = get_tables()
+    infra_map = to_infra_map()
+    
+    # Verify versioned keys are used in infrastructure map
+    assert "InfraMapTest_1.0" in infra_map["tables"]
+    assert "InfraMapTest_2.0" in infra_map["tables"]
+    assert "UnversionedInfraTest" in infra_map["tables"]
+    
+    # Verify table configurations in infra map
+    v1_config = infra_map["tables"]["InfraMapTest_1.0"]
+    v2_config = infra_map["tables"]["InfraMapTest_2.0"]
+    unversioned_config = infra_map["tables"]["UnversionedInfraTest"]
+    
+    assert v1_config["name"] == "InfraMapTest"
+    assert v1_config["version"] == "1.0"
+    assert v1_config["engineConfig"]["engine"] == "MergeTree"
+    
+    assert v2_config["name"] == "InfraMapTest"
+    assert v2_config["version"] == "2.0"
+    assert v2_config["engineConfig"]["engine"] == "ReplacingMergeTree"
+    
+    assert unversioned_config["name"] == "UnversionedInfraTest"
+    assert unversioned_config.get("version") is None
+
+
+def test_version_with_dots_handled_correctly():
+    """Test that versions with dots are handled correctly in keys."""
+    # Create table with semantic version
+    table = OlapTable[UserEvent](
+        "SemanticVersionTest",
+        OlapConfig(
+            version="1.2.3",
+            engine=MergeTreeEngine()
+        )
+    )
+    
+    # Should be registered with version in key
+    tables = get_tables()
+    assert "SemanticVersionTest_1.2.3" in tables
+    assert tables["SemanticVersionTest_1.2.3"] is table
+    
+    # Verify in infrastructure map
+    infra_map = to_infra_map()
+    assert "SemanticVersionTest_1.2.3" in infra_map["tables"]
+    
+    table_config = infra_map["tables"]["SemanticVersionTest_1.2.3"]
+    assert table_config["version"] == "1.2.3"
+
+
+def test_backward_compatibility_with_legacy_engines():
+    """Test that versioning works with legacy enum-based engine configuration."""
+    # Create table with legacy enum engine (should show deprecation warning)
+    table = OlapTable[UserEvent](
+        "LegacyEngineTest",
+        OlapConfig(
+            version="1.0",
+            engine=ClickHouseEngines.ReplacingMergeTree
+        )
+    )
+    
+    # Should still be registered correctly
+    tables = get_tables()
+    assert "LegacyEngineTest_1.0" in tables
+    assert tables["LegacyEngineTest_1.0"] is table
+    
+    # Should work in infrastructure map
+    infra_map = to_infra_map()
+    assert "LegacyEngineTest_1.0" in infra_map["tables"]
+    
+    table_config = infra_map["tables"]["LegacyEngineTest_1.0"]
+    assert table_config["version"] == "1.0"
+    assert table_config["engineConfig"]["engine"] == "ReplacingMergeTree"
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

moose_lib-0.6.114/tests/conftest.py

@@ -1,6 +0,0 @@
-import pytest
-import os
-import sys
-
-# Add the package root to Python path for imports
-sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))