dpst 0.1.0__py3-none-any.whl

dpst/__init__.py

@@ -0,0 +1,5 @@
+from .core import DPST
+
+__all__ = ["DPST"]
+
+__version__ = "0.1.0"

dpst/cli.py

@@ -0,0 +1,27 @@
+# src/dpst/cli.py
+import sys
+import argparse
+from dpst.setup_db import initialize_database, run_clustering_and_indexing
+
+def main():
+    parser = argparse.ArgumentParser(description="DPST Package Management Utility")
+    subparsers = parser.add_subparsers(dest="command")
+    
+    subparsers.add_parser("setup", help="Initialize Weaviate DB, download FineWeb, and generate cluster JSON metadata files.")
+    
+    args = parser.parse_args()
+    
+    if args.command == "setup":
+        print("--- Starting DPST Setup Process ---")
+        try:
+            initialize_database()
+            run_clustering_and_indexing()
+            print("--- Setup Successful! You can now use DPST ---")
+        except Exception as e:
+            print(f"Setup failed with error: {e}", file=sys.stderr)
+            sys.exit(1)
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()

dpst/core.py

@@ -0,0 +1,277 @@
+import os
+import json
+from collections import defaultdict
+from functools import partial
+import importlib.resources as pkg_resources
+
+import numpy as np
+import torch
+from torch.nn import CrossEntropyLoss
+from tqdm.auto import tqdm
+from datasketch import MinHash, MinHashLSH
+from nltk import ngrams
+
+import weaviate
+from weaviate.classes.query import MetadataQuery, Filter
+
+from transformers import AutoModel, AutoTokenizer, AutoModelForCausalLM, pipeline
+from sentence_transformers import util
+from openie import StanfordOpenIE
+
+os.environ["PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION"] = "python"
+
+class DPST:
+    def __init__(self, mode: str, hf_token: str = None, model_checkpoint: str = "meta-llama/Llama-3.2-1B-Instruct"):
+        """
+        DPST Runtime Engine. Assumes that `dpst setup` has already been executed
+        to spin up the Weaviate collections and generate the local data clusters.
+        """
+        print("Initializing DPST Runtime...", flush=True)
+
+        mode_map = {
+            "50k": "fiftyk",
+            "100k": "hundredk",
+            "200k": "twohundredk"
+        }
+
+        if mode not in mode_map:
+            raise ValueError("Error: [MODE] must be one of [50k, 100k, 200k].")
+        
+        self.mode = mode_map[mode]
+
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+
+        try:
+            data_package = pkg_resources.files("dpst.data")
+            
+            with open(data_package / f"{mode}.json", 'r') as f:
+                self.centroids = torch.tensor(json.load(f)).to(self.device)
+
+            with open(data_package / f"{mode}_counts.json", 'r') as f:
+                self.cluster_counts = json.load(f)
+        except FileNotFoundError:
+            raise RuntimeError(
+                f"Cluster data files for mode '{mode}' were not found. "
+                "Please run `dpst setup` in your terminal to initialize database assets before using the runtime."
+            )
+
+        self.client = weaviate.connect_to_local()
+        try:
+            self.collection = self.client.collections.get("Triples")
+        except Exception:
+            self.client.close()
+            raise RuntimeError(
+                "The Weaviate collection 'Triples' does not exist. "
+                "Ensure your local Weaviate instance is running and you have executed `dpst setup`."
+            )
+
+        self.properties = {
+            "openie.affinity_probability_cap": 2 / 3,
+            "openie.triple.strict": False,
+        }
+        self.IEclient = StanfordOpenIE(properties=self.properties)
+
+        self.model_checkpoint = model_checkpoint
+        self.model = AutoModel.from_pretrained("jinaai/jina-embeddings-v3", trust_remote_code=True).to(self.device)
+
+        self.gen_model = AutoModelForCausalLM.from_pretrained(self.model_checkpoint, token=hf_token, device_map=self.device)
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_checkpoint, token=hf_token)
+        
+        self.pipe = pipeline(
+            "text-generation",
+            model=self.gen_model,
+            tokenizer=self.tokenizer,
+            torch_dtype=torch.bfloat16,
+            device_map="auto",
+        )
+
+        self.ppl_model = AutoModelForCausalLM.from_pretrained("gpt2").to(self.device)
+        self.ppl_tokenizer = AutoTokenizer.from_pretrained("gpt2")
+
+        print("Initialization Finished.", flush=True)   
+
+    def cleanup(self):
+        if hasattr(self, 'client') and self.client:
+            self.client.close()
+
+    def exponential(self, candidates, epsilon, sensitivity=1):
+        probabilities = [np.exp(epsilon * x[1] / (2 * sensitivity)) for x in candidates]
+        probabilities = probabilities / np.linalg.norm(probabilities, ord=1)
+        return np.random.choice([x[0] for x in candidates], 1, p=probabilities)[0]
+
+    def query_db(self, vector, cluster):
+        response = self.collection.query.near_vector(
+            near_vector=vector, 
+            limit=self.cluster_counts[cluster], 
+            filters=Filter.by_property(self.mode).equal(cluster), 
+            return_metadata=MetadataQuery(distance=True)
+        )
+        candidates = [(x.properties["text"], max(1 - x.metadata.distance, 0)) for x in response.objects]
+        return candidates
+
+    def get_prompt(self, triples, messages=True):
+        PROMPT = [
+            {"role": "system", "content": "Generate a concise text for the given set of triples. Ensure that the generated output only includes the provided information from the triples, but feel free to fill in the gaps where sensible. If necessary, ignore triples that do not fit into the larger context. It is very important that the output is grammatically correct, natural, and logical. Provide a text that captures the semantic meaning of the triples, without being too verbose or lengthy. Do not provide any further explanation, only provide the output text."},
+            {"role": "user", "content": "Input triples: [{’object’: ’Mike_Mularkey’,’property’: ’coach’,’subject’: ’Tennessee_Titans’}]"},
+            {"role": "assistant", "content": "Output text: Mike Mularkey is the coach of the Tennessee Titans."},
+            {"role": "user", "content": "Input triples: [{’object’: ’Albert_E._Austin’, ’property’: ’successor’, ’subject’: ’Alfred_N._Phillips’}, {’object’: ’Connecticut’, ’property’: ’birthPlace’, ’subject’: ’Alfred_N._Phillips’}, {’object’: ’United_States_House_of_Representatives’, ’property’: ’office’, ’subject’: ’Alfred_N._Phillips’}]"},
+            {"role": "assistant", "content": "Output text: Albert E. Austin succeeded Alfred N. Phillips who was born in Connecticut and worked at the United States House of Representatives."},
+            {"role": "user", "content": "Input triples: [{’object’: ’College_of_William_&_Mary’, ’property’: ’owner’, ’subject’: ’Alan_B._Miller_Hall’}, {’object’: ’2009-06-01’, ’property’: ’completionDate’, ’subject’: ’Alan_B._Miller_Hall’}, {’object’: ’101 Ukrop Way’, ’property’: ’address’, ’subject’: ’Alan_B._Miller_Hall’}, {’object’: ’Williamsburg,_Virginia’, ’property’: ’location’, ’subject’: ’Alan_B._Miller_Hall’}, {’object’: ’Robert_A._M._Stern’, ’property’: ’architect’, ’subject’: ’Alan_B._Miller_Hall’}]"},
+            {"role": "assistant", "content": "Output text: The Alan B Miller Hall’s location is 101 Ukrop Way, Williamsburg, Virginia. It was designed by Robert A.M. Stern and was completed on 1 June 2009. Its owner is the College of William and Mary."},
+            {"role": "user", "content": "Input Triples: {}".format(str(triples))}
+        ]
+        return PROMPT
+    
+    def compute_ppl(self, predictions, batch_size: int = 16, add_start_token: bool = True, max_length=32):
+        if self.ppl_tokenizer.pad_token is None and batch_size > 1:
+            existing_special_tokens = list(self.ppl_tokenizer.special_tokens_map_extended.values())
+            assert len(existing_special_tokens) > 0, "Model must have at least one special token to use for padding."
+            self.ppl_tokenizer.add_special_tokens({"pad_token": existing_special_tokens[0]})
+
+        max_tokenized_len = max_length - 1 if (add_start_token and max_length) else max_length
+
+        encodings = self.ppl_tokenizer(
+            predictions,
+            add_special_tokens=False,
+            padding=True,
+            truncation=True if max_tokenized_len else False,
+            max_length=max_tokenized_len,
+            return_tensors="pt",
+            return_attention_mask=True,
+        ).to(self.device)
+
+        encoded_texts = encodings["input_ids"]
+        attn_masks = encodings["attention_mask"]
+
+        if add_start_token:
+            assert torch.all(torch.ge(attn_masks.sum(1), 1)), "Each input text must be at least one token long."
+        else:
+            assert torch.all(torch.ge(attn_masks.sum(1), 2)), "Each input text must be at least two tokens long."
+
+        ppls = []
+        loss_fct = CrossEntropyLoss(reduction="none")
+
+        for start_index in range(0, len(encoded_texts), batch_size):
+            end_index = min(start_index + batch_size, len(encoded_texts))
+            encoded_batch = encoded_texts[start_index:end_index]
+            attn_mask = attn_masks[start_index:end_index]
+
+            if add_start_token:
+                bos_tokens_tensor = torch.tensor([[self.ppl_tokenizer.bos_token_id]] * encoded_batch.size(dim=0)).to(self.device)
+                encoded_batch = torch.cat([bos_tokens_tensor, encoded_batch], dim=1)
+                attn_mask = torch.cat([torch.ones(bos_tokens_tensor.size(), dtype=torch.int64).to(self.device), attn_mask], dim=1)
+
+            labels = encoded_batch
+
+            with torch.no_grad():
+                out_logits = self.ppl_model(encoded_batch, attention_mask=attn_mask).logits
+
+            shift_logits = out_logits[..., :-1, :].contiguous()
+            shift_labels = labels[..., 1:].contiguous()
+            shift_attention_mask_batch = attn_mask[..., 1:].contiguous()
+
+            perplexity_batch = torch.exp(
+                (loss_fct(shift_logits.transpose(1, 2), shift_labels) * shift_attention_mask_batch).sum(1)
+                / shift_attention_mask_batch.sum(1)
+            )
+            ppls += perplexity_batch.tolist()
+
+        return {"perplexities": ppls, "mean_perplexity": np.mean(ppls)}
+
+    def get_triples_ie(self, text):
+        res = [x for x in self.IEclient.annotate(text)]
+        temp = [tuple(x.values()) for x in res]
+
+        current = defaultdict(list)
+        for t in temp:
+            current[(t[0], t[1])].append(t)
+
+        final = []
+        for t in temp:
+            s = "{} | {} | {}".format(t[0], t[1], t[2])
+            if s not in final:
+                final.append(s.replace("_", " "))
+        
+        lsh = MinHashLSH(threshold=0.4, num_perm=128)
+        minhashes = {}
+        for i, f in enumerate(final):
+            minhash = MinHash(num_perm=128)
+            for d in ngrams(f, 3):
+                minhash.update("".join(d).encode('utf-8'))
+            lsh.insert(i, minhash)
+            minhashes[i] = minhash
+
+        matches = {}
+        for x, y in zip(final, minhashes):
+            matches[x] = [final[z] for z in lsh.query(minhashes[y]) if z != y] 
+
+        clusters = []
+        covered = []
+        for m in sorted(matches, key=lambda x: len(matches[x]), reverse=True):
+            if m not in covered and len(matches[m]) > 0:
+                clusters.append(matches[m])
+                covered.extend(matches[m])
+
+        clean = [x.replace(" | ", " ") for x in covered]
+        if len(clean) == 0:
+            return []
+        ppls = dict(zip(covered, self.compute_ppl(predictions=clean, batch_size=64)["perplexities"]))
+
+        best = []
+        for c in clusters:
+            scores = [ppls[x] for x in c]
+            imin = np.argmin(scores)
+            best.append(c[imin])
+
+        ordered = []
+        for f in final:
+            if f in best:
+                ordered.append(f)
+        return ordered
+
+    def privatize(self, texts, epsilon=10, DP=True):
+        results = []
+        for i, t in tqdm(enumerate(texts), total=len(texts)):
+            triples = self.get_triples_ie(t)
+            if len(triples) == 0:
+                results.append(t)
+                continue
+
+            if DP:
+                eps = epsilon / len(triples)
+                query_vectors = self.model.encode(triples, task="text-matching", truncate_dim=32, max_length=64)
+
+                res = util.semantic_search(query_embeddings=torch.tensor(query_vectors).to(self.device), corpus_embeddings=self.centroids, top_k=1)
+                clusters = [r[0]["corpus_id"] for r in res]
+
+                candidates = []
+                for q, c in zip(query_vectors, clusters):
+                    near = self.query_db(q, c)
+                    if len(near) > 0:
+                        candidates.append(near)
+                private_triples = [self.exponential(c, eps) for c in candidates]
+
+                final = []
+                for p in private_triples:
+                    m = p.split(" | ")
+                    final.append({"object": m[0], "property": m[1], "subject": m[2]})
+                prompt = self.get_prompt(final)
+            else:
+                final = []
+                for x in triples:
+                    m = x.split(" | ")
+                    final.append({"object": m[0], "property": m[1], "subject": m[2]})
+                prompt = self.get_prompt(final)
+
+            outputs = self.pipe(
+                prompt,
+                pad_token_id=self.tokenizer.eos_token_id,
+                max_new_tokens=int(len(self.tokenizer.encode(texts[i], return_tensors="pt")[0]))
+            )
+            generated = outputs[0]["generated_text"][-1]["content"]
+
+            generated = generated.split("Output text: ")[-1].strip().replace("\n", "")
+            generated = generated.split("USER:")[0].strip().replace("\n", "")
+            generated = generated.split("\t")[0].split("ASSISTANT")[0].split("USER")[0].split("###")[0].split("Note:")[0].split("Explanation:")[0].split("```")[0].split("EXPECTED_OUTPUT")[0]
+            results.append(generated.strip())    
+        return results

dpst/setup_db.py

@@ -0,0 +1,156 @@
+# src/dpst/setup_db.py
+import json
+import numpy as np
+from tqdm.auto import tqdm
+import weaviate
+import weaviate.classes.config as wc
+from weaviate.util import generate_uuid5
+from importlib import resources
+from collections import Counter
+
+def initialize_database(max_rows=100000):
+    """Create the DB collection, parse FineWeb text, embed, and store."""
+    from datasets import load_dataset
+    
+    print("Connecting to local Weaviate instance...")
+    client = weaviate.connect_to_local()
+    
+    if not client.collections.exists("Triples"):
+        print("Creating 'Triples' collection schema...")
+        client.collections.create(
+            name="Triples",
+            properties=[
+                wc.Property(name="text", data_type=wc.DataType.TEXT),
+                wc.Property(name="fiftyk", data_type=wc.DataType.INT),
+                wc.Property(name="hundredk", data_type=wc.DataType.INT),
+                wc.Property(name="twohundredk", data_type=wc.DataType.INT),
+            ],
+            vectorizer_config=wc.Configure.Vectorizer.none(),
+        )
+    
+    triples = client.collections.get("Triples")
+    
+    from dpst.core import embedding_model, get_triples_ie 
+    
+    print("Streaming sample-10BT from HuggingFaceFW/fineweb...")
+    dataset = load_dataset("HuggingFaceFW/fineweb", "sample-10BT", split="train", streaming=True)
+    
+    all_data = []
+    total = 0
+    
+    for row in dataset:
+        if idx == max_rows:
+            break
+        
+        if idx % 100000 == 0 and idx != 0:
+            print("{} rows processed.".format(idx))
+
+        if len(row["text"]) > 10000 or row["language"] != "en":
+            continue
+        
+        all_data.append(row["text"])
+
+        if len(all_data) >= 1000:
+            print("Extracting triples...")
+            res = [get_triples_ie(x) for x in tqdm(all_data)]
+            tri = []
+            for r in res:
+                tri.extend(r)
+            
+            total += len(tri)
+            print("Inserting {} triples...".format(len(tri)))
+            embeddings = embedding_model.encode(tri, task="text-matching", truncate_dim=32, max_length=64)
+
+            with triples.batch.dynamic() as batch:
+                for i, t in enumerate(tri):
+                    obj = {"text":t}
+                    vector = embeddings[i]
+            
+                    batch.add_object(
+                        properties=obj,
+                        uuid=generate_uuid5(obj),
+                        vector=vector
+                    )
+            print("Finished. Total: {}".format(total))
+            del tri[:]
+            del tri
+            del all_data[:]
+            all_data = []
+
+        idx += 1
+
+    print("Extracting triples...")
+    res = [get_triples_ie(x) for x in tqdm(all_data)]
+    tri = []
+    for r in res:
+        tri.extend(r)
+
+    total += len(tri)
+    print("Inserting {} triples...".format(len(tri)))
+    embeddings = embedding_model.encode(tri, task="text-matching", truncate_dim=32, max_length=64)
+
+    with triples.batch.dynamic() as batch:
+        for i, t in enumerate(tri):
+            obj = {"text":t}
+            vector = embeddings[i]
+
+            batch.add_object(
+                properties=obj,
+                uuid=generate_uuid5(obj),
+                vector=vector
+            )
+    print("Finished. Total: {}".format(total))
+    del tri[:]
+    del tri
+    del all_data[:]
+    all_data = []
+    
+    client.close()
+    print("Database seeding completed.")
+
+
+def run_clustering_and_indexing():
+    """Pull vectors, run K-Means, export cluster JSONs, and update Weaviate."""
+    from sklearn.cluster import MiniBatchKMeans 
+
+    client = weaviate.connect_to_local()
+    triples = client.collections.get("Triples")
+    
+    print("Fetching vectors from Weaviate...")
+    all_ids, all_vectors, all_texts = [], [], []
+    for t in tqdm(triples.iterator(include_vector=True)):
+        all_ids.append(t.uuid)
+        all_vectors.append(t.vector["default"])
+    
+    x = np.array(all_vectors)
+    
+    print("Running MiniBatchKMeans (50k, 100k, 200k)...")
+    kmeans2 = MiniBatchKMeans(n_clusters=50000, random_state=42, batch_size=8192, max_iter=5, n_init="auto").fit(x)
+    kmeans3 = MiniBatchKMeans(n_clusters=100000, random_state=42, batch_size=8192, max_iter=10, n_init="auto").fit(x)
+    kmeans4 = MiniBatchKMeans(n_clusters=200000, random_state=42, batch_size=8192, max_iter=10, n_init="auto").fit(x)
+    
+    data_dir = resources.files("dpst.data")
+    
+    print(f"Saving cluster assets to: {data_dir}")
+    with open(data_dir / "50k.json", 'w') as f:
+        json.dump(kmeans2.cluster_centers_.tolist(), f)
+    with open(data_dir / "50k_counts.json", 'w') as f:
+        json.dump([Counter(kmeans2.labels_)[k] for k in sorted(Counter(kmeans2.labels_))], f)
+
+    with open(data_dir / "100k.json", 'w') as f:
+        json.dump(kmeans3.cluster_centers_.tolist(), f)
+    with open(data_dir / "100k_counts.json", 'w') as f:
+        json.dump([Counter(kmeans3.labels_)[k] for k in sorted(Counter(kmeans3.labels_))], f)
+
+    with open(data_dir / "200k.json", 'w') as f:
+        json.dump(kmeans4.cluster_centers_.tolist(), f)
+    with open(data_dir / "200k_counts.json", 'w') as f:
+        json.dump([Counter(kmeans4.labels_)[k] for k in sorted(Counter(kmeans4.labels_))], f)
+        
+    print("Updating collection items with cluster allocations...")
+    for uid, b, c, d in tqdm(zip(all_ids, kmeans2.labels_, kmeans3.labels_, kmeans4.labels_), total=len(all_ids)):
+        props = {"fiftyk": int(b), "hundredk": int(c), "twohundredk": int(d)}
+        triples.data.update(uuid=uid, properties=props)
+        
+    client.close()
+    print("Data preparation phase completely finished!")

dpst-0.1.0.dist-info/METADATA

@@ -0,0 +1,132 @@
+Metadata-Version: 2.4
+Name: dpst
+Version: 0.1.0
+Summary: Differentially private document generation leveraging semantic triples.
+Author-email: Stephen Meisenbacher <sjmeis@gtgd.com>
+Maintainer-email: Stephen Meisenbacher <sjmeis@gtgd.com>
+License: MIT License
+        
+        Copyright (c) 2025-2026 Stephen Meisenbacher
+        
+        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.
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: weaviate-client>=4.0.0
+Requires-Dist: transformers
+Requires-Dist: sentence-transformers
+Requires-Dist: openie
+Requires-Dist: tqdm
+Requires-Dist: numpy
+Requires-Dist: spacy
+Requires-Dist: torch
+Requires-Dist: datasketch
+Requires-Dist: nltk
+Provides-Extra: setup
+Requires-Dist: datasets; extra == "setup"
+Requires-Dist: scikit-learn; extra == "setup"
+Dynamic: license-file
+
+<div align="center">
+
+  # DP-ST
+
+  [![PyPI version](https://img.shields.io/pypi/v/dpst.svg)](https://pypi.org/project/dpst/)
+  [![GitHub stars](https://img.shields.io/github/stars/sjmeis/DPST.svg?style=social)](https://github.com/sjmeis/DPST/stargazers)
+  [![License](https://img.shields.io/github/license/sjmeis/DPST.svg)](https://github.com/sjmeis/DPST/blob/main/LICENSE)
+
+</div>
+
+Code repository for the EMNLP 2025 paper: *Leveraging Semantic Triples for Private Document Generation with Local Differential Privacy Guarantees*
+
+## Getting Started
+### Installation
+You can now install `DP-ST` directly as a Python package.
+
+```bash
+# Install the core runtime engine
+pip install dpst
+
+# Install the optional data-preparation extensions required for the initial setup
+pip install "dpst[setup]"
+```
+
+**Note on Heavy Runtimes**: We highly recommend installing the correct flavor of PyTorch matching your hardware's CUDA capability before installing this package.
+
+### Automated Database & Cluster Setup
+In order to run `DP-ST`, you must first run the *preparation* stage as described in the paper. This includes booting up your local vector database, extracting triples from a public text corpus, clustering them, and storing them locally.
+
+Ensure your local Weaviate instance is running, then execute the following automated command in your terminal:
+
+```bash
+dpst setup
+```
+
+**Note:** This can take a very long time! We recommend you set it and forget it. Alternatively, you can tweak the `max_rows` parameter of `initialize_database` to use less texts for the database preparation.
+
+The above replaces the legacy workflow of manually executing `Triple2DB.ipynb` and `triple_cluster.ipynb`. The command will automatically stream the FineWeb public corpus dataset, extract/embed triples into Weaviate, run the MiniBatchKMeans allocations (50k, 100k, and 200k), and write the resulting cluster assets straight into the package data directory. If you prefer a more tailored approach, we still recommend using the notebooks.
+
+## Usage
+
+Running `DP-ST` is simple once the automated setup has completed:
+
+```python
+from dpst import DPST
+
+# Initialize the engine (specify mode: "50k", "100k", or "200k")
+X = DPST(mode="50k", model_checkpoint=MODEL_NAME, hf_token=TOKEN)
+
+# Privatize your text corpus
+private_texts = X.privatize([TEXTS], epsilon=DOC_PRIVACY_BUDGET)
+```
+
+`MODEL_NAME` refers to the model used for text reconstruction (i.e., the `Llama-3.2` models we use in the work), and `hf_token` is only necessary for gated models on Hugging Face.
+
+## Running other DP Methods
+In this repository (under the `comparison` directory), you will find a number of scripts (`*_perturb.py`) to reproduce the privatized texts as performed in our work.
+
+The code for `DP-BART` and `DP-Prompt` can be found in `LLMDP.py`. `DP-MLM` can be found [here](https://github.com/sjmeis/DPMLM/) and the code for `TEM` can be found [here](https://github.com/sjmeis/MLDP/).
+
+We also include the evaluation code for cosine similarity (`CS.py`) and G-Eval (`Geval.ipynb`), located in `evaluation`.
+
+NOTE: in all provided notebooks, please make sure to include the correct libraries and link the paths accordingly. This is necessary for the code to run correctly!
+
+## Citation
+If you use this code in your research, please consider citing the published work:
+
+```
+@inproceedings{meisenbacher-etal-2025-leveraging,
+    title = "Leveraging Semantic Triples for Private Document Generation with Local Differential Privacy Guarantees",
+    author = "Meisenbacher, Stephen  and
+      Chevli, Maulik  and
+      Matthes, Florian",
+    editor = "Christodoulopoulos, Christos  and
+      Chakraborty, Tanmoy  and
+      Rose, Carolyn  and
+      Peng, Violet",
+    booktitle = "Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing",
+    month = nov,
+    year = "2025",
+    address = "Suzhou, China",
+    publisher = "Association for Computational Linguistics",
+    url = "https://aclanthology.org/2025.emnlp-main.455/",
+    doi = "10.18653/v1/2025.emnlp-main.455",
+    pages = "8976--8992",
+    ISBN = "979-8-89176-332-6"
+}
+```

dpst-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+dpst/__init__.py,sha256=gK4XIDT6JcPOkYO5B4XXRloImX_byxGTdoiISGMQHlg,69
+dpst/cli.py,sha256=FC5J4sDHSFw2cBZs_PGsmC-wcm_hHzzo0c-tlgZoWcg,912
+dpst/core.py,sha256=MbmQnsb6N631UzM4qW2eSH1jokfUrCudD8nT6Rq4CUw,13599
+dpst/setup_db.py,sha256=FkVMtQd8wNX2K2ehMmWpHkehEG4v_VH2RbtSP22NFOo,5846
+dpst-0.1.0.dist-info/licenses/LICENSE,sha256=Fidi0t9GAtM6s1nRixU2cOHCfOgIsOJEkqNjgr7Zx8s,1101
+dpst-0.1.0.dist-info/METADATA,sha256=2s8jD8E-KO4dv6qvC00fSN2F9P26qxNDMDGvJr5h8aA,6058
+dpst-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+dpst-0.1.0.dist-info/entry_points.txt,sha256=NhFjOF2MhSoenGFK-kX8nK8aHzzoO4HJkCC3vwlgmzs,39
+dpst-0.1.0.dist-info/top_level.txt,sha256=9NmKe0m8O75T_GUImjBprimRvxqi8YcJAurcCwr47JE,5
+dpst-0.1.0.dist-info/RECORD,,

dpst-0.1.0.dist-info/WHEEL

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

dpst-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dpst = dpst.cli:main

dpst-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Stephen Meisenbacher
+
+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.

dpst-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+dpst