palimpzest 0.7.20__py3-none-any.whl → 0.8.0__py3-none-any.whl

palimpzest/validator/validator.py

@@ -0,0 +1,306 @@
+import json
+import time
+
+import litellm
+from colorama import Fore, Style
+
+from palimpzest.constants import MODEL_CARDS, Cardinality, Model, PromptStrategy
+from palimpzest.core.elements.records import DataRecord
+from palimpzest.core.models import GenerationStats
+from palimpzest.prompts import (
+    FLAT_MAP_IMAGE_VALIDATOR_PROMPT,
+    FLAT_MAP_VALIDATOR_PROMPT,
+    MAP_IMAGE_VALIDATOR_PROMPT,
+    MAP_VALIDATOR_PROMPT,
+    RETRIEVE_VALIDATOR_PROMPT,
+    PromptFactory,
+)
+from palimpzest.query.generators.generators import get_json_from_answer
+from palimpzest.query.operators.convert import LLMConvert
+from palimpzest.query.operators.filter import LLMFilter
+from palimpzest.query.operators.join import JoinOp
+from palimpzest.query.operators.retrieve import RetrieveOp
+
+
+class Validator:
+    """
+    The Validator is used during optimization to score the output of physical operator(s) and physical plan(s).
+
+    TODO: support end-to-end labels; will likely require a different SentinelExecutionStrategy which
+          executes the full input to produce an output, evaluates the output, and then updates
+          intermediate operator(s) based on the evaluation.
+    """
+    def __init__(self, model: Model = Model.o4_MINI):
+        self.model = model
+        self.filter_cache = {}
+        self.join_cache = {}
+
+    def map_score_fn(self, fields: list[str], input_record: dict, output: dict) -> float | None:
+        raise NotImplementedError("Validator.map_score_fn not implemented.")
+
+    def flat_map_score_fn(self, fields: list[str], input_record: dict, output: list[dict]) -> float | None:
+        raise NotImplementedError("Validator.flat_map_score_fn not implemented.")
+
+    def filter_score_fn(self, filter_str: str, input_record: dict, output: bool) -> float | None:
+        raise NotImplementedError("Validator.filter_score_fn not implemented.")
+
+    def join_score_fn(self, condition: str, left_input_record: dict, right_input_record: dict, output: bool) -> float | None:
+        raise NotImplementedError("Validator.join_score_fn not implemented.")
+
+    def retrieve_score_fn(self, fields: list[str], input_record: dict, output: dict) -> float | None:
+        raise NotImplementedError("Validator.map_score_fn not implemented.")
+
+    def _get_gen_stats_from_completion(self, completion, start_time: float) -> GenerationStats:
+        """
+        Extract generation stats from the given completion response.
+        """
+        usage = completion.usage.model_dump()
+
+        # get cost per input/output token for the model and parse number of input and output tokens
+        usd_per_input_token = MODEL_CARDS[self.model.value]["usd_per_input_token"]
+        usd_per_output_token = MODEL_CARDS[self.model.value]["usd_per_output_token"]
+        input_tokens = usage["prompt_tokens"]
+        output_tokens = usage["completion_tokens"]
+
+        return GenerationStats(
+            model_name=self.model.value,
+            llm_call_duration_secs=time.time() - start_time,
+            fn_call_duration_secs=0.0,
+            total_input_tokens=input_tokens,
+            total_output_tokens=output_tokens,
+            total_input_cost=input_tokens * usd_per_input_token,
+            total_output_cost=output_tokens * usd_per_output_token,
+            cost_per_record=input_tokens * usd_per_input_token + output_tokens * usd_per_output_token,
+            total_llm_calls=1,
+        )
+
+    def _default_map_score_fn(self, op: LLMConvert, fields: list[str], input_record: DataRecord, output: dict) -> tuple[float | None, GenerationStats]:
+        """
+        Compute the quality of the generated output for the given fields and input_record.
+        """
+        # create prompt factory
+        prompt_strategy = PromptStrategy.COT_QA_IMAGE if op.is_image_conversion() else PromptStrategy.COT_QA
+        factory = PromptFactory(prompt_strategy, Model.o4_MINI, Cardinality.ONE_TO_ONE) # TODO: switch to o4_MINI after merging in dev
+
+        # get the input messages; strip out the system message(s)
+        msg_kwargs = {"output_schema": op.output_schema, "project_cols": op.get_input_fields()}
+        messages = factory.create_messages(input_record, fields, **msg_kwargs)
+        input_messages = [msg for msg in messages if msg["role"] != "system"]
+        output = json.dumps(output, indent=2)
+        output_message = f"OUTPUT:\n--------\n{output}\n\nEVALUATION: "
+        input_str = '\n'.join(list(map(lambda d: d['content'], input_messages + [{"role": "user", "content": output_message}])))
+
+        # invoke the judge
+        score, gen_stats = None, GenerationStats()
+        try:
+            start_time = time.time()
+            validator_prompt = MAP_IMAGE_VALIDATOR_PROMPT if op.is_image_conversion() else MAP_VALIDATOR_PROMPT
+            val_messages = [{"role": "system", "content": validator_prompt}] + input_messages + [{"role": "user", "content": output_message}]
+            completion = litellm.completion(model="openai/o4-mini", messages=val_messages)
+            completion_text = completion.choices[0].message.content
+            gen_stats = self._get_gen_stats_from_completion(completion, start_time)
+            print(f"INPUT:\n{input_str}")
+            print(Fore.GREEN + f"{completion_text}\n" + Style.RESET_ALL)
+
+            # parse the evaluation
+            eval_dict: dict = get_json_from_answer(completion_text, Model.o4_MINI, Cardinality.ONE_TO_ONE)
+            score = sum(eval_dict.values()) / len(eval_dict)
+
+        except Exception:
+            pass
+
+        return score, gen_stats
+
+    def _default_flat_map_score_fn(self, op: LLMConvert, fields: list[str], input_record: dict, output: list[dict]) -> tuple[float | None, GenerationStats]:
+        """
+        Compute the quality for each record_op_stats object in the given record_set.
+        """
+        # create prompt factory
+        prompt_strategy = PromptStrategy.COT_QA_IMAGE if op.is_image_conversion() else PromptStrategy.COT_QA
+        factory = PromptFactory(prompt_strategy, Model.o4_MINI, Cardinality.ONE_TO_MANY) # TODO: switch to o4_MINI after merging in dev
+
+        # get the input messages; strip out the system message(s)
+        msg_kwargs = {"output_schema": op.output_schema, "project_cols": op.get_input_fields()}
+        messages = factory.create_messages(input_record, fields, **msg_kwargs)
+        input_messages = [msg for msg in messages if msg["role"] != "system"]
+        output = json.dumps(output, indent=2)
+        output_message = f"OUTPUTS:\n--------\n{output}\n\nEVALUATION: "
+        # input_str = '\n'.join(list(map(lambda d: d['content'], input_messages + [{"role": "user", "content": output_message}])))
+
+        # invoke the judge
+        score, gen_stats = None, GenerationStats()
+        try:
+            start_time = time.time()
+            validator_prompt = FLAT_MAP_IMAGE_VALIDATOR_PROMPT if op.is_image_conversion() else FLAT_MAP_VALIDATOR_PROMPT
+            val_messages = [{"role": "system", "content": validator_prompt}] + input_messages + [{"role": "user", "content": output_message}]
+            completion = litellm.completion(model="openai/o4-mini", messages=val_messages)
+            completion_text = completion.choices[0].message.content
+            gen_stats = self._get_gen_stats_from_completion(completion, start_time)
+            # print(f"INPUT:\n{input_str}")
+            # print(Fore.GREEN + f"{completion_text}\n" + Style.RESET_ALL)
+
+            # parse the evaluation
+            eval_dicts: list[dict] = get_json_from_answer(completion_text, Model.o4_MINI, Cardinality.ONE_TO_MANY)
+            all_qualities = []
+            for record_eval_dict in eval_dicts:
+                all_qualities.extend(record_eval_dict.values())
+            score = sum(all_qualities) / len(all_qualities)
+
+        except Exception:
+            pass
+
+        return score, gen_stats
+
+    def _default_filter_score_fn(self, op: LLMFilter, filter_str: str, input_record: dict, output: bool) -> tuple[float | None, GenerationStats]:
+        """
+        Compute the quality for each record_op_stats object in the given record_set.
+        """
+        score, gen_stats = None, GenerationStats()
+        filter_input_hash = hash(f"{filter_str}{hash(input_record)}")
+        label = self.filter_cache.get(filter_input_hash, None)
+        if label is None:
+            validator_op: LLMFilter = op.copy()
+            validator_op.model = Model.o4_MINI
+            try:
+                target_record_set = validator_op(input_record)
+                label = target_record_set[0].passed_operator
+                self.filter_cache[filter_input_hash] = label
+                score = label == output
+                record_op_stats = target_record_set.record_op_stats[0]
+                gen_stats = GenerationStats(
+                    model_name=self.model.value,
+                    total_input_tokens=record_op_stats.total_input_tokens,
+                    total_output_tokens=record_op_stats.total_output_tokens,
+                    total_input_cost=record_op_stats.total_input_cost,
+                    total_output_cost=record_op_stats.total_output_cost,
+                    cost_per_record=record_op_stats.cost_per_record,
+                    llm_call_duration_secs=record_op_stats.llm_call_duration_secs,
+                    fn_call_duration_secs=record_op_stats.fn_call_duration_secs,
+                    total_llm_calls=record_op_stats.total_llm_calls,
+                )
+
+            except Exception:
+                pass
+
+        else:
+            score = label == output
+
+        return score, gen_stats
+
+    def _default_join_score_fn(self, op: JoinOp, condition: str, left_input_record: DataRecord, right_input_record: DataRecord, output: bool) -> tuple[float | None, GenerationStats]:
+        score, gen_stats = None, GenerationStats()
+        join_input_hash = hash(f"{condition}{hash(left_input_record)}{hash(right_input_record)}")
+        label = self.join_cache.get(join_input_hash, None)
+        if label is None:
+            validator_op: JoinOp = op.copy()
+            validator_op.model = Model.o4_MINI
+            try:
+                target_record_set = validator_op([left_input_record], [right_input_record])
+                label = target_record_set[0].passed_operator
+                self.join_cache[join_input_hash] = label
+                score = label == output
+                record_op_stats = target_record_set.record_op_stats[0]
+                gen_stats = GenerationStats(
+                    model_name=self.model.value,
+                    total_input_tokens=record_op_stats.total_input_tokens,
+                    total_output_tokens=record_op_stats.total_output_tokens,
+                    total_input_cost=record_op_stats.total_input_cost,
+                    total_output_cost=record_op_stats.total_output_cost,
+                    cost_per_record=record_op_stats.cost_per_record,
+                    llm_call_duration_secs=record_op_stats.llm_call_duration_secs,
+                    fn_call_duration_secs=record_op_stats.fn_call_duration_secs,
+                    total_llm_calls=record_op_stats.total_llm_calls,
+                )
+
+            except Exception:
+                pass
+
+        else:
+            score = label == output
+
+        return score, gen_stats
+
+    def _default_retrieve_score_fn(self, op: RetrieveOp, fields: list[str], input_record: DataRecord, output: dict) -> tuple[float | None, GenerationStats]:
+        """
+        Compute the quality of the generated output for the given fields and input_record.
+        """
+        # TODO: retrieve k=25; score each item based on relevance; compute F1
+        # TODO: support retrieval over images
+        # create prompt factory
+        factory = PromptFactory(PromptStrategy.COT_QA, Model.o4_MINI, Cardinality.ONE_TO_ONE) # TODO: switch to o4_MINI after merging in dev
+
+        # get the input messages; strip out the system message(s)
+        msg_kwargs = {"output_schema": op.output_schema, "project_cols": op.get_input_fields()}
+        messages = factory.create_messages(input_record, fields, **msg_kwargs)
+        input_messages = [msg for msg in messages if msg["role"] != "system"]
+        output = json.dumps(output, indent=2)
+        output_message = f"OUTPUT:\n--------\n{output}\n\nEVALUATION: "
+        input_str = '\n'.join(list(map(lambda d: d['content'], input_messages + [{"role": "user", "content": output_message}])))
+
+        # invoke the judge
+        score, gen_stats = None, GenerationStats()
+        try:
+            start_time = time.time()
+            # TODO: support retrieval over images
+            validator_prompt = RETRIEVE_VALIDATOR_PROMPT
+            val_messages = [{"role": "system", "content": validator_prompt}] + input_messages + [{"role": "user", "content": output_message}]
+            completion = litellm.completion(model="openai/o4-mini", messages=val_messages)
+            completion_text = completion.choices[0].message.content
+            gen_stats = self._get_gen_stats_from_completion(completion, start_time)
+            print(f"INPUT:\n{input_str}")
+            print(Fore.GREEN + f"{completion_text}\n" + Style.RESET_ALL)
+
+            # parse the evaluation
+            eval_dict: dict = get_json_from_answer(completion_text, Model.o4_MINI, Cardinality.ONE_TO_ONE)
+            score = sum(eval_dict.values()) / len(eval_dict)
+
+        except Exception:
+            pass
+
+        return score, gen_stats
+
+
+    def _score_map(self, op: LLMConvert, fields: list[str], input_record: DataRecord, output: dict, full_hash: str) -> tuple[float | None, GenerationStats, str]:
+        try:
+            out = self.map_score_fn(fields, input_record.to_dict(), output)
+            score, gen_stats = out if isinstance(out, tuple) else (out, GenerationStats())
+            return score, gen_stats, full_hash
+        except NotImplementedError:
+            score, gen_stats = self._default_map_score_fn(op, fields, input_record, output)
+            return score, gen_stats, full_hash
+
+    def _score_flat_map(self, op: LLMConvert, fields: list[str], input_record: DataRecord, output: list[dict], full_hash: str) -> tuple[float | None, GenerationStats, str]:
+        try:
+            out = self.flat_map_score_fn(fields, input_record.to_dict(), output)
+            score, gen_stats = out if isinstance(out, tuple) else (out, GenerationStats())
+            return score, gen_stats, full_hash
+        except NotImplementedError:
+            score, gen_stats = self._default_flat_map_score_fn(op, fields, input_record, output)
+            return score, gen_stats, full_hash
+
+    def _score_filter(self, op: LLMFilter, filter_str: str, input_record: DataRecord, output: bool, full_hash: str) -> tuple[float | None, GenerationStats, str]:
+        try:
+            out = self.filter_score_fn(filter_str, input_record.to_dict(), output)
+            score, gen_stats = out if isinstance(out, tuple) else (out, GenerationStats())
+            return score, gen_stats, full_hash
+        except NotImplementedError:
+            score, gen_stats = self._default_filter_score_fn(op, filter_str, input_record, output)
+            return score, gen_stats, full_hash
+
+    def _score_join(self, op: JoinOp, condition: str, left_input_record: DataRecord, right_input_record: DataRecord, output: bool, full_hash: str) -> tuple[float | None, GenerationStats, str]:
+        try:
+            out = self.join_score_fn(condition, left_input_record.to_dict(), right_input_record.to_dict(), output)
+            score, gen_stats = out if isinstance(out, tuple) else (out, GenerationStats())
+            return score, gen_stats, full_hash
+        except NotImplementedError:
+            score, gen_stats = self._default_join_score_fn(op, condition, left_input_record, right_input_record, output)
+            return score, gen_stats, full_hash
+
+    def _score_retrieve(self, op: RetrieveOp, fields: list[str], input_record: DataRecord, output: dict, full_hash: str) -> tuple[float | None, GenerationStats, str]:
+        try:
+            out = self.retrieve_score_fn(fields, input_record.to_dict(), output)
+            score, gen_stats = out if isinstance(out, tuple) else (out, GenerationStats())
+            return score, gen_stats, full_hash
+        except NotImplementedError:
+            score, gen_stats = self._default_retrieve_score_fn(op, fields, input_record, output)
+            return score, gen_stats, full_hash

{palimpzest-0.7.20.dist-info → palimpzest-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: palimpzest
-Version: 0.7.20
+Version: 0.8.0
 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
@@ -15,12 +15,14 @@ Classifier: Programming Language :: Python :: 3.8
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: anthropic>=0.55.0
 Requires-Dist: beautifulsoup4>=4.13.4
 Requires-Dist: chromadb>=1.0.15
 Requires-Dist: colorama>=0.4.6
 Requires-Dist: datasets>=4.0.0
 Requires-Dist: fastapi~=0.115.0
 Requires-Dist: gradio>=5.26.0
+Requires-Dist: litellm>=1.73.1
 Requires-Dist: numpy==2.0.2
 Requires-Dist: openai>=1.0
 Requires-Dist: pandas>=2.1.1
@@ -37,6 +39,7 @@ Requires-Dist: requests>=2.25
 Requires-Dist: ruff>=0.9.0
 Requires-Dist: sentence-transformers==5.0.0
 Requires-Dist: setuptools>=70.1.1
+Requires-Dist: smolagents[toolkit]
 Requires-Dist: tabulate>=0.9.0
 Requires-Dist: together>=1.5.5
 Requires-Dist: tqdm~=4.66.1
@@ -46,6 +49,8 @@ Requires-Dist: mkdocs>=1.6.1; extra == "docs"
 Requires-Dist: mkdocs-material>=9.6.3; extra == "docs"
 Requires-Dist: mkdocstrings-python>=1.15.0; extra == "docs"
 Requires-Dist: mkdocs-material[imaging]; extra == "docs"
+Provides-Extra: vllm
+Requires-Dist: vllm>=0.10.1.1; extra == "vllm"
 Dynamic: license-file
 
 ![pz-banner](https://palimpzest-workloads.s3.us-east-1.amazonaws.com/palimpzest-cropped.png)

palimpzest-0.8.0.dist-info/RECORD

@@ -0,0 +1,95 @@
+palimpzest/__init__.py,sha256=1PzadDDOVMQJKNEYUH0_tw8tQKUYTT31M0vuzTr2Rqk,1694
+palimpzest/constants.py,sha256=1xGydUfkuVtaeoQ_Ku6P5PDLAelQKAVouivdXkva-zE,21109
+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
+palimpzest/agents/search_agents.py,sha256=t2QMreB5Ph71aoNk5bBtV-0l8im79z-pMAR3JDAySDw,29418
+palimpzest/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+palimpzest/core/models.py,sha256=fLO4T7x0njNeEbUpbhJm9cdnBva0y0Zw5WGBGdzdS_I,42442
+palimpzest/core/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+palimpzest/core/data/context.py,sha256=x1xYyu9qW65dvtK_XayIfv_CgsCEPW6Qe0DTiSf9sjU,16207
+palimpzest/core/data/context_manager.py,sha256=8hAKWD2jhFZgghTu7AYgjkvKDsJUPVxq8g4nG0HWvfo,6150
+palimpzest/core/data/dataset.py,sha256=vqEEMxaG157jdyzUxM_tLt5Xq_49Yq-0dVGhS0ZUiHA,27904
+palimpzest/core/data/index_dataset.py,sha256=adO67DgzHhA4lBME0-h4SjXfdz9UcNMSDGXTpUdKbgE,1929
+palimpzest/core/data/iter_dataset.py,sha256=u7eZNWWT84rH_D8LNIuq0NAnm2roX81ifKTYp-hwY7g,20512
+palimpzest/core/elements/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+palimpzest/core/elements/filters.py,sha256=fU2x0eWDwfP52_5fUmqJXTuhs4H0vvHtPZLdA3IIw8I,1642
+palimpzest/core/elements/groupbysig.py,sha256=Fcbt1GSAkxIILS5me0sWaNMLiptLJ6NIY6BIC0S-g3k,2318
+palimpzest/core/elements/records.py,sha256=Su4d8GRNp5-Q1nSWANm-jehyw53tHUl20iGluyEk8NI,19053
+palimpzest/core/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+palimpzest/core/lib/schemas.py,sha256=0qauaG3uW5tCJXNAo1i0G0UgbTaQLSLT6GoNDX8494Q,8376
+palimpzest/prompts/__init__.py,sha256=sdZbC8RWi_IGjFuzKQMdRjS2Ih4zQnkyzFoJ6Q3Ce70,1764
+palimpzest/prompts/agent_prompts.py,sha256=CUzBVLBiPSw8OShtKp4VTpQwtrNMtcMglo-IZHMvuDM,17459
+palimpzest/prompts/context_search.py,sha256=s3pti4XNRiIyiWzjVNL_NqmqEc31jzSKMF2SlN0Aaf8,357
+palimpzest/prompts/convert_prompts.py,sha256=FR_zUADuOWxMqZED4S0lyO9VNgKPNiVpSZv6ND7a0v4,6009
+palimpzest/prompts/critique_and_refine_convert_prompts.py,sha256=WoXExBxQ7twswd9VCCST26c-2ehZtpD2iQoBi7sqDnQ,7814
+palimpzest/prompts/filter_prompts.py,sha256=lYQFrpAKhOMUQDOVbRBHh7IjuUNMCmBnAqHwDuptQHI,4232
+palimpzest/prompts/join_prompts.py,sha256=viQVvOpa2l9PYM34ua_jPNZnUOU_eCTMIoabBkF5cVc,5929
+palimpzest/prompts/moa_aggregator_convert_prompts.py,sha256=BQRrtGdr53PTqvXzmFh8kfQ_w9KoKw-zTtmdo-8RFjo,2887
+palimpzest/prompts/moa_proposer_convert_prompts.py,sha256=35pxtR2hnjLkv_10VEetRR9qUCR-zD85NZF3BaAANDk,3462
+palimpzest/prompts/prompt_factory.py,sha256=FDBoVdJ_khT7t6T6WAiK6RgC7HqB3efmRkwMam3AIhM,51262
+palimpzest/prompts/split_merge_prompts.py,sha256=0mTZeJhxtvlmv-ro0KwQpxlGgSTwyUhGRHJ-uHk2Zlw,3146
+palimpzest/prompts/split_proposer_prompts.py,sha256=TBHLGaM_ycHjGHrp1JziJoJDw4S5_F4afKSAdt2McKk,2624
+palimpzest/prompts/util_phrases.py,sha256=NWrcHfjJyiOY16Jyt7R50moVnlJDyvSBZ9kBqyX2WQo,751
+palimpzest/prompts/validator.py,sha256=pJTZjlt_OiFM3IFOgsJ0jQdayra8iRVrpqENlXI9tQQ,10532
+palimpzest/query/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+palimpzest/query/execution/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+palimpzest/query/execution/all_sample_execution_strategy.py,sha256=3n2hl8m-WFWIu-a8DiSVsGkz4ej3yB7mSdFR0jsiwAU,14366
+palimpzest/query/execution/execution_strategy.py,sha256=KwBJbWOBOOPBiWRm3ypHcAQiWbCsvtW6UnVU4tHkYz8,18905
+palimpzest/query/execution/execution_strategy_type.py,sha256=vRQBPCQN5_aoyD3TLIeW3VPo15mqF-5RBvEXkENz9FE,987
+palimpzest/query/execution/mab_execution_strategy.py,sha256=LY1JlbYMsnJHCtYjaJ6iklojBqXc2B4KS62lobPFNz0,42341
+palimpzest/query/execution/parallel_execution_strategy.py,sha256=Gn5hB5XddX2jCkxx6d7O-DmitK6fbuwBFnnyKhnGYEw,15706
+palimpzest/query/execution/single_threaded_execution_strategy.py,sha256=1eo-Z9G3u92_PjoSX8HmO3D3phYgA8f0Actbgd1-oKY,16247
+palimpzest/query/generators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+palimpzest/query/generators/generators.py,sha256=pi6gTCzQYs-z93IFNGKyoskIcdYCSnOwyaj-DvSlkb4,20877
+palimpzest/query/operators/__init__.py,sha256=j-yh0P5tzXGa0JU_g8aNn54wCJDXPCMbmtOmazXXEts,3459
+palimpzest/query/operators/aggregate.py,sha256=QvWr4C1arFSZWVqPSF5F5On6Ise5OF3VVWNGSq6Gfjk,11230
+palimpzest/query/operators/compute.py,sha256=bxMKLRU_o7v603daKeR0FayDZ_V6NLI1fGzgu6E-sac,8473
+palimpzest/query/operators/convert.py,sha256=teesuAeYl20ULwm6LIA277SZremdHedD2N2GYDUjb5E,17156
+palimpzest/query/operators/critique_and_refine_convert.py,sha256=nJOQf7RLJR5Acg7fPssb0tTmtsCipG8hHu9PRquM9RE,5271
+palimpzest/query/operators/distinct.py,sha256=MuF3NlC0QMTSGs0_fe2oly0I5Ow0hfOa7h8BFGhHiCs,2594
+palimpzest/query/operators/filter.py,sha256=Wm1PaxURE1ZY5j7E1AitGdJfb_IKJoC_3qQW8aF0XC4,10703
+palimpzest/query/operators/join.py,sha256=z1bzhdazTEq1BjoUSwV6j_DQ84TJ3uaSZJpCzSP61nc,17727
+palimpzest/query/operators/limit.py,sha256=upJ775cGkxjFHRJm8GpSvtJN1cspg2FVYLN_MrIfUo4,2113
+palimpzest/query/operators/logical.py,sha256=rh3XBUVO1JAEijw9AHjU35uf5ag01-KONdpCHJXRs3M,19883
+palimpzest/query/operators/mixture_of_agents_convert.py,sha256=Y6O9-zL_6BPwl5Yix3SyYhI_68wiejOtJ3xuFcn_dbs,6731
+palimpzest/query/operators/physical.py,sha256=buPZjtP4HKNVfOCNWdBtDnRS217dSsIG74gqZ1jmoyo,8320
+palimpzest/query/operators/project.py,sha256=RX5SbHFRwHcMfiQRofIPQr-AHgIDYm68ifiFZAPu7Fo,2094
+palimpzest/query/operators/rag_convert.py,sha256=1QQGrE22-Ec3-MNbnaU3k4TGHdpi2qZqZR9MHUniEM4,10691
+palimpzest/query/operators/retrieve.py,sha256=v1FTFsSctqH4B37aWgBXYIxgOMJwRWQ2kwwXu1huwaQ,13106
+palimpzest/query/operators/scan.py,sha256=Da_EZUrArzlAameHYCmtqo-xbPOFvbTYSktrUcUEUSc,7398
+palimpzest/query/operators/search.py,sha256=xydO5Kni0RArpvLSn2ajzD4TcH442VjpP2x9NakjzaA,22842
+palimpzest/query/operators/split_convert.py,sha256=SgtkwGWnIFlQTk96NsgckRx5q15KaGpsF3Si0FzHEGo,7765
+palimpzest/query/optimizer/__init__.py,sha256=L2E1rOA-8O9oH6JL56wLI1qUVxXBLubJEG1IHMH-HU4,2384
+palimpzest/query/optimizer/cost_model.py,sha256=OldPy-TJdfsQbYRoKlb3yWeKbi15jcldTIUS6BTi9T8,12678
+palimpzest/query/optimizer/optimizer.py,sha256=mgM6c0d_voGNun2hMzqjfumJVieACtcHsNnBP4LyXAA,19626
+palimpzest/query/optimizer/optimizer_strategy.py,sha256=9YlNGkqwgX0WaV6y8tKOOHVN8kC8GjDI3DttvGW5SYY,10206
+palimpzest/query/optimizer/optimizer_strategy_type.py,sha256=V-MMHvJdnfZKoUX1xxxwh66q1RjN2FL35IsiT1C62c8,1084
+palimpzest/query/optimizer/plan.py,sha256=VIhN7tWT7EoRE9BKYa1qvvOhX7dEaM-aiobByX0qjzg,22900
+palimpzest/query/optimizer/primitives.py,sha256=jMMVq37y1tWiPU1lSSKQP9OP-mzkpSxSmUeDajRYYOQ,5445
+palimpzest/query/optimizer/rules.py,sha256=9AsuVjhiZUc0snQPNhIqeyKpmqFsSv7e-v6BEbp9CDw,43315
+palimpzest/query/optimizer/tasks.py,sha256=DJcKDNbVJox61rnTW0HgT1PtxGx2P_NiLvNroXie-Lg,29509
+palimpzest/query/processor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+palimpzest/query/processor/config.py,sha256=b_EQOqOXoRP6AziOw1iLqb8tlSWP-D1_el3mmrnBDAk,2263
+palimpzest/query/processor/query_processor.py,sha256=W01-2FocN1Jsv58gmEo5ALTIcpLt7D0dmI8kghSCdBk,6291
+palimpzest/query/processor/query_processor_factory.py,sha256=H_2pkcN_aVbNDuMLsvZP2PXARLF9MwoHGAzEWkSNNYM,7866
+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
+palimpzest/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+palimpzest/tools/allenpdf.py,sha256=fXMOmSDdSSLXDKAPYYJ8k4egtWEBf_Me9Lq9tM3iyoA,1690
+palimpzest/tools/pdfparser.py,sha256=0DOVUZLxYfqjxM8WNEfYcyiXb1qW9BWVIHEB_B_YhWA,9570
+palimpzest/tools/skema_tools.py,sha256=HXUFpjMhbVxZwKKkATeK-FwtlTCawaCbeP-uHntI1Kg,669
+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=Vlu3KIvbc4Usg4iSI2KMFSc-qcdAubWN2CSjZod2czY,2233
+palimpzest/utils/progress.py,sha256=7gucyZr82udMDZitrrkAOSKHZVljE3R2wv9nf5gA5TM,20807
+palimpzest/utils/udfs.py,sha256=LjHic54B1az-rKgNLur0wOpaz2ko_UodjLEJrazkxvY,1854
+palimpzest/validator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+palimpzest/validator/validator.py,sha256=J2tGvJqfg6v5lOQDYYaqAa9d37uVHBrqkNs-a8d1Ic0,16365
+palimpzest-0.8.0.dist-info/licenses/LICENSE,sha256=5GUlHy9lr-Py9kvV38FF1m3yy3NqM18fefuE9wkWumo,1079
+palimpzest-0.8.0.dist-info/METADATA,sha256=MUkUorsKFMVGPmCeAZOBruvKP8shJ1kbF5kulxPnSHc,7286
+palimpzest-0.8.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+palimpzest-0.8.0.dist-info/top_level.txt,sha256=raV06dJUgohefUn3ZyJS2uqp_Y76EOLA9Y2e_fxt8Ew,11
+palimpzest-0.8.0.dist-info/RECORD,,

palimpzest/core/lib/fields.py

@@ -1,141 +0,0 @@
-from __future__ import annotations
-
-
-class Field:
-    """
-    A Field is defined by its description and its type. The Field class is subclassed to specify
-    that values of the subclass should belong to a specific type.
-
-    For example, if you wanted to define Fields relevant to indexing research papers, you could define a field
-    representing the title of a paper, the year it was published, and the journal it was published in:
-
-    ```python
-    paper_title = Field(desc="The title of a scientific paper")
-    paper_year = Field(desc="The year the paper was published")
-    paper_journal = Field(desc="The name of the journal that published the paper")
-    ```
-    """
-    is_image_field = False
-
-    def __init__(self, desc: str = "") -> None:
-        self._desc = desc
-        self.type = None
-
-    def __str__(self) -> str:
-        return f"{self.__class__.__name__}(desc={self._desc})"
-
-    def __hash__(self) -> int:
-        return hash(self._desc + self.__class__.__name__)
-
-    def __eq__(self, other) -> bool:
-        return self._desc == other._desc and self.__class__ == other.__class__
-
-    @property
-    def desc(self) -> str:
-        return self._desc
-
-    def json_schema(self) -> dict:
-        return {"description": self._desc, "type": str(self.type)}
-
-
-class BooleanField(Field):
-    """A BooleanField is a Field that is True or False."""
-
-    def __init__(self, desc: str):
-        super().__init__(desc=desc)
-        self.type = bool
-
-
-class BytesField(Field):
-    """A BytesField is a Field that is definitely an array of bytes."""
-
-    def __init__(self, desc: str):
-        super().__init__(desc=desc)
-        self.type = bytes
-
-    def json_schema(self) -> dict[str, str]:
-        return {
-            "description": self._desc,
-            "type": str(self.type),
-            "contentEncoding": "base64",
-            "contentMediaType": "application/octet-stream",
-        }
-
-
-class CallableField(Field):
-    """A CallableField is a Field that stores a function."""
-
-    def __init__(self, desc: str):
-        super().__init__(desc=desc)
-        self.type = type(lambda x: x)
-
-
-class FloatField(Field):
-    """A FloatField is a Field that is definitely an integer or a float."""
-
-    def __init__(self, desc: str):
-        super().__init__(desc=desc)
-        self.type = float
-
-
-class IntField(Field):
-    """An IntField is a Field that is definitely an integer or a float."""
-
-    def __init__(self, desc: str):
-        super().__init__(desc=desc)
-        self.type = int
-
-
-class NumericField(Field):
-    """A NumericField is a Field that is definitely a number."""
-
-    def __init__(self, desc: str):
-        super().__init__(desc=desc)
-        self.type = int | float
-
-
-class StringField(Field):
-    """A StringField is a Field that is definitely a string of text."""
-
-    def __init__(self, desc: str):
-        super().__init__(desc=desc)
-        self.type = str
-
-
-class ImageFilepathField(StringField):
-    """An ImageFilepathField is a StringField that contains the filepath to an image."""
-    is_image_field = True
-
-    def __init__(self, desc: str):
-        super().__init__(desc=desc)
-
-
-class ImageURLField(StringField):
-    """An ImageURLField is a StringField that contains the publicly accessible URL for an image."""
-    is_image_field = True
-
-    def __init__(self, desc: str):
-        super().__init__(desc=desc)
-
-
-class ImageBase64Field(BytesField):
-    """An ImageBase64Field is a BytesField that contains a base64 encoded image."""
-    is_image_field = True
-
-    def __init__(self, desc: str):
-        super().__init__(desc=desc)
-
-
-### fields which are metaclasses that produce other field types ###
-class ListField(Field):
-    """A field representing a list of elements of specified types, with full list functionality."""
-
-    def __new__(cls, element_type: Field, desc: str | None = None):
-        attrs = {
-            "element_type": element_type,
-            "is_image_field": element_type.is_image_field,
-            "type": list,
-            "_desc": desc,
-        }
-
-        return type(f"List[{element_type.__name__}]", (Field,), attrs)

palimpzest/prompts/code_synthesis_prompts.py

@@ -1,28 +0,0 @@
-### CODE SYNTHESIS PROMPTS ###
-EXAMPLE_PROMPT = """Example{idx}:
-Example Input
--------------
-{example_inputs}
-
-Example Output
---------------
-{example_output}
-"""
-
-CODEGEN_PROMPT = """You are a helpful programming assistant and an expert {language} programmer. Implement the {language} function `{api}` that extracts `{output}` ({output_desc}) from given inputs:
-{inputs_desc}
-{examples_desc}
-Notice that the evaluation will severely punish incorrect outputs. Thus, when the function is uncertain, it should return `None` to abstain instead of returning an incorrect guess.
-{advice}
-Return the implementation only."""
-
-ADVICEGEN_PROMPT = """You are a helpful programming assistant and an expert {language} programmer. Your job is to provide programming ideas to help me write {language} programs.
-For example, if I want to complete a task: "extract the salary number (in USD) from a given employee's document", you can provide me with {n} different ways to do it like:
-Idea 1: Use regular expressions to extract the salary number: a number with a dollar sign in front of it. For example, $100,000.
-Idea 2: Find the table entry with the salary number.
-Idea 3: Use a pre-trained NLP model to extract the salary number.
-# 
-Now, consider the following {language} programming task that extracts `{output}` ({output_desc}) from given inputs:
-{examples_desc}
-Please provide me with {n} different ideas to complete this task. Return the ideas only, following the format above.
-"""