palimpzest 1.3.2__py3-none-any.whl → 1.3.4__py3-none-any.whl

palimpzest/constants.py

@@ -25,7 +25,7 @@ class Model(str, Enum):
     GPT_5_MINI = "openai/gpt-5-mini-2025-08-07"
     GPT_5_NANO = "openai/gpt-5-nano-2025-08-07"
     o4_MINI = "openai/o4-mini-2025-04-16"  # noqa: N815
-    CLAUDE_3_5_SONNET = "anthropic/claude-3-5-sonnet-20241022"
+    # CLAUDE_3_5_SONNET = "anthropic/claude-3-5-sonnet-20241022"
     CLAUDE_3_7_SONNET = "anthropic/claude-3-7-sonnet-20250219"
     CLAUDE_3_5_HAIKU = "anthropic/claude-3-5-haiku-20241022"
     GEMINI_2_0_FLASH = "vertex_ai/gemini-2.0-flash"
@@ -621,7 +621,7 @@ MODEL_CARDS = {
     # Model.o1.value: o1_MODEL_CARD,
     Model.TEXT_EMBEDDING_3_SMALL.value: TEXT_EMBEDDING_3_SMALL_MODEL_CARD,
     Model.CLIP_VIT_B_32.value: CLIP_VIT_B_32_MODEL_CARD,
-    Model.CLAUDE_3_5_SONNET.value: CLAUDE_3_5_SONNET_MODEL_CARD,
+    # Model.CLAUDE_3_5_SONNET.value: CLAUDE_3_5_SONNET_MODEL_CARD,
     Model.CLAUDE_3_7_SONNET.value: CLAUDE_3_7_SONNET_MODEL_CARD,
     Model.CLAUDE_3_5_HAIKU.value: CLAUDE_3_5_HAIKU_MODEL_CARD,
     Model.GEMINI_2_0_FLASH.value: GEMINI_2_0_FLASH_MODEL_CARD,

palimpzest/query/generators/generators.py

@@ -26,6 +26,7 @@ from palimpzest.constants import (
 from palimpzest.core.elements.records import DataRecord
 from palimpzest.core.models import GenerationStats
 from palimpzest.prompts import PromptFactory
+from palimpzest.utils.model_helpers import resolve_reasoning_effort
 
 # DEFINITIONS
 GenerationOutput = tuple[dict, str | None, GenerationStats, list[dict]]
@@ -108,7 +109,7 @@ class Generator(Generic[ContextType, InputType]):
         self,
         model: Model,
         prompt_strategy: PromptStrategy,
-        reasoning_effort: str | None,
+        reasoning_effort: str,
         api_base: str | None = None,
         cardinality: Cardinality = Cardinality.ONE_TO_ONE,
         desc: str | None = None,
@@ -325,7 +326,8 @@ class Generator(Generic[ContextType, InputType]):
             if is_audio_op:
                 completion_kwargs = {"modalities": ["text"], **completion_kwargs}
             if self.model.is_reasoning_model():
-                completion_kwargs = {"reasoning_effort": self.reasoning_effort, **completion_kwargs}
+                reasoning_effort = resolve_reasoning_effort(self.model, self.reasoning_effort)
+                completion_kwargs = {"reasoning_effort": reasoning_effort, **completion_kwargs}
             if self.model.is_vllm_model():
                 completion_kwargs = {"api_base": self.api_base, "api_key": os.environ.get("VLLM_API_KEY", "fake-api-key"), **completion_kwargs}
             completion = litellm.completion(model=self.model_name, messages=messages, **completion_kwargs)

palimpzest/query/operators/aggregate.py

@@ -531,7 +531,7 @@ class MaxAggregateOp(AggregateOp):
 
 class SemanticAggregate(AggregateOp):
 
-    def __init__(self, agg_str: str, model: Model, prompt_strategy: PromptStrategy = PromptStrategy.AGG, reasoning_effort: str | None = None, *args, **kwargs):
+    def __init__(self, agg_str: str, model: Model, prompt_strategy: PromptStrategy = PromptStrategy.AGG, reasoning_effort: str = "default", *args, **kwargs):
         # call parent constructor
         super().__init__(*args, **kwargs)
         self.agg_str = agg_str

palimpzest/query/operators/convert.py

@@ -268,7 +268,7 @@ class LLMConvert(ConvertOp):
         self,
         model: Model,
         prompt_strategy: PromptStrategy = PromptStrategy.MAP,
-        reasoning_effort: str | None = None,
+        reasoning_effort: str = "default",
         *args,
         **kwargs,
     ):

palimpzest/query/operators/filter.py

@@ -167,7 +167,7 @@ class LLMFilter(FilterOp):
         self,
         model: Model,
         prompt_strategy: PromptStrategy = PromptStrategy.FILTER,
-        reasoning_effort: str | None = None,
+        reasoning_effort: str = "default",
         *args,
         **kwargs,
     ):

palimpzest/query/operators/join.py

@@ -293,7 +293,7 @@ class LLMJoin(JoinOp):
         self,
         model: Model,
         prompt_strategy: PromptStrategy = PromptStrategy.JOIN,
-        reasoning_effort: str | None = None,
+        reasoning_effort: str = "default",
         *args,
         **kwargs,
     ):

palimpzest/query/optimizer/optimizer.py

@@ -75,7 +75,7 @@ class Optimizer:
         cost_model: BaseCostModel,
         available_models: list[Model],
         join_parallelism: int = 64,
-        reasoning_effort: str | None = "default",
+        reasoning_effort: str = "default",
         api_base: str | None = None,
         verbose: bool = False,
         allow_bonded_query: bool = True,

palimpzest/query/optimizer/rules.py

@@ -54,7 +54,7 @@ from palimpzest.query.operators.search import (
 from palimpzest.query.operators.split import SplitConvert, SplitFilter
 from palimpzest.query.operators.topk import TopKOp
 from palimpzest.query.optimizer.primitives import Expression, Group, LogicalExpression, PhysicalExpression
-from palimpzest.utils.model_helpers import resolve_reasoning_settings
+from palimpzest.utils.model_helpers import use_reasoning_prompt
 
 logger = logging.getLogger(__name__)
 
@@ -631,13 +631,13 @@ class LLMConvertBondedRule(ImplementationRule):
         models = [model for model in runtime_kwargs["available_models"] if cls._model_matches_input(model, logical_expression)]
         variable_op_kwargs = []
         for model in models:
-            use_reasoning_prompt, reasoning_effort = resolve_reasoning_settings(model, runtime_kwargs["reasoning_effort"])
-            prompt_strategy = PromptStrategy.MAP if use_reasoning_prompt else PromptStrategy.MAP_NO_REASONING
+            reasoning_prompt_strategy = use_reasoning_prompt(runtime_kwargs["reasoning_effort"])
+            prompt_strategy = PromptStrategy.MAP if reasoning_prompt_strategy else PromptStrategy.MAP_NO_REASONING
             variable_op_kwargs.append(
                 {
                     "model": model,
                     "prompt_strategy": prompt_strategy,
-                    "reasoning_effort": reasoning_effort,
+                    "reasoning_effort": runtime_kwargs["reasoning_effort"],
                 }
             )
 
@@ -670,25 +670,28 @@ class RAGRule(ImplementationRule):
         models = [model for model in runtime_kwargs["available_models"] if cls._model_matches_input(model, logical_expression)]
         variable_op_kwargs = []
         for model in models:
-             use_reasoning_prompt, reasoning_effort = resolve_reasoning_settings(model, runtime_kwargs["reasoning_effort"])
-             prompt_strategy = (
-                 PromptStrategy.MAP if use_reasoning_prompt else PromptStrategy.MAP_NO_REASONING
-                 if phys_op_cls is RAGConvert
-                 else PromptStrategy.FILTER if use_reasoning_prompt else PromptStrategy.FILTER_NO_REASONING
-             )
-             variable_op_kwargs.extend(
-                 [
+            reasoning_prompt_strategy = use_reasoning_prompt(runtime_kwargs["reasoning_effort"])
+            if phys_op_cls is RAGConvert:
+                reasoning = PromptStrategy.MAP
+                no_reasoning = PromptStrategy.MAP_NO_REASONING
+            elif phys_op_cls is RAGFilter:
+                reasoning = PromptStrategy.FILTER
+                no_reasoning = PromptStrategy.FILTER_NO_REASONING
+
+            prompt_strategy = reasoning if reasoning_prompt_strategy else no_reasoning
+            variable_op_kwargs.extend(
+                [
                     {
                         "model": model,
                         "prompt_strategy": prompt_strategy,
                         "num_chunks_per_field": num_chunks_per_field,
                         "chunk_size": chunk_size,
-                        "reasoning_effort": reasoning_effort,
+                        "reasoning_effort": runtime_kwargs["reasoning_effort"],
                     }
                     for num_chunks_per_field in cls.num_chunks_per_fields
                     for chunk_size in cls.chunk_sizes
-                 ]
-             )
+                ]
+            )
 
         return cls._perform_substitution(logical_expression, phys_op_cls, runtime_kwargs, variable_op_kwargs)
 
@@ -716,7 +719,6 @@ class MixtureOfAgentsRule(ImplementationRule):
         phys_op_cls = MixtureOfAgentsConvert if isinstance(logical_expression.operator, ConvertScan) else MixtureOfAgentsFilter
 
         # create variable physical operator kwargs for each model which can implement this logical_expression
-        _, reasoning_effort = resolve_reasoning_settings(None, runtime_kwargs["reasoning_effort"])
         proposer_model_set = {model for model in runtime_kwargs["available_models"] if cls._model_matches_input(model, logical_expression)}
         aggregator_model_set = {model for model in runtime_kwargs["available_models"] if model.is_text_model()}
         variable_op_kwargs = [
@@ -724,7 +726,7 @@ class MixtureOfAgentsRule(ImplementationRule):
                 "proposer_models": list(proposer_models),
                 "temperatures": [temp] * len(proposer_models),
                 "aggregator_model": aggregator_model,
-                "reasoning_effort": reasoning_effort,
+                "reasoning_effort": runtime_kwargs["reasoning_effort"],
             }
             for k in cls.num_proposer_models
             for temp in cls.temperatures
@@ -758,12 +760,15 @@ class CritiqueAndRefineRule(ImplementationRule):
         models = [model for model in runtime_kwargs["available_models"] if cls._model_matches_input(model, logical_expression)]
         variable_op_kwargs = []
         for model in models:
-            use_reasoning_prompt, reasoning_effort = resolve_reasoning_settings(model, runtime_kwargs["reasoning_effort"])
-            prompt_strategy = (
-                PromptStrategy.MAP if use_reasoning_prompt else PromptStrategy.MAP_NO_REASONING
-                if phys_op_cls is CritiqueAndRefineConvert
-                else PromptStrategy.FILTER if use_reasoning_prompt else PromptStrategy.FILTER_NO_REASONING
-            )
+            reasoning_prompt_strategy = use_reasoning_prompt(runtime_kwargs["reasoning_effort"])
+            if phys_op_cls is CritiqueAndRefineConvert:
+                reasoning = PromptStrategy.MAP
+                no_reasoning = PromptStrategy.MAP_NO_REASONING
+            elif phys_op_cls is CritiqueAndRefineFilter:
+                reasoning = PromptStrategy.FILTER
+                no_reasoning = PromptStrategy.FILTER_NO_REASONING
+
+            prompt_strategy = reasoning if reasoning_prompt_strategy else no_reasoning
             variable_op_kwargs.extend(
                 [
                     {
@@ -771,7 +776,7 @@ class CritiqueAndRefineRule(ImplementationRule):
                         "critic_model": critic_model,
                         "refine_model": refine_model,
                         "prompt_strategy": prompt_strategy,
-                        "reasoning_effort": reasoning_effort,
+                        "reasoning_effort": runtime_kwargs["reasoning_effort"],
                     }
                     for critic_model in models
                     for refine_model in models
@@ -804,13 +809,12 @@ class SplitRule(ImplementationRule):
 
         # create variable physical operator kwargs for each model which can implement this logical_expression
         models = [model for model in runtime_kwargs["available_models"] if cls._model_matches_input(model, logical_expression)]
-        _, reasoning_effort = resolve_reasoning_settings(None, runtime_kwargs["reasoning_effort"])
         variable_op_kwargs = [
             {
                 "model": model,
                 "min_size_to_chunk": min_size_to_chunk,
                 "num_chunks": num_chunks,
-                "reasoning_effort": reasoning_effort,
+                "reasoning_effort": runtime_kwargs["reasoning_effort"],
             }
             for model in models
             for min_size_to_chunk in cls.min_size_to_chunk
@@ -880,13 +884,13 @@ class LLMFilterRule(ImplementationRule):
         models = [model for model in runtime_kwargs["available_models"] if cls._model_matches_input(model, logical_expression)]
         variable_op_kwargs = []
         for model in models:
-            use_reasoning_prompt, reasoning_effort = resolve_reasoning_settings(model, runtime_kwargs["reasoning_effort"])
-            prompt_strategy = PromptStrategy.FILTER if use_reasoning_prompt else PromptStrategy.FILTER_NO_REASONING
+            reasoning_prompt_strategy = use_reasoning_prompt(runtime_kwargs["reasoning_effort"])
+            prompt_strategy = PromptStrategy.FILTER if reasoning_prompt_strategy else PromptStrategy.FILTER_NO_REASONING
             variable_op_kwargs.append(
                 {
                     "model": model,
                     "prompt_strategy": prompt_strategy,
-                    "reasoning_effort": reasoning_effort,
+                    "reasoning_effort": runtime_kwargs["reasoning_effort"],
                 }
             )
 
@@ -929,14 +933,14 @@ class NestedLoopsJoinRule(ImplementationRule):
         models = [model for model in runtime_kwargs["available_models"] if cls._model_matches_input(model, logical_expression)]
         variable_op_kwargs = []
         for model in models:
-            use_reasoning_prompt, reasoning_effort = resolve_reasoning_settings(model, runtime_kwargs["reasoning_effort"])
-            prompt_strategy = PromptStrategy.JOIN if use_reasoning_prompt else PromptStrategy.JOIN_NO_REASONING
+            reasoning_prompt_strategy = use_reasoning_prompt(runtime_kwargs["reasoning_effort"])
+            prompt_strategy = PromptStrategy.JOIN if reasoning_prompt_strategy else PromptStrategy.JOIN_NO_REASONING
             variable_op_kwargs.append(
                 {
                     "model": model,
                     "prompt_strategy": prompt_strategy,
                     "join_parallelism": runtime_kwargs["join_parallelism"],
-                    "reasoning_effort": reasoning_effort,
+                    "reasoning_effort": runtime_kwargs["reasoning_effort"],
                     "retain_inputs": not runtime_kwargs["is_validation"],
                 }
             )
@@ -963,14 +967,14 @@ class EmbeddingJoinRule(ImplementationRule):
         models = [model for model in runtime_kwargs["available_models"] if cls._model_matches_input(model, logical_expression)]
         variable_op_kwargs = []
         for model in models:
-            use_reasoning_prompt, reasoning_effort = resolve_reasoning_settings(model, runtime_kwargs["reasoning_effort"])
-            prompt_strategy = PromptStrategy.JOIN if use_reasoning_prompt else PromptStrategy.JOIN_NO_REASONING
+            reasoning_prompt_strategy = use_reasoning_prompt(runtime_kwargs["reasoning_effort"])
+            prompt_strategy = PromptStrategy.JOIN if reasoning_prompt_strategy else PromptStrategy.JOIN_NO_REASONING
             variable_op_kwargs.append(
                 {
                     "model": model,
                     "prompt_strategy": prompt_strategy,
                     "join_parallelism": runtime_kwargs["join_parallelism"],
-                    "reasoning_effort": reasoning_effort,
+                    "reasoning_effort": runtime_kwargs["reasoning_effort"],
                     "retain_inputs": not runtime_kwargs["is_validation"],
                     "num_samples": 10, # TODO: iterate over different choices of num_samples
                 }
@@ -997,13 +1001,13 @@ class SemanticAggregateRule(ImplementationRule):
         models = [model for model in runtime_kwargs["available_models"] if cls._model_matches_input(model, logical_expression) and not model.is_llama_model()]
         variable_op_kwargs = []
         for model in models:
-            use_reasoning_prompt, reasoning_effort = resolve_reasoning_settings(model, runtime_kwargs["reasoning_effort"])
-            prompt_strategy = PromptStrategy.AGG if use_reasoning_prompt else PromptStrategy.AGG_NO_REASONING
+            reasoning_prompt_strategy = use_reasoning_prompt(runtime_kwargs["reasoning_effort"])
+            prompt_strategy = PromptStrategy.AGG if reasoning_prompt_strategy else PromptStrategy.AGG_NO_REASONING
             variable_op_kwargs.append(
                 {
                     "model": model,
                     "prompt_strategy": prompt_strategy,
-                    "reasoning_effort": reasoning_effort,
+                    "reasoning_effort": runtime_kwargs["reasoning_effort"],
                 }
             )
 

palimpzest/query/processor/config.py

@@ -28,7 +28,7 @@ class QueryProcessorConfig(BaseModel):
     max_workers: int | None = Field(default=64)
     join_parallelism: int = Field(default=64)
     batch_size: int | None = Field(default=None)
-    reasoning_effort: str | None = Field(default="default")  # Gemini: "disable", "low", "medium", "high"
+    reasoning_effort: str = Field(default="default")  # Gemini: "disable", "low", "medium", "high"
     use_vertex: bool = Field(default=False)  # Whether to use Vertex models for Gemini or Google models
     gemini_credentials_path: str | None = Field(default=None)  # Path to Gemini credentials file
     api_base: str | None = Field(default=None)  # API base URL for vLLM

palimpzest/utils/model_helpers.py

@@ -60,29 +60,32 @@ def get_models(include_embedding: bool = False, use_vertex: bool = False, gemini
     return models
 
 
-def resolve_reasoning_settings(model: Model | None, reasoning_effort: str | None) -> tuple[bool, str]:
+def use_reasoning_prompt(reasoning_effort: str) -> bool:
     """
-    Resolve the reasoning settings based on the model and provided reasoning effort.
-    Returns a tuple indicating whether reasoning prompt should be used and the reasoning effort level.
-    By default, we use the reasoning prompt everywhere while setting the model reasoning effort to None (or minimal).
-    If a user explicitly provides a reasoning_effort, we pass that through to the model.
-    If the user explicitly disables reasoning_effort, we disable the reasoning prompt as well.
+    Determine whether to use the reasoning prompt based on the provided reasoning effort.
+    By default, we use the reasoning prompt everywhere unless the reasoning_effort is in [None, "disable", "minimal", "low"].
     """
-    # turn off reasoning prompt if reasoning_effort is in [None, "disable", "minimal", "low"]
-    use_reasoning_prompt = reasoning_effort not in [None, "disable", "minimal", "low"]
+    return reasoning_effort not in ["disable", "minimal", "low"]
+
+
+def resolve_reasoning_effort(model: Model, reasoning_effort: str) -> str | None:
+    """
+    Resolve the reasoning effort setting based on the model and provided reasoning effort.
+    """
+    # check that model is a reasoning model, throw an assertion error otherwise
+    assert model.is_reasoning_model(), f"Model {model} is not a reasoning model. Should only use resolve_reasoning_effort with reasoning models."
 
     # if reasoning_effort is set to "default", set it to None to use model defaults
     if reasoning_effort == "default":
         reasoning_effort = None
 
     # translate reasoning_effort into model-specific settings
-    if model is not None and model.is_reasoning_model():
-        if model.is_vertex_model() or model.is_google_ai_studio_model():
-            if reasoning_effort is None and model in [Model.GEMINI_2_5_PRO, Model.GOOGLE_GEMINI_2_5_PRO]:
-                reasoning_effort = "low"
-            elif reasoning_effort is None:
-                reasoning_effort = "disable"
-        elif model.is_openai_model():
-            reasoning_effort = "minimal" if reasoning_effort in [None, "disable", "minimal", "low"] else reasoning_effort
+    if model.is_vertex_model() or model.is_google_ai_studio_model():
+        if reasoning_effort is None and model in [Model.GEMINI_2_5_PRO, Model.GOOGLE_GEMINI_2_5_PRO]:
+            reasoning_effort = "low"
+        elif reasoning_effort is None:
+            reasoning_effort = "disable"
+    elif model.is_openai_model():
+        reasoning_effort = "low" if reasoning_effort in [None, "disable", "minimal", "low"] else reasoning_effort
 
-    return use_reasoning_prompt, reasoning_effort
+    return reasoning_effort

{palimpzest-1.3.2.dist-info → palimpzest-1.3.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: palimpzest
-Version: 1.3.2
+Version: 1.3.4
 Summary: Palimpzest is a system which enables anyone to process AI-powered analytical queries simply by defining them in a declarative language
 Author-email: MIT DSG Semantic Management Lab <michjc@csail.mit.edu>
 Project-URL: homepage, https://palimpzest.org

{palimpzest-1.3.2.dist-info → palimpzest-1.3.4.dist-info}/RECORD

@@ -1,5 +1,5 @@
 palimpzest/__init__.py,sha256=1PzadDDOVMQJKNEYUH0_tw8tQKUYTT31M0vuzTr2Rqk,1694
-palimpzest/constants.py,sha256=kfuDTdSdeTCWp2JJopeuwpGIf8MC6jQ8SDBFuRIhN3k,23334
+palimpzest/constants.py,sha256=67E4FsvWsNs_EQGtdNR0MO-vzq4Oh7qZutGnkg-rITo,23338
 palimpzest/policy.py,sha256=lIvw_C_rmwCH4LZaeNkAuixl8zw9RAW_JcSWSHPjKyc,11628
 palimpzest/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 palimpzest/agents/compute_agents.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -42,15 +42,15 @@ palimpzest/query/execution/mab_execution_strategy.py,sha256=BLRTSQXPeWBlJ_-8GAFH
 palimpzest/query/execution/parallel_execution_strategy.py,sha256=Di-8d7waE0bev4kNDXEJJqQ0wwQ87_sPV-t5qFtAlPQ,17589
 palimpzest/query/execution/single_threaded_execution_strategy.py,sha256=1rjMel0-AI6KUi_SMNgPPXxMgG5-t9lenLKoYEClgjk,17464
 palimpzest/query/generators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-palimpzest/query/generators/generators.py,sha256=PexL2hVTqx3CZmdZSjoZ5Ylw2M6BQARvVq24_J5x_RA,20934
+palimpzest/query/generators/generators.py,sha256=iDiTInKsmeJGrZyf-oWDyGcTG5qMpGf2DE90h9w_hgk,21085
 palimpzest/query/operators/__init__.py,sha256=B9zr_VmUs6YRep4fjbj7e0aTM6T9-GrqbY7tKWxEdkc,4734
-palimpzest/query/operators/aggregate.py,sha256=nQ6Zh1DYeqDoIDwkPQDw8QCwW0y52sGC-No6uPSRc8A,27367
+palimpzest/query/operators/aggregate.py,sha256=Lrs0ZccNoNVWkulXQwREvmyvuMWvbjPQPue0RaboL-8,27365
 palimpzest/query/operators/compute.py,sha256=X_pWN45smg8L4dV54nOae7dldQGL1nJVlVyJ3ULWSmI,8432
-palimpzest/query/operators/convert.py,sha256=beJLS-vnVc_VLnngoDKTj-k_Ul7GmDA-yMKM6-mX5Ho,16218
+palimpzest/query/operators/convert.py,sha256=gT0aMoj1zponZkmjypyzyaP-p1KtXVStAdUgmRs8Ks4,16216
 palimpzest/query/operators/critique_and_refine.py,sha256=Q-NhasVoD9meX7g36RPrv3q4R48_8XEU4d3TE46hRJI,8979
 palimpzest/query/operators/distinct.py,sha256=ZTXlIS7IaFRTsWv9RemzCo1JLz25vEma-TB42CV5fJQ,2614
-palimpzest/query/operators/filter.py,sha256=h559CweLdcWw_-LPyR2h04pKsm-jVM_Kazif-BXYBFo,10516
-palimpzest/query/operators/join.py,sha256=hxIbSSDMy_5bch7kpYQ-iQS5XEth_T19cTSlXd76gdg,38845
+palimpzest/query/operators/filter.py,sha256=S4U5U39qHbH3Ceyl2jak97uXoKJ3OQbP1XegAqGMorg,10514
+palimpzest/query/operators/join.py,sha256=ZA_54d8uY3nSMEMEMeToNMA-pAx05_8zJwWMsaMWeAI,38843
 palimpzest/query/operators/limit.py,sha256=pdo7WfWY97SW3c-WqZ4SIPw7lHIVbaXPEWqHyK8qkF8,2130
 palimpzest/query/operators/logical.py,sha256=OtB82L1X19ibtLx1GIfeXXyO7YfjkFmh3puIUgqKQRE,21160
 palimpzest/query/operators/mixture_of_agents.py,sha256=KC-ZpjtGY28sfwlk2TpduLC_fADj_UASFCaicaKqSFc,11671
@@ -63,15 +63,15 @@ palimpzest/query/operators/split.py,sha256=oLzwnYb8TNf3XA9TMKEAIw7EIA12wHneaD42B
 palimpzest/query/operators/topk.py,sha256=MZl83Cu43QmN4skjlfpR8EVFFCgA7sR6PbGgBGWC0tg,13564
 palimpzest/query/optimizer/__init__.py,sha256=v9fSBOL2p3sQew4LrN2DQUPe0WezO328Hr54qBTqrAs,2799
 palimpzest/query/optimizer/cost_model.py,sha256=JaxdLuUZuq52BJ52YdW4ChfWptwXsh7Rk7oaPCn_gWc,12956
-palimpzest/query/optimizer/optimizer.py,sha256=I1AwsSaMgnhOOImsWAYZEsyXTZFX-kmwDh89gHL4Sg0,20068
+palimpzest/query/optimizer/optimizer.py,sha256=kOB8NaGYNfnNcB_Ko3uXz8D17QLSRCX9Y98IBCHcftI,20061
 palimpzest/query/optimizer/optimizer_strategy.py,sha256=0foDaBHqQehK_zz6IlDEbNIw-44wxY6LO5H1anJi56Y,10042
 palimpzest/query/optimizer/optimizer_strategy_type.py,sha256=V-MMHvJdnfZKoUX1xxxwh66q1RjN2FL35IsiT1C62c8,1084
 palimpzest/query/optimizer/plan.py,sha256=O33uzcpwhcHVu5MuxcLzrwodcF86ZrcMZSOy4xoOb7A,22792
 palimpzest/query/optimizer/primitives.py,sha256=jMMVq37y1tWiPU1lSSKQP9OP-mzkpSxSmUeDajRYYOQ,5445
-palimpzest/query/optimizer/rules.py,sha256=Xu7VjLYExD_sxpD-N7kXsw0-Jo7cwKPjgpuFq7sEhy8,55098
+palimpzest/query/optimizer/rules.py,sha256=brsySU2O4GK6HrZJ1zqePPmLD_TF3GHIpEDuM9xcvok,55113
 palimpzest/query/optimizer/tasks.py,sha256=DNJjY2QldfKFWj6INHElMh88dYc36Z5m3wHwbs4jyF4,30455
 palimpzest/query/processor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-palimpzest/query/processor/config.py,sha256=Msi9q6GPkRyu6I4C27I4zrIvEs3Lg0neGMz_MZnNtbQ,2712
+palimpzest/query/processor/config.py,sha256=V3znG_nL8JDo8dIlQEL2pCaGgFDM9WNacaF8FefR0Ms,2705
 palimpzest/query/processor/query_processor.py,sha256=T4ffPbnOX23G8FDITzmM7Iw7DUEDWIHnwl8XLYllgjg,6240
 palimpzest/query/processor/query_processor_factory.py,sha256=-8Q3yCIFY1cbCJL3tZKEajEF01ZxDHdSukjOEtYuqeI,9753
 palimpzest/schemabuilder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -84,13 +84,13 @@ palimpzest/tools/skema_tools.py,sha256=HXUFpjMhbVxZwKKkATeK-FwtlTCawaCbeP-uHntI1
 palimpzest/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 palimpzest/utils/env_helpers.py,sha256=n81KzoJ459pRxo7QmJA7duazwWsfoMGTHc71D2LatFk,334
 palimpzest/utils/hash_helpers.py,sha256=3A8dA7SbXTwnnvZvPVNqqMLlVRhCKyKF_bjNNAu3Exk,334
-palimpzest/utils/model_helpers.py,sha256=11dmGztBms9FyHsFdCXIkTFV_1oahKfMzv4-kkH5wCY,4076
+palimpzest/utils/model_helpers.py,sha256=PsAPA567nOgSobIFUJZWm22o3lRWCqHf7HVuMvcdfuo,3945
 palimpzest/utils/progress.py,sha256=eHXrTPTCRHjMdK0EjYRUzSxcV6N1lK8TS3Ju_ZlQLhY,22002
 palimpzest/utils/udfs.py,sha256=LjHic54B1az-rKgNLur0wOpaz2ko_UodjLEJrazkxvY,1854
 palimpzest/validator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 palimpzest/validator/validator.py,sha256=SvjK09zCpGtK0yM0OasvQlSzyq3loy32DyOOKRmYXC0,15977
-palimpzest-1.3.2.dist-info/licenses/LICENSE,sha256=5GUlHy9lr-Py9kvV38FF1m3yy3NqM18fefuE9wkWumo,1079
-palimpzest-1.3.2.dist-info/METADATA,sha256=VEk0zS9OYEnB8CxBQG8o8-cdoeYhb5XMwFdbFWngYxY,5395
-palimpzest-1.3.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-palimpzest-1.3.2.dist-info/top_level.txt,sha256=raV06dJUgohefUn3ZyJS2uqp_Y76EOLA9Y2e_fxt8Ew,11
-palimpzest-1.3.2.dist-info/RECORD,,
+palimpzest-1.3.4.dist-info/licenses/LICENSE,sha256=5GUlHy9lr-Py9kvV38FF1m3yy3NqM18fefuE9wkWumo,1079
+palimpzest-1.3.4.dist-info/METADATA,sha256=qc_BI7yU6mIdZWpHBCjd78BXWHZ6AX6E--4KivpysTw,5395
+palimpzest-1.3.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+palimpzest-1.3.4.dist-info/top_level.txt,sha256=raV06dJUgohefUn3ZyJS2uqp_Y76EOLA9Y2e_fxt8Ew,11
+palimpzest-1.3.4.dist-info/RECORD,,