palimpzest 1.3.0__py3-none-any.whl → 1.3.1__py3-none-any.whl

palimpzest/query/generators/generators.py

@@ -108,7 +108,7 @@ class Generator(Generic[ContextType, InputType]):
         self,
         model: Model,
         prompt_strategy: PromptStrategy,
-        reasoning_effort: str | None = None,
+        reasoning_effort: str | None,
         api_base: str | None = None,
         cardinality: Cardinality = Cardinality.ONE_TO_ONE,
         desc: str | None = None,
@@ -325,18 +325,7 @@ class Generator(Generic[ContextType, InputType]):
             if is_audio_op:
                 completion_kwargs = {"modalities": ["text"], **completion_kwargs}
             if self.model.is_reasoning_model():
-                if self.model.is_vertex_model():
-                    reasoning_effort = self.reasoning_effort
-                    if self.reasoning_effort is None and self.model == Model.GEMINI_2_5_PRO:
-                        reasoning_effort = "low"
-                    elif self.reasoning_effort is None:
-                        reasoning_effort = "disable"
-                    completion_kwargs = {"reasoning_effort": reasoning_effort, **completion_kwargs}
-                elif self.model.is_anthropic_model() and self.reasoning_effort is not None:
-                    completion_kwargs = {"reasoning_effort": self.reasoning_effort, **completion_kwargs}
-                elif self.model.is_openai_model():
-                    reasoning_effort = "minimal" if self.reasoning_effort is None else self.reasoning_effort
-                    completion_kwargs = {"reasoning_effort": reasoning_effort, **completion_kwargs}
+                completion_kwargs = {"reasoning_effort": self.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/optimizer/optimizer.py

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

palimpzest/query/optimizer/rules.py

@@ -54,6 +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
 
 logger = logging.getLogger(__name__)
 
@@ -628,15 +629,17 @@ class LLMConvertBondedRule(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)]
-        no_reasoning = runtime_kwargs["reasoning_effort"] in [None, "minimal", "low"]
-        variable_op_kwargs = [
-            {
-                "model": model,
-                "prompt_strategy": PromptStrategy.MAP_NO_REASONING if model.is_reasoning_model() and no_reasoning else PromptStrategy.MAP,
-                "reasoning_effort": runtime_kwargs["reasoning_effort"],
-            }
-            for model in models
-        ]
+        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
+            variable_op_kwargs.append(
+                {
+                    "model": model,
+                    "prompt_strategy": prompt_strategy,
+                    "reasoning_effort": reasoning_effort,
+                }
+            )
 
         return cls._perform_substitution(logical_expression, LLMConvertBonded, runtime_kwargs, variable_op_kwargs)
 
@@ -665,18 +668,27 @@ class RAGRule(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)]
-        variable_op_kwargs = [
-            {
-                "model": model,
-                "prompt_strategy": PromptStrategy.MAP if phys_op_cls is RAGConvert else PromptStrategy.FILTER,
-                "num_chunks_per_field": num_chunks_per_field,
-                "chunk_size": chunk_size,
-                "reasoning_effort": runtime_kwargs["reasoning_effort"],
-            }
-            for model in models
-            for num_chunks_per_field in cls.num_chunks_per_fields
-            for chunk_size in cls.chunk_sizes
-        ]
+        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(
+                 [
+                    {
+                        "model": model,
+                        "prompt_strategy": prompt_strategy,
+                        "num_chunks_per_field": num_chunks_per_field,
+                        "chunk_size": chunk_size,
+                        "reasoning_effort": 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)
 
@@ -704,6 +716,7 @@ 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 = [
@@ -711,7 +724,7 @@ class MixtureOfAgentsRule(ImplementationRule):
                 "proposer_models": list(proposer_models),
                 "temperatures": [temp] * len(proposer_models),
                 "aggregator_model": aggregator_model,
-                "reasoning_effort": runtime_kwargs["reasoning_effort"],
+                "reasoning_effort": reasoning_effort,
             }
             for k in cls.num_proposer_models
             for temp in cls.temperatures
@@ -743,18 +756,27 @@ class CritiqueAndRefineRule(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)]
-        variable_op_kwargs = [
-            {
-                "model": model,
-                "critic_model": critic_model,
-                "refine_model": refine_model,
-                "prompt_strategy": PromptStrategy.MAP if phys_op_cls is CritiqueAndRefineConvert else PromptStrategy.FILTER,
-                "reasoning_effort": runtime_kwargs["reasoning_effort"],
-            }
-            for model in models
-            for critic_model in models
-            for refine_model in models
-        ]
+        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
+            )
+            variable_op_kwargs.extend(
+                [
+                    {
+                        "model": model,
+                        "critic_model": critic_model,
+                        "refine_model": refine_model,
+                        "prompt_strategy": prompt_strategy,
+                        "reasoning_effort": reasoning_effort,
+                    }
+                    for critic_model in models
+                    for refine_model in models
+                ]
+            )
 
         return cls._perform_substitution(logical_expression, phys_op_cls, runtime_kwargs, variable_op_kwargs)
 
@@ -782,12 +804,13 @@ 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": runtime_kwargs["reasoning_effort"],
+                "reasoning_effort": reasoning_effort,
             }
             for model in models
             for min_size_to_chunk in cls.min_size_to_chunk
@@ -855,15 +878,17 @@ class LLMFilterRule(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)]
-        no_reasoning = runtime_kwargs["reasoning_effort"] in [None, "minimal", "low"]
-        variable_op_kwargs = [
-            {
-                "model": model,
-                "prompt_strategy": PromptStrategy.FILTER_NO_REASONING if model.is_reasoning_model() and no_reasoning else PromptStrategy.FILTER,
-                "reasoning_effort": runtime_kwargs["reasoning_effort"]
-            }
-            for model in models
-        ]
+        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
+            variable_op_kwargs.append(
+                {
+                    "model": model,
+                    "prompt_strategy": prompt_strategy,
+                    "reasoning_effort": reasoning_effort,
+                }
+            )
 
         return cls._perform_substitution(logical_expression, LLMFilter, runtime_kwargs, variable_op_kwargs)
 
@@ -902,17 +927,19 @@ class NestedLoopsJoinRule(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)]
-        no_reasoning = runtime_kwargs["reasoning_effort"] in [None, "minimal", "low"]
-        variable_op_kwargs = [
-            {
-                "model": model,
-                "prompt_strategy": PromptStrategy.JOIN_NO_REASONING if model.is_reasoning_model() and no_reasoning else PromptStrategy.JOIN,
-                "join_parallelism": runtime_kwargs["join_parallelism"],
-                "reasoning_effort": runtime_kwargs["reasoning_effort"],
-                "retain_inputs": not runtime_kwargs["is_validation"],
-            }
-            for model in models
-        ]
+        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
+            variable_op_kwargs.append(
+                {
+                    "model": model,
+                    "prompt_strategy": prompt_strategy,
+                    "join_parallelism": runtime_kwargs["join_parallelism"],
+                    "reasoning_effort": reasoning_effort,
+                    "retain_inputs": not runtime_kwargs["is_validation"],
+                }
+            )
 
         return cls._perform_substitution(logical_expression, NestedLoopsJoin, runtime_kwargs, variable_op_kwargs)
 
@@ -934,18 +961,20 @@ class EmbeddingJoinRule(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)]
-        no_reasoning = runtime_kwargs["reasoning_effort"] in [None, "minimal", "low"]
-        variable_op_kwargs = [
-            {
-                "model": model,
-                "prompt_strategy": PromptStrategy.JOIN_NO_REASONING if model.is_reasoning_model() and no_reasoning else PromptStrategy.JOIN,
-                "join_parallelism": runtime_kwargs["join_parallelism"],
-                "reasoning_effort": runtime_kwargs["reasoning_effort"],
-                "retain_inputs": not runtime_kwargs["is_validation"],
-                "num_samples": 10, # TODO: iterate over different choices of num_samples
-            }
-            for model in models
-        ]
+        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
+            variable_op_kwargs.append(
+                {
+                    "model": model,
+                    "prompt_strategy": prompt_strategy,
+                    "join_parallelism": runtime_kwargs["join_parallelism"],
+                    "reasoning_effort": reasoning_effort,
+                    "retain_inputs": not runtime_kwargs["is_validation"],
+                    "num_samples": 10, # TODO: iterate over different choices of num_samples
+                }
+            )
 
         return cls._perform_substitution(logical_expression, EmbeddingJoin, runtime_kwargs, variable_op_kwargs)
 
@@ -966,15 +995,17 @@ class SemanticAggregateRule(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) and not model.is_llama_model()]
-        no_reasoning = runtime_kwargs["reasoning_effort"] in [None, "minimal", "low"]
-        variable_op_kwargs = [
-            {
-                "model": model,
-                "prompt_strategy": PromptStrategy.AGG_NO_REASONING if model.is_reasoning_model() and no_reasoning else PromptStrategy.AGG,
-                "reasoning_effort": runtime_kwargs["reasoning_effort"]
-            }
-            for model in models
-        ]
+        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
+            variable_op_kwargs.append(
+                {
+                    "model": model,
+                    "prompt_strategy": prompt_strategy,
+                    "reasoning_effort": reasoning_effort,
+                }
+            )
 
         return cls._perform_substitution(logical_expression, SemanticAggregate, runtime_kwargs, variable_op_kwargs)
 

palimpzest/query/processor/config.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from pydantic import BaseModel, ConfigDict, Field
 
 from palimpzest.constants import Model
@@ -18,7 +20,7 @@ class QueryProcessorConfig(BaseModel):
     policy: Policy = Field(default_factory=MaxQuality)
     enforce_types: bool = Field(default=False)
     scan_start_idx: int = Field(default=0)
-    num_samples: int = Field(default=None)
+    num_samples: int | None = Field(default=None)
     verbose: bool = Field(default=False)
     progress: bool = Field(default=True)
     available_models: list[Model] | None = Field(default=None)
@@ -26,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=None)  # Gemini: "disable", "low", "medium", "high"
+    reasoning_effort: str | None = 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
@@ -53,3 +55,7 @@ class QueryProcessorConfig(BaseModel):
     def to_dict(self) -> dict:
         """Convert the config to a dict representation."""
         return self.model_dump()
+
+    def copy(self) -> QueryProcessorConfig:
+        """Create a copy of the config."""
+        return QueryProcessorConfig(**self.to_dict())

palimpzest/query/processor/query_processor_factory.py

@@ -170,6 +170,9 @@ class QueryProcessorFactory:
         if config is None:
             config = QueryProcessorConfig()
 
+        # make a copy of the config to avoid modifying the original
+        config = config.copy()
+
         # apply any additional keyword arguments to the config and validate its contents
         config, validator = cls._config_validation_and_normalization(config, train_dataset, validator)
 

palimpzest/utils/model_helpers.py

@@ -58,3 +58,31 @@ def get_models(include_embedding: bool = False, use_vertex: bool = False, gemini
         models.extend(vllm_models)
 
     return models
+
+
+def resolve_reasoning_settings(model: Model | None, reasoning_effort: str | None) -> tuple[bool, str]:
+    """
+    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.
+    """
+    # turn off reasoning prompt if reasoning_effort is in [None, "disable", "minimal", "low"]
+    use_reasoning_prompt = reasoning_effort not in [None, "disable", "minimal", "low"]
+
+    # 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
+
+    return use_reasoning_prompt, reasoning_effort

{palimpzest-1.3.0.dist-info → palimpzest-1.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: palimpzest
-Version: 1.3.0
+Version: 1.3.1
 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.0.dist-info → palimpzest-1.3.1.dist-info}/RECORD

@@ -42,7 +42,7 @@ 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=OV2HBZvCQtvhj6rOwti_8dpQX_bqTZ-uehyUCFG2BBE,21758
+palimpzest/query/generators/generators.py,sha256=PexL2hVTqx3CZmdZSjoZ5Ylw2M6BQARvVq24_J5x_RA,20934
 palimpzest/query/operators/__init__.py,sha256=B9zr_VmUs6YRep4fjbj7e0aTM6T9-GrqbY7tKWxEdkc,4734
 palimpzest/query/operators/aggregate.py,sha256=nQ6Zh1DYeqDoIDwkPQDw8QCwW0y52sGC-No6uPSRc8A,27367
 palimpzest/query/operators/compute.py,sha256=X_pWN45smg8L4dV54nOae7dldQGL1nJVlVyJ3ULWSmI,8432
@@ -63,17 +63,17 @@ 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=ksLkzQ2sVgJFbkxGF3ncF74EsAHZFos8G19xlHQrtJo,20063
+palimpzest/query/optimizer/optimizer.py,sha256=I1AwsSaMgnhOOImsWAYZEsyXTZFX-kmwDh89gHL4Sg0,20068
 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=awhe76trskv5Tq5E2QHpUN_YV6jH8INywa0Ige8IIhY,53341
+palimpzest/query/optimizer/rules.py,sha256=Xu7VjLYExD_sxpD-N7kXsw0-Jo7cwKPjgpuFq7sEhy8,55098
 palimpzest/query/optimizer/tasks.py,sha256=DNJjY2QldfKFWj6INHElMh88dYc36Z5m3wHwbs4jyF4,30455
 palimpzest/query/processor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-palimpzest/query/processor/config.py,sha256=rVpXNfzJvYstNZ2PxhQMWBpHCmjLDfiKh4ERKWRojc0,2522
+palimpzest/query/processor/config.py,sha256=Msi9q6GPkRyu6I4C27I4zrIvEs3Lg0neGMz_MZnNtbQ,2712
 palimpzest/query/processor/query_processor.py,sha256=T4ffPbnOX23G8FDITzmM7Iw7DUEDWIHnwl8XLYllgjg,6240
-palimpzest/query/processor/query_processor_factory.py,sha256=qED6pJtJJXVci2a4nScURSpJohrz1LIW6tXY05un2R8,9653
+palimpzest/query/processor/query_processor_factory.py,sha256=-8Q3yCIFY1cbCJL3tZKEajEF01ZxDHdSukjOEtYuqeI,9753
 palimpzest/schemabuilder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 palimpzest/schemabuilder/schema_builder.py,sha256=QraGp66dcD-ej6Y2mER40o86G9JqlBkL7swkJzjUAIY,7968
 palimpzest/tools/README.md,sha256=56_6LPG80uc0CLVhTBP6I1wgIffNv9cyTr0TmVZqmrM,483
@@ -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=SqcY8rWzZ7D3Vgeq8d4OGNLGv4dXXVMWiJDqSCaalRQ,2490
+palimpzest/utils/model_helpers.py,sha256=11dmGztBms9FyHsFdCXIkTFV_1oahKfMzv4-kkH5wCY,4076
 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.0.dist-info/licenses/LICENSE,sha256=5GUlHy9lr-Py9kvV38FF1m3yy3NqM18fefuE9wkWumo,1079
-palimpzest-1.3.0.dist-info/METADATA,sha256=1VcCZTtJHg1ujb41-3QquXQLYaWtpCG9AHuvtrvJGvg,5395
-palimpzest-1.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-palimpzest-1.3.0.dist-info/top_level.txt,sha256=raV06dJUgohefUn3ZyJS2uqp_Y76EOLA9Y2e_fxt8Ew,11
-palimpzest-1.3.0.dist-info/RECORD,,
+palimpzest-1.3.1.dist-info/licenses/LICENSE,sha256=5GUlHy9lr-Py9kvV38FF1m3yy3NqM18fefuE9wkWumo,1079
+palimpzest-1.3.1.dist-info/METADATA,sha256=pDfvhYW8xmKZrc-4yJQ4dkvatr0FMdJ3kWxpiclTwvk,5395
+palimpzest-1.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+palimpzest-1.3.1.dist-info/top_level.txt,sha256=raV06dJUgohefUn3ZyJS2uqp_Y76EOLA9Y2e_fxt8Ew,11
+palimpzest-1.3.1.dist-info/RECORD,,