palimpzest 1.3.2__tar.gz → 1.3.4__tar.gz

{palimpzest-1.3.2/src/palimpzest.egg-info → palimpzest-1.3.4}/PKG-INFO

@@ -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 → palimpzest-1.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "palimpzest"
-version = "1.3.2"
+version = "1.3.4"
 description = "Palimpzest is a system which enables anyone to process AI-powered analytical queries simply by defining them in a declarative language"
 readme = "README.md"
 requires-python = ">=3.12"

{palimpzest-1.3.2 → palimpzest-1.3.4}/src/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-1.3.2 → palimpzest-1.3.4}/src/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-1.3.2 → palimpzest-1.3.4}/src/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-1.3.2 → palimpzest-1.3.4}/src/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-1.3.2 → palimpzest-1.3.4}/src/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-1.3.2 → palimpzest-1.3.4}/src/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-1.3.2 → palimpzest-1.3.4}/src/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-1.3.2 → palimpzest-1.3.4}/src/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-1.3.2 → palimpzest-1.3.4}/src/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-1.3.2 → palimpzest-1.3.4}/src/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 → palimpzest-1.3.4/src/palimpzest.egg-info}/PKG-INFO

@@ -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