promptlearn 0.1.0__py3-none-any.whl

promptlearn/__init__.py

@@ -0,0 +1,5 @@
+from .classifier import PromptClassifier
+from .regressor import PromptRegressor
+from .version import __version__
+
+__all__ = ["PromptClassifier", "PromptRegressor"]

promptlearn/base.py

@@ -0,0 +1,130 @@
+import os
+import openai
+import logging
+from typing import List, Union
+from io import StringIO
+import numpy as np
+import pandas as pd
+import warnings
+
+from sklearn.base import BaseEstimator
+from sklearn.utils.validation import check_X_y
+
+
+class BasePromptEstimator(BaseEstimator):
+    model: str
+    prompt_template: str
+    verbose: bool
+    feature_names_in_: List[str]
+    heuristic_: str
+    target_name_: str
+
+    def __init__(self, model: str, prompt_template: str, verbose: bool = False):
+        self.model = model
+        self.prompt_template = prompt_template
+        self.verbose = verbose
+
+        openai.api_key = os.getenv("OPENAI_API_KEY")
+        self.llm_client = openai.OpenAI()
+
+    def _get_feature_names(self, X: Union[np.ndarray, pd.DataFrame]) -> List[str]:
+        return X.columns.tolist() if isinstance(X, pd.DataFrame) else [f"x{i+1}" for i in range(X.shape[1])]
+
+    def _get_target_name(self, y: Union[np.ndarray, pd.Series]) -> str:
+        return str(y.name) if isinstance(y, pd.Series) and y.name else "target"
+
+    def _format_training_data(self, X: np.ndarray, y: Union[np.ndarray, List], feature_names: List[str], target_name: str) -> str:
+        rows = ["\t".join(feature_names + [target_name])]
+        for xi, yi in zip(X, y):
+            row = list(map(str, xi)) + [str(yi)]
+            rows.append("\t".join(row))
+        return "\n".join(rows)
+
+    def _format_features(self, x: Union[np.ndarray, pd.Series]) -> str:
+        if isinstance(x, pd.Series):
+            return ", ".join(
+                f"{k}={v:.3f}" if isinstance(v, (int, float)) else f"{k}='{v}'"
+                for k, v in x.items()
+            )
+        else:
+            return ", ".join(
+                f"{name}={value:.3f}" if isinstance(value, (int, float)) else f"{name}='{value}'"
+                for name, value in zip(self.feature_names_in_, x)
+            )
+
+    def _call_llm(self, prompt: str) -> str:
+        if self.verbose:
+            logging.debug(f"LLM prompt:\n{prompt}")
+        try:
+            response = self.llm_client.chat.completions.create(
+                model=self.model,
+                messages=[{"role": "user", "content": prompt}]
+            )
+            result = (response.choices[0].message.content or "").strip()
+
+            if self.verbose:
+                logging.info(f"LLM result: {result}")
+            return result
+        except Exception as e:
+            raise RuntimeError(f"LLM call failed: {e}")
+
+    def _fit_common(self, X, y) -> None:
+        if not isinstance(X, pd.DataFrame):
+            X, y = check_X_y(X, y)
+
+        self.feature_names_in_ = self._get_feature_names(X)
+        self.target_name_ = self._get_target_name(y)
+        X_values = X.values if isinstance(X, pd.DataFrame) else X
+
+        formatted_data = self._format_training_data(X_values, y, self.feature_names_in_, self.target_name_)
+        self.training_prompt_ = self.prompt_template.format(data=formatted_data)
+        self.heuristic_ = self._call_llm(self.training_prompt_)
+
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        # Remove non-pickleable objects
+        if "llm_client" in state:
+            del state["llm_client"]
+        return state
+
+    def __setstate__(self, state):
+        self.__dict__.update(state)
+        api_key = os.getenv("OPENAI_API_KEY")
+
+        if not api_key:
+            warnings.warn(
+                "OPENAI_API_KEY is not set. "
+                "This PromptEstimator cannot make predictions until the key is available.",
+                RuntimeWarning
+            )
+
+        openai.api_key = api_key
+        self.llm_client = openai.OpenAI()
+
+    def _parse_tsv(self, tsv: str) -> pd.DataFrame:
+        """Parse tab-separated values (TSV) into a pandas DataFrame."""
+        try:
+            # Clean common LLM output artifacts
+            tsv_cleaned = tsv.strip().replace("```", "").strip()
+
+            # Use StringIO to treat the string like a file
+            df = pd.read_csv(StringIO(tsv_cleaned), sep="\t")
+
+            # Optionally: strip whitespace from column names
+            df.columns = df.columns.str.strip()
+
+            return df
+
+        except Exception as e:
+            raise ValueError(f"Failed to parse TSV output:\n{tsv}\nError: {e}")
+
+    def sample(self, n: int = 5) -> pd.DataFrame:
+        """Generate n synthetic examples that illustrate the heuristic."""
+        prompt = (
+            f"{self.heuristic_}\n\n"
+            f"Please generate {n} example rows in tabular format with the following columns:\n"
+            f"{', '.join(self.feature_names_in_ + [self.target_name_])}.\n"
+            f"Use tab-separated format. Do not explain."
+        )
+        text = self._call_llm(prompt)
+        return self._parse_tsv(text)

promptlearn/classifier.py

@@ -0,0 +1,142 @@
+from typing import Optional, List
+import re
+import pandas as pd
+from sklearn.base import ClassifierMixin
+from sklearn.metrics import accuracy_score
+from sklearn.utils.validation import check_array
+from .base import BasePromptEstimator
+from tqdm import tqdm
+
+DEFAULT_PROMPT_TEMPLATE = """\\
+You are a seasoned data scientist tasked with building a classification prompt for an LLM.
+
+Treat the data as a sample of a much larger problem domain, so don't just memorize the data as-is. Try to minimize prediction error, not just describe dominant patterns. Include exceptions and counterexamples in your logic.
+
+Look at the name of the target column and figure out its meaning. It the input features seem to be text or text entities, it is OK to output a prompt that will ask the LLM to reason by itself what the target value could be, but it should always result in an integer value (if it's a boolean then True=1 and False=0).
+
+Conduct an analysis based on the following data, and output only the final trained classifier (like a decision tree, human-readable instructions, etc) that will be conveyed in the form of an LLM prompt to another system. The rules will be executed as given so you need to have all the weights, equations, thresholds, etc in your output. The classifier should be able to accurately predict the value (class) of the last column based on the data in the other columns.
+
+If you find that a single rule is too broad, break it down into more specific cases to reduce false positives and false negatives.
+
+Note that if you can predict the target value using your own logic or built-in knowledge, output a text prompt that will direct the prediction LLM to do so.
+
+Data:
+{data}
+"""
+
+class PromptClassifier(BasePromptEstimator, ClassifierMixin):
+    def __init__(self, model: str = "o4-mini", prompt_template: Optional[str] = None,
+                 verbose: bool = False, chunk_threshold: int = 300,
+                 force_chunking: bool = False, max_chunks: Optional[int] = None):
+        super().__init__(model, prompt_template or DEFAULT_PROMPT_TEMPLATE, verbose)
+        self.chunk_threshold = chunk_threshold
+        self.force_chunking = force_chunking
+        self.max_chunks = max_chunks
+        self.heuristic_history_: List[str] = []
+
+    def _normalize_target_values(self, y):
+        values = pd.Series(y)
+        classes = sorted(values.unique())
+        self.allowed_classes_ = list(map(int, classes))
+        return values.astype(int)
+
+    def _instruction_suffix(self) -> str:
+        class_str = ", ".join(str(c) for c in self.allowed_classes_)
+        return (
+            f"Use only numeric values when predicting {self.target_name_}.\n"
+            f"For example: predict {class_str}.\n"
+            f"Respond only with one of: {class_str}."
+        )
+
+    def fit(self, X, y) -> "PromptClassifier":
+        self.target_name_ = self._get_target_name(y)
+        y = self._normalize_target_values(y)
+        if self.force_chunking or (isinstance(X, pd.DataFrame) and len(X) > self.chunk_threshold):
+            if self.verbose:
+                print(f"🌀 Switching to chunked fit: {len(X)} rows > threshold {self.chunk_threshold}")
+            return self.fit_chunked(X, y, max_chunks=self.max_chunks)
+        self._fit_common(X, y)
+        print(f"🧠 Final heuristic:\n{self.heuristic_}")
+        return self
+
+    def fit_chunked(self, X, y, chunk_size: int = 100, max_chunks: Optional[int] = None) -> "PromptClassifier":
+        if not isinstance(X, pd.DataFrame):
+            raise ValueError("fit_chunked requires a pandas DataFrame for X")
+
+        df = X.copy()
+        df[self.target_name_] = y.values if hasattr(y, "values") else y
+
+        total_rows = len(df)
+        num_chunks = (total_rows - 1) // chunk_size + 1
+        if max_chunks:
+            num_chunks = min(num_chunks, max_chunks)
+
+        scratchpad = ""
+
+        for i in tqdm(range(num_chunks), desc="🧠 Chunked training"):
+            chunk = df.iloc[i * chunk_size : (i + 1) * chunk_size]
+            chunk_csv = chunk.to_csv(index=False)
+
+            prompt = f"""You are analyzing a large dataset in sequential windows.
+
+This is the current window (rows {i * chunk_size} to {(i + 1) * chunk_size - 1}):
+
+{chunk_csv}
+
+Your current scratchpad (classifier-in-progress):
+
+{scratchpad}
+
+Update the classifier description based on this window. Use rules, thresholds, decision structures, or conditions.
+Do not output predictions for this window. Instead, revise the general classifier logic.
+Respond only with the full classifier description in plain text. The classifier should always output an integer value for each possible path (no string returns).
+"""
+
+            scratchpad = self._call_llm(prompt)
+            self.heuristic_history_.append(scratchpad)
+            if self.verbose:
+                print(f"🧠 Updated heuristic after chunk {i + 1}:\n{scratchpad}\n")
+
+        print(f"🧠 Final heuristic:\n{scratchpad}")
+        self.heuristic_ = scratchpad
+        return self
+
+    def _predict_one(self, x) -> int:
+        feature_string = self._format_features(x)
+        prompt = (
+            self.heuristic_ + "\n\n"
+            f"Given: {feature_string}\n"
+            f"What is the predicted {self.target_name_}?\n"
+            f"{self._instruction_suffix()}"
+        )
+        response = self._call_llm(prompt).strip()
+
+        # Try parsing directly
+        try:
+            return int(response)
+        except ValueError:
+            # Try regex extraction
+            match = re.search(r"\b(\d+)\b", response)
+            if match:
+                return int(match.group(1))
+
+        # If both fail, raise a clear error
+        raise ValueError(f"⚠️ Could not parse numeric prediction from LLM response: {response}")
+
+    def predict(self, X) -> List[int]:
+        if isinstance(X, pd.DataFrame):
+            return [self._predict_one(row) for _, row in tqdm(X.iterrows(), total=len(X), desc="🔮 Predicting")]
+        else:
+            X_checked = check_array(X)
+            return [self._predict_one(x) for x in tqdm(X_checked, desc="🔮 Predicting")]
+
+    def score(self, X, y, sample_weight=None) -> float:
+        y_pred = self.predict(X)
+        return float(accuracy_score(y, y_pred, sample_weight=sample_weight))
+
+    def show_heuristic_evolution(self):
+        print("🧠 Heuristic Evolution:\n")
+        for i, h in enumerate(self.heuristic_history_):
+            print(f"--- After chunk {i+1} ---")
+            print(h.strip())
+            print()

promptlearn/regressor.py

@@ -0,0 +1,79 @@
+from typing import Optional, List
+import numpy as np
+import pandas as pd
+import re
+from sklearn.base import RegressorMixin
+from sklearn.metrics import mean_squared_error
+from sklearn.utils.validation import check_array
+from .base import BasePromptEstimator
+from tqdm import tqdm
+
+DEFAULT_PROMPT_TEMPLATE = """\
+Analyze the following data and output only the final trained regression function (e.g., a linear or nonlinear equation) that best fits the data. The data has one of more features as input and the last column is the target value.
+
+Consider if there are known Laws of Physics or well-established relationships to the target variable and use these to inform or completely determine the output.
+
+The function will be evaluated by an LLM, so just have an equation with the names of the variables in the dataset. 
+
+Your answer should not include explanations, only the final equation. Use ascii characters only.
+
+Data:
+{data}
+"""
+
+
+class PromptRegressor(BasePromptEstimator, RegressorMixin):
+    def __init__(self, model: str = "o4-mini", prompt_template: Optional[str] = None, verbose: bool = False):
+        super().__init__(model, prompt_template or DEFAULT_PROMPT_TEMPLATE, verbose)
+        self.failed_predictions_: List[tuple] = []
+        self.explanation_: Optional[str] = None
+
+    def fit(self, X, y) -> "PromptRegressor":
+        print("🔧 Fitting PromptRegressor...")
+        self._fit_common(X, y)
+        self.explanation_ = self.heuristic_
+        print("\n📜 Final regression function:")
+        print(self.heuristic_)
+        return self
+
+    def _predict_one(self, x) -> float:
+        feature_string = self._format_features(x)
+        prompt = (
+            f"Given: {feature_string}\n"
+            f"Answer this question: What is the predicted {self.target_name_}?\n"
+            f"Use the following heuristic to calculate it: {self.heuristic_}\n"
+            "Respond only with a single number like 13.2 — no units, no formula, no explanation."
+        )
+        print(prompt)
+        raw = self._call_llm(prompt)
+
+        match = re.search(r"-?\d+(\.\d+)?", raw)
+        if match:
+            try:
+                result = float(match.group())
+                print(f"Predicted: {result}")
+                return result
+            except ValueError:
+                pass
+
+        print("⚠️ Non-numeric LLM response:\n", raw)
+        self.failed_predictions_.append((feature_string, raw))
+        return np.nan
+
+    def predict(self, X) -> List[float]:
+        if isinstance(X, pd.DataFrame):
+            return [self._predict_one(row) for _, row in tqdm(X.iterrows(), total=len(X), desc="🔮 Predicting")]
+        else:
+            X_checked = check_array(X)
+            return [self._predict_one(x) for x in tqdm(X_checked, desc="🔮 Predicting")]
+
+    def score(self, X, y, sample_weight=None) -> float:
+        y_pred = self.predict(X)
+        y_pred = np.array(y_pred)
+        y_true = np.array(y)
+
+        mask = ~np.isnan(y_pred)
+        if mask.sum() == 0:
+            raise ValueError("All predictions were NaN — check LLM output or prompt format.")
+
+        return -mean_squared_error(y_true[mask], y_pred[mask], sample_weight=sample_weight)

promptlearn/version.py

@@ -0,0 +1,2 @@
+# promptlearn/version.py
+__version__ = "0.1.0"

promptlearn-0.1.0.dist-info/METADATA

@@ -0,0 +1,223 @@
+Metadata-Version: 2.4
+Name: promptlearn
+Version: 0.1.0
+Summary: LLM-powered estimators for scikit-learn pipelines
+Home-page: https://github.com/frlinaker/promptlearn
+Author: Fredrik Linaker
+Author-email: fredrik.linaker@gmail.com
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: scikit-learn
+Requires-Dist: openai
+Requires-Dist: pandas
+Requires-Dist: numpy
+Requires-Dist: joblib
+Requires-Dist: tqdm
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+
+# ⚡️ promptlearn
+
+**promptlearn** brings large language models into your scikit-learn workflow.  
+It replaces traditional estimators with language-native reasoning systems that learn, adapt, and describe patterns using natural language as the model substrate.
+
+---
+
+### 📊 Outperforming Traditional Models with Built-In Knowledge
+
+`promptlearn` allows LLMs to internalize both structure and semantics during training. As a result, the models often exceed the capabilities of classical estimators when the task requires reasoning, real-world knowledge, or symbolic understanding.
+
+Consider a simple binary classification task: predicting whether an [animal is a mammal](examples/data/mammal_train.csv) based on its name, weight, and lifespan.
+
+Traditional models depend solely on the input features. But `promptlearn` models can use their internal understanding of zoology to form highly accurate rules. Even when a label like `"Whale"` is never seen during training, the model knows it belongs to the mammal class.
+
+| Model                 | Accuracy |
+|-----------------------|----------|
+| `promptlearn-o4-mini` | **1.00** |
+| `promptlearn-gpt-4o`  | 0.97     |
+| `logistic_regression`| 0.60     |
+| `random_forest`       | 0.46     |
+| `dummy`               | 0.34     |
+
+This type of semantic generalization is a powerful advantage for LLM-backed models.
+
+---
+
+Now compare performance on a regression task where the data contains samples of objects falling from different heights, under different gravity. This is a classic physics problem, with a well-known equation:
+
+```
+fall_time_s = sqrt((2 * height_m) / gravity_mps2)
+```
+
+Recent `promptlearn` estimators are able to recover this exact formula and use it to generate near-perfect predictions:
+
+| Model                  | MSE       |
+|------------------------|-----------|
+| `promptlearn-o4-mini`  | **0.00006** |
+| `promptlearn-gpt-4o`   | 0.00006   |
+| `gradient_boosting`    | 0.035     |
+| `linear_regression`    | 0.498     |
+| `dummy`                | 5.27      |
+| `promptlearn-gpt-4`    | 43.17     |
+
+No feature engineering was performed. No physics constants were added. The model discovered the rule and applied it directly. Classical regressors, by contrast, approximated a curve but missed the exact structure.
+
+These results highlight the practical benefit of reasoning models: they learn compact, expressive heuristics and can outperform traditional systems when symbolic insight or background knowledge is essential.
+
+---
+
+### 🤖 Estimators Powered by Language
+
+`promptlearn` provides scikit-learn-compatible estimators that use LLMs as the modeling engine:
+
+- **`PromptClassifier`** – for predicting classes through generalized reasoning
+- **`PromptRegressor`** – for modeling numeric relationships in data
+
+These estimators follow the same API as other `scikit-learn` models (`fit`, `predict`, `score`) but operate via dynamic prompt construction and few-shot abstraction.
+
+---
+
+### 📘 What it Learns: The Heuristic
+
+When you call `.fit()`, the LLM reviews your data and writes out an internal heuristic — a compact representation of what it has inferred. This heuristic might describe:
+
+- A relationship between age, hours worked, and income
+- How education, gender, and occupation relate to survival rates
+- Why one row differs from another
+
+The result is a plain-text model. It is readable, portable, and expressive. This is stored in `.heuristic_`, and it powers all predictions.
+
+---
+
+### 🧠 Language-Aware Reasoning
+
+Because the models are backed by LLMs, they can reason across both structure and semantics:
+
+- Names of columns matter
+- Missing data can be explained or inferred
+- World knowledge is available by default
+
+A trained model might use context like:
+
+> “Bachelors” typically correlates with medium income  
+> “Private” workclass often means lower capital gain  
+> Rows with missing `native-country` likely default to “United States”
+
+This allows reasoning across incomplete, skewed, or lightly structured data without hand-tuning features.
+
+---
+
+### 🧬 Background Knowledge Included
+
+The LLM brings its internal knowledge graph to the modeling task. For instance:
+
+```
+Input: country = "Norway"
+Output: has_blue_in_flag = 1
+```
+
+Even if there is no signal in the data, the model may still predict correctly by referencing background information. This creates a kind of ambient “web join” during training and inference.
+
+---
+
+### 🕳 Zero-Example Learning
+
+If you call `.fit()` with no rows — just column names — `promptlearn` will still return a working model.
+
+This is possible because the LLM can hallucinate a plausible mapping based on:
+
+- Column names
+- Prior knowledge
+- Type hints or value patterns
+
+This makes rapid prototyping and conceptual modeling trivial.
+
+---
+
+### 🧠 Scaling with Chunked Training
+
+To support large datasets, `promptlearn` uses a sliding window training mechanism.
+
+During `.fit()`:
+- The dataset is processed in batches (“chunks”)
+- The current heuristic is passed forward like a scratchpad
+- Each chunk contributes feedback and refinement
+- The model evolves with each window
+
+This allows training on limitless rows using a fixed memory budget. The process is transparent. If the dataset is large, chunked training activates automatically.
+
+---
+
+### 🧪 Native `.sample()` Support
+
+You can generate synthetic rows directly from any trained model using `.sample(n)`:
+
+```
+>>> model.sample(3)
+fruit    is_citrus
+Lime     1
+Banana   0
+Orange   1
+```
+
+This is useful for:
+
+- Understanding what the model believes
+- Creating test sets or bootstrapped data
+- Building readable examples from internal logic
+
+---
+
+### 💾 Save and Reload with `joblib`
+
+Like any scikit-learn model, `promptlearn` estimators can be serialized:
+
+```python
+import joblib
+
+joblib.dump(model, "model.joblib")
+model = joblib.load("model.joblib")
+```
+
+The LLM client is excluded from the saved file and re-initialized on load. The heuristic remains intact, interpretable, and ready to use.
+
+---
+
+## 📚 Related Work
+
+### Scikit-LLM
+
+[Scikit-LLM](https://github.com/BeastByteAI/scikit-llm) provides zero- and few-shot classification through template-based prompting.  
+It is lightweight and NLP-focused.
+
+**promptlearn** offers a broader modeling philosophy:
+
+| Capability                  | Scikit-LLM         | promptlearn                |
+|-----------------------------|--------------------|----------------------------|
+| Prompt generated during fit | ❌ No               | ✅ Yes                     |
+| Regression support          | ❌ No               | ✅ Yes                     |
+| Produces textual heuristics | ❌ No               | ✅ Yes                     |
+| Works on tabular data       | ✅ Partial          | ✅ Full                    |
+| Generates sample rows       | ❌ No               | ✅ `.sample()`             |
+
+---
+
+## 📁 License
+
+MIT © 2025 Fredrik Linaker

promptlearn-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+promptlearn/__init__.py,sha256=MEwDOUKS-eT2qTeJXvs79OykaCVj4nq8TKwwCM--zAY,169
+promptlearn/base.py,sha256=M5NOlqNw_-_YsgEo3TrF1MlYo0fJYnlzRZs4xPlXTbk,4885
+promptlearn/classifier.py,sha256=EiuMHdXAIKPVB9LODyc0u_Zh6NEbCBmm9v5v5DEP0v8,6643
+promptlearn/regressor.py,sha256=pQWmtlJjuVaSIyvwc-_XTYHd1BgjtfUQANUpH3R-DKA,3272
+promptlearn/version.py,sha256=3MtN4yLt02e1-GxJiwHyA3zL1tcu_6CWpXKHAD1zLAI,49
+promptlearn-0.1.0.dist-info/licenses/LICENSE,sha256=wem7QBzjXI8wmdMKsM3ndt4O2Lpa59rOpQcylMoWVc8,1101
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/test_classifier.py,sha256=11apdCumJ5DSZPEk0RFpW9SAB1rmwokd0FzNncrQUwM,1254
+tests/test_regressor.py,sha256=ncJtxGNfUNR8oivvqacwjsNhCimwl-5OOloiB4g_kRM,353
+promptlearn-0.1.0.dist-info/METADATA,sha256=ovVNkZk8TRL71ImEwbfBQ6tGeO4EINQYZ2pvcJxSkLE,8084
+promptlearn-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+promptlearn-0.1.0.dist-info/top_level.txt,sha256=ddd47vS9AWtb98x34_g8I04FSHN5HH9Yk9S-Wt1d-Ak,18
+promptlearn-0.1.0.dist-info/RECORD,,

promptlearn-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

promptlearn-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Fredrik Linaker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

promptlearn-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+promptlearn
+tests

tests/test_classifier.py

@@ -0,0 +1,39 @@
+import joblib
+import pandas as pd
+from promptlearn import PromptClassifier
+
+def test_zero_row_classifier_runs():
+    X = pd.DataFrame(columns=["country_name"])
+    y = pd.Series(name="has_blue_in_flag", dtype=int)
+
+    clf = PromptClassifier(verbose=False)
+    clf.fit(X, y)
+
+    result = clf.predict(pd.DataFrame([{"country_name": "France"}]))
+    assert isinstance(result[0], int)
+
+def test_promptclassifier_joblib_roundtrip(tmp_path):
+    # Define a minimal "trained" classifier manually
+    clf = PromptClassifier(model="o4-mini", verbose=False)
+    clf.feature_names_in_ = ["name"]
+    clf.target_name_ = "is_animal"
+    clf.heuristic_ = "IF name in {cat, dog, tiger} THEN is_animal = 1 ELSE 0"
+
+    # Save to disk
+    model_path = tmp_path / "clf.joblib"
+    joblib.dump(clf, model_path)
+
+    # Load it back
+    loaded = joblib.load(model_path)
+
+    # Confirm state round-tripped
+    assert loaded.model == "o4-mini"
+    assert loaded.target_name_ == "is_animal"
+    assert loaded.heuristic_.startswith("IF name")
+
+    # Run prediction
+    X = pd.DataFrame([{"name": "cat"}, {"name": "car"}])
+    preds = loaded.predict(X)
+
+    assert isinstance(preds, list)
+    assert all(isinstance(p, int) for p in preds)

tests/test_regressor.py

@@ -0,0 +1,12 @@
+import pandas as pd
+from promptlearn import PromptRegressor
+
+def test_zero_row_regressor_runs():
+    X = pd.DataFrame(columns=["length"])
+    y = pd.Series(name="mass", dtype=float)
+
+    reg = PromptRegressor(verbose=False)
+    reg.fit(X, y)
+
+    result = reg.predict(pd.DataFrame([{"length": 2.5}]))
+    assert isinstance(result[0], float)